Alphabeta Math
TheoremStatement: AI-adaptedProof: AI-adaptedPipeline-generatedprecheck passjudge pass (gpt-5.6-terra)audited 2026-09-10
How statement and proof provenance work

The first chip identifies the source of the statement or construction; the second identifies the source of its local proof or verification.

  • Literature-sourced: the exact statement appears in a cited source; only wording and notation differ.
  • AI-adapted: a semantically identical restatement of literature-sourced material, modulo indexing, notation, and boundary cases adopted by the library.
  • AI-generated: a genuinely novel statement formulated by AI, with no source for the claim itself.

These labels describe origin, not correctness: citations and verification chips remain separate evidence.

Stay-put elimination with an explicit simulation interface

Statement

Let M be any deterministic right-infinite stay-put one-tape machine. Let N and E be the ordinary simulator and configuration embedding of The right-left macro simulates one stay-put step. From any starting configuration C, write (Ci) for the unique maximal run of M. For every index i reached by this run, let si count the stay-put transitions among its first i transitions, and set ki=i+si. Then the run of N from E(C) reaches E(Ci) at exactly the designated macro-boundary time ki; this does not assert that the configuration cannot recur at other times.

The two maximal runs accept together, reject together, and diverge together. If the original halts after t transitions, the simulator first halts after exactly t+st transitions, with tt+stt+t, and the same head and entire tape, with original state represented by its unmarked copy. Thus on every input, including the empty input, the simulation preserves recognition, decision, and any fixed output read from the halting tape (or tape and head). Ordinary machines themselves form the subcase with no stay-put entries, so allowing stay-put moves changes neither the class of recognized languages nor that of decided languages.

Facts & Assumptions

Given: M,C,N,E as above. A step count counts transitions, so an already-halting arbitrary start has count zero. Work in ZF without Choice.

[F1]

The machine/run interface gives a unique maximal run, ending at the first halt or continuing infinitely, and fixes initial tapes and the two halting predicates (Stay-put one-tape machines and their runs).

[F2]

Each original step expands to its unique next-unmarked segment of length one or two, preserving head and tape at its end; every interior configuration is marked and nonhalting (The right-left macro simulates one stay-put step).

[F3]

A total self-map of a set with a specified start has a unique sequence of iterates (The recursion theorem).

[F4]

A property with a base case and successor step holds on the naturals (The principle of mathematical induction).

[F5]

Addition satisfies a+0=a and a+σ(b)=σ(a+b) (Addition of natural numbers); also σ(a)+b=σ(a+b) (Left successor law for addition) and 0+b=b (Left identity for addition).

[F6]

The relation ab means a+d=b for some natural d, and a<b additionally means ab (Order on the natural numbers); it is a linear order ( is a linear order on N).

[F7]

Adding a fixed natural preserves and reflects both weak and strict order (Order is compatible with addition).

[F8]

a<b iff a+1b, and no natural lies strictly between a and a+1 (Discreteness: σ(n) is the immediate successor).

Proof

1.1

Regard N also as an extended machine with no S entries; its ordinary and extended steps coincide. F1 gives its maximal run as well as that of M. For formal counters use the set CM×N×N, starting at (C,0,0). At a nonhalting (X,k,s), take the unique successor X and send the triple to (X,k+1,s) for an L/R entry and to (X,(k+1)+1,s+1) for an S entry. At a halting X, leave the whole triple fixed. This is a total self-map, so F3 constructs its iterates. Restrict to the genuine indices of the original maximal run. Their coordinates are (Ci,ki,si) and si is exactly the running count of S entries: it starts at zero and increases by one precisely at such entries. No fixed tail is counted as genuine steps.

F1F2F3
2.1

At index zero k0=s0=0 and the simulator starts at E(C0). Suppose it has reached E(Ci) and M has a next step. F2 expands that step into precisely one simulator step for L/R or two for S, reaching E(Ci+1) at the recursively prescribed ki+1. There is no halt inside that segment. Applying induction to these finite expansions gives equality at every reached boundary, and supplies every transition in each expansion. If the original ends, apply induction up to its last index; otherwise apply it on all naturals.

step 1.1F2F4
2.2

