From: Thomas Walker Lynch Date: Thu, 9 Jul 2026 09:35:28 +0000 (+0000) Subject: . X-Git-Url: https://git.reasoningtechnology.com/?a=commitdiff_plain;h=98976056ced81ce5dd00601aaa146ee18766eb59;p=TM-2026 . --- diff --git a/document/TM-2026.html b/document/TM-2026.html index cb3f75b..34b6b06 100644 --- a/document/TM-2026.html +++ b/document/TM-2026.html @@ -1111,7 +1111,7 @@

The multiplicative inverse of the additive identity

- 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.

@@ -1139,11 +1139,11 @@

- There is no special help here. Hence, (divide 0 0) remains as an error flag. + There is no special help here. Hence, (divide 0 0) remains as an error flag.

- 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, x \cdot y = q operations, when given an x and a q value, there is only one possible y value, and it can be recovered with q/x. However, when x is zero, and only when it is zero, q is solely determined by x independent of y, so y is ignored; it could be any value. There is no way to recover it from q/x. + 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 x \cdot y = q operations, when given an x and a q value, there is only one possible y value, and it can be recovered with q/x. However, when x is zero, and only when it is zero, q is solely determined by x independent of y, so y is ignored; it could be any value. There is no way to recover it from q/x.

Evaluating and Extending

@@ -1157,15 +1157,15 @@

- In a variation of analytical evaluation, we can instead mount an initial value for a function, and call a machine to repeatedly extend the function. To state this more precisely, when a machine tape is given the initial value of f(t_i) on its input tape, and then when run until it halts, writes the result f(t_{i+1}), 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, f(t_0), f(t_1), f(t_2), \ldots. + In a variation of analytical evaluation, we can instead mount an initial value for a function, and call a machine to repeatedly extend the function. To state this more precisely, when a machine tape is given the initial value of f(t_i) on its input tape, and then when run until it halts having written the result f(t_{i+1}) 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, f(t_0), f(t_1), f(t_2), \ldots.

- 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: \Delta_i = f(t_{i+1}) - f(t_i). While the backwards first difference is \Delta_i = f(t_i) - f(t_{i-1}). - 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.

@@ -1224,11 +1224,11 @@

- 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: [f(t), \Delta^1(t), \Delta^2(t)]. 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.

- Here is the sequence of tape states as the machine is repeatedly called to extend the function from its initial conditions at t = 0. During each step, the machine adds \Delta^1 to f, and \Delta^2 to \Delta^1: + Here is the sequence of tape states as the machine is repeatedly called to extend the function from its initial conditions at t = 0. During each step, the machine adds \Delta^1 to f, and \Delta^2 to \Delta^1, as there is no \Delta^3, it is taken to be zero, so \Delta^2 is merely copied down.

@@ -1240,66 +1240,72 @@

- 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.

- 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 t^2 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 t^2 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.

Lemma: Only row 0 is needed

- 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.

- 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 Nth call is identical to row N of the table. + This follows from the mechanical procedure given above for computing the next row of the table from any given row.

+

Lemma: Evaluating call \omega requires an initial tape populated with components 0 through \omega of row 0

-

Lemma: Evaluating call \omega requires an initial tape populated with components 0 through \omega of row 0

+

+ Let the extent refer to the maximum index for accessing a component of a vector; the extent is often denoted as \omega. Performing extensions to calculate the function value at call \omega makes use of the initial tape up to index \omega, or as many nonzero values as are available up to that extent. +

- Let the extent refer to the maximum index for accessing a component of a vector; the extent is often denoted as \omega. Performing extensions to calculate the function value at call \omega will make use of the initial tape up to index \omega, or as many nonzero values as are available up to that extent. + To make this precise, let us define the difference vector at call k as D_k. The components of this vector are D_{k, 0}, D_{k, 1}, \ldots up to the maximum available difference. The first component, D_{k, 0}, is the function value itself. The component D_{k, 1} is the first difference, and so on.

