From: Thomas Walker Lynch Date: Wed, 8 Jul 2026 09:03:54 +0000 (+0000) Subject: . X-Git-Url: https://git.reasoningtechnology.com/RT-Manuscript_locator.js?a=commitdiff_plain;h=90b55195090e75d7baa8e1ba4d705246be25e196;p=TM-2026 . --- diff --git a/document/TM-2026.html b/document/TM-2026.html index d42b437..b4f442c 100644 --- a/document/TM-2026.html +++ b/document/TM-2026.html @@ -1108,7 +1108,7 @@

This technique of composing Turing Machine programs in the presence of simplification is closely related to that of symbol computation and expression simplification that we find in math tools such as Mathematica. We can imagine our Turing Machines as functions with names, and then symbolic computation leave them unevaluated as here. Then the the Mathematica Simplify is the compiler optimization simplifier as above. A difference in these two systems is that of the functions being reduced to Turing Machine head and tape transport unit commands.

-

The multiplicative inverse of the additive identity

+

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. @@ -1139,121 +1139,199 @@

- There is no special help here. 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. + There is no special help here. Hence, (divide 0 0) remains as an error flag.

- We have been defining a function as a Turing Machine given inputs on its tape, doing a computation, running until the halt state, then stopping. For example, consider a Turing Machine given the natural number, t, we would denote this as y = f(t), where t is the initial value of the tape, and y is the value left on the tape after the machine halts. + 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. +

+ +

Evaluating and Extending

+ +

+ When a machine is 1) programmed to perform a function f, 2) has its tape initialized with a constant input value, say t (which can be a vector of values), and 3) is then run, writing the result f(t) and halting; we say that the run evaluates the function at t.

- Now consider a variation of our one variable function example. Instead of placing t on the tape as input, suppose that we define a new Turing Machine, say F, where the initial tape is given a value, and that t is the count of the number of times we call F without changing the tape. Thus after one call to F, the tape will have the value of f(1), after two calls it will have the value f(2), etc. Then apparently the machine F adds the first finite difference of the function to the tape upon each call. + When an evaluator erases the input and leaves only the result in its place, we say it is a substitution evaluator. It is an inconsequential modification to add multiple tapes each with their own tape head to a Turing Machine, so it is possible that an evaluator will have a dedicated tape for the input, a dedicated tape for the output, and have zero or more additional tapes for scratch work. In which case, instead of substitution, one tape is mounted as an input, the machine is run until it halts, and then separately the result tape can be unmounted to potentially be used in a downstream computation.

- Now imagine that we have a second machine G that also creates the next value of a function of natural numbers, each time it is called. And furthermore we would like to know the function resulting from the division of these functions, (divide F G). + 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.

- This is all stated rather abstractly, so let us consider an example. Suppose that our machines evaluate the functions f(t) = 2^t - 32, and g(u) = u - 15. Here the free variables, which are the call counts, are independent. So when doing the division we do not know how many times F and G were called, and the call counts can be different. For the division to resolve, we describe the synchronization between t and u. So that our example may continue, let us suppose that u = 3t. That says that each time F is called, G will be called three times. + The difference between function values is called the first finite difference. The forward first difference is defined as: + Δ_i = f(t_{i+1}) - f(t_i). + While the backwards first difference is + Δ_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 the same as adding the first difference.

- So for the first step, the initial value when t is zero, the value written to the initial tape, will be -31. Also, the initial value on the tape for the denominator will be -15. We got the initial values by putting zero for t into the functions, f and g. + A second difference can be defined as the difference between two adjacent first differences, etc. A second difference can be added to a prior first difference to create the next first difference, which could then be added to a prior function value to extend the function to its next value. This pattern can be extended to any number of levels.

- Let us observe the raw integer sequence this generates over 10 steps. By retaining the unreduced fractions resulting from cross multiplication, we expose the underlying structural patterns driving the division. + The mechanical application of finite differences was famously leveraged by Charles Babbage in the design of his Difference Engine. By examining the discrete changes between consecutive outputs of a polynomial function, a person can observe that the higher order differences eventually reduce to a constant. This structure allows the computation of subsequent sequential values using only addition, bypassing the need for complex multiplication machinery. +

+ +

+ Let us construct a forward difference pyramid for the polynomial f(t) = t^2.