We prove ki=i+si by induction. At zero, 0+0=0. In an L/R step, ki+1=ki+1=(i+si)+1=(i+1)+si, and si+1=si. In an S step, ki+1=(ki+1)+1=((i+si)+1)+1=(i+1)+(si+1), and si+1=si+1. Both identities follow by the two successor laws of F5. These are the only transition types, so the equation holds at every reached index.

step 1.1F4F5
3.1

Also 0sii. Nonnegativity follows since 0+si=si, a witness in F6. For the upper bound the base is 00. If sii, an L/R step retains siii+1, where the second inequality has witness one. An S step gives si+1i+1 by F7. Thus induction proves the upper bound. To bound ki, induction using F5 shows that for every fixed si and every j, j+sj+i: the base is si, and adding one to both sides preserves order by F7 and converts them into (j+1)+s and (j+1)+i. Take j=i,s=si. The lower bound ii+si has witness si. Hence ikii+i.

step 2.2F4F5F6F7
3.2

For each reached i, the times 0j<ki are partitioned by the first i half-open segments [kr,kr+1), r<i. This follows by induction: at i=0 the interval is empty; appending [ki,ki+1) extends exactly to [0,ki+1) with disjoint interiors, because ki+1 is ki+1 or (ki+1)+1. By F8 the appended interval contains only its boundary ki, and in the second case also ki+1. Thus every covered time is either a macro boundary or the sole interior time of an S macro. The latter has the marked nonhalting configuration calculated in F2.

step 1.1step 2.1F2F4F6F8
4.1

If the original first halts at t, then at each boundary ki for i<t its unmarked simulator copy is nonhalting. Every other time before kt is a nonhalting interior by the partition. At kt the simulator is E(Ct) and is halting with exactly the same accept/reject designation, head and tape. Thus this is its first halt. Its time is t+st and satisfies the stated bounds. This includes t=0, when the partition is empty and both configurations already halt.

F1F2step 2.1step 2.2step 3.1step 3.2
4.2

If the original is infinite, fix any simulator time j. The boundary kj+1 exists and satisfies j<j+1kj+1 by the bounds. Hence the finite expansion through that boundary includes time j. The partition makes its configuration either the unmarked copy of a nonhalting original state or a marked interior state; in both cases it is nonhalting. Uniqueness of successors makes all these finite expansions agree where they overlap. Equivalently they agree with the unique identity-extended simulator sequence supplied by F1; every one of its times is nonhalting, so every transition is genuine. The simulator therefore diverges.

F1F2F6F8step 2.1step 3.1step 3.2
5.1

These implications are equivalences. If the simulator accepts, the original cannot be infinite by step 4.2 and cannot halt rejecting by step 4.1, so the exhaustive alternatives in F1 force original acceptance. The same argument exchanges acceptance and rejection. If the simulator diverges, step 4.1 rules out either finite original outcome, so the original diverges. The forward implications are already proved in steps 4.1 and 4.2.

F1step 4.1step 4.2
6.1

For every input w, unchanged alphabets and blank give the same initial tape tw, and the designated start of N gives IN(w)=((q0,0),0,tw)=E(IM(w)). For the empty word both initial tapes are wholly blank. Applying step 5.1 to these starts proves equality of accepted-input sets and preservation of halting on every input, hence of recognition and decision. At a finite halt the tapes and heads are equal by step 4.1, so applying any fixed output-reading function to them gives equal outputs. Conversely an ordinary machine is already a stay-put machine using only L/R, with identical steps and runs, proving both inclusions for the two language classes.

F1F2step 4.1step 5.1

Sources

Checkoway, Lecture 16, printed slides 8–10 (PDF pp. 14–19) supplies the inclusion and outcome-preserving simulation route. The counters, partition and exact time bounds are derived here for the specified model. Savage, §5.1, pp. 210–211 discusses language acceptance, decision and tape output with different machine conventions; the consequences here use the explicit local predicates.

Depends on

Used by

Nothing in the library uses this result yet.

Dependency tree · two levels

29 results within two dependency steps of this one, each drawn at its shortest distance from it. An arrow runs from a result to what uses it, so the chart reads left to right and ends at this result, which carries a heavier outline. Every node is a link to that result. Click elsewhere on the chart to enlarge it.

Sources