- To make this precise, let us define the difference vector at call k as D_k. The components of this vector are D_{k, 0}, D_{k, 1}, \ldots, D_{k, m}, where m is the maximum available difference. The first component, D_{k, 0}, is the function value itself. The component D_{k, 1} is the first difference, and so on. + Thus, this lemma claims that to compute D_{\omega, 0}, the highest component index accessed from the initial tape vector D_{0, i} will be i = \omega.

- +

- The extension operation follows a simple recurrence relation for any component j: D_{k+1, j} = D_{k, j} + D_{k, j+1}. + Note that to compute the D_{k, 0} result by the mechanical procedure given above requires adding the input tape first difference to the prior difference. That is, D_{k, 0} = D_{k-1, 0} + D_{k-1, 1}. Hence we see immediately the lemma holds for the first call where k = \omega = 1.

- We can now prove by induction on the call index k that computing D_{k, 0} requires exactly the components D_{0, 0} through D_{0, k} from the initial tape D_0. + For an arbitrary k value we discovered that the highest index required of the D_{k-1, i} vector is i=1. + The value D_{k-1, 1} is computed from our mechanical procedure as + D_{k-1, 1} = D_{k-2, 1} + D_{k-2, 2}. 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 D_{k-2, i} is 2.

- Base Case (k=0): To generate the value at call 0, D_{0, 0}, 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 D_{k, i} inherently requires D_{k-1, i} and D_{k-1, i+1}. Therefore, each step backwards in time k expands the required index i by exactly one. By induction, computing the base value D_{\omega, 0} at call \omega requires tracing back \omega steps to the initial tape at k=0, which forces the maximum accessed index to be 0 + \omega = \omega. Thus, the highest required component from the initial tape is D_{0, \omega}.

- Inductive Hypothesis: Assume that generating the value at call k, which is D_{k, 0}, requires the initial tape components D_{0, 0} through D_{0, k}. + The exact algebraic composition of this mechanical expansion is formalized by Newton's calculus of finite differences Isaac Newton formalized this interpolation method in 1675, later published in his Methodus Differentialis (1711). For a comprehensive foundational treatment, see George Boole, A Treatise on the Calculus of Finite Differences (Cambridge: Macmillan and Co., 1860), Chapter II.. Instead of executing the machine incrementally, a person can calculate the function value at call \omega directly as a linear combination of the initial tape components using Newton's forward difference formula:

- Inductive Step: Consider the requirement for the value at call k+1, which is D_{k+1, 0}. By the extension rule, D_{k+1, 0} = D_{k, 0} + D_{k, 1}. + D_{\omega, 0} = \sum_{j=0}^{\omega} \binom{\omega}{j} D_{0, j}

- + +

+ Because the binomial coefficient \binom{\omega}{j} evaluates to exactly zero for any integer j > \omega, the summation naturally truncates at index \omega. 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, D_{0, n}, directly from the sequence of evaluated function calls, D_{k, 0}, using the alternating binomial sum: +

+

- The union of the dependencies for D_{k, 0} and D_{k, 1} spans from index 0 to index k+1. Thus, generating the value at call k+1 requires the initial tape to have an extent of exactly k+1. The lemma holds. + D_{0, n} = \sum_{k=0}^{n} (-1)^{n-k} \binom{n}{k} D_{k, 0}

- 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 \omega, the initial tape must have an extent of \omega, meaning it holds \omega + 1 values. + As a consequence of this lemma, we know that for any finite number of calls, i.e. finite \omega, that a finite prefix of D_0 is used.

-

Lemma: A polynomial function of degree \omega generates a difference vector in row 0 with an extent of \omega

+

Lemma: A polynomial function of degree \omega will have a D_0 vector of extent \omega

A polynomial of degree \omega is defined by a highest order term a_\omega t^\omega. The first forward difference operator, \Delta f(t) = f(t+1) - f(t), inherently cancels the t^\omega term. The binomial expansion of (t+1)^\omega yields t^\omega as its leading term, which subtracts out, leaving a new polynomial of exactly degree \omega - 1. @@ -1309,48 +1315,163 @@ Taking successive finite differences reduces the degree of the polynomial by exactly one at each step. Consequently, the \omegath difference evaluates to a constant, and the next difference evaluates to exactly zero.