- - - - + + + + - - - + + + - - - + + + - - - + + + - - - + + + - - - + + + + +
Call Count (t)Quotient f(t) / g(3t)1st Forward DiffExtrapolated 1st Forward DiffCount (t)f(t) = t^21st Diff (Δ^1)2nd Diff (Δ^2)
0-31/-1578/18078/180012
1-30/-1266/10866/108132
2-28/-948/5448/54452
3-24/-624/1824/1897
4-16/-3Undefined-6/016
+ +

+ 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), Δ^1(t), Δ^2(t)]. No matter how long the finite difference table becomes, each row will have three entries. +

+ +

+ 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 Δ^1 to f, and Δ^2 to Δ^1: +

+ + + Initial Tape (t=0): [0, 1, 2] + Call 1 (t=1): [1, 3, 2] + Call 2 (t=2): [4, 5, 2] + Call 3 (t=3): [9, 7, 2] + Call 4 (t=4): [16, 9, 2] + + +

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, to write 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, to write 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 2, the input tape is the result tape from Call 1. Execution then proceeds the same as it did for Call 1. This pattern repeats for all successive calls. We can see the values of t^2 as the first number of each result tape. +

+ +

Lemma, only first row needed

+ +

The extension function can be called any number of times, when the initial tape is identical to the first row of the finite difference table. No other row is needed from he diagonal table.

+ +

This follows from the fact that the extension function is performing the exact operations that were performed when we generated the difference table. At each step, the result tape is identical to the different table row. I.e. the extension function captures formally our definition of how to make the table. +

+ +

Lemma, for the first N values, the first row need only have N + 1 columns

+ +

Before calling the extension function, the initial result is on the initial tape. Hence, for zero calls, only the value the first column is needed.

+ +

For the first call, the initial first difference is needed to add to the first value, but no other values are needed. Hence at call 1, it is sufficient that the first row has two columns.

+ +

In general, for the Nth call, the Nth difference from the first row, so if the recurrence function is to be called N time, the initial row need only have N + 1 values.

+ +

Lemma, a polynomial function degree N will always be defined with a N + 1 column first row

+ +

A N+1 column first row means the table came from an N degree polynomial

+ + +

Finite difference table for an exponential function

+ +

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

+ + + - - - - + + + + + + + - - - - + + + + + - - - - + + + + + + + + + + + + + + - - - + + - - - - + + + + +
5(divide 0 0)Undefined-42/0Count (t)f(t) = 2^t1st Diff (Δ^1)2nd Diff (Δ^2)3rd Diff (Δ^3)
632/396/18-84/1801111
796/6480/54-132/5412222
2444
38 8224/91632/108-186/108
9480/124704/180-246/180416

- Notice what happens at step 5. The first order machine crashes because the raw arithmetic zeroes out, leaving the indeterminate (divide 0 0). Because computing the first difference requires reading adjacent values, the difference sequence fails early at step 4, unable to look across the undefined gap. + 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.

-

- However, if a person observes the unreduced fractions before the crash, distinct structural patterns emerge. The denominators of the differences (180, 108, 54, 18) decrease by -72, -54, and -36. This forms a perfect parabola with a constant second difference of 18. Extending this sequence yields denominators of 0 and 0. -

+

Composition of recurrence functions

+ +

If we desire to compose recurrence functions, in the first order or the second order, the call counts must first be synchronized.

+ +

Say for example, we have a machine called fizz that adds 3 to the input on the tape, while buzz added 5 to the input on the tape, and we wanted to compose the two machines. We would have to define what a call to the resultant machine means to the machines in composition.

+ +

Suppose one call to the resultant machine makes 3 calls -

- Similarly, the numerators (78, 66, 48, 24) decrease by an expanding arithmetic progression (-12, -18, -24), which implies a constant second difference of -6. Continuing this pattern yields -30 and -36 for the next steps. Applying these gives extrapolated numerators of -6 and -42. -

- -

- By isolating the sequences, we fill the logical holes with the extrapolated differences of -6/0 and -42/0. The reason this works is that though the first order value goes to zero over zero, constructing the logic from the underlying finite differences separates the operation into predictable polynomials. Even though the discrete quotient still hits a division by zero at the gap, these isolated polynomials give a second order composer the continuous structural geometry needed to bridge it. -

Address