Alphabeta Math
TheoremStatement: Literature-sourcedProof: AI-adaptedPipeline-generatedprecheck passaudited 2026-09-30
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.

Fixed-alphabet reduction with constant gap retention

Statement

For every finite alphabet Σ with ∣Σ∣≥2 there is a deterministic map AΣ sending finite binary constraint graphs over Σ to finite binary constraint graphs over the one fixed alphabet Σ^={B(0),B(1)}⊔{T(a):a∈{0,1}6} of size 2+26=66, with the following properties for every input G with m=∣E(G)∣ edges.

  1. Value one. val⁡(G)=1 if and only if val⁡(AΣ(G))=1.
  2. Size. ∣E(AΣ(G))∣≤CΣm and ∣V(AΣ(G))∣≤CΣm for a constant CΣ depending only on Σ, never on G.
  3. Gap retention. With ρ0=1/1000 and δ=1/2, UNSAT⁡(AΣ(G))≥κUNSAT⁡(G),κ=ρ0δ4⋅6=148000.
  4. Uniformity. AΣ is computable by a deterministic algorithm in time polynomial in the bit length of the explicit encoding of G.

The output alphabet depends only on the arity bound six of the local tester, not on Σ or on the input size, and the constant κ is absolute.

Facts & Assumptions

Given: Fix a finite alphabet Σ with W:=∣Σ∣≥2, its code length ℓ=2⌈log⁡2W⌉, and an input graph G with m edge records. Let P be the two-piece Boolean assignment tester of A two-piece constant-query PCP of proximity and put H=G∘P.

[F1]

If E(G)≠∅, then H is a Boolean constraint system of arity at most six whose variables are the active vertex blocks and edge-private auxiliary copies, and whose constraint list has exactly ∣E(G)∣M constraints, where M=lcm⁡{qe:e∈E(G)} is the least common multiple of the positive local gadget sizes. If E(G)=∅, then H has no variables and no constraints. (Composition of an edge system with an assignment tester)

[F2]

The map C from Σ to the selected Walsh–Hadamard codewords is injective, and every two distinct selected codewords have relative distance δ=1/2; the selected block length is ℓ with W≤ℓ<2W. (Shared codeword blocks and edge acceptance circuits, Distinct Walsh–Hadamard words differ on half the cube)

[F3]

For an edge relation Re, the robust edge circuit has the 2ℓ formal input bits and at most O(W3) gates, so its size is bounded by a constant depending only on Σ. (Shared codeword blocks and edge acceptance circuits)

[F4]

The local tester is a Boolean assignment tester of arity at most six and rejection ratio ρ0=1/1000; for a circuit of N wires its finite constraint list has at most 27N2+4 constraints. (A two-piece constant-query PCP of proximity)

[F5]

If val⁡(G)=1 then val⁡(H)=1, including the edgeless case. (Composition preserves perfect satisfiability)

[F6]

If E(G)≠∅ then UNSAT⁡(H)≥ρ0δ4UNSAT⁡(G)=18000UNSAT⁡(G); if E(G)=∅ then both unsatisfaction values are zero. (Composition transfers a constant fraction of unsatisfaction)

[F7]

For q≥2, every finite explicit Boolean constraint system whose listed constraints have arities between 1 and q has a deterministically constructible binary constraint graph over {B(0),B(1)}⊔{T(a):a∈{0,1}q} with at most q edge records per listed constraint, perfect completeness, and UNSAT⁡(G′)≥UNSAT⁡(C)/q. Its construction keeps one shared vertex per input variable and adds one private tuple vertex per listed constraint. (Bounded-arity Boolean constraints become binary graph constraints)

[F8]

Graph value is the maximum satisfied edge fraction and system value is the maximum satisfied constraint fraction; both are 1 on an empty list, and UNSAT⁡=1−val⁡ on each side. (Constraint graph and labeling value, Assignment tester and rejection ratio)

[F9]

An explicit constraint graph with ∣V∣ vertices and ∣E∣ edges uses O(∣V∣+∣E∣∣Σ∣2) table entries and endpoint names of O(log⁡(∣V∣+2)) bits, and a graph with m edge records has at most 2m nonisolated vertices. (Constraint graph and labeling value)

[F10]

For an edge circuit on two formal pieces of length ℓ, the two-piece tester has Ne≥2ℓ≥4 QUADEQ wires, uses 2ℓ+2ℓ+1+2Ne+2Ne2 local variables, and pads its nine test families to qe=9De2Ke constraints, where De≥1 and Ke≥2Ne2 because the BLR test on the tensor table uses 2Ne2 random bits. Therefore the local variable count is at most 4⋅2Ne2≤qe. (A two-piece constant-query PCP of proximity, proof steps 1.2, 2.3, 3.2])

Proof

Given: Use the fixed alphabet, code length and input graph from the statement, and define AΣ(G) below by the two cited constructions.

1.1F7givenconstruct

Define AΣ(G) to be the binary graph produced by applying Bounded-arity Boolean constraints become binary graph constraints with q=6 to the Boolean system H=G∘P when E(G)≠∅, and to the empty system when E(G)=∅. Its output alphabet is the Σ^ displayed in the statement, independent of Σ: the two bit labels B(0),B(1) and the 64 tuple labels T(a), a∈{0,1}6.

1.2F1F7F8givencases