+ + +

Lemma: A D_0 vector of finite extent \omega generates a polynomial function of degree \omega

+

- Because component 0 of the initial difference vector, D_{0, 0}, holds the function value itself, and the differences occupy components 1 through \omega, the initial vector D_0 requires a component count of \text{sampi}, where \text{sampi} = \omega + 1. This defines a vector with a maximum index, or extent, of \omega. + If an initial difference vector D_0 has an extent of \omega, the sequence of function values generated by the machine corresponds to a polynomial of exactly degree \omega. A person can demonstrate this by algebraically recovering the polynomial constants, a_i, directly from the initial tape components, D_{0, i}.

-

Lemma: A difference vector in row 0 with an extent of \omega uniquely constructs a polynomial of degree \omega

+

+ Consider an extent of \omega = 0, forming a polynomial of degree 0, f(t) = a_0. Evaluating at t = 0 yields f(0) = a_0. Because the machine's initial value is D_{0,0}, a person establishes a_0 = D_{0,0}. +

- If an initial difference vector D_0 has an extent of \omega (meaning the component D_{0, \omega} is constant and all higher differences are zero), the sequence of function values can be generated by a polynomial of degree \omega. + When a person extends the extent to \omega = 1, the next term is added to form f(t) = a_0 + a_1 t. The first forward difference at t = 0 is D_{0,1} = f(1) - f(0) = (a_0 + a_1) - a_0 = a_1. Therefore, a_1 = D_{0,1}. Note that the addition of the linear term did not change the evaluation at t = 0; the a_0 constant remains firmly anchored to D_{0,0}.

- 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 t is given by a linear combination of the initial difference components multiplied by binomial coefficients: + Extending to \omega = 2, the polynomial becomes f(t) = a_0 + a_1 t + a_2 t^2. The second difference at t = 0 is calculated as D_{0,2} = f(2) - 2f(1) + f(0). Substituting the polynomial yields D_{0,2} = (a_0 + 2a_1 + 4a_2) - 2(a_0 + a_1 + a_2) + a_0 = 2a_2. Thus, a person recovers a_2 = D_{0,2} / 2. The lower coefficient then adjusts to a_1 = D_{0,1} - a_2.

- f(t) = \sum_{j=0}^{\omega} D_{0, j} \binom{t}{j} + Continuing to \omega = 3, the polynomial is f(t) = a_0 + a_1 t + a_2 t^2 + a_3 t^3. Evaluating the third difference D_{0,3} isolates the highest order term, yielding D_{0,3} = 6a_3. This allows immediate recovery of the highest constant: a_3 = D_{0,3} / 6.

- To determine the degree of this constructed function, a person must evaluate the binomial coefficient, \binom{t}{j}. It expands into a polynomial in t: + Once a_3 is known, the shifting nature of the lower order constants becomes apparent through back substitution. The second difference equation expands to D_{0,2} = 2a_2 + 6a_3. Substituting the known a_3 allows recovery of a_2 = (D_{0,2} - 6a_3) / 2. Similarly, the first difference equation expands to D_{0,1} = a_1 + a_2 + a_3, which resolves to a_1 = D_{0,1} - a_2 - a_3. Through all of this shifting, a_0 = D_{0,0} remains entirely unperturbed.

- \binom{t}{j} = \frac{t(t - 1)(t - 2) \cdots (t - j + 1)}{j!} + To observe the formal mechanics of this progression, a person can array these relationships into a matrix equation mapping the polynomial constants, a_i, to the initial tape differences, D_{0,n}. The coefficients of this transformation are defined by the Stirling numbers of the second kind, denoted S(i,n):

+ + \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} + +

