Consider an interpreter evaluation configuration whose table tape is the buffer tape of a bit string \(T\) with cursor \(p\), whose state tape is \(\sigma \) with cursor \(s\), and whose remaining data come from a base configuration. The four symbols under its work heads are, in order: the symbol of the buffer tape of \(T\) at \(p\), the state symbol \(\sigma (s)\), and the two symbols read by the base configuration on its third and fourth work tapes.

Applying the administrative action with target control state \(q'\), table movement \(d_t\), optional state-tape write \(w\), and state movement \(d_s\) to an interpreter evaluation configuration with table cursor \(p\) and state tape \(\sigma \) with cursor \(s\) yields the evaluation configuration over the same base with control state \(q'\), table cursor \(p + d_t\), state tape equal to \(\sigma \) updated at \(s\) by \(w\) when a write is present (and \(\sigma \) otherwise), and state cursor \(s + d_s\). The input head, the other two work tapes, and the accumulated output are unchanged.

Consider an evaluation configuration of the table interpreter with control state \(q\), table \(T\) with cursor \(p\), and state tape \(\sigma \) with cursor \(s\) over some base configuration. If the interpreter’s transition function at \(q\), applied to the physical input symbol and the represented reads (the buffer-tape symbol of \(T\) at \(p\), the state symbol \(\sigma (s)\), and the base configuration’s two remaining work reads), is the administrative action with target \(q'\), table movement \(d_t\), optional state write \(w\), and state movement \(d_s\), then one interpreter step takes the configuration to the evaluation configuration with control state \(q'\), table cursor \(p + d_t\), state tape updated by \(w\) at \(s\), and state cursor \(s + d_s\), leaving all other fields unchanged.

For bit strings \(l, r\) and a bit \(b\), the buffer tape of the concatenation \(l \cdot b \cdot r\) (holding the string in cells \(0, 1, \dots \) with blanks elsewhere) reads exactly \(b\) at position \(|l|\).

Consider the table interpreter in its table-rewind phase (carrying a Boolean flag and a record index that it merely preserves), in an evaluation configuration over a table \(T\) with table cursor \(j - 1\) for some \(j \le |T|\), and with an arbitrary state tape \(\sigma \) and state cursor \(s\). Then exactly \(j + 1\) interpreter steps bring it to the count-parsing phase with the same flag and index and with the table cursor at \(0\); the state tape, state cursor, and all other data are unchanged.

Suppose the table is \(l \cdot d(\beta ) \cdot 01 \cdot r\), where \(d(\beta )\) doubles each bit of a bit string \(\beta \) and \(01\) is the unequal delimiter pair. Starting the interpreter’s count parser (carrying a Boolean flag and a record index) at table cursor \(|l|\), exactly \(2|\beta | + 2\) steps move the table cursor past the doubled count field and the delimiter to position \(|l| + 2|\beta | + 2\), entering the initial-state copier when the flag is set and the initial-state skipper with the carried index otherwise. No binary arithmetic on the value of \(\beta \) is performed, and the state tape, state cursor, and all other data are unchanged.

With no cells erased, the state window with \(n\) remaining unary cells — marker \(0\) at the origin, \(1\)s in cells \(1, \dots , n\), blanks elsewhere — coincides with the intact unary state tape encoding the state index \(n\).

In a state window with \(j\) erased cells and \(n + 1\) remaining unary cells, the cell at position \(j + 1\) (the current lookup position) holds the bit \(1\).

In a state window with \(j\) erased cells and no remaining unary cells, the cell at position \(j + 1\) is blank.

Erasing the cell at position \(j + 1\) of a state window with \(j\) erased and \(n + 1\) remaining unary cells (writing the blank there) yields exactly the state window with \(j + 1\) erased and \(n\) remaining cells.

A state window with no remaining unary cells is the same tape regardless of the number of erased cells: the permanent origin marker \(0\) at position \(0\) and blanks everywhere else.

Writing the bit \(1\) into cell \(n + 1\) of the intact unary state tape encoding the index \(n\) yields the intact unary state tape encoding the index \(n + 1\).

The intact unary state tape encoding the index \(n\) is blank at position \(n + 1\), immediately after its last unary symbol.

