Alphabeta Math
TheoremStatement: Literature-sourcedProof: AI-adaptedPipeline-generatedjudge pass (gpt-6-luna)
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.

Unbounded error counting time space alternative

Statement

For either fixed profile P∈{seq,basis}, every real d and every ε>0, there is a constant c>1 such that at least one of the following holds: MajMajSAT∉PrTIMEP(nc), or MajSAT∉PrTISPP(nd,n1−ε). The basis profile is the derived full-basis comparison model. Formula thresholds are at least-half and machine acceptance is strict majority.

Facts & Assumptions

Given: real d, ε>0, one fixed profile, and the local majority-formula encodings.

[F1]

Probabilistic polynomial time hierarchy gives proper containment for rational strictly separated time exponents in the selected profile.

[F2]

Counting time space to linear hierarchy maps the selected profile's polynomial-time/sublinear-space machines to a fixed level of its linear counting hierarchy.

[F3]

Tight majority formula completeness supplies near-linear reductions for both hierarchy levels, direct polylogarithmic-time/logspace bit generation, and sequential on-demand generation with the same per-transition overhead.

[F4]

Unbounded error time space counting model fixes the two profiles and exact charged oracle access. The time-only normalization can carry an exact classical oracle by forwarding its completed query and using its deterministic answer; its dictionary invariants are independent of that answer. Query copying adds only polylogarithmic time per original query symbol, absorbed by the strict padding margins below.

[F5]

Time normalization of classical basis queries normalizes time-bounded basis queries into an index-only computation when its clock is at least input length. This time-only use adds polylogarithmic overhead.

[F6]

Bounded-space simulation of a generated input handles generated inputs while retaining O(M+log⁡n) work extent for a known polynomial bound M on source work operands, using maintained range-OR trees. It is the space-preserving tool below; [F5] is not used to transport a sublinear space bound.

Proof

1.1F3F4F6givenconstructalgebra

Choose rational 0<η<η1<min⁡(ε,1) and a>max⁡(d,1). Suppose MajSAT has the stated time/space decider. For a language in LCHP,1, [F3] produces a formula of length N=O(nlog⁡kn). Its source decider work extent is eventually below a known power-of-two bound M=O(n1−η1), because η1<ε absorbs fixed constants and polylogs in N. In the basis profile use [F6] to simulate both ordinary reads and native basis queries on this generated formula in time O((n+N+Nd+1)polylog n) and space O(M+log⁡n). In the sequential profile [F3]'s ordered source-constant block, or a logarithmic virtual-input-position counter, gives at most the same overhead for each local input move without changing work records. The strict margins a>max⁡(d,1) and η<η1 bound these resources by O(na) and O(n1−η). Hence PrTIMEP(n)⊆PrTISPP(na,n1−η).

2.1F2F4F5F6step 1.1constructalgebra

Choose rational 1<b<B with B(1−η)<1, put β=1−B(1−η)>0, and choose rational A>Ba. For any PrTIMEP(nb) language, its self-delimited padded version at length m=Θ(nB) has a linear-time decider. In the basis profile apply [F5] to the original fixed decider, then translate its short indices to the original-input portion of the actual padded word; the cost nbpolylog n fits O(m) because b<B. Sequential simulation is no slower. Apply step 1.1 to that padded language. On the original word, its resulting time/space decider sees a generated input of length m. For the basis profile [F6] simulates this virtual padded input with a known work bound M=O(m1−η) rounded to a power of two; its delimiter and zero bits have polylogarithmic-time/logspace generators. Time is O(nBapolylog n)⊆O(nA) and work extent O(m1−η+log⁡n)=O(n1−β). The sequential virtual-input simulation has the same bounds. Thus PrTIMEP(nb)⊆PrTISPP(nA,n1−β)⊆LCHP,τ by [F2] for a fixed finite τ. Increase τ to at least two if necessary.

3.1F3F4F5F6step 2.1givenconstructalgebra

Choose rational constants 1<c<ρ<δ<b1/(τ−1) and suppose MajMajSAT has a fixed PrTIMEP(nc) decider. Let the reduction in [F3] map an n-bit input to a formula y=R(x) of length N=O(nlog⁡k(n+2)) for some fixed k, with the stated direct bit generator. If P=seq, supply this formula on demand using [F3]'s sequential streaming guarantee; the decider then takes O(Ncpolylog n)=O(ncpolylog n) time. If P=basis, the bit generator alone does not justify composition with a time-only decider that can issue long block queries. Choose a constructible clock T=⌈K0(N+2)c⌉≥N and apply [F5] to the decider's fixed explicit code. The resulting exact index-only interpreter has time and physical work-access extent bounded by a constructible T′=O(Ncpolylog N). Choose a power-of-two majorant Mn=2⌈K1log⁡2(n+2)⌉ with fixed K1 large enough that T′≤Mn≤(n+2)K1+1. The normalized index-only interpreter is a special case of the basis machine's head-access operations, with no native block query left; apply [F6] to its run on the generated formula R(x). The formula length, bit generator, clock and address majorant satisfy [F6]'s hypotheses, so the exact simulation takes O((n+T′+1)log⁡O(1)(n+2))=O(nclog⁡O(1)n) time. Thus in either profile LCHP,2⊆PrTIMEP(nρ), with the strict exponent margin absorbing the reduction, normalization and generated-input overheads.