- Because the numerator contains j factors of t, the term \binom{t}{j} is a polynomial of exactly degree j. + Because each successive forward difference operator annihilates the lowest power of t, the resulting matrix is strictly upper triangular. For any extent \omega, the final row simplifies to D_{0,\omega} = \omega! a_\omega. Because an initial tape of extent \omega strictly dictates that D_{0,\omega} is nonzero, a_\omega is guaranteed to be nonzero.

- The initial tape components, D_{0, j}, are static scalar constants. Therefore, the summation f(t) consists of adding together polynomials of increasing degrees from 0 up to \omega. Because the extent is \omega, the scalar D_{0, \omega} is nonzero, ensuring that the highest degree term in the summation does not vanish. Thus, the constructed function f(t) is strictly a polynomial of degree \omega. + 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 a_i. The inversion utilizes the signed Stirling numbers of the first kind, denoted s(n,i) (see the Appendix on Stirling numbers).

+

+ a_i = \sum_{n=i}^{\omega} \frac{s(n,i)}{n!} D_{0,n} +

+

+ Thus, extending this procedure \omega times definitively recovers the constants for exactly a polynomial of degree \omega. +

+

+ This mechanical recovery of standard polynomial constants is completely analogous to Newton's interpolation formula Ibid.. Instead of resolving the standard constants a_i 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: +

+ +

+ f(t) = \sum_{n=0}^{\omega} D_{0, n} \binom{t}{n} +

+ +

+ Because the nth binomial coefficient expands into a polynomial of exactly degree n, and the summation is bounded by the finite extent \omega where D_{0, \omega} is definitively nonzero, the constructed function f(t) is guaranteed to be a polynomial of degree \omega. +

+ +

Lemma: A D_0 vector of finite extent \omega generates a polynomial function of degree \omega

+ +

+ If an initial difference vector D_0 has an extent of \omega, the sequence of function values generated by the machine corresponds to a polynomial of exactly degree \omega. A person can demonstrate this by algebraically recovering the polynomial constants, a_i, directly from the initial tape components, D_{0, i}. +

+

+ Consider an extent of \omega = 0, forming a polynomial of degree 0, f(t) = a_0. Evaluating at t = 0 yields f(0) = a_0. Because the machine's initial value is D_{0,0}, a person establishes a_0 = D_{0,0}. +

+ +

+ When a person extends the extent to \omega = 1, the next term is added to form f(t) = a_0 + a_1 t. The first forward difference at t = 0 is D_{0,1} = f(1) - f(0) = (a_0 + a_1) - a_0 = a_1. Therefore, a_1 = D_{0,1}. Note that the addition of the linear term did not change the evaluation at t = 0; the a_0 constant remains firmly anchored to D_{0,0}. +

+ +

+ Extending to \omega = 2, the polynomial becomes f(t) = a_0 + a_1 t + a_2 t^2. The second difference at t = 0 is calculated as D_{0,2} = f(2) - 2f(1) + f(0). Substituting the polynomial yields D_{0,2} = (a_0 + 2a_1 + 4a_2) - 2(a_0 + a_1 + a_2) + a_0 = 2a_2. Thus, a person recovers a_2 = D_{0,2} / 2. The lower coefficient then adjusts to a_1 = D_{0,1} - a_2. +

+ +

+ Continuing to \omega = 3, the polynomial is f(t) = a_0 + a_1 t + a_2 t^2 + a_3 t^3. Evaluating the third difference D_{0,3} isolates the highest order term, yielding D_{0,3} = 6a_3. This allows immediate recovery of the highest constant: a_3 = D_{0,3} / 6. +

+ +

+ Once a_3 is known, the shifting nature of the lower order constants becomes apparent through back substitution. The second difference equation expands to D_{0,2} = 2a_2 + 6a_3. Substituting the known a_3 allows recovery of a_2 = (D_{0,2} - 6a_3) / 2. Similarly, the first difference equation expands to D_{0,1} = a_1 + a_2 + a_3, which resolves to a_1 = D_{0,1} - a_2 - a_3. Through all of this shifting, a_0 = D_{0,0} remains entirely unperturbed. +