Suppose first that E(G)=∅. Then H has no variables and no constraints by [F1], so val⁡(H)=1 and UNSAT⁡(H)=0 by [F8]; the conversion of the empty system is an edgeless graph, so val⁡(AΣ(G))=1 and UNSAT⁡(AΣ(G))=0 by [F8] and [F7]. The input also has val⁡(G)=1 and UNSAT⁡(G)=0, and 0≤CΣ⋅0 holds for every constant. This disposes of the edgeless case for all four clauses.

1.3F1F3F4F10givenalgebra

Suppose now that E(G)≠∅. By [F3] and [F4], for a fixed Σ every edge circuit has at most NΣ:=2ℓ+O(W3) wires, with the implicit constant of [F3] depending only on Σ; hence every local gadget size satisfies qe≤QΣ:=27NΣ2+4. The least common multiple M of the finitely many numbers qe therefore divides lcm⁡(1,…,QΣ)=:MΣ, a finite integer depending only on Σ. Thus H has Mm≤MΣm constraints by [F1], each of arity at most six, and its variable set is the union of the 2ℓ coordinates of each active block and the m edge-private auxiliary lists. For the explicit vertex count, [F10] shows that each local gadget has at most qe variables, so the number of edge-private variables contributed by one edge is at most qe≤qmax⁡:=max⁡eqe≤QΣ.

1.4F7F8F5givenconstruct

Assume val⁡(G)=1. Then [F5] gives val⁡(H)=1, so H has a labeling satisfying every one of its constraints. Applying the perfect-completeness clause of [F7] to that labeling produces a labeling of AΣ(G) satisfying every output edge, so val⁡(AΣ(G))=1.

1.5F2F6F7F8givenalgebra

Assume E(G)≠∅ and apply the gap clause of [F7] to H with q=6. Combined with [F6] and the code distance δ=1/2 of [F2], the transfer factor ρ0δ/4=1/8000 gives UNSAT⁡(AΣ(G))≥UNSAT⁡(H)6≥16⋅8000UNSAT⁡(G)=148000UNSAT⁡(G)=κUNSAT⁡(G).

2.1F8step 1.2step 1.4step 1.5algebracases

Conversely assume val⁡(AΣ(G))=1. Then UNSAT⁡(AΣ(G))=0 by [F8]. If E(G)=∅ then val⁡(G)=1 by [F8]. If E(G)≠∅, then step 1.5 gives κUNSAT⁡(G)≤0, so UNSAT⁡(G)=0 and val⁡(G)=1. This proves the reverse direction of clause 1, and step 1.4 proves the forward direction.

2.2F1F7F9F10step 1.2step 1.3algebracases

For the size clause assume E(G)≠∅. The conversion adds at most six edge records per constraint of H by [F7], so ∣E(AΣ(G))∣≤6∣E(H)∣=6Mm≤6MΣm, using step 1.3. Its vertex set consists of the vertices of H, one per variable, together with one private tuple vertex per constraint of H; by [F1] the number of vertices of H is at most (2ℓ+qmax⁡)m, where 2ℓ accounts for a block per nonisolated vertex (at most two per edge), and [F10] together with step 1.3 bounds the private variables of each edge gadget by qmax⁡. Hence ∣V(AΣ(G))∣≤(2ℓ+qmax⁡+MΣ)m by [F1] and [F9]. Both bounds hold with CΣ:=6MΣ+2ℓ+QΣ+MΣ, a constant depending only on Σ; for E(G)=∅ the output is edgeless and both quantities are zero.

3.1F1F3F4F7step 1.3step 2.2algebradischarge-construct

The map AΣ is deterministic: the robust edge circuits and the two-piece tester are deterministic constructions, the least common multiple and the conversion are computed from finite explicit lists, and no sampling or selection from an infinite family occurs. For fixed Σ each edge contributes a search over a constant-size tester transcript enumeration and a constant number of copied constraints, so all relation tables and endpoint names are written in time polynomial in the input encoding length plus the output bit length OΣ(mlog⁡(m+2)), which is itself polynomial in the input length by clause 2.

4.1F7step 1.1step 1.2step 1.4step 1.5step 2.1step 2.2step 3.1algebradischarge-construct∎

Clauses 1, 2, 3 and 4 are now proved: clause 1 by steps 1.4 and 2.1, clause 2 by step 2.2, clause 3 by step 1.5 together with the trivial edgeless identity of step 1.2, and clause 4 by step 3.1. The defining constant is κ=ρ0δ/(4⋅6)=(1/1000)(1/2)/24=1/48000, and the output alphabet is Σ^ of size 2+26=66 for every Σ.

Remarks

The construction is the alphabet-reduction step of Dinur's proof: each edge's robust Walsh–Hadamard gadget is replaced by the constant-arity Boolean tester of A two-piece constant-query PCP of proximity, and the resulting arity-six system is converted into a binary graph over the tagged alphabet {B(0),B(1)}⊔{0,1}6. Lemma 1.8 of the source and its proof supply the composition pattern, the decoding of shared blocks, and the linear size accounting; the quantitative distance constant δ/4, the ratio ρ0, the arity-six conversion and the constant κ=1/48000 are proved in the local items cited above, not read off from the source's asymptotic statements.

The bound MΣ is enormous but depends only on Σ: the tester's constraint count is exponential in the square of the edge-circuit size, which is a constant once the input alphabet is fixed. That is exactly what the later fixed-alphabet iteration needs, since the iteration applies A with the one alphabet Σt selected before the input size is known. No axiom of choice is used: every construction here is deterministic, and the finite least common multiple is canonical.

Depends on

Used by

Dependency tree · two levels

24 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