Let \(\sigma \) be a state tape whose cell \(0\) reads the marker bit \(0\) and none of whose cells at positive natural positions reads \(0\) (they may be \(1\) or blank). Let \(q\) be an interpreter control state such that, for every combination of reads whose state-tape read is \(0\), the transition at \(q\) is the administrative action passing to a fixed state \(q'\) and moving the state cursor right, and for every combination whose state-tape read is not \(0\) it is the administrative action staying in \(q\) and moving the state cursor left, in both cases touching nothing else. Then for every natural number \(j\), starting from the evaluation configuration in state \(q\) with state tape \(\sigma \) and state cursor \(j\), exactly \(j + 1\) interpreter steps reach state \(q'\) with state cursor \(1\), leaving \(\sigma \), the table cursor, and all other data unchanged. The hypotheses are deliberately independent of whether the traversed cells are erased blanks or retained unary symbols.

Suppose the table is \(l \cdot 1^n \cdot 0 \cdot r\). From the interpreter’s initial-state skipping phase (carrying a record index) with table cursor \(|l|\), exactly \(n + 1\) steps move the table cursor past the unary field and its terminating \(0\) to position \(|l| + n + 1\) and enter the record-group phase with the carried index; the state tape, state cursor, and all other data are unchanged.

Let \(q\) be an interpreter control state that, on every combination of reads with table read \(1\), stays in \(q\), writes a \(1\) at the state cursor, and moves both the table and state cursors right; and on every combination with table read \(0\) passes to a state \(q'\) with a fixed table movement \(d \in \{ -1, 0, +1\} \) and no other change. Suppose the table is \(l \cdot 1^n \cdot 0 \cdot r\), the state tape is the intact unary encoding of an index \(j\), the table cursor is \(|l|\), and the state cursor is \(j + 1\). Then exactly \(n + 1\) interpreter steps reach \(q'\) with table cursor \(|l| + n + d\), state tape the intact unary encoding of \(j + n\), and state cursor \(j + n + 1\); all other data are unchanged. This single gadget serves both initial-state extraction and live successor-state replacement.

For every state index \(n\), the intact unary state tape encoding \(n\) reads the marker bit \(0\) at position \(0\), and reads \(0\) at no positive natural position.

Updating the everywhere-blank two-way infinite tape by writing a bit \(b\) at position \(0\) yields the buffer tape of the one-character string \(b\): the tape holding \(b\) in cell \(0\) and blanks elsewhere.

One step of the table interpreter from its entry configuration on a captured table \(T\) installs the two permanent markers — the origin marker \(0\) on the state tape and the boundary bit \(1\) on the marker tape — and starts the unconditional table rewind: the result is the evaluation configuration over the initialization base whose control is the initial table-rewind phase, with table cursor \(|T| - 1\), the unary state tape encoding the index \(0\), and state cursor \(1\).

For every coded machine \(M\) with initial state index \(q_0\) and state count \(m\), there is a bit string \(\rho \) (the transition-record table) such that the canonical serialization of \(M\) equals the pair encoding of the binary digit string of \(m\) with the string \(1^{q_0} \cdot 0 \cdot \rho \); that is, the serialization begins with exactly its doubled count field and delimiter, then the initial state in unary with its terminator, then the record table.

Suppose the captured table \(T\) is the pair encoding of a bit string \(\beta \) (the count field) with a string of the form \(1^n \cdot 0 \cdot \rho \) (the initial state \(n\) in unary, followed by an arbitrary remainder \(\rho \)). Then from the interpreter’s entry configuration with physical input head parked at a position \(p\), exactly \(|T| + 2|\beta | + 2n + 7\) interpreter steps reach the evaluation configuration over the initialization base at \(p\) whose control is the main dispatch state, with table cursor \(2|\beta | + 2 + n + 1\) (just past the serialized header), the unary state tape encoding the index \(n\), and state cursor \(1\). No transition-table lookup is involved yet.

The interpreter checkpoint representing a source configuration of a coded machine is halted exactly when the source configuration is halted, and its accumulated output equals the source’s accumulated output.

Let \(M\) be a finite-tape machine over \(\{ 0,1\} \), \(D\) a four-tape follower machine, and consider a configuration of \(M\) on an input \(x\). The endpoint configuration of the capture stage — which copies \(M\)’s accumulated output onto a fresh tape and hands control to \(D\) — equals the right-block embedding into the combined machine of the \(D\)-configuration with control at \(D\)’s initial state, the same physical input head as the source, first work tape holding the buffer tape of the captured output string with head at its right blank, and three blank tapes with heads at \(0\), where \(M\)’s work tapes and head positions are retained unchanged as the inactive left block.

