Alphabeta Math
TheoremStatement: Literature-sourcedProof: AI-adaptedPipeline-generatedjudge pass (gpt-5.6-terra)audited 2026-09-13
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.

Nondeterministic recursive-padding separation

Statement

Let T:NN have an exact clock and satisfy T(n)n. There is one binary language LNTIME(T) such that for every total recursive an with a(n+1)=o(T(n)), one has LNTIME(a). These are the library's all-branch-halting classes with constants fixed per machine. No monotonicity of T or a is assumed.

Facts & Assumptions

Given: A fixed exact clock T. All intermediate unclocked machines below are acceptors measured by shortest accepting time.

[F1]

Exact clocks are positive, cutoffs are inclusive, and a T-clocked acceptor has all-branch time O(n+T(n)+1) (Nondeterministic acceptance time and exact clocks).

[F2]

Fixed multitape acceptors have two-tape simulations with linear shortest-time overhead (Linear acceptance-time simulation on two tapes).

[F3]

There is a fixed prefix universal U with per-code linear acceptance bounds (Prefix program codes admit linear nondeterministic universal simulation).

[F4]

A fixed two-tape A has a code e with L(Me)={w:ewL(A)} and shortest-time bound Oe(w+τA(ew)+1) (Time-controlled self-reference for nondeterministic machines).

[F5]

Union and clock cutoffs have explicit fixed-constant machines (Clocks, cutoffs, and finite unions preserve nondeterministic time bounds).

[F6]

No recursive bound covers all recursive unary languages even in shortest-acceptance time (No recursive bound covers all recursive unary languages).

[F7]

Little-o means every fixed multiple is eventually bounded by the comparison function, with no monotonicity implicit (Uniform asymptotic time space comparison).

Proof

1.1

Define L=LT(U). The direct clocked construction in F1 halts on every branch and accepts exactly this cutoff. Since T is positive and T(n)n, its time is O(T(n)), so LNTIME(T). L depends only on U and T. Fix any candidate a as in the statement and suppose an all-branch machine B recognizes L in O(a). Let V be the union acceptor for B and U from F5. Because LL(U), it recognizes exactly L(U). For a sufficiently large fixed integer K, whenever zL its shortest V-time is at most A(z), where A(n)=K(a(n)+n+1). Enlarge K to cover all finitely many accepted short strings: A is positive there. Thus A(n)n+1 and A(n+1)=o(T(n)), since a(n+1)n+1.

F1F3F5F7
1.2

Fix for now an arbitrary recursive unary language R and a deterministic decider D for it. Let r(m) be D's finite running time on 1m. Construct a multitape acceptor H as follows. Parse its input uniquely as e1m0k with valid prefix e; after e, take the maximal initial run of ones and then require only zeros. Reject malformed strings. Simulate D on 1m for at most k steps, counting this budget by a unary copy of the zero suffix. If D halts by that instant, accept or reject according to D. Otherwise, nondeterministically extend the zero suffix to some k>k and run V on e1m0k, accepting just when V does. A branch may extend forever. Parsing, bounded simulation and copying cost OH(m+k+e+1); in the recursive case preparation costs OH(m+k+e+1) before the direct V run. No computation of the possibly enormous r(m) is needed before the bounded test.

F3F5construct
2.1

Apply F2 to H and F4 to its resulting two-tape acceptor. Obtain a fixed code e0 and acceptor P=Me0 with L(P)={w:e0wL(H)}. Put =e0, wk=1m0k, zk=e0wk, and Nk=+m+k. Combining the two fixed linear overheads with step 1.2 gives an integer d1, independent of m,k,k', such that on accepted instances: kr(m)  τP(wk)d(Nk+1), k<r(m), k>k, zkL(V)  τP(wk)d(Nk+1+τV(zk)). The second inequality uses the branch which chooses that particular k'. Additive compiler constants and the input-copy terms are absorbed using Nk+11. By F3 choose κ1 with τU(zk)κ(Nk+τP(wk)+1) whenever P accepts. These constants are fixed after R,D,V and e0 are fixed, before any length induction.

F2F3F4step 1.2
3.1

First prove the language identity wkL(P) iff 1mR for every m,k. For every kr(m), H's bounded D-test finishes and gives exactly R's answer. Now descend through k=r(m)1,,0, assuming the identity for all larger k'. The compiler identity and H's recursive branch give wkL(P) iff some zkL(V) with k>k. Since L(V)=L(U) and e0 is valid, this is equivalent to some wkL(P). The induction hypothesis makes it equivalent to 1mR: if R answers yes, take k=r(m); if no, no larger k' works. This is a finite downward induction below a base range, not an inference from an ungrounded recursive call.

F3step 1.1step 1.2step 2.1
3.2

For k<r(m) take k=k+1 in the second estimate of step 2.1, which applies whenever zk+1L(V): τP(wk)d(Nk+2+τV(zk+1)). If also τV(zk+1)A(Nk+1), then τP(wk)d(Nk+2+A(Nk+1)), the step-down estimate used in the second induction below; since A(Nk+1)Nk+2 by step 1.1 it is in particular at most 2dA(Nk+1).

step 1.1step 2.1
4.1

Set B0=κ(d+2) and choose N01 such that 2B0A(N+1)T(N) for all NN0, possible by F7. Fix a yes input 1mR with +mN0. We prove by a second downward induction on k, starting from the entire range kr(m), that κ(Nk+τP(wk)+1)T(Nk) and τV(zk)A(Nk). In the base range the first expression is at most B0(Nk+1)2B0A(Nk+1)T(Nk). Therefore U accepts zk within its exact T-cutoff, so zkL and the bound for V follows from step 1.1.

F7step 1.1step 2.1step 3.1

For the step from k+1 to k the induction hypothesis gives τV(zk+1)A(Nk+1); hence zk+1L(V) and step 3.2 applies, so κ(Nk+τP(wk)+1)B0(Nk+2+A(Nk+1))2B0A(Nk+1)T(Nk). The middle inequality uses A(Nk+1)Nk+2. Thus zk again lies in the actual U-cutoff L, yielding τV(zk)A(Nk). This closes the second induction without comparing T at different arguments. In particular τP(1m)T(m+) for every sufficiently long yes input. The original zero suffix may be empty; k=0 is exactly the last induction case. [step 1.1, step 2.1, step 3.2]

4.2

Filter P's inputs to unary words by a complete scan costing O(m+1), rejecting nonunary words. For a fixed threshold m0 covering the preceding finite exceptions, a literal finite trie can decide all unary strings 1m with m<m0 by D's computed answers; on longer inputs run the filtered P. Step 3.1 proves exact recognition of R for all lengths. Now define the single positive recursive function b(m)=m+1+j=02mT(j). It is recursive because running the fixed exact clock on each finite length computes T. For m, T(m+)b(m), without any monotonicity hypothesis. Therefore this acceptor of R has shortest acceptance OR(b(m)); the finite trie costs and finitely many exceptional values are absorbed since b is everywhere positive. Crucially b depends only on T, not on the arbitrary recursive unary language R. This contradicts F6.

F1F6step 3.1step 3.2
5.1

Hence no such B exists for the fixed candidate a. Because step 1.1 chose the same cutoff L before a, this excludes the union over all the stated recursive lower bounds, not merely one separately chosen lower bound. If there are no such a, the exclusion is vacuous and the same clocked L still supplies membership. All searches, branch guesses and code constructions are finite or computable; thresholds are fixed natural witnesses to little-o and do not invoke AC. The all-branch claim is exactly the clocked membership proved in step 1.1.

step 1.1step 4.2

Depends on

Used by

Dependency tree · two levels

17 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