+ +

+ 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: +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
DifferenceEquation
D_{0,0}= a_0
D_{0,1}= a_1 + a_2 + a_3 + \ldots + a_\omega
D_{0,2}= 2a_2 + 6a_3 + \ldots
D_{0,3}= 6a_3 + \ldots
\ldots\ldots
D_{0,\omega}= \omega! a_\omega
+ +

+ A definitive pattern emerges. Because each successive forward difference operator annihilates the lowest power of t, the resulting algebraic system is strictly upper triangular. For any extent \omega, the \omegath difference equation reduces to D_{0,\omega} = \omega! a_\omega. This structural guarantee permits a person to reliably recover a_\omega = D_{0,\omega} / \omega!. Because an initial tape of extent \omega strictly dictates that D_{0,\omega} is nonzero, a_\omega is guaranteed to be nonzero. All subsequent lower order constants are then systematically resolved through cascading back substitution. Thus, extending this procedure \omega times definitively recovers the constants for exactly a polynomial of degree \omega. +

+ +

+ This mechanical recovery of standard polynomial constants is completely analogous to Newton's interpolation formula Ibid.. Instead of resolving the standard constants a_i 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: +

+ +

+ f(t) = \sum_{n=0}^{\omega} D_{0, n} \binom{t}{n} +

+ +

+ Because the nth binomial coefficient expands into a polynomial of exactly degree n, and the summation is bounded by the finite extent \omega where D_{0, \omega} is definitively nonzero, the constructed function f(t) is structurally guaranteed to be a polynomial of degree \omega. +

Difference table for an exponential function

- Here is the finite difference table for the function 2^t. + Here is the table of finite differences for the function 2^t.

@@ -1358,9 +1479,9 @@ - - - + + + @@ -1403,7 +1524,11 @@
Count (t) f(t) = 2^t1st Diff (Δ^1)2nd Diff (Δ^2)3rd Diff (Δ^3)1st Diff (\Delta^1)2nd Diff (\Delta^2)3rd Diff (\Delta^3)

- The first difference of 2^t is also 2^t, 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 2^t is also 2^t, so row 0 of the table will have an infinite number of values. Fortunately, due to the lemma stating that evaluating call \omega requires an initial tape populated with components 0 through \omega 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. +

+ +

+ 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.

Composition of recurrence functions

@@ -1416,11 +1541,214 @@

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).

+ +

Multiplication of synchronized difference vectors

+ +

+ 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. +

+ +

+ Suppose a programmer has two initial difference vectors, A_0 representing function f(t) with an extent of \omega_a, and B_0 representing function g(t) with an extent of \omega_b. The goal is to compute the initial difference vector C_0 for the product function h(t) = f(t)g(t). +

+ +

+ Multiplying two polynomials of degrees \omega_a and \omega_b yields a polynomial of degree \omega_a + \omega_b. Therefore, the resulting vector C_0 will strictly have an extent of \omega_c = \omega_a + \omega_b, requiring a tape component count of \omega_a + \omega_b + 1. +

+ +

+ To determine the components of C_0 directly from A_0 and B_0 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: +

+ +

+ \binom{t}{i} \binom{t}{j} = \sum_{k=\max(i,j)}^{i+j} \binom{k}{i} \binom{i}{k-j} \binom{t}{k} +

+ +

+ By applying this identity across the summations of both input functions, the component k of the resulting vector C_0 can be computed algebraically. Each component C_{0, k} is the sum of the cross products of the input components, weighted by combinations of their indices: +

+ +

+ 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} +

+ +

+ 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. +

+ +

Division and the Reciprocal Difference Vector

+ +

+ 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. +

+ +

+ Let A_0 be the initial difference vector for a polynomial f(t). We seek the reciprocal difference vector C_0, which represents the function h(t) = 1/f(t). Because the reciprocal of a polynomial is a rational function, its forward differences will never reduce to zero. Thus, C_0 is an infinite vector. +

