Addressed two comments I had missed.

Author: johanneskloos

doc/architectural/background-concepts.md

@@ -230,7 +230,7 @@ digraph ast {
 }
 \enddot
 
-In the end, we produce a sequence of graphs modeling each declaration
+In the end, we produce a sequence of trees modeling each declaration
 in the translation unit (i.e., the file `factorial.c`).
 
 This data structure is already useful: At this level, we can easily
@@ -371,9 +371,7 @@ here is the code:
   }
   return fac;
 ```
-
-This function
-consists of four basic blocks:
+This function consists of four basic blocks:
 1. `Declaration: unsigned long fac.1, value 1`<br/>
    `Declaration: unsigned i.1, value 1`
 2. `i.1 <= n.1`
@@ -708,7 +706,18 @@ An abstract interpretation is made up from four ingredients:
    in the previous step that describes the behavior of the program.
 
 The first ingredient we need for abstract interpretation is the
-**abstract domain**. An abstract domain is a set $D$ (or, if you
+**abstract domain**.
+The domain allows us to express what we know about a given variable or
+value at a given program location; in our example, whether it is zero or not.
+The way we use the abstract domain is for each program point, we have a
+map from visible variables to elements of the abstract domain,
+describing what we know about the values of the variables at this point.
+
+For instance, consider the `factorial` example again. After running the
+first basic block, we know that `fac` and `i` both contain 1, so we have
+a map that associates both `fac` and `i` to "not 0".
+
+An abstract domain is a set $D$ (or, if you
 prefer, a data type) with the following properties:
 - There is a function merge that takes two elements of $D$ and returns
   an element of $D$. This function is associative (merge(x, merge(y,z))
@@ -717,9 +726,11 @@ prefer, a data type) with the following properties:
 - There is an element bottom of $D$ such that merge(x, bottom) = x.
 
 Algebraically speaking, $D$ needs to be a semi-lattice.
+
 For our example, we use the following domain:
 - D contains the elements "bottom" (nothing is known),
   "equals 0", "not 0" and "could be 0".
+
 - merge is defined as follows:
   merge(bottom, x) = x
   merge("could be 0", x) = "could be 0"
@@ -728,16 +739,6 @@ For our example, we use the following domain:
 - bottom is bottom, obviously.
 It is easy but tedious to check that all conditions hold.
 
-The domain allows us to express what we know about a given variable or
-value at a given program location; in our example, whether it is zero or not.
-The way we use the abstract domain is for each program point, we have a
-map from visible variables to elements of the abstract domain,
-describing what we know about the values of the variables at this point.
-
-For instance, consider the `factorial` example again. After running the
-first basic block, we know that `fac` and `i` both contain 1, so we have
-a map that associates both `fac` and `i` to "not 0".
-
 The second ingredient we need are the **abstract state transformers**.
 An abstract state transformer describes how a specific expression or
 statement processes abstract values. For the example, we need to define