<h2>The multiplicative inverse of the additive identity</h2>
<p>
- Generally it is more efficient to perform arithmetic in the first order. Also, it is easier to write Turing Machine control programs if we take Natural Number arithmetic as already available, say, from a subroutine library. Where second order computation becomes useful is in places where a result cannot be computed.
+ Generally it is more efficient to perform arithmetic in the first order. Also, it is easier to write Turing Machine control programs if we take Natural Number arithmetic as already available, say, from a subroutine library. On processors fixed word length arithmetic is built into the hardware. Where second order computation becomes useful is in places where a result cannot be computed in the first order.
</p>
<p>
</RT·code>
<p>
- There is no special help here. Hence, <RT·math>(divide 0 0)</RT·math> remains as an error flag.
+ There is no special help here. Hence, <RT·code>(divide 0 0)</RT·code> remains as an error flag.
</p>
<p>
- The divide machine cannot be run to produce a value, as any value from the field assigned to it would lead to contradictions. For other values, <RT·math>x \cdot y = q</RT·math> operations, when given an <RT·math>x</RT·math> and a <RT·math>q</RT·math> value, there is only one possible <RT·math>y</RT·math> value, and it can be recovered with <RT·math>q/x</RT·math>. However, when <RT·math>x</RT·math> is zero, and only when it is zero, <RT·math>q</RT·math> is solely determined by <RT·math>x</RT·math> independent of <RT·math>y</RT·math>, so <RT·math>y</RT·math> is ignored; it could be any value. There is no way to recover it from <RT·math>q/x</RT·math>.
+ The divide machine cannot be run to produce a value, as any value from the field assigned to it would lead to contradictions. Stated more precisely, for <RT·math>x \cdot y = q</RT·math> operations, when given an <RT·math>x</RT·math> and a <RT·math>q</RT·math> value, there is only one possible <RT·math>y</RT·math> value, and it can be recovered with <RT·math>q/x</RT·math>. However, when <RT·math>x</RT·math> is zero, and only when it is zero, <RT·math>q</RT·math> is solely determined by <RT·math>x</RT·math> independent of <RT·math>y</RT·math>, so <RT·math>y</RT·math> is ignored; it could be any value. There is no way to recover it from <RT·math>q/x</RT·math>.
</p>
<h2>Evaluating and Extending</h2>
</p>
<p>
- In a variation of analytical evaluation, we can instead mount an initial value for a function, and call a machine to repeatedly <RT·term>extend</RT·term> the function. To state this more precisely, when a machine tape is given the initial value of <RT·math>f(t_i)</RT·math> on its input tape, and then when run until it halts, writes the result <RT·math>f(t_{i+1})</RT·math>, then running the machine extends the function. Typically extension machines are designed so they can be used recurrently to generate a sequence of function values, <RT·math>f(t_0), f(t_1), f(t_2), \ldots</RT·math>.
+ In a variation of analytical evaluation, we can instead mount an initial value for a function, and call a machine to repeatedly <RT·term>extend</RT·term> the function. To state this more precisely, when a machine tape is given the initial value of <RT·math>f(t_i)</RT·math> on its input tape, and then when run until it halts having written the result <RT·math>f(t_{i+1})</RT·math> to the tape, we say that running the machine extends the function. Typically extension machines are designed so they can be used recurrently to extend the function indefinitely, thus producing a sequence of function values, <RT·math>f(t_0), f(t_1), f(t_2), \ldots</RT·math>.
</p>
<p>
- The difference between function values in the above sequence is called the first finite difference. The forward first difference is defined as:
+ The difference between adjacent function values in the above sequence is called the first finite difference. The forward first difference is defined as:
<RT·math>\Delta_i = f(t_{i+1}) - f(t_i)</RT·math>.
While the backwards first difference is
<RT·math>\Delta_i = f(t_i) - f(t_{i-1})</RT·math>.
- If 'forward' or 'backwards' is not specified, then the difference is taken to be 'forward'. Hence, extending a function is identical to adding the first difference.
+ If 'forward' or 'backwards' is not specified, then the difference is taken to be 'forward'. Hence, extending a function is identical to adding the first difference. Thus a sequence of function values, implies a sequence of first differences.
</p>
<p>
</table>
<p>
- In order to design for recurrent extensions, the Turing Machine tape must retain the current function value alongside its forward differences. Because the second difference is constant, the tape requires three logical cells of state to compute the next step: <RT·math>[f(t), \Delta^1(t), \Delta^2(t)]</RT·math>. No matter how long the finite difference table becomes, each row will have three entries.
+ In order to design for indefinite extension, the Turing Machine tape must retain the function value alongside with its forward differences. Because the second difference is constant higher order differences are all zero. Hence the tape requires a three component vector to hold the differences.
</p>
<p>
- Here is the sequence of tape states as the machine is repeatedly called to extend the function from its initial conditions at <RT·math>t = 0</RT·math>. During each step, the machine adds <RT·math>\Delta^1</RT·math> to <RT·math>f</RT·math>, and <RT·math>\Delta^2</RT·math> to <RT·math>\Delta^1</RT·math>:
+ Here is the sequence of tape states as the machine is repeatedly called to extend the function from its initial conditions at <RT·math>t = 0</RT·math>. During each step, the machine adds <RT·math>\Delta^1</RT·math> to <RT·math>f</RT·math>, and <RT·math>\Delta^2</RT·math> to <RT·math>\Delta^1</RT·math>, as there is no <RT·math>\Delta^3</RT·math>, it is taken to be zero, so <RT·math>\Delta^2</RT·math> is merely copied down.
</p>
<RT·code>
</RT·code>
<p>
- For Call 1, the input tape is the Initial Tape. In Call 1 the machine will take the function value on the input tape, 0, and add the first difference, writing the function value to the result tape. The machine will then continue on and take the first difference on the input tape, 1, and add the second difference on the input tape, 2, writing the first difference for the result tape, 3. Continuing on, the machine will not find a third difference on the input tape, so it will copy the second difference found on the input tape as the second difference for the result tape.
+ For Call 1, the input tape is the Initial Tape. In Call 1 the machine will take the function value on the input tape, 0, and add the first difference, 1, writing the result 1, to the result tape. The machine will then continue on and take the first difference on the input tape, 1, and add the second difference on the input tape, 2, writing the result first difference to the result tape, 3. Then finishing up, the machine will not find a third difference on the input tape, so it will copy the second difference found on the input tape as the second difference for the result tape.
</p>
<p>
- For Call 2, the input tape is the result tape from Call 1. Execution then proceeds identically to Call 1. This pattern repeats for all successive calls. A person can see the values of <RT·math>t^2</RT·math> as the first number on each result tape.
+ For Call 2, the input tape is the result tape from Call 1. Execution then proceeds identically to Call 1. This pattern repeats for all successive calls. A person can see the values of <RT·math>t^2</RT·math> as the first number on each result tape. Any polynomial can be computed in this manner, and the only ALU required is an adder that is also capable of subtraction.
</p>
<h3>Lemma: Only row 0 is needed</h3>
<p>
- The extension function can be called any number of times when the initial tape is identical to row 0 of the finite difference table. No other row is needed from the table.
+ The extension function can be called any number of times when the initial tape is identical to row 0 of the table of finite differences. No other row is needed from the table of finite differences.
</p>
<p>
- This follows from the fact that the extension function is performing the exact operations that were performed when we generated the difference table. The extension function is merely formalizing the rules used for generating the table. As a consequence, the result tape after the <em>N</em>th call is identical to row <em>N</em> of the table.
+ This follows from the mechanical procedure given above for computing the next row of the table from any given row.
</p>
+ <h3>Lemma: Evaluating call <RT·math>\omega</RT·math> requires an initial tape populated with components 0 through <RT·math>\omega</RT·math> of row 0</h3>
-<h3>Lemma: Evaluating call <RT·math>\omega</RT·math> requires an initial tape populated with components 0 through <RT·math>\omega</RT·math> of row 0</h3>
+ <p>
+ Let the <RT·term>extent</RT·term> refer to the maximum index for accessing a component of a vector; the extent is often denoted as <RT·math>\omega</RT·math>. Performing extensions to calculate the function value at call <RT·math>\omega</RT·math> makes use of the initial tape up to index <RT·math>\omega</RT·math>, or as many nonzero values as are available up to that extent.
+ </p>
<p>
- Let the <RT·term>extent</RT·term> refer to the maximum index for accessing a component of a vector; the extent is often denoted as <RT·math>\omega</RT·math>. Performing extensions to calculate the function value at call <RT·math>\omega</RT·math> will make use of the initial tape up to index <RT·math>\omega</RT·math>, or as many nonzero values as are available up to that extent.
+ To make this precise, let us define the <RT·term>difference vector</RT·term> at call <RT·math>k</RT·math> as <RT·math>D_k</RT·math>. The components of this vector are <RT·math>D_{k, 0}, D_{k, 1}, \ldots</RT·math> up to the maximum available difference. The first component, <RT·math>D_{k, 0}</RT·math>, is the function value itself. The component <RT·math>D_{k, 1}</RT·math> is the first difference, and so on.
</p>
<p>
- To make this precise, let us define the <RT·term>difference vector</RT·term> at call <RT·math>k</RT·math> as <RT·math>D_k</RT·math>. The components of this vector are <RT·math>D_{k, 0}, D_{k, 1}, \ldots, D_{k, m}</RT·math>, where <RT·math>m</RT·math> is the maximum available difference. The first component, <RT·math>D_{k, 0}</RT·math>, is the function value itself. The component <RT·math>D_{k, 1}</RT·math> is the first difference, and so on.
+ Thus, this lemma claims that to compute <RT·math>D_{\omega, 0}</RT·math>, the highest component index accessed from the initial tape vector <RT·math>D_{0, i}</RT·math> will be <RT·math>i = \omega</RT·math>.
</p>
-
+
<p>
- The extension operation follows a simple recurrence relation for any component <RT·math>j</RT·math>: <RT·math>D_{k+1, j} = D_{k, j} + D_{k, j+1}</RT·math>.
+ Note that to compute the <RT·math>D_{k, 0}</RT·math> result by the mechanical procedure given above requires adding the input tape first difference to the prior difference. That is, <RT·math>D_{k, 0} = D_{k-1, 0} + D_{k-1, 1}</RT·math>. Hence we see immediately the lemma holds for the first call where <RT·math>k = \omega = 1</RT·math>.
</p>
<p>
- We can now prove by induction on the call index <RT·math>k</RT·math> that computing <RT·math>D_{k, 0}</RT·math> requires exactly the components <RT·math>D_{0, 0}</RT·math> through <RT·math>D_{0, k}</RT·math> from the initial tape <RT·math>D_0</RT·math>.
+ For an arbitrary <RT·math>k</RT·math> value we discovered that the highest index required of the <RT·math>D_{k-1, i}</RT·math> vector is <RT·math>i=1</RT·math>.
+ The value <RT·math>D_{k-1, 1}</RT·math> is computed from our mechanical procedure as
+ <RT·math>D_{k-1, 1} = D_{k-2, 1} + D_{k-2, 2}</RT·math>. Given we already know that to compute the value merely requires the prior value and first difference, we find that the largest index needed from vector <RT·math>D_{k-2, i}</RT·math> is 2.
</p>
<p>
- <strong>Base Case (k=0):</strong> To generate the value at call 0, <RT·math>D_{0, 0}</RT·math>, the machine performs zero extensions. It accesses only the value at index 0 of the initial tape. The required extent is 0.
+ There is a strict linear progression here. The computation of any component <RT·math>D_{k, i}</RT·math> inherently requires <RT·math>D_{k-1, i}</RT·math> and <RT·math>D_{k-1, i+1}</RT·math>. Therefore, each step backwards in time <RT·math>k</RT·math> expands the required index <RT·math>i</RT·math> by exactly one. By induction, computing the base value <RT·math>D_{\omega, 0}</RT·math> at call <RT·math>\omega</RT·math> requires tracing back <RT·math>\omega</RT·math> steps to the initial tape at <RT·math>k=0</RT·math>, which forces the maximum accessed index to be <RT·math>0 + \omega = \omega</RT·math>. Thus, the highest required component from the initial tape is <RT·math>D_{0, \omega}</RT·math>.
</p>
<p>
- <strong>Inductive Hypothesis:</strong> Assume that generating the value at call <RT·math>k</RT·math>, which is <RT·math>D_{k, 0}</RT·math>, requires the initial tape components <RT·math>D_{0, 0}</RT·math> through <RT·math>D_{0, k}</RT·math>.
+ The exact algebraic composition of this mechanical expansion is formalized by Newton's calculus of finite differences <RT·endnote>Isaac Newton formalized this interpolation method in 1675, later published in his <em>Methodus Differentialis</em> (1711). For a comprehensive foundational treatment, see George Boole, <em>A Treatise on the Calculus of Finite Differences</em> (Cambridge: Macmillan and Co., 1860), Chapter II.</RT·endnote>. Instead of executing the machine incrementally, a person can calculate the function value at call <RT·math>\omega</RT·math> directly as a linear combination of the initial tape components using Newton's forward difference formula:
</p>
<p>
- <strong>Inductive Step:</strong> Consider the requirement for the value at call <RT·math>k+1</RT·math>, which is <RT·math>D_{k+1, 0}</RT·math>. By the extension rule, <RT·math>D_{k+1, 0} = D_{k, 0} + D_{k, 1}</RT·math>.
+ <RT·math>D_{\omega, 0} = \sum_{j=0}^{\omega} \binom{\omega}{j} D_{0, j}</RT·math>
</p>
- <ul>
- <li>By the inductive hypothesis, computing <RT·math>D_{k, 0}</RT·math> depends on the initial tape components <RT·math>D_{0, 0}</RT·math> through <RT·math>D_{0, k}</RT·math>.</li>
- <li>The term <RT·math>D_{k, 1}</RT·math> represents the result of applying <RT·math>k</RT·math> extensions starting from the initial first difference, <RT·math>D_{0, 1}</RT·math>. Applying the exact same inductive reasoning to this shifted starting position, computing <RT·math>D_{k, 1}</RT·math> requires <RT·math>k+1</RT·math> components starting from index 1. Therefore, it depends on the components <RT·math>D_{0, 1}</RT·math> through <RT·math>D_{0, k+1}</RT·math> of the initial tape.</li>
- </ul>
+
+ <p>
+ Because the binomial coefficient <RT·math>\binom{\omega}{j}</RT·math> evaluates to exactly zero for any integer <RT·math>j > \omega</RT·math>, the summation naturally truncates at index <RT·math>\omega</RT·math>. This algebraic property perfectly mirrors the physical boundary established by the machine execution trace. Furthermore, the relationship is symmetric. A person can compute the specific components of the initial tape, <RT·math>D_{0, n}</RT·math>, directly from the sequence of evaluated function calls, <RT·math>D_{k, 0}</RT·math>, using the alternating binomial sum:
+ </p>
+
<p>
- The union of the dependencies for <RT·math>D_{k, 0}</RT·math> and <RT·math>D_{k, 1}</RT·math> spans from index 0 to index <RT·math>k+1</RT·math>. Thus, generating the value at call <RT·math>k+1</RT·math> requires the initial tape to have an extent of exactly <RT·math>k+1</RT·math>. The lemma holds.
+ <RT·math>D_{0, n} = \sum_{k=0}^{n} (-1)^{n-k} \binom{n}{k} D_{k, 0}</RT·math>
</p>
<p>
- This proof applies regardless of whether the finite difference table is infinitely deep or truncated. If a person evaluates a tenth degree polynomial but only programs the machine to perform two calls, the initial tape only needs an extent of 2, utilizing components 0, 1, and 2. Each extension consumes one cell of state. If a programmer intends to execute the extension function to reach call <RT·math>\omega</RT·math>, the initial tape must have an extent of <RT·math>\omega</RT·math>, meaning it holds <RT·math>\omega + 1</RT·math> values.
+ As a consequence of this lemma, we know that for any finite number of calls, i.e. finite <RT·math>\omega</RT·math>, that a finite prefix of <RT·math>D_0</RT·math> is used.
</p>
- <h3>Lemma: A polynomial function of degree <RT·math>\omega</RT·math> generates a difference vector in row 0 with an extent of <RT·math>\omega</RT·math></h3>
+ <h3>Lemma: A polynomial function of degree <RT·math>\omega</RT·math> will have a <RT·math>D_0</RT·math> vector of extent <RT·math>\omega</RT·math></h3>
<p>
A polynomial of degree <RT·math>\omega</RT·math> is defined by a highest order term <RT·math>a_\omega t^\omega</RT·math>. The first forward difference operator, <RT·math>\Delta f(t) = f(t+1) - f(t)</RT·math>, inherently cancels the <RT·math>t^\omega</RT·math> term. The binomial expansion of <RT·math>(t+1)^\omega</RT·math> yields <RT·math>t^\omega</RT·math> as its leading term, which subtracts out, leaving a new polynomial of exactly degree <RT·math>\omega - 1</RT·math>.
Taking successive finite differences reduces the degree of the polynomial by exactly one at each step. Consequently, the <RT·math>\omega</RT·math>th difference evaluates to a constant, and the next difference evaluates to exactly zero.
</p>
+
+
+ <h3>Lemma: A <RT·math>D_0</RT·math> vector of finite extent <RT·math>\omega</RT·math> generates a polynomial function of degree <RT·math>\omega</RT·math></h3>
+
<p>
- Because component 0 of the initial difference vector, <RT·math>D_{0, 0}</RT·math>, holds the function value itself, and the differences occupy components 1 through <RT·math>\omega</RT·math>, the initial vector <RT·math>D_0</RT·math> requires a component count of <RT·math>\text{sampi}</RT·math>, where <RT·math>\text{sampi} = \omega + 1</RT·math>. This defines a vector with a maximum index, or extent, of <RT·math>\omega</RT·math>.
+ If an initial difference vector <RT·math>D_0</RT·math> has an extent of <RT·math>\omega</RT·math>, the sequence of function values generated by the machine corresponds to a polynomial of exactly degree <RT·math>\omega</RT·math>. A person can demonstrate this by algebraically recovering the polynomial constants, <RT·math>a_i</RT·math>, directly from the initial tape components, <RT·math>D_{0, i}</RT·math>.
</p>
- <h3>Lemma: A difference vector in row 0 with an extent of <RT·math>\omega</RT·math> uniquely constructs a polynomial of degree <RT·math>\omega</RT·math></h3>
+ <p>
+ Consider an extent of <RT·math>\omega = 0</RT·math>, forming a polynomial of degree 0, <RT·math>f(t) = a_0</RT·math>. Evaluating at <RT·math>t = 0</RT·math> yields <RT·math>f(0) = a_0</RT·math>. Because the machine's initial value is <RT·math>D_{0,0}</RT·math>, a person establishes <RT·math>a_0 = D_{0,0}</RT·math>.
+ </p>
<p>
- If an initial difference vector <RT·math>D_0</RT·math> has an extent of <RT·math>\omega</RT·math> (meaning the component <RT·math>D_{0, \omega}</RT·math> is constant and all higher differences are zero), the sequence of function values can be generated by a polynomial of degree <RT·math>\omega</RT·math>.
+ When a person extends the extent to <RT·math>\omega = 1</RT·math>, the next term is added to form <RT·math>f(t) = a_0 + a_1 t</RT·math>. The first forward difference at <RT·math>t = 0</RT·math> is <RT·math>D_{0,1} = f(1) - f(0) = (a_0 + a_1) - a_0 = a_1</RT·math>. Therefore, <RT·math>a_1 = D_{0,1}</RT·math>. Note that the addition of the linear term did not change the evaluation at <RT·math>t = 0</RT·math>; the <RT·math>a_0</RT·math> constant remains firmly anchored to <RT·math>D_{0,0}</RT·math>.
</p>
<p>
- This is proven by constructing the function directly from the initial tape utilizing Newton's forward difference formula. The function value at any discrete step <RT·math>t</RT·math> is given by a linear combination of the initial difference components multiplied by binomial coefficients:
+ Extending to <RT·math>\omega = 2</RT·math>, the polynomial becomes <RT·math>f(t) = a_0 + a_1 t + a_2 t^2</RT·math>. The second difference at <RT·math>t = 0</RT·math> is calculated as <RT·math>D_{0,2} = f(2) - 2f(1) + f(0)</RT·math>. Substituting the polynomial yields <RT·math>D_{0,2} = (a_0 + 2a_1 + 4a_2) - 2(a_0 + a_1 + a_2) + a_0 = 2a_2</RT·math>. Thus, a person recovers <RT·math>a_2 = D_{0,2} / 2</RT·math>. The lower coefficient then adjusts to <RT·math>a_1 = D_{0,1} - a_2</RT·math>.
</p>
<p>
- <RT·math>f(t) = \sum_{j=0}^{\omega} D_{0, j} \binom{t}{j}</RT·math>
+ Continuing to <RT·math>\omega = 3</RT·math>, the polynomial is <RT·math>f(t) = a_0 + a_1 t + a_2 t^2 + a_3 t^3</RT·math>. Evaluating the third difference <RT·math>D_{0,3}</RT·math> isolates the highest order term, yielding <RT·math>D_{0,3} = 6a_3</RT·math>. This allows immediate recovery of the highest constant: <RT·math>a_3 = D_{0,3} / 6</RT·math>.
</p>
<p>
- To determine the degree of this constructed function, a person must evaluate the binomial coefficient, <RT·math>\binom{t}{j}</RT·math>. It expands into a polynomial in <RT·math>t</RT·math>:
+ Once <RT·math>a_3</RT·math> is known, the shifting nature of the lower order constants becomes apparent through back substitution. The second difference equation expands to <RT·math>D_{0,2} = 2a_2 + 6a_3</RT·math>. Substituting the known <RT·math>a_3</RT·math> allows recovery of <RT·math>a_2 = (D_{0,2} - 6a_3) / 2</RT·math>. Similarly, the first difference equation expands to <RT·math>D_{0,1} = a_1 + a_2 + a_3</RT·math>, which resolves to <RT·math>a_1 = D_{0,1} - a_2 - a_3</RT·math>. Through all of this shifting, <RT·math>a_0 = D_{0,0}</RT·math> remains entirely unperturbed.
</p>
<p>
- <RT·math>\binom{t}{j} = \frac{t(t - 1)(t - 2) \cdots (t - j + 1)}{j!}</RT·math>
+ To observe the formal mechanics of this progression, a person can array these relationships into a matrix equation mapping the polynomial constants, <RT·math>a_i</RT·math>, to the initial tape differences, <RT·math>D_{0,n}</RT·math>. The coefficients of this transformation are defined by the Stirling numbers of the second kind, denoted <RT·math>S(i,n)</RT·math>:
</p>
+ <RT·math>
+ \begin{bmatrix} D_{0,0} \\ D_{0,1} \\ D_{0,2} \\ \vdots \\ D_{0,\omega} \end{bmatrix} =
+ \begin{bmatrix}
+ 0! S(0,0) & 0! S(1,0) & 0! S(2,0) & \cdots & 0! S(\omega,0) \\
+ 0 & 1! S(1,1) & 1! S(2,1) & \cdots & 1! S(\omega,1) \\
+ 0 & 0 & 2! S(2,2) & \cdots & 2! S(\omega,2) \\
+ \vdots & \vdots & \vdots & \ddots & \vdots \\
+ 0 & 0 & 0 & \cdots & \omega! S(\omega,\omega)
+ \end{bmatrix}
+ \begin{bmatrix} a_0 \\ a_1 \\ a_2 \\ \vdots \\ a_\omega \end{bmatrix}
+ </RT·math>
+
<p>
- Because the numerator contains <RT·math>j</RT·math> factors of <RT·math>t</RT·math>, the term <RT·math>\binom{t}{j}</RT·math> is a polynomial of exactly degree <RT·math>j</RT·math>.
+ Because each successive forward difference operator annihilates the lowest power of <RT·math>t</RT·math>, the resulting matrix is strictly upper triangular. For any extent <RT·math>\omega</RT·math>, the final row simplifies to <RT·math>D_{0,\omega} = \omega! a_\omega</RT·math>. Because an initial tape of extent <RT·math>\omega</RT·math> strictly dictates that <RT·math>D_{0,\omega}</RT·math> is nonzero, <RT·math>a_\omega</RT·math> is guaranteed to be nonzero.
</p>
<p>
- The initial tape components, <RT·math>D_{0, j}</RT·math>, are static scalar constants. Therefore, the summation <RT·math>f(t)</RT·math> consists of adding together polynomials of increasing degrees from <RT·math>0</RT·math> up to <RT·math>\omega</RT·math>. Because the extent is <RT·math>\omega</RT·math>, the scalar <RT·math>D_{0, \omega}</RT·math> is nonzero, ensuring that the highest degree term in the summation does not vanish. Thus, the constructed function <RT·math>f(t)</RT·math> is strictly a polynomial of degree <RT·math>\omega</RT·math>.
+ The main diagonal contains strictly non-zero factorials, ensuring the matrix is invertible. By inverting this matrix, a person replaces the cascading back substitution with a direct, closed-form equation to recover any constant <RT·math>a_i</RT·math>. The inversion utilizes the signed Stirling numbers of the first kind, denoted <RT·math>s(n,i)</RT·math> (see the Appendix on Stirling numbers).
</p>
+ <p>
+ <RT·math>a_i = \sum_{n=i}^{\omega} \frac{s(n,i)}{n!} D_{0,n}</RT·math>
+ </p>
+ <p>
+ Thus, extending this procedure <RT·math>\omega</RT·math> times definitively recovers the constants for exactly a polynomial of degree <RT·math>\omega</RT·math>.
+ </p>
+ <p>
+ This mechanical recovery of standard polynomial constants is completely analogous to Newton's interpolation formula <RT·endnote>Ibid.</RT·endnote>. Instead of resolving the standard constants <RT·math>a_i</RT·math> through an upper triangular matrix, a person can construct the polynomial directly by treating the initial tape components as the exact coefficients for a basis of binomial terms:
+ </p>
+
+ <p>
+ <RT·math>f(t) = \sum_{n=0}^{\omega} D_{0, n} \binom{t}{n}</RT·math>
+ </p>
+
+ <p>
+ Because the <RT·math>n</RT·math>th binomial coefficient expands into a polynomial of exactly degree <RT·math>n</RT·math>, and the summation is bounded by the finite extent <RT·math>\omega</RT·math> where <RT·math>D_{0, \omega}</RT·math> is definitively nonzero, the constructed function <RT·math>f(t)</RT·math> is guaranteed to be a polynomial of degree <RT·math>\omega</RT·math>.
+ </p>
+
+ <h3>Lemma: A <RT·math>D_0</RT·math> vector of finite extent <RT·math>\omega</RT·math> generates a polynomial function of degree <RT·math>\omega</RT·math></h3>
+
+ <p>
+ If an initial difference vector <RT·math>D_0</RT·math> has an extent of <RT·math>\omega</RT·math>, the sequence of function values generated by the machine corresponds to a polynomial of exactly degree <RT·math>\omega</RT·math>. A person can demonstrate this by algebraically recovering the polynomial constants, <RT·math>a_i</RT·math>, directly from the initial tape components, <RT·math>D_{0, i}</RT·math>.
+ </p>
+ <p>
+ Consider an extent of <RT·math>\omega = 0</RT·math>, forming a polynomial of degree 0, <RT·math>f(t) = a_0</RT·math>. Evaluating at <RT·math>t = 0</RT·math> yields <RT·math>f(0) = a_0</RT·math>. Because the machine's initial value is <RT·math>D_{0,0}</RT·math>, a person establishes <RT·math>a_0 = D_{0,0}</RT·math>.
+ </p>
+
+ <p>
+ When a person extends the extent to <RT·math>\omega = 1</RT·math>, the next term is added to form <RT·math>f(t) = a_0 + a_1 t</RT·math>. The first forward difference at <RT·math>t = 0</RT·math> is <RT·math>D_{0,1} = f(1) - f(0) = (a_0 + a_1) - a_0 = a_1</RT·math>. Therefore, <RT·math>a_1 = D_{0,1}</RT·math>. Note that the addition of the linear term did not change the evaluation at <RT·math>t = 0</RT·math>; the <RT·math>a_0</RT·math> constant remains firmly anchored to <RT·math>D_{0,0}</RT·math>.
+ </p>
+
+ <p>
+ Extending to <RT·math>\omega = 2</RT·math>, the polynomial becomes <RT·math>f(t) = a_0 + a_1 t + a_2 t^2</RT·math>. The second difference at <RT·math>t = 0</RT·math> is calculated as <RT·math>D_{0,2} = f(2) - 2f(1) + f(0)</RT·math>. Substituting the polynomial yields <RT·math>D_{0,2} = (a_0 + 2a_1 + 4a_2) - 2(a_0 + a_1 + a_2) + a_0 = 2a_2</RT·math>. Thus, a person recovers <RT·math>a_2 = D_{0,2} / 2</RT·math>. The lower coefficient then adjusts to <RT·math>a_1 = D_{0,1} - a_2</RT·math>.
+ </p>
+
+ <p>
+ Continuing to <RT·math>\omega = 3</RT·math>, the polynomial is <RT·math>f(t) = a_0 + a_1 t + a_2 t^2 + a_3 t^3</RT·math>. Evaluating the third difference <RT·math>D_{0,3}</RT·math> isolates the highest order term, yielding <RT·math>D_{0,3} = 6a_3</RT·math>. This allows immediate recovery of the highest constant: <RT·math>a_3 = D_{0,3} / 6</RT·math>.
+ </p>
+
+ <p>
+ Once <RT·math>a_3</RT·math> is known, the shifting nature of the lower order constants becomes apparent through back substitution. The second difference equation expands to <RT·math>D_{0,2} = 2a_2 + 6a_3</RT·math>. Substituting the known <RT·math>a_3</RT·math> allows recovery of <RT·math>a_2 = (D_{0,2} - 6a_3) / 2</RT·math>. Similarly, the first difference equation expands to <RT·math>D_{0,1} = a_1 + a_2 + a_3</RT·math>, which resolves to <RT·math>a_1 = D_{0,1} - a_2 - a_3</RT·math>. Through all of this shifting, <RT·math>a_0 = D_{0,0}</RT·math> remains entirely unperturbed.
+ </p>
+
+ <p>
+ To observe the structural integrity of this progression, a person can array these relationships into a system of equations mapping the initial tape to the polynomial constants:
+ </p>
+
+ <table>
+ <thead>
+ <tr>
+ <th>Difference</th>
+ <th>Equation</th>
+ </tr>
+ </thead>
+ <tbody>
+ <tr>
+ <td><RT·math>D_{0,0}</RT·math></td>
+ <td><RT·math>= a_0</RT·math></td>
+ </tr>
+ <tr>
+ <td><RT·math>D_{0,1}</RT·math></td>
+ <td><RT·math>= a_1 + a_2 + a_3 + \ldots + a_\omega</RT·math></td>
+ </tr>
+ <tr>
+ <td><RT·math>D_{0,2}</RT·math></td>
+ <td><RT·math>= 2a_2 + 6a_3 + \ldots</RT·math></td>
+ </tr>
+ <tr>
+ <td><RT·math>D_{0,3}</RT·math></td>
+ <td><RT·math>= 6a_3 + \ldots</RT·math></td>
+ </tr>
+ <tr>
+ <td><RT·math>\ldots</RT·math></td>
+ <td><RT·math>\ldots</RT·math></td>
+ </tr>
+ <tr>
+ <td><RT·math>D_{0,\omega}</RT·math></td>
+ <td><RT·math>= \omega! a_\omega</RT·math></td>
+ </tr>
+ </tbody>
+ </table>
+
+ <p>
+ A definitive pattern emerges. Because each successive forward difference operator annihilates the lowest power of <RT·math>t</RT·math>, the resulting algebraic system is strictly upper triangular. For any extent <RT·math>\omega</RT·math>, the <RT·math>\omega</RT·math>th difference equation reduces to <RT·math>D_{0,\omega} = \omega! a_\omega</RT·math>. This structural guarantee permits a person to reliably recover <RT·math>a_\omega = D_{0,\omega} / \omega!</RT·math>. Because an initial tape of extent <RT·math>\omega</RT·math> strictly dictates that <RT·math>D_{0,\omega}</RT·math> is nonzero, <RT·math>a_\omega</RT·math> is guaranteed to be nonzero. All subsequent lower order constants are then systematically resolved through cascading back substitution. Thus, extending this procedure <RT·math>\omega</RT·math> times definitively recovers the constants for exactly a polynomial of degree <RT·math>\omega</RT·math>.
+ </p>
+
+ <p>
+ This mechanical recovery of standard polynomial constants is completely analogous to Newton's interpolation formula <RT·endnote>Ibid.</RT·endnote>. Instead of resolving the standard constants <RT·math>a_i</RT·math> through an upper triangular matrix, a person can construct the polynomial directly by treating the initial tape components as the exact coefficients for a basis of binomial terms:
+ </p>
+
+ <p>
+ <RT·math>f(t) = \sum_{n=0}^{\omega} D_{0, n} \binom{t}{n}</RT·math>
+ </p>
+
+ <p>
+ Because the <RT·math>n</RT·math>th binomial coefficient expands into a polynomial of exactly degree <RT·math>n</RT·math>, and the summation is bounded by the finite extent <RT·math>\omega</RT·math> where <RT·math>D_{0, \omega}</RT·math> is definitively nonzero, the constructed function <RT·math>f(t)</RT·math> is structurally guaranteed to be a polynomial of degree <RT·math>\omega</RT·math>.
+ </p>
<h2>Difference table for an exponential function</h2>
<p>
- Here is the finite difference table for the function <RT·math>2^t</RT·math>.
+ Here is the table of finite differences for the function <RT·math>2^t</RT·math>.
</p>
<table>
<tr>
<th>Count (<RT·math>t</RT·math>)</th>
<th><RT·math>f(t) = 2^t</RT·math></th>
- <th>1st Diff (<RT·math>Δ^1</RT·math>)</th>
- <th>2nd Diff (<RT·math>Δ^2</RT·math>)</th>
- <th>3rd Diff (<RT·math>Δ^3</RT·math>)</th>
+ <th>1st Diff (<RT·math>\Delta^1</RT·math>)</th>
+ <th>2nd Diff (<RT·math>\Delta^2</RT·math>)</th>
+ <th>3rd Diff (<RT·math>\Delta^3</RT·math>)</th>
</tr>
</thead>
<tbody>
</table>
<p>
- The first difference of <RT·math>2^t</RT·math> is also <RT·math>2^t</RT·math>, so the first row of the table will have an infinite number of values. Fortunately, due to the "Lemma, for the first N values, the first row need only have N + 1 columns" only N+1 of these values are needed for the Nth call of the recurrence function. Furthermore, when new values are needed, they are easily computed. We need not store the first row of the difference table on the tape.
+ The first difference of <RT·math>2^t</RT·math> is also <RT·math>2^t</RT·math>, so row 0 of the table will have an infinite number of values. Fortunately, due to the lemma stating that evaluating call <RT·math>\omega</RT·math> requires an initial tape populated with components 0 through <RT·math>\omega</RT·math> of row 0, exactly those components are needed for the recurrence to proceed. Furthermore, when new values are needed, they are easily computed. A programmer need not store the entire infinite first row of the difference table on a static tape.
+ </p>
+
+ <p>
+ Instead of attempting to write an infinite sequence to a physical tape, a person can encapsulate the generation logic within a dedicated Turing Machine. In the tradition of constructive arithmetic associated with Boehm, this generator machine acts as a virtual tape. When the primary extension machine requires the next difference component, it queries the generator machine, which computes and yields the value on demand. This lazy evaluation strategy elegantly handles functions with infinite difference sequences without exhausting finite memory.
</p>
<h2>Composition of recurrence functions</h2>
<p>Performing operations on with recurrence functions requires integrating a call algebra in addition to integrating the machines. Often this is handled by consider the machines being composed to be subroutines, and the outer controller than explicitly calls them. The call algebra can then be dynamic depending on the input. Calls can be skipped due to being inside conditionals, or performed an arbitrary number of times in loops. Though simple control structures that are static are more math like, and are more likely to be more effected by optimizations (simplifications).</p>
+
+ <h3>Multiplication of synchronized difference vectors</h3>
+
+ <p>
+ Because the forward difference operator is linear, adding or subtracting two polynomials is achieved by the elementwise addition or subtraction of their initial difference vectors. Multiplication, however, requires a discrete convolution of the two vectors.
+ </p>
+
+ <p>
+ Suppose a programmer has two initial difference vectors, <RT·math>A_0</RT·math> representing function <RT·math>f(t)</RT·math> with an extent of <RT·math>\omega_a</RT·math>, and <RT·math>B_0</RT·math> representing function <RT·math>g(t)</RT·math> with an extent of <RT·math>\omega_b</RT·math>. The goal is to compute the initial difference vector <RT·math>C_0</RT·math> for the product function <RT·math>h(t) = f(t)g(t)</RT·math>.
+ </p>
+
+ <p>
+ Multiplying two polynomials of degrees <RT·math>\omega_a</RT·math> and <RT·math>\omega_b</RT·math> yields a polynomial of degree <RT·math>\omega_a + \omega_b</RT·math>. Therefore, the resulting vector <RT·math>C_0</RT·math> will strictly have an extent of <RT·math>\omega_c = \omega_a + \omega_b</RT·math>, requiring a tape component count of <RT·math>\omega_a + \omega_b + 1</RT·math>.
+ </p>
+
+ <p>
+ To determine the components of <RT·math>C_0</RT·math> directly from <RT·math>A_0</RT·math> and <RT·math>B_0</RT·math> without evaluating the functions, we rely on the multiplication of their basis elements. In the calculus of finite differences, polynomials are expanded using binomial coefficients. The product of two binomial coefficients expands into a linear combination of higher binomial coefficients according to a known combinatorial identity:
+ </p>
+
+ <p>
+ <RT·math>\binom{t}{i} \binom{t}{j} = \sum_{k=\max(i,j)}^{i+j} \binom{k}{i} \binom{i}{k-j} \binom{t}{k}</RT·math>
+ </p>
+
+ <p>
+ By applying this identity across the summations of both input functions, the component <RT·math>k</RT·math> of the resulting vector <RT·math>C_0</RT·math> can be computed algebraically. Each component <RT·math>C_{0, k}</RT·math> is the sum of the cross products of the input components, weighted by combinations of their indices:
+ </p>
+
+ <p>
+ <RT·math>C_{0, k} = \sum_{i=0}^{\omega_a} \sum_{j=0}^{\omega_b} A_{0, i} B_{0, j} \binom{k}{i} \binom{i}{k-j}</RT·math>
+ </p>
+
+ <p>
+ Thus, while a Turing Machine extending the function only requires a simple accumulator, a machine tasked with multiplying two initial tapes must perform a combinatorial cross multiplication to generate the expanded tape before the extension sequence can begin.
+ </p>
+
+ <h2>Division and the Reciprocal Difference Vector</h2>
+
+ <p>
+ If the multiplication of two polynomials in the finite difference domain is a discrete convolution, then division is a discrete deconvolution. By finding the reciprocal of a difference vector, a programmer can perform division using the same combinatorial architecture.
+ </p>
+
+ <p>
+ Let <RT·math>A_0</RT·math> be the initial difference vector for a polynomial <RT·math>f(t)</RT·math>. We seek the reciprocal difference vector <RT·math>C_0</RT·math>, which represents the function <RT·math>h(t) = 1/f(t)</RT·math>. Because the reciprocal of a polynomial is a rational function, its forward differences will never reduce to zero. Thus, <RT·math>C_0</RT·math> is an infinite vector.
+ </p>
+
+ <p>
+ Following the lazy evaluation strategy, <RT·math>C_0</RT·math> is not written to a static tape. It is implemented as a generator machine. The main evaluator queries this generator for its values up to the required extent <RT·math>\omega</RT·math> only as they are demanded.
+ </p>
+
+ <p>
+ By definition, <RT·math>f(t)h(t) = 1</RT·math>. In the difference domain, this means the convolution of <RT·math>A_0</RT·math> and <RT·math>C_0</RT·math> must equal the identity vector <RT·math>I_0</RT·math>, where <RT·math>I_{0, 0} = 1</RT·math> and all subsequent components are exactly zero.
+ </p>
+
+ <p>
+ Recall the convolution formula for component <RT·math>k</RT·math> of the product:
+ </p>
+
+ <p>
+ <RT·math>I_{0, k} = \sum_{i=0}^{k} \sum_{j=0}^{k} A_{0, i} C_{0, j} \binom{k}{i} \binom{i}{k-j}</RT·math>
+ </p>
+
+ <p>
+ To perform the deconvolution, we isolate the unknown component <RT·math>C_{0, k}</RT·math>. This term occurs in the summation strictly when <RT·math>j = k</RT·math>. When <RT·math>j = k</RT·math>, the term <RT·math>k-j</RT·math> equals 0, making the binomial coefficient <RT·math>\binom{i}{0} = 1</RT·math>. Factoring <RT·math>C_{0, k}</RT·math> out of the sum yields:
+ </p>
+
+ <p>
+ <RT·math>C_{0, k} \sum_{i=0}^{k} A_{0, i} \binom{k}{i}</RT·math>
+ </p>
+
+ <p>
+ A person familiar with Newton's forward difference formula will recognize that the summation <RT·math>\sum_{i=0}^{k} A_{0, i} \binom{k}{i}</RT·math> is exactly the evaluation of the original function at step <RT·math>k</RT·math>, or <RT·math>f(k)</RT·math>.
+ </p>
+
+ <p>
+ We can now solve for <RT·math>C_{0, k}</RT·math> recursively. For the base case <RT·math>k = 0</RT·math>, where <RT·math>I_{0, 0} = 1</RT·math>:
+ </p>
+
+ <p>
+ <RT·math>C_{0, 0} = \frac{1}{A_{0, 0}}</RT·math>
+ </p>
+
+ <p>
+ For all subsequent components where <RT·math>k > 0</RT·math> and <RT·math>I_{0, k} = 0</RT·math>, we subtract the previously known terms of the convolution and divide by <RT·math>f(k)</RT·math>:
+ </p>
+
+ <p>
+ <RT·math>C_{0, k} = \frac{-1}{f(k)} \sum_{i=0}^{k} \sum_{j=0}^{k-1} A_{0, i} C_{0, j} \binom{k}{i} \binom{i}{k-j}</RT·math>
+ </p>
+
+ <p>
+ This reveals a strict recurrent structure. To generate component <RT·math>k</RT·math> of the reciprocal vector, the generator machine relies entirely on the static components of the input polynomial <RT·math>A_0</RT·math> and the previously computed components of the reciprocal <RT·math>C_{0, 0}</RT·math> through <RT·math>C_{0, k-1}</RT·math>. By encapsulating this recurrence within a generator, a programmer can perform exact division while maintaining finite memory bounds, extending the reciprocal vector only when the execution demands it. Note, this is a reciprocal of a function, rather than that of a value.
+ </p>
+<h2>A pole and zero cancellation</h2>
+
+ <p>The row 0 vector for the function <RT·math>g(u) = u - 15</RT·math> is:</p>
+
+ <RT·math>
+ [-15, 1]
+ </RT·math>
+
+ <p>The row 0 vector for <RT·math>f(t) = 2^t - 32</RT·math> is:</p>
+
+ <RT·math>
+ [-31, 1, 1, 1, \ldots]
+ </RT·math>
+
+ <p>We will place these functions into a single system, so we need to synchronize them. Let us assume that <RT·math>[-15, 1]</RT·math> will be called 3 times each time that <RT·math>[-31, 1, 1, 1, \ldots]</RT·math> is called once. Then it becomes:</p>
+
+ <RT·math>
+ [-15, 3]
+ </RT·math>
+
+ <p>It still starts in the same place, but every 3 steps it jumps by 3 rather than the 1 it jumps per step.</p>
+
+ <p>Consider the quotient:</p>
+ <RT·math>
+ [-31, 1, 1, 1, \ldots] / [-15, 3]
+ </RT·math>
+
+ <p>The two synchronized machines that are called against this quotient can be simplified to a rational generator machine. This machine runs the two initial difference vectors in parallel and evaluates their ratio dynamically at each step, rather than attempting to compute a static deconvolution vector upfront.</p>
+
+ <p>By applying the discrete Leibniz rule, a person can simplify the heavy combinatorial deconvolution into a highly optimized linear recurrence relation. Let <RT·math>F_{0,k}</RT·math> be the component of the numerator and <RT·math>D_{0,k}</RT·math> be the component of the quotient. The relation to find the next quotient component reduces cleanly to:</p>
+
+ <RT·math>
+ D_{0,k} = \frac{F_{0,k} - 3k D_{0,k-1}}{3k - 15}
+ </RT·math>
+
+ <p>Using this recurrence, the machine will successfully generate quotient values, but on call 5 there is again a <RT·code>(divide 0 0)</RT·code>.</p>
+ <RT·math>
+ [31/15, 13/30, 8/45, 1/10, 1/15, (divide 0 0)]
+ </RT·math>
+ <p>------</p>
- <RT·chapter>Address</RT·chapter>
+ <table>
+ <thead>
+ <tr>
+ <th>Count (<RT·math>t</RT·math>)</th>
+ <th>Quotient (<RT·math>f(t)/g(t)</RT·math>)</th>
+ <th>1st Diff Ratio (<RT·math>\Delta^1 f(t) / \Delta^1 g(t)</RT·math>)</th>
+ <th>2nd Diff Ratio (<RT·math>\Delta^2 f(t) / \Delta^2 g(t)</RT·math>)</th>
+ </tr>
+ </thead>
+ <tbody>
+ <tr>
+ <td>0</td>
+ <td>31/15</td>
+ <td>1/3</td>
+ <td><RT·code>(divide 1 0)</RT·code></td>
+ </tr>
+ <tr>
+ <td>1</td>
+ <td>30/12</td>
+ <td>2/3</td>
+ <td><RT·code>(divide 2 0)</RT·code></td>
+ </tr>
+ <tr>
+ <td>2</td>
+ <td>28/9</td>
+ <td>4/3</td>
+ <td><RT·code>(divide 4 0)</RT·code></td>
+ </tr>
+ <tr>
+ <td>3</td>
+ <td>24/6</td>
+ <td>8/3</td>
+ <td><RT·code>(divide 8 0)</RT·code></td>
+ </tr>
+ <tr>
+ <td>4</td>
+ <td>16/3</td>
+ <td>16/3</td>
+ <td><RT·code>(divide 16 0)</RT·code></td>
+ </tr>
+ <tr>
+ <td>5</td>
+ <td><RT·code>(divide 0 0)</RT·code></td>
+ <td>32/3</td>
+ <td><RT·code>(divide 32 0)</RT·code></td>
+ </tr>
+ <tr>
+ <td>6</td>
+ <td>32/3</td>
+ <td>64/3</td>
+ <td><RT·code>(divide 64 0)</RT·code></td>
+ </tr>
+ <tr>
+ <td>7</td>
+ <td>96/6</td>
+ <td>128/3</td>
+ <td><RT·code>(divide 128 0)</RT·code></td>
+ </tr>
+ <tr>
+ <td>8</td>
+ <td>224/9</td>
+ <td>256/3</td>
+ <td><RT·code>(divide 256 0)</RT·code></td>
+ </tr>
+ <tr>
+ <td>9</td>
+ <td>480/12</td>
+ <td>512/3</td>
+ <td><RT·code>(divide 512 0)</RT·code></td>
+ </tr>
+ </tbody>
+ </table>
<h2>Unary Representation address</h2>
<li>[f g h] – indirect function call. f is a variable replaced by its value, and that value is then looked up and called as a function. g and h are variables replaced by their values and passed as arguments. The result of the function replaces the entire form.</li>
</ul>
- <RT·endnotes></RT·endnotes>
+<!-- -------------------------------------------------------------------------------- -->
- </RT·article>
- </body>
-</html>
+ <RT·chapter>Appendix: The Tension Between Formal Methods and Practical Architecture</RT·chapter>
+ <h2>Does computation theory matter to computing?</h2>
-<!--
+ <p>
+ Let us put this into perspective. Suppose in ancient Roman times that a clock tick for a computer was scaled to be one day long. Under this scale, a single nanosecond of real world execution time equates to three days. Suppose a program initiated a read request for a location in memory on the Ides of March, the date when Caesar was assassinated on -0043-03-15. The following table provides the historical date that the variable value would finally be loaded into the processor, depending on the memory tier being accessed:
+ </p>
-Does computation theory matter to computing.
+ <table>
+ <thead>
+ <tr>
+ <th>Memory Tier</th>
+ <th>Real World Latency</th>
+ <th>Scaled Delay</th>
+ <th>Scaled Arrival Era</th>
+ <th>Historical Context</th>
+ </tr>
+ </thead>
+ <tbody>
+ <tr>
+ <td>L1 Cache Hit</td>
+ <td>1 ns</td>
+ <td>3 days</td>
+ <td>-0043-03-18</td>
+ <td>Three days after the assassination.</td>
+ </tr>
+ <tr>
+ <td>DRAM (Main memory)</td>
+ <td>100 ns</td>
+ <td>300 days</td>
+ <td>-0042-01-09</td>
+ <td>Nearly a year later, during the Liberators' civil war.</td>
+ </tr>
+ <tr>
+ <td>NVMe SSD Page Swap</td>
+ <td>15 µs</td>
+ <td>45,000 days</td>
+ <td>0080</td>
+ <td>123 years later, exactly as the Colosseum is completed in Rome.</td>
+ </tr>
+ <tr>
+ <td>SATA SSD Page Swap</td>
+ <td>100 µs</td>
+ <td>300,000 days</td>
+ <td>0778</td>
+ <td>821 years later, during the reign of Charlemagne and the Frankish Empire.</td>
+ </tr>
+ <tr>
+ <td>Magnetic HDD Page Swap</td>
+ <td>10 ms</td>
+ <td>30,000,000 days</td>
+ <td>82092</td>
+ <td>Tens of thousands of years in the future, long after current human civilizations are dust.</td>
+ </tr>
+ </tbody>
+ </table>
+ <h2>Do formal methods belong in computer design?</h2>
<p>
- Let us put this into perspective. Suppose in ancient Roman times that a clock tick for a computer was scaled to be one day long. Under this scale, a single nanosecond of real world execution time equates to three days. Suppose a program initiated a read request for a location in memory on the Ides of March, the date when Caesar was assassinated on -0043-03-15. The following table provides the historical date that the variable value would finally be loaded into the processor, depending on the memory tier being accessed:
+ The latency table above speaks to the physical reality that constrains all programs, entirely independent of their theoretical complexity class. This illustrates why computer architects spend almost their entire effort designing machines that execute as many instructions per cycle as possible, operating within a memory subsystem mathematically optimized to keep data in the lowest latency tiers. As a demonstration of this industry focus, there is not a single chapter dedicated to computation theory in Hennessy and Patterson's definitive textbook on the subject <RT·endnote>John L. Hennessy and David A. Patterson, <em>Computer Architecture: A Quantitative Approach</em>, 6th ed. (Cambridge: Morgan Kaufmann, 2017).</RT·endnote>.
</p>
-
+
<table>
- <tr>
- <th>Memory Tier</th>
- <th>Real World Latency</th>
- <th>Scaled Delay</th>
- <th>Scaled Arrival Era</th>
- <th>Historical Context</th>
- </tr>
- <tr>
- <td>L1 Cache Hit</td>
- <td>1 ns</td>
- <td>3 days</td>
- <td>-0043-03-18</td>
- <td>Three days after the assassination.</td>
- </tr>
- <tr>
- <td>DRAM (Main memory)</td>
- <td>100 ns</td>
- <td>300 days</td>
- <td>-0042-01-09</td>
- <td>Nearly a year later, during the Liberators' civil war.</td>
- </tr>
- <tr>
- <td>NVMe SSD Page Swap</td>
- <td>15 µs</td>
- <td>45,000 days</td>
- <td>0080</td>
- <td>123 years later, exactly as the Colosseum is completed in Rome.</td>
- </tr>
- <tr>
- <td>SATA SSD Page Swap</td>
- <td>100 µs</td>
- <td>300,000 days</td>
- <td>0778</td>
- <td>821 years later, during the reign of Charlemagne and the Frankish Empire.</td>
- </tr>
- <tr>
- <td>Magnetic HDD Page Swap</td>
- <td>10 ms</td>
- <td>30,000,000 days</td>
- <td>82092</td>
- <td>Tens of thousands of years in the future, long after current human civilizations are dust.</td>
- </tr>
+ <tbody>
+ <tr>
+ <td>Chapter 1</td>
+ <td>Fundamentals of Quantitative Design and Analysis</td>
+ </tr>
+ <tr>
+ <td>Chapter 2</td>
+ <td>Memory Hierarchy Design</td>
+ </tr>
+ <tr>
+ <td>Chapter 3</td>
+ <td>Instruction Level Parallelism and Its Exploitation</td>
+ </tr>
+ <tr>
+ <td>Chapter 4</td>
+ <td>Data Level Parallelism in Vector, SIMD, and GPU Architectures</td>
+ </tr>
+ <tr>
+ <td>Chapter 5</td>
+ <td>Thread Level Parallelism</td>
+ </tr>
+ <tr>
+ <td>Chapter 6</td>
+ <td>Warehouse Scale Computers</td>
+ </tr>
+ <tr>
+ <td>Chapter 7</td>
+ <td>Domain Specific Architectures</td>
+ </tr>
+ <tr>
+ <td>Chapter 8</td>
+ <td>The Future of Computing</td>
+ </tr>
+ </tbody>
</table>
+ <p>
+ Professor Gonzalez once observed that the primary purpose of computer architecture is to execute the customer's programs as rapidly as possible. IBM later amended this philosophy to add 'for what they paid for,' famously designing a computer model where performance was artificially restricted unless the customer paid to have a physical hardware jumper removed. Within this prevailing design philosophy, the graceful handling of computational end cases, where most formal theoretical questions arise, is deemed secondary because such cases do not occur frequently in the critical execution path.
+ </p>
+ <p>
+ The primary data structure of Lisp is the list, and its programs are designed fundamentally around list traversal. In this sense, the language closely mirrors the pure formal execution of a Turing Machine. Throughout the 1980s, companies such as Symbolics, Lisp Machines Incorporated, Texas Instruments, and Xerox produced computers based on architectures designed specifically to run Lisp natively. However, when Sun Microsystems introduced their workstations, the industry discovered these general purpose machines were relatively inexpensive and offered higher performance for the exact same Lisp programs. The commercial mandate to execute programs quickly decisively defeated formal architectural purity.
+ </p>
- <RT·chapter>Do formal methods belong in computer design.
+ <p>
+ A counterexample to this trend occurred during the 1980s when two competing floating point standards emerged. The proposal from DEC allowed for optimally fast computation provided the behavior was well documented. Under this model, the bottom few bits of a computation could be imprecise, and following an interrupt, a program would be required to do diagnostic work to determine the specific instruction that caused the fault. The reasoning was that floating point computation is approximate by its very nature, and because end case interrupts occur infrequently, it makes no sense to sacrifice performance on workhorse computations to accelerate rare anomalies.
+ </p>
+ <p>
+ The competing standard, initially backed by Intel and soon adopted as the IEEE standard, demanded accuracy to the last bit for each operation, alongside synchronized interrupts. This predictable structure permitted a program to overflow, promote the value, and seamlessly continue an operation. It also specified the use of error tags that participate in a higher order error algebra. This standard ultimately prevailed because its precision guarantees and deterministic predictability provided the necessary foundation for the formal analysis of programs.
+ </p>
- <p>The table at the end of the prior chapter which speaks to the reality of real constraints on all programs, no matter their complexity class, illustrates why
- computer architects spend almost all of their effort designing computers that execute as many instructions per cycle as possible within a memory subsystems that has a high statistical chance of executing in the lower levels of the memory abstraction stack. As a demonstration of this, there is not a single chapter on computation theory in Hennessy and Patterson's <em>Computer Architecture: A Quantitative Approach</em>. <RT·endnote>John L. Hennessy and David A. Patterson, <em>Computer Architecture: A Quantitative Approach</em>, 6th ed. (Cambridge: Morgan Kaufmann, 2017).</RT·endnote></p>
-
- <table>
- <tr>
- <td>Chapter 1</td>
- <td>Fundamentals of Quantitative Design and Analysis</td>
- </tr>
- <tr>
- <td>Chapter 2</td>
- <td>Memory Hierarchy Design</td>
- </tr>
- <tr>
- <td>Chapter 3</td>
- <td>Instruction-Level Parallelism and Its Exploitation</td>
- </tr>
- <tr>
- <td>Chapter 4</td>
- <td>Data-Level Parallelism in Vector, SIMD, and GPU Architectures</td>
- </tr>
- <tr>
- <td>Chapter 5</td>
- <td>Thread-Level Parallelism</td>
- </tr>
- <tr>
- <td>Chapter 6</td>
- <td>Warehouse-Scale Computers</td>
- </tr>
- <tr>
- <td>Chapter 7</td>
- <td>Domain-Specific Architectures</td>
- </tr>
- <tr>
- <td>Chapter 8</td>
- <td>The Future of Computing</td>
- </tr>
- </table>
+ <p>
+ This continuous tension between pure formal models and practical execution speed remains a defining characteristic of the field, driving the structural logic behind modern mechanisms dealing with instruction pipelines, branch prediction, and memory aliasing.
+ </p>
+
+ <RT·chapter>Appendix: Stirling Numbers</RT·chapter>
- <p>Professor Gonzalez once said that the point of computer architecture is to run the customer's programs as quickly as possible. (IBM tacked on to that "for what they paid for", having one computer model with a jumper removed to speed it up, if the customer paid for that). Within this design philosophy the handling of end cases, where most formal questions arise, is not important, because they do not occur often.
+ <p>
+ James Stirling introduced these numbers in his 1730 publication, <em>Methodus Differentialis</em>, a text that directly expanded upon the foundational work laid by Newton.
</p>
- <p>The primary data structure of Lisp is a list, and programs are designed around list traversal. In this sense the language comes very close to Turing Machine computation, and it has a certainly formal purity to it. Though the 1980s with designs originally coming out of MIT companies such as Symbolics, Lisp Machines Incorporated, and Texas Instruments, and Xerox made computers based on architecture specifically to run Lisp. However, when Sun Microsystems came out with their workstation, it was discovered they were relative inexpensive and higher performance, for the same programs, so the 'run the customer's program as fast as possible' commercially beat out formal purity.
+ <p>
+ The profound utility of Stirling numbers lies in their function as the definitive translation layer between continuous mathematics and discrete mathematics. In the context of the Turing Machine architecture, they are the exact mechanisms that bridge the continuous abstract polynomial with the discrete mechanical steps of the machine.
</p>
- <p>In the 1980s there were two competing floating-point standards. DEC's proposal allowed for optimally fast computation as long as the behavior was well documented. This means the bottom few bits of computations might be imprecise, and after an interrupt a program might have to do some work to figure out which instruction caused it. The reasoning was that floating-point computation is approximate by its nature anyway, and that end case interrupts do not happy very often, so it makes no sense to sacrifice performance for workhorse computations so as to make the rare end cases faster.</p>
+ <p>
+ To understand their mechanical role, a person must look at the mathematical basis used in each domain.
+ </p>
- <p>The competing standard backed by Intel, and soon gained other backers and was proposed as an IEEE standard, called for accuracy to the last bit for each operation, and for synchronized interrupts. Thus, for example, it would be possible to overflow, promote, and continue an operation. It also specified an alternative of error tags that would then participate in a higher order error algebra. This standard with its precision guarantees and predictability, which better supported the formal analysis of programs, won out.</p>
+ <h2>The Continuous vs. Discrete Basis</h2>
-aliasing
+ <p>
+ In continuous calculus, the natural basis for polynomials is standard exponentiation, <RT·math>t^n</RT·math>. The continuous derivative operator, <RT·math>D</RT·math>, interacts beautifully with this basis, dropping the degree by exactly one: <RT·math>D(t^n) = n t^{n - 1}</RT·math>.
+ </p>
+
+ <p>
+ However, in the calculus of finite differences, standard exponents are clumsy. Because the Turing Machine evaluates discrete jumps, the natural basis is the falling factorial, denoted as <RT·math>t^{\underline{n}}</RT·math>:
+ </p>
+
+ <p>
+ <RT·math>t^{\underline{n}} = t(t - 1)(t - 2) \cdots (t - n + 1)</RT·math>
+ </p>
+
+ <p>
+ When a person applies the discrete forward difference operator, <RT·math>\Delta</RT·math>, to a falling factorial, it behaves identically to the continuous derivative: <RT·math>\Delta(t^{\underline{n}}) = n t^{\underline{n - 1}}</RT·math>.
+ </p>
+
+ <h2>Stirling Numbers of the Second Kind, <RT·math>S(n, k)</RT·math></h2>
+
+ <p>
+ The Stirling numbers of the second kind are the coefficients required to project the continuous basis onto the discrete basis. They express standard powers as a sum of falling factorials:
+ </p>
+
+ <p>
+ <RT·math>t^n = \sum_{k=0}^n S(n,k) t^{\underline{k}}</RT·math>
+ </p>
+
+ <p>
+ In combinatorics, <RT·math>S(n,k)</RT·math> represents the number of distinct ways to partition a set of <RT·math>n</RT·math> items into <RT·math>k</RT·math> non empty subsets.
+ </p>
+
+ <p>
+ In the Turing Machine architecture, the polynomial coefficients <RT·math>a_i</RT·math> represent the abstract continuous function. The initial tape components <RT·math>D_{0, k}</RT·math> represent the discrete physical realization of that function. Because the Turing Machine operates in discrete integer steps, mapping the abstract polynomial onto the physical tape forces the conversion from standard powers to falling factorials. This is why <RT·math>S(n,k)</RT·math> governs the upper triangular matrix in the preceding lemma.
+ </p>
+
+ <h2>Stirling Numbers of the First Kind, <RT·math>s(n, k)</RT·math></h2>
+
+ <p>
+ The signed Stirling numbers of the first kind perform the exact inverse operation. They reconstruct standard continuous powers from falling factorials:
+ </p>
+
+ <p>
+ <RT·math>t^{\underline{n}} = \sum_{k=0}^n s(n,k) t^k</RT·math>
+ </p>
+
+ <p>
+ Combinatorially, the unsigned magnitude of <RT·math>s(n,k)</RT·math> represents the number of ways to arrange <RT·math>n</RT·math> items into <RT·math>k</RT·math> disjoint cycles. The alternating signs account for the algebraic expansion of the falling factorial terms <RT·math>(t - 1)(t - 2)</RT·math>, etc.
+ </p>
+
+ <p>
+ In the context of the quotient machine or the coefficient recovery matrix, taking the inverse of the matrix formed by the second kind inherently generates a matrix composed of the first kind. This provides the direct algorithmic path to extract the continuous polynomial identity from the discrete mechanical state of the tape.
+ </p>
+
+ <p>
+ They essentially prove that no information is lost when moving a polynomial from the abstract realm into the physical constraints of a stepping machine.
+ </p>
+
+ <RT·endnotes></RT·endnotes>
+
+ </RT·article>
+ </body>
+</html>
--->
projects / TM-2026 / commitdiff