Index: doc/theses/mike_brooks_MMath/background.tex
===================================================================
--- doc/theses/mike_brooks_MMath/background.tex	(revision c3e41cda7b7a639338faa16c005b96ed95202da9)
+++ doc/theses/mike_brooks_MMath/background.tex	(revision 7d95bce9de502e9d5dd74e87ec42790e93cce18e)
@@ -685,29 +685,32 @@
 Here, the distance between the first and second elements of each array depends on the inner dimension size.
 
-The last observation is a fact of the callee's perspective.
-There is little type-system checking, in the caller's perspective, that what is being passed, matches.
-\PAB{I do not understand}
-\begin{cfa}
-void f( float [][10] );
-int n = 100;
-float a[100], b[n];
-f(&a); // reject
-f(&b); // accept
-
+This significance of an inner dimension's length is a fact of the callee's perspective.
+In the caller's perspective, the type sytem is quite lax.
+Here, there is (some, but) little checking that what is being passed, matches.
+% void f( float [][10] );
+% int n = 100;
+% float a[100], b[n];
+% f(&a); // reject
+% f(&b); // accept
+\begin{cfa}
 void foo() {
 	void f( float [][10] );
 	int n = 100;
 	float a[100], b[3][12], c[n], d[n][n];
-	f( a );    // reject
-	f( b );    // reject
-	f( c );    // reject
-	f( d );    // accept
-	f( &a );   // reject
-	f( &b );   // reject
-	f( &c );   // accept
-	f( &d );   // reject
+	f( a );
+	f( b );    $\C{// reject: inner dimension 12 for 10}$
+	f( c );
+	f( @d@ );  $\C{// accept with inner dimension n for 10}$
+	f( &a );   $\C{// reject: inner dimension 100 for 10}$
+	f( &b );
+	f( @&c@ ); $\C{// accept with inner dimension n for 10}$
+	f( &d );
 }
 \end{cfa}
-This size is therefore, a callee's assumption.
+The cases without comments are rejections, but simply because the array ranks do not match; in the commented cases, the ranks match and the rules being discussed apply.
+The cases @f(b)@ and @f(&a)@ show where some length checking occurs.
+But this checking misses the cases @f(d)@ and @f(&c)@, allowing the calls with mismatched lengths, actually 100 for 10.
+The C checking rule avoids false alarms, at the expense of safety, by allowing any combinations that involve dynamic values.
+Ultimately, an inner dimension's size is a callee's \emph{assumption} because the type system uses declaration details in the callee's perspective that it does not enforce in the caller's perspective.
 
 Finally, to handle higher-dimensional VLAs, C repurposed the @*@ \emph{within} the dimension in a declaration to mean that the callee has make an assumption about the size, but no (unchecked, possibly wrong) information about this assumption is included for the caller-programmer's benefit/over-confidence.