Review more chapters.
authorMatthijs Kooijman <matthijs@stdin.nl>
Fri, 27 Nov 2009 12:03:43 +0000 (13:03 +0100)
committerMatthijs Kooijman <matthijs@stdin.nl>
Fri, 27 Nov 2009 12:03:43 +0000 (13:03 +0100)
Chapters/Future.tex
Chapters/Normalization.tex
Outline

index f61044d..3b9161f 100644 (file)
@@ -1,6 +1,6 @@
 \chapter[chap:future]{Future work}
 \section{Improved notation for hierarchical state}
-The hierarchic state model requires quite some boilerplate code for unpacking
+The hierarchical state model requires quite some boilerplate code for unpacking
 and distributing the input state and collecting and repacking the output
 state.
 
@@ -29,7 +29,7 @@ be effectively the same thing). This means it makes extra sense to hide this
 boilerplate away. This would incur no flexibility cost at all, since there are
 no other ways that would work.
 
-One particular notation in Haskell that seemed promising, whas he \hs{do}
+One particular notation in Haskell that seems promising, is the \hs{do}
 notation. This is meant to simplify Monad notation by hiding away some
 details. It allows one to write a list of expressions, which are composited
 using the monadic \emph{bind} operator, written in Haskell as \hs{>>}. For
@@ -44,9 +44,10 @@ do
 will be desugared into:
 
 \starthaskell
-(somefunc a b) >> (otherfunc b c)
+(somefunc a) >> (otherfunc b)
 \stophaskell
 
+\todo{Properly introduce >>=}
 There is also the \hs{>>=} operator, which allows for passing variables from
 one expression to the next. If we could use this notation to compose a
 stateful computation from a number of other stateful functions, this could
@@ -58,7 +59,7 @@ This is highlights an important aspect of using a functional language for our
 descriptions: We can use the language itself to provide abstractions of common
 patterns, making our code smaller.
 
-\subsection{Outside the Monad}
+\subsection{Breaking out of the Monad}
 However, simply using the monad notation is not as easy as it sounds. The main
 problem is that the Monad type class poses a number of limitations on the
 bind operator \hs{>>}. Most importantly, it has the following type signature:
@@ -117,7 +118,7 @@ passing it to two functions and repacking the new state. With these
 definitions, we could have writting \in{example}[ex:NestedState] a lot
 shorter, see \in{example}[ex:DoState]. In this example the type signature of
 foo is the same (though it is now written using the \hs{Stateful} type
-synonym, it is still completel equivalent to the original: \hs{foo :: Word ->
+synonym, it is still completely equivalent to the original: \hs{foo :: Word ->
 FooState -> (FooState, Word)}.
 
 Note that the \hs{FooState} type has changed (so indirectly the type of
@@ -133,8 +134,8 @@ happening.
   type FooState = ( AState, (BState, ()) )
   foo :: Word -> Stateful FooState Word
   foo in = do
-      outa <- funca in sa
-      outb <- funcb outa sb
+      outa <- funca in
+      outb <- funcb outa
       return outb
 \stopbuffer
 \placeexample[here][ex:DoState]{Simple function composing two stateful
@@ -152,8 +153,10 @@ the expressions that come after it. This prevents values from flowing between
 two functions (components) in two directions. For most Monad instances, this
 is a requirement, but here it could have been different.
 
+\todo{Add examples or reference for state synonyms}
+
 \subsection{Alternative syntax}
-Because of the above issues, misusing Haskell's do notation is probably not
+Because of these typing issues, misusing Haskell's do notation is probably not
 the best solution here. However, it does show that using fairly simple
 abstractions, we could hide a lot of the boilerplate code. Extending
 \small{GHC} with some new syntax sugar similar to the do notation might be a
@@ -161,7 +164,7 @@ feasible.
 
 \section[sec:future:pipelining]{Improved notation or abstraction for pipelining}
 Since pipelining is a very common optimization for hardware systems, it should
-be easy to specify a pipelined system. Since it involves quite some registers
+be easy to specify a pipelined system. Since it introduces quite some registers
 into an otherwise regular combinatoric system, we might look for some way to
 abstract away some of the boilerplate for pipelining.
 
@@ -177,7 +180,7 @@ if it introduced an extra, useless, pipeline stage).
 
 This problem is slightly more complex than the problem we've seen before. One
 significant difference is that each variable that crosses a stage boundary
-needs a registers. However, when a variable crosses multiple stage boundaries,
+needs a register. However, when a variable crosses multiple stage boundaries,
 it must be stored for a longer period and should receive multiple registers.
 Since we can't find out from the combinator code where the result of the
 combined values is used (at least not without using Template Haskell to
@@ -194,6 +197,7 @@ There seem to be two obvious ways of handling this problem:
 
   This produces cumbersome code, where there is still a lot of explicitness
   (though this could be hidden in syntax sugar).
+  \todo{The next sentence is unclear}
   \item Scope each variable over every subsequent pipeline stage and allocate
   the maximum amount of registers that \emph{could} be needed. This means we
   will allocate registers that are never used, but those could be optimized
@@ -216,12 +220,12 @@ stateful, mixing pipelined with normal computation, etc.
 \section{Recursion}
 The main problems of recursion have been described in
 \in{section}[sec:recursion]. In the current implementation, recursion is
-therefore not possible, instead we rely on a number of implicit list-recursive
+therefore not possible, instead we rely on a number of implicitly list-recursive
 builtin functions.
 
 Since recursion is a very important and central concept in functional
 programming, it would very much improve the flexibility and elegance of our
-hardware descriptions if we could support full recursion.
+hardware descriptions if we could support (full) recursion.
 
 For this, there are two main problems to solve:
 
@@ -239,7 +243,7 @@ base case of the recursion influences the type signatures). For general
 recursion, this requires a complete set of simplification and evaluation
 transformations to prevent infinite expansion. The main challenge here is how
 to make this set complete, or at least define the constraints on possible
-recursion which guarantee it will work.
+recursion that guarantee it will work.
 
 \todo{Reference Christian for loop unrolling?}
 \stopitemize
@@ -254,7 +258,7 @@ signal can be synchronous, that is less flexible (and a hassle to describe in
 Cλash, currently). Since every function in Cλash describes the behaviour on
 each cycle boundary, we really can't fit in asynchronous behaviour easily.
 
-Due to the same reason, multiple clock domains cannot be supported. There is
+Due to the same reason, multiple clock domains cannot be easily supported. There is
 currently no way for the compiler to know in which clock domain a function
 should operate and since the clock signal is never explicit, there is also no
 way to express circuits that synchronize various clock domains.
@@ -263,7 +267,7 @@ A possible way to express more complex timing behaviour would be to make
 functions more generic event handlers, where the system generates a stream of
 events (Like \quote{clock up}, \quote{clock down}, \quote{input A changed},
 \quote{reset}, etc.). When working with multiple clock domains, each domain
-could get its own events.
+could get its own clock events.
 
 As an example, we would have something like the following:
 
index 427ab0a..ed55016 100644 (file)
     }
   }
 
-  \define[3]\transexample{
-    \placeexample[here]{#1}
+  \define[4]\transexample{
+    \placeexample[here][ex:trans:#1]{#2}
     \startcombination[2*1]
-      {\example{#2}}{Original program}
-      {\example{#3}}{Transformed program}
+      {\example{#3}}{Original program}
+      {\example{#4}}{Transformed program}
     \stopcombination
   }
 
@@ -32,6 +32,7 @@
   \VHDL we want to generate should look like.}
 
   \section{Normal form}
+    \todo{Refresh or refer to distinct hardware per application principle}
     The transformations described here have a well-defined goal: To bring the
     program in a well-defined form that is directly translatable to hardware,
     while fully preserving the semantics of the program. We refer to this form as
 
       \item Any complex \emph{nested scopes} must be removed. In the \small{VHDL}
       description, every signal is in a single scope. Also, full expressions are
-      not supported everywhere (in particular port maps can only map signal names,
-      not expressions). To make the \small{VHDL} generation easy, all values must be bound
-      on the \quote{top level}.
+      not supported everywhere (in particular port maps can only map signal
+      names and constants, not complete expressions). To make the \small{VHDL}
+      generation easy, a separate binder must be bound to ever application or
+      other expression.
     \stopitemize
 
     \todo{Intermezzo: functions vs plain values}
 
     A very simple example of a program in normal form is given in
     \in{example}[ex:MulSum]. As you can see, all arguments to the function (which
-    will become input ports in the final hardware) are at the top. This means that
-    the body of the final lambda abstraction is never a function, but always a
-    plain value.
+    will become input ports in the final hardware) are at the outer level.
+    This means that the body of the inner lambda abstraction is never a
+    function, but always a plain value.
 
-    After the lambda abstractions, we see a single let expression, that binds two
-    variables (\lam{mul} and \lam{sum}). These variables will be signals in the
-    final hardware, bound to the output port of the \lam{*} and \lam{+}
-    components.
+    As the body of the inner lambda abstraction, we see a single (recursive)
+    let expression, that binds two variables (\lam{mul} and \lam{sum}). These
+    variables will be signals in the final hardware, bound to the output port
+    of the \lam{*} and \lam{+} components.
 
     The final line (the \quote{return value} of the function) selects the
     \lam{sum} signal to be the output port of the function. This \quote{return
     value} can always only be a variable reference, never a more complex
     expression.
 
+    \todo{Add generated VHDL}
+
     \startbuffer[MulSum]
     alu :: Bit -> Word -> Word -> Word
     alu = λa.λb.λc.
       newCircle.sum(btex $res$ etex) "framed(false)";
 
       % Components
-      newCircle.mul(btex - etex);
+      newCircle.mul(btex * etex);
       newCircle.add(btex + etex);
 
       a.c      - b.c   = (0cm, 2cm);
       ncline(add)(sum);
     \stopuseMPgraphic
 
-    \placeexample[here][ex:MulSum]{Simple architecture consisting of an adder and a
-    subtractor.}
+    \placeexample[here][ex:MulSum]{Simple architecture consisting of a
+    multiplier and a subtractor.}
       \startcombination[2*1]
         {\typebufferlam{MulSum}}{Core description in normal form.}
         {\boxedgraphic{MulSum}}{The architecture described by the normal form.}
       \stopcombination
 
     The previous example described composing an architecture by calling other
-    functions (operators), resulting in a simple architecture with component and
-    connection. There is of course also some mechanism for choice in the normal
+    functions (operators), resulting in a simple architecture with components and
+    connections. There is of course also some mechanism for choice in the normal
     form. In a normal Core program, the \emph{case} expression can be used in a
     few different ways to describe choice. In normal form, this is limited to a
     very specific form.
 
     \in{Example}[ex:AddSubAlu] shows an example describing a
     simple \small{ALU}, which chooses between two operations based on an opcode
-    bit. The main structure is the same as in \in{example}[ex:MulSum], but this
+    bit. The main structure is similar to \in{example}[ex:MulSum], but this
     time the \lam{res} variable is bound to a case expression. This case
     expression scrutinizes the variable \lam{opcode} (and scrutinizing more
     complex expressions is not supported). The case expression can select a
     architecture contains a slightly simplified version, since the state tuple
     packing and unpacking have been left out. Instead, two seperate registers are
     drawn. Also note that most synthesis tools will further optimize this
-    architecture by removing the multiplexers at the register input and replace
-    them with some logic in the clock inputs, but we want to show the architecture
-    as close to the description as possible.
+    architecture by removing the multiplexers at the register input and
+    instead put some gates in front of the register's clock input, but we want
+    to show the architecture as close to the description as possible.
+
+    As you can see from the previous examples, the generation of the final
+    architecture from the normal form is straightforward. In each of the
+    examples, there is a direct match between the normal form structure,
+    the generated VHDL and the architecture shown in the images.
 
     \startbuffer[NormalComplete]
       regbank :: Bit 
                  -> State (Word, Word) 
                  -> (State (Word, Word), Word)
 
-      -- All arguments are an inital lambda
+      -- All arguments are an inital lambda (address, data, packed state)
       regbank = λa.λd.λsp.
       -- There are nested let expressions at top level
       let
         -- State (Word, Word) to (Word, Word))
         s = sp :: (Word, Word)
         -- Extract both registers from the state
-        r1 = case s of (fst, snd) -> fst
-        r2 = case s of (fst, snd) -> snd
+        r1 = case s of (a, b) -> a
+        r2 = case s of (a, b) -> b
         -- Calling some other user-defined function.
         d' = foo d
         -- Conditional connections
       ncline(muxout)(out) "posA(out)";
     \stopuseMPgraphic
 
+    \todo{Don't split registers in this image?}
     \placeexample[here][ex:NormalComplete]{Simple architecture consisting of an adder and a
     subtractor.}
       \startcombination[2*1]
         {\typebufferlam{NormalComplete}}{Core description in normal form.}
         {\boxedgraphic{NormalComplete}}{The architecture described by the normal form.}
       \stopcombination
+    
+
 
     \subsection{Intended normal form definition}
       Now we have some intuition for the normal form, we can describe how we want
       Some clauses have an expression listed in parentheses. These are conditions
       that need to apply to the clause.
 
+      \todo{Fix indentation}
       \startlambda
       \italic{normal} = \italic{lambda}
       \italic{lambda} = λvar.\italic{lambda} (representable(var))
       no longer true, btw}
 
       When looking at such a program from a hardware perspective, the top level
-      lambda's define the input ports. The value produced by the let expression is
-      the output port. Most function applications bound by the let expression
-      define a component instantiation, where the input and output ports are mapped
-      to local signals or arguments. Some of the others use a builtin
-      construction (\eg the \lam{case} statement) or call a builtin function
-      (\eg \lam{add} or \lam{sub}). For these, a hardcoded \small{VHDL} translation is
+      lambda's define the input ports. The variable referenc in the body of
+      the recursive let expression is the output port. Most function
+      applications bound by the let expression define a component
+      instantiation, where the input and output ports are mapped to local
+      signals or arguments. Some of the others use a builtin construction (\eg
+      the \lam{case} expression) or call a builtin function (\eg \lam{+} or
+      \lam{map}). For these, a hardcoded \small{VHDL} translation is
       available.
 
-  \section{Transformation notation}
-    To be able to concisely present transformations, we use a specific format to
-    them. It is a simple format, similar to one used in logic reasoning.
+  \section[sec:normalization:transformation]{Transformation notation}
+    To be able to concisely present transformations, we use a specific format
+    for them. It is a simple format, similar to one used in logic reasoning.
 
     Such a transformation description looks like the following.
 
     <context additions>
     \stoptrans
 
-    This format desribes a transformation that applies to \lam{original
-    expresssion} and transforms it into \lam{transformed expression}, assuming
+    This format desribes a transformation that applies to \lam{<original
+    expresssion>} and transforms it into \lam{<transformed expression>}, assuming
     that all conditions apply. In this format, there are a number of placeholders
     in pointy brackets, most of which should be rather obvious in their meaning.
     Nevertheless, we will more precisely specify their meaning below:
       against (subexpressions of) the expression to be transformed. We call this a
       pattern, because it can contain \emph{placeholders} (variables), which match
       any expression or binder. Any such placeholder is said to be \emph{bound} to
-      the expression it matches. It is convention to use an uppercase latter (\eg
-      \lam{M} or \lam{E} to refer to any expression (including a simple variable
+      the expression it matches. It is convention to use an uppercase letter (\eg
+      \lam{M} or \lam{E}) to refer to any expression (including a simple variable
       reference) and lowercase letters (\eg \lam{v} or \lam{b}) to refer to
       (references to) binders.
 
       For example, the pattern \lam{a + B} will match the expression 
-      \lam{v + (2 * w)} (and bind \lam{a} to \lam{v} and \lam{B} to 
-      \lam{(2 * 2)}), but not \lam{v + (2 * w)}.
+      \lam{v + (2 * w)} (binding \lam{a} to \lam{v} and \lam{B} to 
+      \lam{(2 * w)}), but not \lam{(2 * w) + v}.
       \stopdesc
 
       \startdesc{<expression conditions>}
       These are extra conditions on the expression that is matched. These
       conditions can be used to further limit the cases in which the
-      transformation applies, in particular to prevent a transformation from
+      transformation applies, commonly to prevent a transformation from
       causing a loop with itself or another transformation.
 
-      Only if these if these conditions are \emph{all} true, this transformation
+      Only if these conditions are \emph{all} true, the transformation
       applies.
       \stopdesc
 
       \startdesc{<context conditions>}
       These are a number of extra conditions on the context of the function. In
-      particular, these conditions can require some other top level function to be
+      particular, these conditions can require some (other) top level function to be
       present, whose value matches the pattern given here. The format of each of
       these conditions is: \lam{binder = <pattern>}.
 
       expression>}, while the pattern contains some placeholders that are used in
       the \lam{transformed expression}.
       
-      Only if a top level binder exists that matches each binder and pattern, this
-      transformation applies.
+      Only if a top level binder exists that matches each binder and pattern,
+      the transformation applies.
       \stopdesc
 
       \startdesc{<transformed expression>}
       This is the expression template that is the result of the transformation. If, looking
-      at the above three items, the transformation applies, the \lam{original
-      expression} is completely replaced with the \lam{<transformed expression>}.
+      at the above three items, the transformation applies, the \lam{<original
+      expression>} is completely replaced with the \lam{<transformed expression>}.
       We call this a template, because it can contain placeholders, referring to
       any placeholder bound by the \lam{<original expression>} or the
       \lam{<context conditions>}. The resulting expression will have those
 
       \startdesc{<context additions>}
       These are templates for new functions to add to the context. This is a way
-      to have a transformation create new top level functiosn.
+      to have a transformation create new top level functions.
 
       Each addition has the form \lam{binder = template}. As above, any
       placeholder in the addition is replaced with the value bound to it, and any
     λx.E x            \lam{E} is not a lambda abstraction.
     \stoptrans
 
+    η-abstraction is a well known transformation from lambda calculus. What
+    this transformation does, is take any expression that has a function type
+    and turn it into a lambda expression (giving an explicit name to the
+    argument). There are some extra conditions that ensure that this
+    transformation does not apply infinitely (which are not necessarily part
+    of the conventional definition of η-abstraction).
+
     Consider the following function, which is a fairly obvious way to specify a
-    simple ALU (Note \at{example}[ex:AddSubAlu] is the normal form of this
-    function):
+    simple ALU (Note that \in{example}[ex:AddSubAlu] shows the normal form of this
+    function). The parentheses around the \lam{+} and \lam{-} operators are
+    commonly used in Haskell to show that the operators are used as normal
+    functions, instead of \emph{infix} operators (\eg, the operators appear
+    before their arguments, instead of in between).
 
     \startlambda 
     alu :: Bit -> Word -> Word -> Word
 
     Continuing with this expression, we see that the transformation does not
     apply again (it is a lambda expression). Next we look at the body of this
-    labmda abstraction:
+    lambda abstraction:
 
     \startlambda
     (case opcode of
     \stoplambda
 
     Obviously, the transformation does not apply here, since it occurs in
-    function position. In the same way the transformation does not apply to both
-    components of this expression (\lam{case opcode of Low -> (+); High -> (-)}
-    and \lam{a}), so we'll skip to the components of the case expression: The
-    scrutinee and both alternatives. Since the opcode is not a function, it does
-    not apply here, and we'll leave both alternatives as an exercise to the
-    reader. The final function, after all these transformations becomes:
+    function position (which makes the second condition false). In the same
+    way the transformation does not apply to both components of this
+    expression (\lam{case opcode of Low -> (+); High -> (-)} and \lam{a}), so
+    we'll skip to the components of the case expression: The scrutinee and
+    both alternatives. Since the opcode is not a function, it does not apply
+    here.
+
+    The first alternative is \lam{(+)}. This expression has a function type
+    (the operator still needs two arguments). It does not occur in function
+    position of an application and it is not a lambda expression, so the
+    transformation applies.
+
+    We look at the \lam{<original expression>} pattern, which is \lam{E}.
+    This means we bind \lam{E} to \lam{(+)}. We then replace the expression
+    with the \lam{<transformed expression>}, replacing all occurences of
+    \lam{E} with \lam{(+)}. In the \lam{<transformed expression>}, the This gives us the replacement expression:
+    \lam{λx.(+) x} (A lambda expression binding \lam{x}, with a body that
+    applies the addition operator to \lam{x}).
+
+    The complete function then becomes:
+    \startlambda
+    (case opcode of Low -> λa1.(+) a1; High -> (-)) a
+    \stoplambda
+
+    Now the transformation no longer applies to the complete first alternative
+    (since it is a lambda expression). It does not apply to the addition
+    operator again, since it is now in function position in an application. It
+    does, however, apply to the application of the addition operator, since
+    that is neither a lambda expression nor does it occur in function
+    position. This means after one more application of the transformation, the
+    function becomes:
+
+    \startlambda
+    (case opcode of Low -> λa1.λb1.(+) a1 b1; High -> (-)) a
+    \stoplambda
+
+    The other alternative is left as an exercise to the reader. The final
+    function, after applying η-abstraction until it does no longer apply is:
 
     \startlambda 
     alu :: Bit -> Word -> Word -> Word
       High -> λa2.λb2 (-) a2 b2) a b
     \stoplambda
 
-    In this case, the transformation does not apply anymore, though this might
-    not always be the case (e.g., the application of a transformation on a
-    subexpression might open up possibilities to apply the transformation
-    further up in the expression).
-
     \subsection{Transformation application}
       In this chapter we define a number of transformations, but how will we apply
       these? As stated before, our normal form is reached as soon as no
       an efficient implementation.
 
       When applying a single transformation, we try to apply it to every (sub)expression
-      in a function, not just the top level function. This allows us to keep the
-      transformation descriptions concise and powerful.
+      in a function, not just the top level function body. This allows us to
+      keep the transformation descriptions concise and powerful.
 
     \subsection{Definitions}
       In the following sections, we will be using a number of functions and
 
       \todo{Define substitution (notation)}
 
-      \subsubsection{Other concepts}
-        A \emph{global variable} is any variable that is bound at the
+      \subsubsection{Concepts}
+        A \emph{global variable} is any variable (binder) that is bound at the
         top level of a program, or an external module. A \emph{local variable} is any
         other variable (\eg, variables local to a function, which can be bound by
         lambda abstractions, let expressions and pattern matches of case
 
         A \emph{hardware representable} (or just \emph{representable}) type or value
         is (a value of) a type that we can generate a signal for in hardware. For
-        example, a bit, a vector of bits, a 32 bit unsigned word, etc. Types that are
+        example, a bit, a vector of bits, a 32 bit unsigned word, etc. Values that are
         not runtime representable notably include (but are not limited to): Types,
         dictionaries, functions.
         \defref{representable}
       A \emph{user-defined} function is a function for which we do have a Cλash
       implementation available.
 
-      \subsubsection{Functions}
-        Here, we define a number of functions that can be used below to concisely
-        specify conditions.
+      \subsubsection{Predicates}
+        Here, we define a number of predicates that can be used below to concisely
+        specify conditions.\refdef{global variable}
 
-        \refdef{global variable}\emph{gvar(expr)} is true when \emph{expr} is a variable that references a
+        \emph{gvar(expr)} is true when \emph{expr} is a variable that references a
         global variable. It is false when it references a local variable.
 
         \refdef{local variable}\emph{lvar(expr)} is the complement of \emph{gvar}; it is true when \emph{expr}
         \refdef{representable}\emph{representable(expr)} or \emph{representable(var)} is true when
         \emph{expr} or \emph{var} is \emph{representable}.
 
-    \subsection{Binder uniqueness}
+    \subsection[sec:normalization:uniq]{Binder uniqueness}
       A common problem in transformation systems, is binder uniqueness. When not
       considering this problem, it is easy to create transformations that mix up
       bindings and cause name collisions. Take for example, the following core
       (λa.λb.λc. a * b * c) x c
       \stoplambda
 
-      By applying β-reduction (see below) once, we can simplify this expression to:
+      By applying β-reduction (see \in{section}[sec:normalization:beta]) once,
+      we can simplify this expression to:
 
       \startlambda
       (λb.λc. x * b * c) c
 
       In our transformation system, maintaining this non-shadowing invariant is
       a bit harder to do (mostly due to implementation issues, the prototype doesn't
-      use \small{GHC}'s subsitution code). Also, we can observe the following
-      points.
+      use \small{GHC}'s subsitution code). Also, the following points can be
+      observed.
 
       \startitemize
       \item Deshadowing does not guarantee overall uniqueness. For example, the
       \stoplambda
 
       \item In our normal form (and the resulting \small{VHDL}), all binders
-      (signals) will end up in the same scope. To allow this, all binders within the
-      same function should be unique.
+      (signals) within the same function (entity) will end up in the same
+      scope. To allow this, all binders within the same function should be
+      unique.
 
       \item When we know that all binders in an expression are unique, moving around
       or removing a subexpression will never cause any binder conflicts. If we have
       \stopitemize
 
       Given the above, our prototype maintains a unique binder invariant. This
-      meanst that in any given moment during normalization, all binders \emph{within
+      means that in any given moment during normalization, all binders \emph{within
       a single function} must be unique. To achieve this, we apply the following
       technique.
 
       \startitemize
       \item Before starting normalization, all binders in the function are made
       unique. This is done by generating a fresh binder for every binder used. This
-      also replaces binders that did not pose any conflict, but it does ensure that
-      all binders within the function are generated by the same unique supply. See
+      also replaces binders that did not cause any conflict, but it does ensure that
+      all binders within the function are generated by the same unique supply.
       \refdef{fresh binder}
       \item Whenever a new binder must be generated, we generate a fresh binder that
       is guaranteed to be different from \emph{all binders generated so far}. This
       can thus never introduce duplication and will maintain the invariant.
-      \item Whenever (part of) an expression is duplicated (for example when
+      \item Whenever (part of) an expression is duplicated (for example when
       inlining), all binders in the expression are replaced with fresh binders
       (using the same method as at the start of normalization). These fresh binders
       can never introduce duplication, so this will maintain the invariant.
       \stopitemize
 
   \section{Transform passes}
-    In this section we describe the actual transforms. Here we're using
-    the core language in a notation that resembles lambda calculus.
-
-    Each of these transforms is meant to be applied to every (sub)expression
-    in a program, for as long as it applies. Only when none of the
-    transformations can be applied anymore, the program is in normal form (by
-    definition). We hope to be able to prove that this form will obey all of the
-    constraints defined above, but this has yet to happen (though it seems likely
-    that it will).
-
-    Each of the transforms will be described informally first, explaining
-    the need for and goal of the transform. Then, a formal definition is
-    given, using a familiar syntax from the world of logic. Each transform
-    is specified as a number of conditions (above the horizontal line) and a
-    number of conclusions (below the horizontal line). The details of using
-    this notation are still a bit fuzzy, so comments are welcom.
+    In this section we describe the actual transforms.
+
+    Each transformation will be described informally first, explaining
+    the need for and goal of the transformation. Then, we will formally define
+    the transformation using the syntax introduced in
+    \in{section}[sec:normalization:transformation].
 
     \subsection{General cleanup}
       These transformations are general cleanup transformations, that aim to
 
        Most of these transformations are standard optimizations in other
        compilers as well. However, in our compiler, most of these are not just
-       optimizations, but they are required to get our program into normal
-       form.
+       optimizations, but they are required to get our program into intended
+       normal form.
 
-      \subsubsection{β-reduction}
+      \subsubsection[sec:normalization:beta]{β-reduction}
         β-reduction is a well known transformation from lambda calculus, where it is
-        the main reduction step. It reduces applications of labmda abstractions,
+        the main reduction step. It reduces applications of lambda abstractions,
         removing both the lambda abstraction and the application.
 
         In our transformation system, this step helps to remove unwanted lambda
         \starttrans
         (λx.E) M
         -----------------
-        E[M/x]
+        E[x=>M]
         \stoptrans
 
         % And an example
         2 * (2 * b)
         \stopbuffer
 
-        \transexample{β-reduction}{from}{to}
+        \transexample{beta}{β-reduction}{from}{to}
 
       \subsubsection{Empty let removal}
         This transformation is simple: It removes recursive lets that have no bindings
         (which usually occurs when unused let binding removal removes the last
         binding from it).
 
+        Note that there is no need to define this transformation for
+        non-recursive lets, since they always contain exactly one binding.
+
         \starttrans
         letrec in M
         --------------
         \todo{Example}
 
       \subsubsection{Simple let binding removal}
-        This transformation inlines simple let bindings (\eg a = b).
-
-        This transformation is not needed to get into normal form, but makes the
-        resulting \small{VHDL} a lot shorter.
-
+        This transformation inlines simple let bindings, that bind some
+        binder to some other binder instead of a more complex expression (\ie
+        a = b).
+
+        This transformation is not needed to get an expression into intended
+        normal form (since these bindings are part of the intended normal
+        form), but makes the resulting \small{VHDL} a lot shorter.
+        
         \starttrans
         letrec
           a0 = E0
         in
           M
         -----------------------------  \lam{b} is a variable reference
-        letrec
-          a0 = E0 [b/ai]
+        letrec                         \lam{ai} ≠ \lam{b}
+          a0 = E0 [ai=>b]
           \vdots
-          ai-1 = Ei-1 [b/ai]
-          ai+1 = Ei+1 [b/ai]
+          ai-1 = Ei-1 [ai=>b]
+          ai+1 = Ei+1 [ai=>b]
           \vdots
-          an = En [b/ai]
+          an = En [ai=>b]
         in
-          M[b/ai]
+          M[ai=>b]
         \stoptrans
 
         \todo{example}
 
       \subsubsection{Unused let binding removal}
-        This transformation removes let bindings that are never used. Usually,
-        the desugarer introduces some unused let bindings.
+        This transformation removes let bindings that are never used.
+        Occasionally, \GHC's desugarer introduces some unused let bindings.
 
-        This normalization pass should really be unneeded to get into normal form
+        This normalization pass should really be unneeded to get into intended normal form
         (since unused bindings are not forbidden by the normal form), but in practice
         the desugarer or simplifier emits some unused bindings that cannot be
-        normalized (e.g., calls to a \type{PatError} (\todo{Check this name}). Also,
+        normalized (e.g., calls to a \type{PatError}\todo{Check this name}). Also,
         this transformation makes the resulting \small{VHDL} a lot shorter.
 
+        \todo{Don't use old-style numerals in transformations}
         \starttrans
         letrec
           a0 = E0
           \vdots
           an = En
         in
-          M                             \lam{a} does not occur free in \lam{M}
-        ----------------------------    \forall j, 0 <= j <= n, j ≠ i (\lam{a} does not occur free in \lam{Ej})
+          M                             \lam{ai} does not occur free in \lam{M}
+        ----------------------------    \forall j, 0 ≤ j ≤ n, j ≠ i (\lam{ai} does not occur free in \lam{Ej})
         letrec
           a0 = E0
           \vdots
         references.
 
         Note that this transformation is completely optional. It is not
-        required to get any function into normal form, but it does help making
+        required to get any function into intended normal form, but it does help making
         the resulting VHDL output easier to read (since it removes a bunch of
         components that are really boring).
 
         GHC.Num.(+) @ Alu.Word $dNum a b
         \stopbuffer
 
-        \transexample{Top level binding inlining}{from}{to}
+        \transexample{toplevelinline}{Top level binding inlining}{from}{to}
        
-        Without this transformation, the (+) function would generate an
+        Example \in{ex:trans:toplevelinline} shows a typical application of
+        the addition operator generated by \GHC. The type and dictionary
+        arguments used here are described in
+        \in{section:prototype:polymorphism}.
+
+        Without this transformation, there would be a (+) entity in the
         architecture which would just add its inputs. This generates a lot of
         overhead in the VHDL, which is particularly annoying when browsing the
         generated RTL schematic (especially since + is not allowed in VHDL
     \subsection{Program structure}
       These transformations are aimed at normalizing the overall structure
       into the intended form. This means ensuring there is a lambda abstraction
-      at the top for every argument (input port), putting all of the other
-      value definitions in let bindings and making the final return value a
-      simple variable reference.
+      at the top for every argument (input port or current state), putting all
+      of the other value definitions in let bindings and making the final
+      return value a simple variable reference.
 
       \subsubsection{η-abstraction}
         This transformation makes sure that all arguments of a function-typed
             False -> λy.id y) x
         \stopbuffer
 
-        \transexample{η-abstraction}{from}{to}
+        \transexample{eta}{η-abstraction}{from}{to}
 
       \subsubsection{Application propagation}
         This transformation is meant to propagate application expressions downwards
         opportunities for other transformations (like β-reduction and
         specialization).
 
+        Since all binders in our expression are unique (see
+        \in{section}[sec:normalization:uniq]), there is no risk that we will
+        introduce unintended shadowing by moving an expression into a lower
+        scope. Also, since only move expression into smaller scopes (down into
+        our expression), there is no risk of moving a variable reference out
+        of the scope in which it is defined.
+
         \starttrans
         (letrec binds in E) M
         ------------------------
           add val 3
         \stopbuffer
 
-        \transexample{Application propagation for a let expression}{from}{to}
+        \transexample{appproplet}{Application propagation for a let expression}{from}{to}
 
         \starttrans
         (case x of
           False -> neg 1
         \stopbuffer
 
-        \transexample{Application propagation for a case expression}{from}{to}
+        \transexample{apppropcase}{Application propagation for a case expression}{from}{to}
 
       \subsubsection{Let recursification}
         This transformation makes all non-recursive lets recursive. In the
 
       \subsubsection{Let flattening}
         This transformation puts nested lets in the same scope, by lifting the
-        binding(s) of the inner let into a new let around the outer let. Eventually,
-        this will cause all let bindings to appear in the same scope (they will all be
-        in scope for the function return value).
+        binding(s) of the inner let into the outer let. Eventually, this will
+        cause all let bindings to appear in the same scope.
+
+        This transformation only applies to recursive lets, since all
+        non-recursive lets will be made recursive (see
+        \in{section}[sec:normalization:letrecurse]).
+
+        Since we are joining two scopes together, there is no risk of moving a
+        variable reference out of the scope where it is defined.
 
         \starttrans
         letrec 
+          a0 = E0
           \vdots
-          x = (letrec bindings in M)
+          ai = (letrec bindings in M)
           \vdots
+          an = En
         in
           N
         ------------------------------------------
         letrec
+          a0 = E0
           \vdots
-          bindings
-          x = M
+          ai = M
           \vdots
+          an = En
+          bindings
         in
           N
         \stoptrans
 
         \startbuffer[from]
         letrec
-          a = letrec
-            x = 1
-            y = 2
+          a = 1
+          b = letrec
+            x = a
+            y = c
           in
             x + y
+          c = 2
         in
-          a
+          b
         \stopbuffer
         \startbuffer[to]
         letrec
-          x = 1
-          y = 2
-          a = x + y
+          a = 1
+          b = x + y
+          c = 2
+          x = a
+          y = c
         in
-          a
+          b
         \stopbuffer
 
-        \transexample{Let flattening}{from}{to}
+        \transexample{letflat}{Let flattening}{from}{to}
 
       \subsubsection{Return value simplification}
         This transformation ensures that the return value of a function is always a
 
         Note that the return value is not simplified if its not representable.
         Otherwise, this would cause a direct loop with the inlining of
-        unrepresentable bindings, of course. If the return value is not
+        unrepresentable bindings. If the return value is not
         representable because it has a function type, η-abstraction should
         make sure that this transformation will eventually apply. If the value
         is not representable for other reasons, the function result itself is
-        not representable, meaning this function is not representable anyway!
+        not representable, meaning this function is not translatable anyway.
 
         \starttrans
         x = E                            \lam{E} is representable
         x = λv0 ... λvn.let ... in E
         ~                                \lam{E} is representable
         E                                \lam{E} is not a local variable reference
-        ---------------------------
+        -----------------------------
         letrec x = E in x
         \stoptrans
 
         x = letrec x = add 1 2 in x
         \stopbuffer
 
-        \transexample{Return value simplification}{from}{to}
+        \transexample{retvalsimpl}{Return value simplification}{from}{to}
+        
+        \todo{More examples}
 
     \subsection{Argument simplification}
       The transforms in this section deal with simplifying application
       arguments into normal form. The goal here is to:
 
+      \todo{This section should only talk about representable arguments. Non
+      representable arguments are treated by specialization.}
+
       \startitemize
        \item Make all arguments of user-defined functions (\eg, of which
        we have a function body) simple variable references of a runtime
               reduced to simple variables (for which signals will be
               produced). This is taken care of by the argument extraction
               transform.
-        \item Non-runtime representable typed arguments.
+        \item Non-runtime representable typed arguments. \todo{Move this
+        bullet to specialization}
               
               These arguments cannot be preserved in the program, since we
               cannot represent them as input or output ports in the resulting
               inlining.
       \stopitemize
 
-      \todo{Check the following itemization.}
-
+      \todo{Move this itemization into a new section about builtin functions}
       When looking at the arguments of a builtin function, we can divide them
       into categories: 
 
       \subsubsection{Argument simplification}
         This transform deals with arguments to functions that
         are of a runtime representable type. It ensures that they will all become
-        references to global variables, or local signals in the resulting \small{VHDL}. 
+        references to global variables, or local signals in the resulting
+        \small{VHDL}, which is required due to limitations in the component
+        instantiation code in \VHDL (one can only assign a signal or constant
+        to an input port). By ensuring that all arguments are always simple
+        variable references, we always have a signal available to assign to
+        input ports.
 
-        \todo{It seems we can map an expression to a port, not only a signal.}
-        Perhaps this makes this transformation not needed?
         \todo{Say something about dataconstructors (without arguments, like True
         or False), which are variable references of a runtime representable
         type, but do not result in a signal.}
         expression to a new variable. The original function is then applied to
         this variable.
 
+        Note that a reference to a \emph{global variable} (like a top level
+        function without arguments, but also an argumentless dataconstructors
+        like \lam{True}) is also simplified. Only local variables generate
+        signals in the resulting architecture. 
+
+        \refdef{representable}
         \starttrans
         M N
-        --------------------    \lam{N} is of a representable type
+        --------------------    \lam{N} is representable
         letrec x = N in M x     \lam{N} is not a local variable reference
         \stoptrans
+        \refdef{local variable}
 
         \startbuffer[from]
         add (add a 1) 1
         letrec x = add a 1 in add x 1
         \stopbuffer
 
-        \transexample{Argument extraction}{from}{to}
-
+        \transexample{argextract}{Argument extraction}{from}{to}
+      
       \subsubsection{Function extraction}
-        This transform deals with function-typed arguments to builtin functions.
-        Since these arguments cannot be propagated, we choose to extract them
-        into a new global function instead.
+        \todo{Move to section about builtin functions}
+        This transform deals with function-typed arguments to builtin
+        functions.  Since builtin functions cannot be specialized to remove
+        the arguments, we choose to extract these arguments into a new global
+        function instead. This greatly simplifies the translation rules needed
+        for builtin functions. \todo{Should we talk about these? Reference
+        Christiaan?}
 
         Any free variables occuring in the extracted arguments will become
         parameters to the new global function. The original argument is replaced
         even more complicated expressions).
 
         \starttrans
-        M N                     \lam{M} is a (partial aplication of a) builtin function.
-        ---------------------   \lam{f0 ... fn} = free local variables of \lam{N}
+        M N                     \lam{M} is (a partial aplication of) a builtin function.
+        ---------------------   \lam{f0 ... fn} are all free local variables of \lam{N}
         M (x f0 ... fn)         \lam{N :: a -> b}
         ~                       \lam{N} is not a (partial application of) a top level function
         x = λf0 ... λfn.N
         \stoptrans
 
+        \todo{Split this example}
         \startbuffer[from]
         map (λa . add a b) xs
 
         x1 = λb.add b
         \stopbuffer
 
-        \transexample{Function extraction}{from}{to}
+        \transexample{funextract}{Function extraction}{from}{to}
 
         Note that \lam{x0} and {x1} will still need normalization after this.
 
       \subsubsection{Argument propagation}
-        \fxnote{This section should be generalized and describe
-        specialization, so other transformations can refer to this (since
-        specialization is really used in multiple categories).}
+        \todo{Rename this section to specialization and move it into a
+        separate section}
 
         This transform deals with arguments to user-defined functions that are
         not representable at runtime. This means these arguments cannot be
 
         Special care must be taken when the to-be-propagated expression has any
         free variables. If this is the case, the original argument should not be
-        removed alltogether, but replaced by all the free variables of the
+        removed completely, but replaced by all the free variables of the
         expression. In this way, the original expression can still be evaluated
         inside the new function. Also, this brings us closer to our goal: All
         these free variables will be simple variable references.
         ~
         x Y0 ... Yi ... Yn                               \lam{Yi} is not of a runtime representable type
         ---------------------------------------------    \lam{Yi} is not a local variable reference
-        x' y0 ... yi-1 f0 ...  fm Yi+1 ... Yn            \lam{f0 ... fm} = free local vars of \lam{Yi}
+        x' y0 ... yi-1 f0 ...  fm Yi+1 ... Yn            \lam{f0 ... fm} are all free local vars of \lam{Yi}
         ~
-        x' = λy0 ... yi-1 f0 ... fm yi+1 ... yn .       
+        x' = λy0 ... λyi-1. λf0 ... λfm. λyi+1 ... λyn .       
               E y0 ... yi-1 Yi yi+1 ... yn   
-
         \stoptrans
 
+        \todo{Describe what the formal specification means}
+        \todo{Note that we don't change the sepcialised function body, only
+        wrap it}
+
         \todo{Example}
 
-    \subsection{Case simplification}
+
+    \subsection{Case normalisation}
       \subsubsection{Scrutinee simplification}
         This transform ensures that the scrutinee of a case expression is always
         a simple variable reference.
             False -> b
         \stopbuffer
 
-        \transexample{Let flattening}{from}{to}
+        \transexample{letflat}{Let flattening}{from}{to}
 
 
       \subsubsection{Case simplification}
         makes a choice between expressions based on the constructor of another
         expression, \eg \lam{case x of Low -> a; High -> b}.
         \stopitemize
-
+        
+        \defref{wild binder}
         \starttrans
         case E of
           C0 v0,0 ... v0,m -> E0
           \vdots
           Cn vn,0 ... vn,m -> En
-        --------------------------------------------------- \forall i \forall j, 0 <= i <= n, 0 <= i < m (\lam{wi,j} is a wild (unused) binder)
+        --------------------------------------------------- \forall i \forall j, 0 ≤ i ≤ n, 0 ≤ i < m (\lam{wi,j} is a wild (unused) binder)
         letrec
-          v0,0 = case x of C0 v0,0 .. v0,m -> v0,0
+          v0,0 = case E of C0 v0,0 .. v0,m -> v0,0
           \vdots
-          v0,m = case x of C0 v0,0 .. v0,m -> v0,m
+          v0,m = case E of C0 v0,0 .. v0,m -> v0,m
+          \vdots
+          vn,m = case E of Cn vn,0 .. vn,m -> vn,m
           x0 = E0
-          \dots
-          vn,m = case x of Cn vn,0 .. vn,m -> vn,m
+          \vdots
           xn = En
         in
           case E of
             \vdots
             Cn wn,0 ... wn,m -> xn
         \stoptrans
+        \todo{Check the subscripts of this transformation}
+
+        Note that this transformation applies to case statements with any
+        scrutinee. If the scrutinee is a complex expression, this might result
+        in duplicate hardware. An extra condition to only apply this
+        transformation when the scrutinee is already simple (effectively
+        causing this transformation to be only applied after the scrutinee
+        simplification transformation) might be in order. 
 
         \fxnote{This transformation specified like this is complicated and misses
         conditions to prevent looping with itself. Perhaps it should be split here for
             False -> x1
         \stopbuffer
 
-        \transexample{Selector case simplification}{from}{to}
+        \transexample{selcasesimpl}{Selector case simplification}{from}{to}
 
         \startbuffer[from]
         case a of
             (,) w0 w1 -> x0
         \stopbuffer
 
-        \transexample{Extractor case simplification}{from}{to}
+        \transexample{excasesimpl}{Extractor case simplification}{from}{to}
 
-      \subsubsection{Case removal}
+        \refdef{selector case}
+        In \in{example}[ex:trans:excasesimpl] the case expression is expanded
+        into multiple case expressions, including a pretty useless expression
+        (that is neither a selector or extractor case). This case can be
+        removed by the Case removal transformation in
+        \in{section}[sec:transformation:caseremoval].
+
+      \subsubsection[sec:transformation:caseremoval]{Case removal}
         This transform removes any case statements with a single alternative and
         only wild binders.
 
         \starttrans
         case x of
           C v0 ... vm -> E
-        ----------------------     \lam{\forall i, 0 <= i <= m} (\lam{vi} does not occur free in E)
+        ----------------------     \lam{\forall i, 0 ≤ i ≤ m} (\lam{vi} does not occur free in E)
         E
         \stoptrans
 
         x0
         \stopbuffer
 
-        \transexample{Case removal}{from}{to}
+        \transexample{caserem}{Case removal}{from}{to}
 
+  \todo{Move these two sections somewhere? Perhaps not?}
   \subsection{Removing polymorphism}
     Reference type-specialization (== argument propagation)
 
     Reference higher-order-specialization (== argument propagation)
 
       \subsubsection{Non-representable binding inlining}
-        This transform inlines let bindings that have a non-representable type. Since
-        we can never generate a signal assignment for these bindings (we cannot
-        declare a signal assignment with a non-representable type, for obvious
-        reasons), we have no choice but to inline the binding to remove it.
+        \todo{Move this section into a new section (together with
+        specialization?)}
+        This transform inlines let bindings that are bound to a
+        non-representable value. Since we can never generate a signal
+        assignment for these bindings (we cannot declare a signal assignment
+        with a non-representable type, for obvious reasons), we have no choice
+        but to inline the binding to remove it.
 
         If the binding is non-representable because it is a lambda abstraction, it is
         likely that it will inlined into an application and β-reduction will remove
         literal \hs{SizedInt} in Haskell, like \hs{1 :: SizedInt D8}, this results in
         the following core: \lam{fromInteger (smallInteger 10)}, where for example
         \lam{10 :: GHC.Prim.Int\#} and \lam{smallInteger 10 :: Integer} have
-        non-representable types. \todo{This/these paragraph(s) should probably become a
-        separate discussion somewhere else}
+        non-representable types. \todo{Expand on this. This/these paragraph(s)
+        should probably become a separate discussion somewhere else}
 
+        \todo{Can this duplicate work?}
 
         \starttrans
         letrec 
           M
         --------------------------    \lam{Ei} has a non-representable type.
         letrec
-          a0 = E0 [Ei/ai]
-          \vdots
-          ai-1 = Ei-1 [Ei/ai]
-          ai+1 = Ei+1 [Ei/ai]
+          a0 = E0 [ai=>Ei] \vdots
+          ai-1 = Ei-1 [ai=>Ei]
+          ai+1 = Ei+1 [ai=>Ei]
           \vdots
-          an = En [Ei/ai]
+          an = En [ai=>Ei]
         in
-          M[Ei/ai]
+          M[ai=>Ei]
         \stoptrans
 
         \startbuffer[from]
           (λb -> add b 1) (add 1 x)
         \stopbuffer
 
-        \transexample{None representable binding inlining}{from}{to}
+        \transexample{nonrepinline}{Nonrepresentable binding inlining}{from}{to}
 
 
   \section{Provable properties}
     \startitemize[KR]
     \item[q:termination] Does our system \emph{terminate}? Since our system will
     keep running as long as transformations apply, there is an obvious risk that
-    it will keep running indefinitely. One transformation produces a result that
-    is transformed back to the original by another transformation, for example.
+    it will keep running indefinitely. This typically happens when one
+    transformation produces a result that is transformed back to the original
+    by another transformation, or when one or more transformations keep
+    expanding some expression.
     \item[q:soundness] Is our system \emph{sound}? Since our transformations
     continuously modify the expression, there is an obvious risk that the final
     normal form will not be equivalent to the original program: Its meaning could
         drawObj(a, b, c, d);
       \stopuseMPgraphic
 
-      \placeexample[right][ex:TransformGraph]{Partial graph of a labmda calculus
+      \placeexample[right][ex:TransformGraph]{Partial graph of a lambda calculus
       system with β and η reduction (solid lines) and expansion (dotted lines).}
           \boxedgraphic{TransformGraph}
 
       simple lambda calculus that contains just the expressions \lam{(λx.λy. (+) x
       y) 1}, \lam{λy. (+) 1 y}, \lam{(λx.(+) x) 1} and \lam{(+) 1}. The
       transformation system consists of β-reduction and η-reduction (solid edges) or
-      β-reduction and η-reduction (dotted edges).
+      β-expansion and η-expansion (dotted edges).
 
       \todo{Define β-reduction and η-reduction?}
 
       From such a graph, we can derive some properties easily:
       \startitemize[KR]
         \item A system will \emph{terminate} if there is no path of infinite length
-        in the graph (this includes cycles).
+        in the graph (this includes cycles, but can also happen without cycles).
         \item Soundness is not easily represented in the graph.
         \item A system is \emph{complete} if all of the nodes in the normal set have
         the intended normal form. The inverse (that all of the nodes outside of
         the normal set are \emph{not} in the intended normal form) is not
         strictly required.
-        \item A system is deterministic if all paths from a node, which end in a node
-        in the normal set, end at the same node.
+        \item A system is deterministic if all paths starting at a particular
+        node, which end in a node in the normal set, end at the same node.
       \stopitemize
 
       When looking at the \in{example}[ex:TransformGraph], we see that the system
       terminates for both the reduction and expansion systems (but note that, for
-      expansion, this is only true because we've limited the possible expressions!
-      In comlete lambda calculus, there would be a path from \lam{(λx.λy. (+) x y)
-      1} to \lam{(λx.λy.(λz.(+) z) x y) 1} to \lam{(λx.λy.(λz.(λq.(+) q) z) x y) 1}
-      etc.)
+      expansion, this is only true because we've limited the possible
+      expressions.  In comlete lambda calculus, there would be a path from
+      \lam{(λx.λy. (+) x y) 1} to \lam{(λx.λy.(λz.(+) z) x y) 1} to
+      \lam{(λx.λy.(λz.(λq.(+) q) z) x y) 1} etc.)
 
-      If we would consider the system with both expansion and reduction, there would
-      no longer be termination, since there would be cycles all over the place.
+      If we would consider the system with both expansion and reduction, there
+      would no longer be termination either, since there would be cycles all
+      over the place.
 
       The reduction and expansion systems have a normal set of containing just
       \lam{(+) 1} or \lam{(λx.λy. (+) x y) 1} respectively. Since all paths in
       either system end up in these normal forms, both systems are \emph{complete}.
-      Also, since there is only one normal form, it must obviously be
+      Also, since there is only one node in the normal set, it must obviously be
       \emph{deterministic} as well.
 
+    \todo{Add content to these sections}
     \subsection{Termination}
       Approach: Counting.
 
diff --git a/Outline b/Outline
index c8be93d..8f2d0c3 100644 (file)
--- a/Outline
+++ b/Outline
@@ -54,3 +54,5 @@ TODO: User-defined type classes (future work?)
 TODO: Entity / Architecture / Component vs Function?
 TODO: Expand on "representable"
 TODO: Register
+TODO: Variable vs binder
+TODO: simplification -> Normalisation?