;; (write s) (step))
</RT·code>
+ <p>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 <RT·code>Simplify<RT·code> 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.</p>
+ <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 is 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 can not be computed.</p>
+
+ <p>The IEEE 754 floating-point standard includes error algebra tags. These are explored in depth by Popova, Evgenija D. "On a Formally Correct Implementation of IEEE Computer Arithmetic." Journal of Universal Computer Science 1, no. 7 (1995): 560-569. This is a form of second order arithmetic, because each of the error tags is standing in for a machine that did not complete. When a computation fails to result in a first order object, this becomes a gateway for replacing the result with a second order object.
+ </p>
+
+ <p>Let us take for an example, the multiplicative inverse of the additive identity, as an example, AKA division by zero. In the second order, when we divide, say 6/0, the machine will not reduce. It will return a second order value:</p>
+
+ <RT·code>
+ (divide 6 0)
+ </RT·code>
+
+ <p>Now consider the compiler optimization like simplification of this expression:</p>
+
+ <RT·code>
+ (divide (divide 6 0) (divide 3 0))
+ </RT·code>
+
+ <p>The result will be:</p>
+ <RT·code>
+ (multiple 2 (divide 0 0))
+ </RT·code>
+
+ <p>There is no special help here. The divide machine can not 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·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>
+
+ <p>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, <RT·math>t</RT·math>, we would denote this as <RT·math>y = f(t)</RT·math>, where <RT·term>t</RT·term> is the initial value of the tape, and <RT·math>y</RT·math> is the value left on the tape after the machine halts.
+ </p>
+
+ <p>Now suppose consider a variation of our one variable function example. Instead of placing <RT·math>t</RT·math> on the tape as input, suppose that we define a new Turing Machine, say <RT·math>\dot{f}</RT·math>, where the initial tape is given a value, and that <RT·math>t</RT·math> is the count of the number of times we call <RT·math>\dot{f}</RT·math> without changing the tape. Thus after one call to <RT·math>\dot{f}</RT·math>, the tape will have the value of <RT·math>f(1)</RT·math>, after two calls it will have the value <RT·math>f(2)</RT·math>, etc. Then apparently the machine <RT·math>\dot{f}</RT·math> adds the first finite difference of the function to the tape upon each call.
+ </p>
+
+ <p>Now imagine that we have a second machine <RT·math>\dot{g}</RT·math> 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, <RT·math>(divide \dot(f} \dot{g})</RT·math>.<p>
+
+ <p>This is all stated rather abstractly, so let us consider an example. Suppose that <RT·math>f(t) = 2^t - 14</RT·math>, and that <RT·math>g(u) = u - 9</RT·math>. Here the free variables, which are the call counts, are independent. So when doing the division we don't know how many times <RT·math>\dot{f}</RT·math> and <RT·math>\dot{g}</RT·math> were called, and the call counts can be different. For the division to resolve we describe the synchronization between <RT·math>t</RT·math> and <RT·math>u</RT·math>. So that our example may continue, let us suppose that <RT·math>u = 3t</RT·math>. That says that each time <RT·math>\dot{f}</RT·math> is called, <RT·math>\dot{g}</RT·math> will be called three times.
+ </p>
+
+ <p>So for the first differences, we have <RT·math>\dot{f} = 2^t</RT·math>. The initial value when t is zero, the value written to the initial tape, will be </RT·math>-14</RT·math>. Also, then <RT·math>\dot{g} = 1</RT·math> the initial value on the tape will be <RT·math>-9</RT·math>. We got the initial values by putting zero for <RT·math>t</RT·math> into the functions, </RT·math>f</RT·math> and <RT·math>g</RT·math>.
+ </p>
+
+ <p>So then calling the machines 4 times results in the following values:</p>
+
+
+
+
<RT·chapter>Address</RT·chapter>
projects / TM-2026 / commitdiff