4.1F3F4F5step 2.1step 3.1constructinductionalgebra

We prove the stronger induction assertion that for every j≥2 there is a rational ej′<δj−1 with LCHP,j⊆PrTIMEP(nej′). The base is e2′=ρ. For the induction step, set e=δj−1 and take any B∈LCHP,j with the resulting decider of time O(∣q∣ej′), where ej′<e and ej′>1. Encode each padded query self-delimited, with its original query q in a designated prefix and a zero suffix, to a length m=Θ((∣q∣+2)e). This padded language is in LCHP,1: verify its format in O(m) time and run the B decider on the logical input q. For P=basis, first apply [F5] to the fixed B decider on its actual ∣q∣-bit input using the constructible clock Tq=⌈K2(∣q∣+2)ej′⌉≥∣q∣. The normalized interpreter's index-only input reads are redirected to the encoded q substring, returning the original blank or zero answer for addresses outside that substring; offsetting and saturating the emitted input indices is charged within the normalization bound. Its run takes O(∣q∣ej′polylog ∣q∣)=O(m) because ej′<e. The sequential case reads the same encoded substring by local input moves within the same bound. Hence the padded language belongs to LCHP,1. The original linear-time oracle machine for LCHP,j+1 makes queries whose total lengths are O(n). For P=seq, use that machine directly on the logical input x. For P=basis, apply [F5] to its fixed code with a constructible clock K4(n+2)≥n; [F4] permits forwarding its exact completed oracle queries and answers. The resulting index-only simulation takes O(npolylog n) time. Use a self-delimited padded input with the length and x available in a designated prefix. The padded-language machine checks that encoding in O(m) time; the index-only simulation redirects each logical input read to the encoded x substring and returns the original blank/zero answer outside it. This offset handling is charged to the emitted input-index bits. Replace each query q by its padded version of length Θ((∣q∣+2)e). The sum of these query lengths is O(∑q(∣q∣+2)e)=O(ne) because the original query lengths and query count sum to O(n). Padding counters and query writes have the same total bound, so the padded outer language is decided in O(m) time with oracle Be∈LCHP,1 and hence lies in LCHP,2.

5.1F3F4F5F6step 3.1step 4.1constructalgebra

Apply the mρ time decider from step 3.1 to that padded outer language, whose input is y=pad⁡e(x) of length m=Θ((n+2)e). In the basis profile its block queries may again use long address blocks, so normalize this decider with [F5] at the constructible clock Tm=⌈K3(m+2)ρ⌉≥m. Its exact index-only interpreter has time and physical work-access extent bounded by a constructible Tm′=O(mρpolylog m). The bits of y are generated from x by the self-delimited prefix and zero-padding map in polylogarithmic time and logarithmic space; its padding length, the clocks, and the address majorants have polylog-time/logspace binary generators. Since Tm′ is polynomial in n, choose a constructible power-of-two address majorant Mn=2⌈Klog⁡2(n+2)⌉≤(n+2)K+1 and apply [F6] to simulate the normalized run on this generated input. The resulting time is O((n+Tm′+1)log⁡O(1)(n+2))=O(neρpolylog n). In the sequential profile, supply the same padded bits on demand to the sequential decider with at most polylogarithmic overhead per input transition. Choose rational ej+1′ strictly between eρ and eδ=δj; the strict margin absorbs all polylogarithmic factors. This proves the induction assertion with its needed margin for the next padding step.

6.1F1F2F3step 2.1step 4.1step 5.1contradiction∎

Steps 2.1 and 4.1–5.1 give PrTIMEP(nb)⊆PrTIMEP(nδτ−1) although δτ−1<b. Both exponents are rational and strictly greater than or equal to one, so [F1] contradicts this containment. The two assumed deciders therefore cannot both exist. This proves the stated alternative in either fixed profile without converting a VMW time/space computation to a sequential one.

Historical profile

The separately named preprint-delimited profile is not identified with the final erased-index profile. An extension of this theorem to that distinct profile is not proved or used here.

Depends on

Used by

Dependency tree · two levels

14 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