From: Thomas Walker Lynch Date: Thu, 9 Jul 2026 10:06:42 +0000 (+0000) Subject: . X-Git-Url: https://git.reasoningtechnology.com/?a=commitdiff_plain;h=70de1f05ffe02e1b93579540de39d2c96219554d;p=TM-2026 . --- diff --git a/document/TM-2026.html b/document/TM-2026.html index 34b6b06..daed3a0 100644 --- a/document/TM-2026.html +++ b/document/TM-2026.html @@ -1541,99 +1541,160 @@

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

+

A pole and zero cancellation

-

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). + To construct the D_0 vector for the quotient H(t) = f(t) / g(t), where f(t) = 2^t - 32 and g(t) = 3t - 15, the machine evaluates the standard combinatorial recurrence for the nth forward difference:

-

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

+ + H_n = \sum_{k=0}^n (-1)^{n-k} \binom{n}{k} \frac{f(k)}{g(k)} +

- \binom{t}{i} \binom{t}{j} = \sum_{k=\max(i,j)}^{i+j} \binom{k}{i} \binom{i}{k-j} \binom{t}{k} + The generator machine successfully computes the first several entries. However, testing the structural integrity of this sequence generation reveals a hard mechanical fault at step 5. When the generator attempts to evaluate H_5, the summation requires evaluating the term at k=5. The denominator evaluates to g(5) = 3(5) - 15 = 0. The numerator evaluates to f(5) = 2^5 - 32 = 0.

- 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: + If this were executing strictly in the first order, the arithmetic logic unit would blindly attempt the operation and crash, yielding a strict hardware fault: (divide 0 0). Because this execution occurs in the second order, the structural logic of the functions is preserved. The machine intercepts the fault before reduction, trapping the unresolved expression as (divide f(k)|k=5 g(k)|k=5). This trapped expression is routed to a specialized limit analyzer, acting as a L'Hôpital evaluator, to resolve the indeterminate form.

- 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} + To see how this operates dynamically, a person can observe the vectors directly. The row 0 vector for the function g(u) = u - 15 is:

+ + + [-15, 1] +

- 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. + The row 0 vector for f(t) = 2^t - 32 is:

-

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

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

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

-

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

+ + [-15, 3] +

- Recall the convolution formula for component k of the product: + 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] +

- I_{0, k} = \sum_{i=0}^{k} \sum_{j=0}^{k} A_{0, i} C_{0, j} \binom{k}{i} \binom{i}{k-j} + 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.

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

-

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

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

- 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). + Using this recurrence, the machine successfully generates quotient values, but on call 5 it encounters the exact same singularity.

-

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

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

- C_{0, 0} = \frac{1}{A_{0, 0}} + By shifting from the difference vector to the direct function values over time, the behavior around the singularity becomes clear:

-

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

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
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
130/122/3
228/94/3
324/68/3
416/316/3
5(divide f(5) g(5))32/3
632/364/3
796/6128/3
8224/9256/3
9480/12512/3

- 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} + Observing the execution table reveals a profound structural alignment. Exactly at the singularity t=5, the continuous trajectory of the quotient aligns perfectly with the ratio of the first differences, \Delta^1 f(t) / \Delta^1 g(t), taking the value 32/3. The L'Hôpital evaluator utilizes this discrete geometry to bridge the gap. This specific physical property is highly suggestive of L'Hôpital's rule from continuous calculus. In a later chapter concerning non standard analysis, we will formally define how this exact difference quotient mechanism maps seamlessly into continuous limits when stepping across infinitesimal bounds.

-

- 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

+

A pole and zero cancellation

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

@@ -1675,8 +1736,6 @@ [31/15, 13/30, 8/45, 1/10, 1/15, (divide 0 0)] -

------

- @@ -1691,65 +1750,57 @@ - - - - - - - - - -
0 31/15 1/3(divide 1 0)
1 30/12 2/3(divide 2 0)
2 28/9 4/3(divide 4 0)
3 24/6 8/3(divide 8 0)
4 16/3 16/3(divide 16 0)
5 (divide 0 0) 32/3(divide 32 0)
6 32/3 64/3(divide 64 0)
7 96/6 128/3(divide 128 0)
8 224/9 256/3(divide 256 0)
9 480/12 512/3(divide 512 0)
+ Address +

Unary Representation address

@@ -3113,3 +3164,98 @@ +