+ +

+ Following the lazy evaluation strategy, C_0 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 \omega only as they are demanded. +

+ +

+ By definition, f(t)h(t) = 1. In the difference domain, this means the convolution of A_0 and C_0 must equal the identity vector I_0, where I_{0, 0} = 1 and all subsequent components are exactly zero. +

+ +

+ Recall the convolution formula for component k of the product: +

+ +

+ I_{0, k} = \sum_{i=0}^{k} \sum_{j=0}^{k} A_{0, i} C_{0, j} \binom{k}{i} \binom{i}{k-j} +

+ +

+ To perform the deconvolution, we isolate the unknown component C_{0, k}. This term occurs in the summation strictly when j = k. When j = k, the term k-j equals 0, making the binomial coefficient \binom{i}{0} = 1. Factoring C_{0, k} out of the sum yields: +

+ +

+ C_{0, k} \sum_{i=0}^{k} A_{0, i} \binom{k}{i} +

+ +

+ A person familiar with Newton's forward difference formula will recognize that the summation \sum_{i=0}^{k} A_{0, i} \binom{k}{i} is exactly the evaluation of the original function at step k, or f(k). +

+ +

+ We can now solve for C_{0, k} recursively. For the base case k = 0, where I_{0, 0} = 1: +

+ +

+ C_{0, 0} = \frac{1}{A_{0, 0}} +

+ +

+ For all subsequent components where k > 0 and I_{0, k} = 0, we subtract the previously known terms of the convolution and divide by f(k): +

+ +

+ 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} +

+ +

+ This reveals a strict recurrent structure. To generate component k of the reciprocal vector, the generator machine relies entirely on the static components of the input polynomial A_0 and the previously computed components of the reciprocal C_{0, 0} through C_{0, k-1}. 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. +

+

A pole and zero cancellation

+ +

The row 0 vector for the function g(u) = u - 15 is:

+ + + [-15, 1] + + +

The row 0 vector for f(t) = 2^t - 32 is:

+ + + [-31, 1, 1, 1, \ldots] + + +

We will place these functions into a single system, so we need to synchronize them. Let us assume that [-15, 1] will be called 3 times each time that [-31, 1, 1, 1, \ldots] is called once. Then it becomes:

+ + + [-15, 3] + + +

It still starts in the same place, but every 3 steps it jumps by 3 rather than the 1 it jumps per step.

+ +

Consider the quotient:

+ + [-31, 1, 1, 1, \ldots] / [-15, 3] + + +

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.

+ +

By applying the discrete Leibniz rule, a person can simplify the heavy combinatorial deconvolution into a highly optimized linear recurrence relation. Let F_{0,k} be the component of the numerator and D_{0,k} be the component of the quotient. The relation to find the next quotient component reduces cleanly to:

+ + + D_{0,k} = \frac{F_{0,k} - 3k D_{0,k-1}}{3k - 15} + + +

Using this recurrence, the machine will successfully generate quotient values, but on call 5 there is again a (divide 0 0).

+ + [31/15, 13/30, 8/45, 1/10, 1/15, (divide 0 0)] + +

------

- Address + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Count (t)Quotient (f(t)/g(t))1st Diff Ratio (\Delta^1 f(t) / \Delta^1 g(t))2nd Diff Ratio (\Delta^2 f(t) / \Delta^2 g(t))
031/151/3(divide 1 0)
130/122/3(divide 2 0)
228/94/3(divide 4 0)
324/68/3(divide 8 0)
416/316/3(divide 16 0)
5(divide 0 0)32/3(divide 32 0)
632/364/3(divide 64 0)
796/6128/3(divide 128 0)
8224/9256/3(divide 256 0)
9480/12512/3(divide 512 0)

Unary Representation address

@@ -2585,120 +2913,203 @@
  • [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.
    • - + - - - + Appendix: The Tension Between Formal Methods and Practical Architecture +

    Does computation theory matter to computing?

    -