Let \(M\) be a finite-tape machine over \(\{ 0,1\} \). For every four-tape configuration of the table interpreter, every assignment of contents and head positions to \(M\)’s work tapes, and every number of steps \(t\): running the combined capture machine (which pairs \(M\) with the fixed table interpreter) for \(t\) steps from the right-block embedding of the interpreter configuration equals the right-block embedding of the interpreter’s own \(t\)-step run, with the inactive tapes and heads unchanged.

Let \(c\) be an effective machine-coding scheme, \(\alpha \) a code string, and \(x\) an input string, and let \(N\) denote the machine decoded from \(\alpha \), with \(\ell \) the number of binary digits of its state count and \(q_0\) its initial state index. Then there exist a time \(t\) not exceeding the startup bound for \(\alpha \) (which is independent of \(x\)) and contents and head positions for the inactive canonizer tapes such that running the complete universal-machine candidate for \(t\) steps from its initial configuration on the pair encoding \(\langle \alpha , x \rangle \) yields exactly the right-block embedding, over those inactive tapes, of the interpreter checkpoint representing the initial configuration of \(N\) on \(x\) with table cursor \(2\ell + 2 + q_0 + 1\) — that is, with the canonical table captured, its cursor parked just past the header, the initial state in unary, a blank simulated work tape, and the virtual-input boundary marker installed.

Let \(M\) and \(U\) be multi-tape machines over \(\{ 0,1\} \) on inputs \(x\) and \(y\) respectively, let \(R\) be a relation between their configurations, and let \(S, B \in \mathbb {N}\). Assume (startup) there is a \(t \le S\) such that the configuration of \(U\) after \(t\) steps from its initial configuration is related to \(M\)’s initial configuration, and (step) whenever a source configuration is related to a target configuration, there is a duration \(d\) with \(1 \le d \le B\) such that running \(U\) for \(d\) further steps yields a configuration related to the source’s successor. Then for every \(n\) there is a time \(t\) with \(n \le t \le S + Bn\) such that the configuration of \(U\) after \(t\) steps is related to the configuration of \(M\) after \(n\) steps. The lower bound \(n \le t\) makes the run cofinal, without assuming that either machine eventually halts.

Let \(c\) be an effective machine-coding scheme, \(U\) a finite-tape machine over \(\{ 0,1\} \), and \(S, B\) functions assigning a bound to each code string. For each code string \(\alpha \) and input \(x\), let a relation be given between configurations of the machine decoded from \(\alpha \) (in one-work-tape form) on \(x\) and configurations of \(U\) on the pair encoding \(\langle \alpha , x \rangle \). Assume: (startup) for all \(\alpha , x\), within some \(t \le S(\alpha )\) steps \(U\) reaches a configuration related to the decoded machine’s initial configuration; (step) every related pair advances — one source step against some \(d\) target steps with \(1 \le d \le B(\alpha )\) — to a related pair; (halting) related configurations are halted simultaneously; and (output) related configurations have equal accumulated output. Then for every \(\alpha \) there is a constant \(C\) such that for every input \(x\): whenever the decoded machine computes an output within \(t\) steps on \(x\), the machine \(U\) computes the same output on \(\langle \alpha , x \rangle \) within \(C(t+1)\) steps; and conversely, every output \(U\) computes on \(\langle \alpha , x \rangle \) within some time is computed by the decoded machine on \(x\) within some time.

The serialized record of any one-work-tape machine action decomposes as its eight fixed action bits, followed by a block of \(1\)s whose length is the unary size of the optional successor field (zero when the action halts, one more than the successor index otherwise), followed by a single terminating \(0\).

Consider the interpreter’s fixed-field skipping phase, carrying a destination and a count of remaining records, with field register \(f \in \{ 0,\dots ,7\} \) and table cursor \(p\). If \(f + n = 7\), then exactly \(n + 1\) interpreter steps advance the table cursor to \(p + n + 1\) and enter the unary-skipping phase with the same destination and remaining count; no tape cell is inspected or modified, and the state tape, state cursor, and all other data are unchanged.