Alphabeta Math
Pipeline-generated
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.

✓ 26 results · all verified · 14 also independently AI-judged
Every result on this page is machine-checked by a proof checker and read in full and owner-audited; the judge is an additional, independent cross-model AI review of the proofs. The 12 not AI-judged were verified by owner audit (typically over a confirmed judge false positive), not failures.

Alphabet Reduction and the PCP Theorem

1 · Prerequisites

2 · Summary

The PCP theorem gives an alternative way to verify an NP certificate: a polynomial-time verifier reads a fixed proof string at only a constant number of locations chosen with O(log⁡n) random bits. This page fixes the proof length, completeness, soundness and nonadaptive-query conventions before turning two-query verifiers into binary constraint graphs.

The alphabet-reduction argument first encodes graph labels as shared Walsh–Hadamard blocks. A violated decoded edge stays far from the accepting inputs of its edge circuit. Linear and tensor consistency tests, random subsum checks, and a two-piece PCP of proximity supply a constant-query assignment tester. Composing the tester with each edge preserves perfect completeness and transfers a constant fraction of the original unsatisfaction to a Boolean bounded-arity system. A binary-star conversion then gives one fixed 66-symbol alphabet, with controlled graph size and degree.

The fixed-alphabet transformation combines that reduction with the earlier graph gap-amplification step. One iteration doubles sufficiently small unsatisfaction while growing the explicit graph by only a constant factor; O(log⁡m) iterations reach a constant gap at polynomial size. The three-CNF graph reduction and Cook–Levin theorem make this gap promise NP-hard. Sampling a random graph edge proves NP=PCP⁡(log⁡n,O(1)) with perfect completeness and constant soundness below one. Independent repetition amplifies soundness on the same fixed proof. The two false statements delimit the construction: graph powering alone can enlarge its view alphabet, and the PCP proof string is not sampled afresh for each verifier run.

3 · Logical flowchart

4 · Definitions, theorems and proofs

DefinitionDefinition: Literature-sourcedProof: Not applicablejudge pass (gpt-6-sol)audited 2026-09-30Open item page →

PCP verifier resources and deterministic proof strings

Definition

Fix a finite proof alphabet Γ independent of the input length. A nonadaptive PCP verifier with resource bounds r,q,L is a uniform polynomial-time randomized oracle algorithm V such that, on each input x∈{0,1}n, it uses at most r(n) unbiased random bits, reads a fixed proof π∈ΓL(n) at at most q(n) locations, and outputs accept or reject. For every input and every coin string, the queried locations are computed from x and the coins before any proof symbol is read; each lies in [L(n)]. Repeated locations count as repeated queries. The bound L(n) is polynomial in n and counts addressable symbols, not the bits in their binary addresses. When L(n)=0, the proof is empty and the verifier makes no queries.

For a fixed input x and a fixed proof π, the acceptance probability is the proportion of the 2r(n) coin strings on which Vπ(x) accepts. The coin set is nonempty even when r(n)=0, in which case it contains the empty string. Completeness asks for one fixed proof on each yes input; soundness bounds the acceptance probability for every fixed proof on each no input. Thus the proof is not resampled when the verifier runs. This oracle version refines the verifier viewpoint of The class NP via polynomial-time verifiers, with its coin space interpreted as the uniform finite probability space of The uniform probability space on a nonempty finite set.

DefinitionDefinition: Literature-sourcedProof: Not applicablejudge pass (gpt-6-sol)audited 2026-09-30Open item page →

PCP classes with completeness and soundness

Definition

Let r,q:N→N be resource bounds and let 0≤s<c≤1 be constants independent of input length. A language K⊆{0,1}∗ belongs to PCP⁡(r,q;c,s) exactly when there are a verifier V of the type in PCP verifier resources and deterministic proof strings, with randomness bound r(n) and query bound q(n), a fixed finite proof alphabet, and a polynomial p such that its addressable proof length LV(n) is at most p(n) and the following hold for every input x of length n:

  • If x∈K, there is one fixed proof π with Pr⁡[Vπ(x) accepts]≥c.
  • If x∉K, every fixed proof π satisfies Pr⁡[Vπ(x) accepts]≤s.

Both probabilities are over the verifier's coins; the same deterministic proof is used for every coin string. In the shorthand PCP⁡(log⁡n,O(1)), the proof alphabet is {0,1}, the randomness is O(log⁡n), the number of bit queries is bounded by a constant, completeness is perfect (c=1), and soundness is at most some fixed constant s<1. Here O(1) means a constant query bound, not exactly one query.

LemmaStatement: Literature-sourcedProof: AI-adaptedprecheck passjudge pass (gpt-6-sol)audited 2026-09-30Open item page →

Two-query PCPs and binary constraint graphs

Statement

Fix a finite nonempty alphabet Σ. First, let G be an explicit binary (arity-two) constraint multigraph over Σ with m≥1 edges. There is a nonadaptive verifier whose proof is a labeling σ:V(G)→Σ, which uses exactly ⌈log⁡2m⌉ random bits and reads at most two symbols, such that for every fixed labeling Pr⁡[Vσ rejects]=m2⌈log⁡2m⌉ UNSAT⁡σ(G)≥12UNSAT⁡σ(G). It has perfect completeness on satisfiable graphs, and if UNSAT⁡(G)≥δ then every proof is rejected with probability at least δ/2.

Conversely, fix an input x and a nonadaptive verifier with proof alphabet Σ, at most two symbol queries, and r unbiased random bits. One can construct an explicit binary constraint multigraph GV,x over Σ with one edge per random tape (hence at most 2r edges) so that every fixed proof has exactly the same acceptance fraction as its induced graph labeling, and every graph labeling extends to a proof with the same fraction. Therefore val⁡(GV,x)=max⁡πPr⁡[Vπ(x) accepts]. The graph has O(2r) vertices and edges for fixed Σ, is constructible in time polynomial in ∣x∣+2r, and is polynomial size when r=O(log⁡∣x∣). By the definition of GapCSP⁡(c,s), its yes and no value thresholds are exactly the corresponding completeness and soundness thresholds. If a binary proof convention is required, encoding each Σ symbol by a fixed number of bits changes two symbol queries to a constant number of nonadaptive bit queries without changing the best acceptance probability.

Facts & Assumptions

Given: The fixed alphabet, explicit graph or verifier input, and the verifier's fixed proof and random tape in the reverse construction.

[F1]

PCP completeness and soundness quantify over fixed proofs; the verifier has a fixed finite proof alphabet and bounded randomness and queries. (PCP classes with completeness and soundness)

[F2]

Each graph edge has an ordered binary relation on its endpoint labels; loops test the relation on the same label twice. (Constraint graph and labeling value)

[F3]

For a fixed labeling, value is the fraction of satisfied edges and unsatisfaction is one minus that fraction; graph value is the maximum over labelings. (Constraint graph and labeling value)

[F4]

GapCSP⁡(c,s) has yes instances with value at least c and no instances with value at most s; values strictly between the thresholds are outside the promise. (Gap csp)

Proof

1.1F1F2F3givenconstructalgebra

For the graph-to-verifier direction, order the m edges and use rG=⌈log⁡2m⌉ random bits to choose one of 2rG indices. For indices below m, query the edge's endpoints in its specified order and accept exactly when their labels satisfy its relation; surplus indices accept without queries. This is nonadaptive, and a loop reads the same proof symbol twice. For a fixed labeling σ, exactly mUNSAT⁡σ(G) of the m real-edge indices reject, so the rejection probability is mUNSAT⁡σ(G)/2rG. Since 2rG<2m, this is at least half the labeling's unsatisfaction; taking the minimum over labelings gives the stated graph-unsatisfiability bound.

1.2F1F2givenconstruct

For the verifier-to-graph direction, enumerate its 2r random tapes. On each tape the nonadaptive query addresses are fixed. Make one ordered edge per tape with endpoint vertices equal to the two queried proof positions, and put in its relation exactly the answer pairs on which that tape accepts. If the two addresses coincide, make a loop with relation {(a,a):V accepts on this tape when the repeated location returns a}; its off-diagonal entries are empty. If there is one query, use a fresh dummy vertex as the second endpoint and let the relation ignore its label; if there are no queries, use a loop at a dummy vertex with relation Σ2 when that tape accepts and the empty relation when it rejects. Retain parallel edges, including identical tape outcomes, so the graph has exactly 2r edges.

2.1F1F2F3step 1.2algebra

For any fixed proof π, label each retained proof-position vertex by its symbol and each dummy by a fixed default symbol in the nonempty alphabet. The edge for a tape is satisfied exactly when that run accepts, so its satisfied-edge fraction equals Pr⁡[Vπ(x) accepts]. Conversely, any graph labeling extends to a proof by assigning its symbols at retained positions and a fixed default symbol at every unused proof position; hence maximizing over proofs gives exactly val⁡(GV,x). Since the proof space is finite, this maximum is attained.

3.1F1F3F4step 2.1discharge-constructalgebra∎

At most two proof positions occur on each of 2r tapes, so after removing unused proof positions the graph has at most 2r+1+1 vertices, and its fixed-size relation tables and endpoint names can be written in polynomial time in ∣x∣+2r. Thus r=O(log⁡∣x∣) gives a polynomial-size graph. The exact value equality in step 2.1, [F3] and [F4] transfer both threshold directions: value at least c iff some fixed proof accepts with probability at least c, and value at most s iff every fixed proof accepts with probability at most s. For binary proofs, choose k=max⁡(1,⌈log⁡2∣Σ∣⌉) and a fixed surjection D:{0,1}k→Σ; decoding each queried block makes every bit proof a Σ-symbol proof, and every symbol proof has a block encoding, so the maximum is unchanged while at most 2k=O(1) bits are queried.

DefinitionDefinition: Literature-sourcedProof: Not applicableaudited 2026-09-30Open item page →

Walsh–Hadamard encoding and relative Hamming distance

Definition

For n≥0 and u∈F2n, the Walsh–Hadamard encoding WH⁡n(u) is the truth table of the linear function r↦u⋅r on F2n, with coordinates indexed in lexicographic order by r. Thus the table has length 2n, including the one-entry table WH⁡0(())=(0) when n=0. Its entry at a unit vector is WH⁡n(u)(ei)=u⋅ei=ui.

For two tables a,b with the same nonempty finite coordinate set I, their relative Hamming distance is dist⁡(a,b)=∣{i∈I:a(i)≠b(i)}∣∣I∣. For Walsh–Hadamard tables of dimension n, I=F2n and the denominator is 2n>0. In particular the n=0 table has a well-defined relative distance. The linear functions and their truth-table convention are those of The BLR linearity test over F_2, and the coordinates are the cube variables used by Hadamard linearity constraint system.

LemmaStatement: Literature-sourcedProof: AI-adaptedprecheck passaudited 2026-09-30Open item page →

Distinct Walsh–Hadamard words differ on half the cube

Statement

For n≥1 and distinct u,v∈F2n, the tables WH⁡n(u) and WH⁡n(v) differ at exactly 2n−1 of their 2n coordinates, so their relative distance is one half. For n=0 there are no distinct messages.

Facts & Assumptions

[F1]

WH⁡n(u) is the truth table of r↦u⋅r on F2n, indexed by r, and the relative distance is the fraction of disagreeing coordinates. (Walsh–Hadamard encoding and relative Hamming distance)

Proof

Given: Fix n≥1 and distinct u,v∈F2n.

1.1F1givenconstruct

Put d=u+v. Since u≠v, d is nonzero. At a mask r∈F2n, the two table values disagree exactly when (u⋅r)+(v⋅r)=d⋅r=1.

2.1step 1.1algebra

Choose a coordinate j with dj=1 and let ej be its unit vector. The map r↦r+ej is an involution without fixed points, and d⋅(r+ej)=d⋅r+1. Thus it partitions the 2n masks into 2n−1 pairs, with exactly one mask in each pair satisfying d⋅r=1. The coordinate choice exists because d is a nonzero finite binary vector.

3.1F1step 1.1step 2.1algebradischarge-construct∎

By step 2.1 and the disagreement criterion in step 1.1, exactly 2n−1 table coordinates differ. Dividing by the 2n coordinates gives relative distance 2n−1/2n=1/2. If n=0, F20 has only its empty vector, so the statement has no distinct-message pair to check.

DefinitionDefinition: AI-adaptedProof: Not applicableaudited 2026-09-30Open item page →

Shared codeword blocks and edge acceptance circuits

Definition

Fix a finite ordered alphabet Σ={σ0,…,σW−1} with W≥2. Put k=⌈log⁡2W⌉ and ℓ=2k. Let u(0),…,u(2k−1) be the k-bit vectors in lexicographic order and define the codeword of σi to be C(σi):=WH⁡k(u(i))∈{0,1}ℓ,0≤i<W. The map C is injective, and every two distinct selected codewords have relative distance δ=1/2 by Distinct Walsh–Hadamard words differ on half the cube. Moreover, W≤ℓ<2W: the lower bound follows from k=⌈log⁡2W⌉, and 2k−1<W gives the strict upper bound.

For a constraint graph over Σ as in Constraint graph and labeling value, discard its isolated vertices (which do not affect its value). Give each remaining vertex v one physical block Bv∈{0,1}ℓ, shared by all incident edges. A block is valid when it equals C(a) for some a∈Σ; its decoded label is then the unique such a. The table order inside each block is that of Walsh–Hadamard encoding and relative Hamming distance.

For each edge e=(v,w) with its specified endpoint order and relation Re⊆Σ2, define an edge circuit with formal input pieces X,Y∈{0,1}ℓ. Its Boolean function is ERe(X,Y):=⋁(a,b)∈Re([X=C(a)]∧[Y=C(b)]), where [P] is 1 when P holds and 0 otherwise, and the empty disjunction is 0. Thus ERe(X,Y)=1 exactly when both blocks are valid and their decoded labels form a pair in Re. This function has an explicit circuit in the AND/OR/NOT basis of Boolean circuits: basis, fan-in, size, and depth: compare each input bit to the corresponding constant codeword bit, conjoin the 2ℓ comparisons for each allowed pair, then OR the pair tests. The circuit uses O(∣Re∣ℓ) gates (or the constant-zero output if Re=∅), so at most O(W2ℓ)=O(W3) gates. In the graph, compose its first formal piece with Bv and its second with Bw; for a loop v=w, both pieces use the same physical block, so the test is exactly the diagonal test Re(a,a) required for loops. Reversing an endpoint order transposes the relation and swaps the formal pieces. If the graph has no edges, it has no blocks or edge circuits after isolated vertices are discarded.

LemmaStatement: Literature-sourcedProof: AI-adaptedprecheck passjudge pass (gpt-6-sol)audited 2026-09-30Open item page →

A violated decoded edge is far from edge-circuit acceptance

Statement

Use the code C:Σ→{0,1}ℓ and edge circuit ERe of Shared codeword blocks and edge acceptance circuits, where Σ is finite, ordered, ∣Σ∣=W≥2, and distinct codewords have relative distance δ=1/2. For any physical block Bv∈{0,1}ℓ at each graph vertex, decode Bv to a closest codeword, breaking ties by the fixed alphabet order, and write the decoded label as av. Regard the 2ℓ formal input bits of ERe as all named inputs, so its accepting set is SAT⁡(ERe)⊆{0,1}2ℓ. Measure relative Hamming distance on these 2ℓ bits and use distance 1 when the accepting set is empty, as in Assignment tester and rejection ratio.

If edge e=(v,w) is violated by the decoded labels, then dist⁡rel((Bv,Bw),SAT⁡(ERe))≥δ4=18. For a loop v=w, the displayed input is (Bv,Bv) and the same bound holds.

Facts & Assumptions

Given: A finite ordered alphabet with W≥2, its Walsh–Hadamard code blocks, an edge circuit, and arbitrary physical blocks at its vertices.

[F1]

The selected codewords are injective and every two distinct codewords have relative distance δ=1/2. (Shared codeword blocks and edge acceptance circuits)

[F2]

The edge circuit accepts exactly pairs of valid codewords whose decoded labels lie in the ordered edge relation Re. (Shared codeword blocks and edge acceptance circuits)

[F3]

Distance from a named input to a circuit's accepting inputs is relative Hamming distance, with value 1 when the accepting set is empty. (Assignment tester and rejection ratio)

Proof

1.1F1givenconstructalgebra

For each block Bv, the fixed alphabet order makes its nearest valid codeword label av deterministic; a minimizer exists because Σ is finite and nonempty. For every a′≠av, nearestness and the triangle inequality give δℓ≤dH(C(av),C(a′))≤dH(C(av),Bv)+dH(Bv,C(a′))≤2dH(Bv,C(a′)). Hence every changed decoded label has dH(Bv,C(a′))≥δℓ/2=ℓ/4.

2.1F2F3step 1.1constructalgebradischarge-construct∎

Suppose (av,aw)∉Re. By [F2], every accepting formal input (X,Y) is (C(a′),C(b′)) for some (a′,b′)∈Re, so at least one decoded endpoint changes. By step 1.1, the corresponding formal block differs from the actual block by at least ℓ/4 bits; division by the 2ℓ formal input bits gives relative distance at least δ/4=1/8. If v=w, the actual formal pair is (Bv,Bv) and the violated loop pair is (av,av)∉Re, so every accepting pair still changes at least one of the two decoded labels and the same bound applies to that formal block. If there are no accepting inputs, [F3] sets the distance to 1≥1/8.

LemmaStatement: Literature-sourcedProof: AI-adaptedprecheck passjudge pass (gpt-6-sol)audited 2026-09-30Open item page →

Random binary subsums detect every nonzero discrepancy

Statement

For every nonzero d∈F2m and uniform z∈F2m, Pr⁡[z⋅d=1]=12. The same conclusion applies whenever d is a nonzero vector of violated quadratic equations or the difference of two distinct decoded prefixes.

Facts & Assumptions

Given: A nonzero binary vector d∈F2m and the uniform distribution on the finite cube.

[F1]

Distinct Walsh–Hadamard messages in dimension m≥1 have tables that disagree on exactly half the coordinates. (Distinct Walsh–Hadamard words differ on half the cube)

Proof

1.1givenconstructalgebra

Since d≠0, choose the least index j with dj=1, and let ej be its unit vector. The map z↦z+ej is a fixed-point-free involution of the cube and (z+ej)⋅d=z⋅d+1, so it pairs each outcome with one whose dot product has the opposite bit.

2.1F1step 1.1algebradischarge-construct∎

Each pair from step 1.1 has exactly one vector with z⋅d=1, hence exactly 2m−1 of the 2m vectors satisfy the event and its uniform probability is 1/2. Equivalently these are precisely the coordinates where WH⁡m(0) and WH⁡m(d) disagree, consistent with the half-distance lemma in [F1]. Thus every nonzero violated-equation vector and every difference of distinct prefixes has the same detection probability; the number and correlations of its coordinates are irrelevant.

DefinitionDefinition: Literature-sourcedProof: Not applicableaudited 2026-09-30Open item page →

Quadratic equations and tensor-code oracle tables

Definition

For N,M≥0, a QUADEQ instance over F2 is an ordered list (Aj,bj)j=1M, where each Aj is an N×N binary matrix and bj∈F2. Use the row-major order on pairs (i,k)∈[N]2 to identify matrices with vectors in F2N2. The instance is in canonical form when Aj,ik=0 for i>k. A vector w∈F2N satisfies the instance when, for every j∈[M], ∑i,k=1NAj,ikwiwk=bj. For canonical instances the sum may equivalently be restricted to i≤k. For a general matrix, its canonical representative has diagonal entries Aj,ii and upper entries Aj,ik+Aj,ki for i<k, with zero entries below the diagonal; it defines the same quadratic form. Equivalently, after flattening by that row-major order, Aj⋅(w⊗w)=bj. Constants in a quadratic equation are moved to the right-hand side, repeated monomials cancel modulo two, and a square wi2 is represented by the diagonal coordinate (i,i), since wi2=wi in F2. When M=0 the equation list is empty and every w satisfies it; when N=0 the vector and tensor are empty and each equation has left-hand side 0.

For w∈F2N, its intended oracle pair is fw=WH⁡N(w):F2N→F2,gw=WH⁡N2(w⊗w):F2N×N→F2, where the second domain is flattened in the same row-major order. Thus fw(r)=w⋅r and gw(Z)=∑i,k=1NwiwkZik, with the sum interpreted as 0 when N=0. Their truth-table lengths are respectively 2N and 2N2; if stored in one proof string, the fw table precedes the gw table. The table indexing, including the one-entry truth tables at dimension zero, is the convention of Walsh–Hadamard encoding and relative Hamming distance. The tensor coordinates and ordered-pair indexing used by the consistency test are those of Quadratic tensor consistency test.

LemmaStatement: Literature-sourcedProof: AI-adaptedprecheck passaudited 2026-09-30Open item page →

Boolean circuits become quadratic systems with a fixed input prefix

Statement

Let C be an explicit topologically ordered Boolean circuit with s input wires, a designated prefix of n inputs where 0≤n≤s, and m non-input nodes. Each non-input node is a constant 0 or 1, a NOT gate, or a two-input AND or OR gate; represented constant nodes count among the m nodes. Its output is one of the resulting s+m wires. There is a deterministic polynomial-time construction of a QUADEQ instance over F2 with N=s+m wire variables and m+1 equations, each with at most four monomials. The variables are ordered with the s input wires first and the non-input nodes next in topological order, so the named inputs are the first n variables. For every x∈F2n, fixing those first n variables to x extends to a solution of the QUADEQ instance if and only if there is a completion y∈F2s−n such that C(x,y)=1.

Facts & Assumptions

Given: A valid circuit as in the statement and the fixed named-prefix assignment x.

[F1]

In the canonical QUADEQ encoding, constants are moved to the right-hand side, repeated monomials cancel in F2, and a linear term wi is represented by the diagonal monomial wi2. (Quadratic equations and tensor-code oracle tables)

[F2]

A Boolean circuit is a finite directed acyclic graph with input wires, constants, NOT/AND/OR gates, a designated output, and evaluation in topological order. (Boolean circuits: basis, fan-in, size, and depth)

[F3]

Circuit satisfiability asks whether some input assignment makes the designated output one. (Circuit satisfiability)

Proof

1.1F2givenconstruct

Number the s primary input wires first, then number the m remaining nodes in topological order, and associate a variable wi to each wire. Thus N=s+m, and fixing w1,…,wn to x fixes exactly the named prefix; the other primary input variables remain available for the completion.

2.1F1F2step 1.1algebra

For a constant node with variable z and value c, impose z=c; for a NOT node with input a impose z+a=1; for an AND node with inputs a,b impose z+ab=0; and for an OR node impose z+a+b+ab=0. These equations force exactly the indicated Boolean operation: in particular a∨b=a+b+ab for bits. They remain valid when the two input wires coincide, after reducing repeated monomials using a2=a in F2. Append the output equation wout=1. There are m+1 equations, each with at most four monomials. Using [F1], place each linear term on its diagonal tensor coordinate, each quadratic term on its upper-triangular coordinate, and each constant on the right-hand side; this gives a canonical QUADEQ instance.

3.1F2F3step 2.1algebra

Suppose a solution extends the prefix x. Its next s−n coordinates define a completion y. The gate equations in step 2.1, read in topological order, force every non-input wire to equal its evaluated circuit value, and the output equation forces C(x,y)=1.

3.2F2F3step 2.1constructalgebra

Conversely, suppose some completion y makes C(x,y)=1. Set the first s variables to (x,y) and set every remaining variable to the value of its node under the circuit evaluation. Each constant or gate equation in step 2.1 then holds by its defining Boolean operation, and the output equation holds because the output is one. This constructs a QUADEQ solution extending x, proving the reverse implication.

4.1F1F2step 2.1discharge-constructalgebra∎

The construction lists one constant-size equation per node and one output equation. Writing each of the m+1 coefficient matrices with N2 entries takes O((m+1)N2) time; since the explicit description lists all s+m=N wires, this is polynomial in its length. The equations themselves have the claimed bound from step 2.1. The construction uses only the topological order and fixed gate formulas, so it is deterministic.

LemmaStatement: Literature-sourcedProof: AI-adaptedprecheck passaudited 2026-09-30Open item page →

The BLR test supplies a nearby unique linear decoder

Statement

Let n≥0, f:F2n→F2, h(x)=(−1)f(x), and h^(a)=Ex[h(x)(−1)a⋅x]. Define its BLR rejection probability by ϵ=Pr⁡x,y independent uniform in F2n[f(x+y)≠f(x)+f(y)]. Let a∗ be the lexicographically first maximizer of h^(a) over a∈F2n. If ϵ<1/2, then dist⁡(f,WH⁡n(a∗))≤ϵ. If ϵ<1/4, this is the unique linear Walsh–Hadamard word at distance less than 1/4 from f. For every requested r∈F2n, the self-corrector Corr⁡f(r;y)=f(y)+f(r+y), with y uniform, returns a∗⋅r with probability at least 1−2ϵ.

Facts & Assumptions

[F1]

WH⁡n(a) is the truth table of x↦a⋅x; relative distance is normalized disagreement on the cube. (Walsh–Hadamard encoding and relative Hamming distance)

[F2]

For normalized Boolean-cube characters, Fourier inversion is h(x)=∑ah^(a)χa(x). (Character orthogonality, inversion and Parseval)

[F3]

Parseval gives Exh(x)2=∑ah^(a)2. (Character orthogonality, inversion and Parseval)

[F4]

Distinct linear Walsh–Hadamard words have relative distance exactly 1/2 (and there are no distinct messages when n=0). (Distinct Walsh–Hadamard words differ on half the cube)

[F5]

The two-query corrector chooses uniform y and returns f(y)+f(r+y). (Two-query linear self-correction)

Proof

Given: Fix n and f as in the statement; the vectors x,y in the rejection probability are independent and uniform.

1.1givenalgebra

The BLR test accepts exactly when f(x)+f(y)+f(x+y)=0 in F2. Thus h(x)h(y)h(x+y) is 1 on acceptance and −1 on rejection, so Ex,y[h(x)h(y)h(x+y)]=1−2ϵ. For n=0 the only pair is ((),()) and the test rejects exactly when f(())=1, so ϵ<1/2 forces f(())=0.

2.1F2step 1.1algebra

Write χa(x)=(−1)a⋅x. By Fourier inversion (F2), h(x+y)=∑ah^(a)χa(x+y), and χa(x+y)=χa(x)χa(y). Expanding the expectation in step 1.1 and using independence of x,y gives Ex,y[h(x)h(y)h(x+y)]=∑ah^(a)(Exh(x)χa(x))(Eyh(y)χa(y))=∑ah^(a)3.

3.1F1F3step 2.1constructalgebra

Parseval (F3) and h2=1 give ∑ah^(a)2=1. With M=max⁡ah^(a), step 2.1 yields 1−2ϵ=∑ah^(a)3≤M∑ah^(a)2=M. Choose the first maximizer a∗ in the finite lexicographic order. Since h^(a∗)=Pr⁡[f(x)=a∗⋅x]−Pr⁡[f(x)≠a∗⋅x], its Walsh–Hadamard word has distance (1−h^(a∗))/2≤ϵ.

4.1F4step 3.1algebra

If ϵ<1/4, the word from step 3.1 is within distance <1/4. Any other linear word within distance <1/4 would, by the triangle inequality for normalized Hamming distance, be at distance <1/2 from it, contradicting (F4); for n=0 there is only one linear word. Thus the nearby word is unique.

5.1F1F5step 3.1algebradischarge-construct∎

By (F5), the corrector returns f(y)+f(r+y). Each point y and r+y is uniform, so each queried value differs from a∗⋅y or a∗⋅(r+y) with probability δ=dist⁡(f,WH⁡n(a∗))≤ϵ. A union bound, without assuming independence of the two error events, shows that with probability at least 1−2ϵ both values are correct; then their sum is a∗⋅r. When n=0, ϵ<1/2 forces f(())=0, and the singleton-table corrector returns the sole linear value 0.

LemmaStatement: Literature-sourcedProof: AI-adaptedprecheck passaudited 2026-09-30Open item page →

Tensor consistency rejects a wrong decoded tensor

Statement

Let N≥0, u∈F2N, and V∈F2N×N with V≠u⊗u, using row-major tensor coordinates. Put Fu=WH⁡N(u) and GV=WH⁡N2(vec⁡(V)). The ideal test samples independent uniform r,s∈F2N and rejects exactly when GV(r⊗s)≠Fu(r)Fu(s). Its rejection probability is at least 1/4.

Now let fixed tables f:F2N→F2 and g:F2N×N→F2 have relative distances δf=2−N∣{x:f(x)≠Fu(x)}∣,δg=2−N2∣{Z:g(Z)≠GV(Z)}∣. The six-query self-corrected test samples independent uniform r,s,y,y′∈F2N and Y∈F2N×N, forms f^r=f(y)+f(r+y),f^s=f(y′)+f(s+y′),g^r⊗s=g(Y)+g(Y+r⊗s), and rejects exactly when g^r⊗s≠f^rf^s. It makes six nonadaptive table queries, allowing repeated locations, and rejects with probability at least 14−4δf−2δg. When N=0 the condition V≠u⊗u is impossible.

Facts & Assumptions

Given: A dimension N, a vector u, a matrix V≠u⊗u, and fixed tables f,g at the stated distances from the corresponding linear Walsh–Hadamard tables.

[F1]

Walsh–Hadamard tables are truth tables of linear forms, so WH⁡n(w)(x)=w⋅x. (Walsh–Hadamard encoding and relative Hamming distance)

[F2]

The ideal tensor test compares g(r⊗s) with f(r)f(s) for independent uniform r,s. (Quadratic tensor consistency test)

[F3]

Tensor coordinates are (r⊗s)ij=risj in fixed row-major order. (Quadratic tensor consistency test)

[F4]

For every nonzero binary vector d and uniform z, Pr⁡[z⋅d=1]=1/2. (Random binary subsums detect every nonzero discrepancy)

[F5]

The two-query corrector for a fixed oracle h at request q returns h(a)+h(q+a) for uniform a. (Two-query linear self-correction)

[F6]

The self-corrected tensor test independently samples its auxiliary points and uses two table queries for each of its three decoded values. (Quadratic tensor consistency test)

Proof

1.1F1F2F3F4givenconstructalgebra

Let D=V+u⊗u≠0 over F2, choose the first nonzero column j of D, and view r as a row vector. By [F4], rD≠0 with probability at least Pr⁡[r⋅D∗,j=1]=1/2. For each such r, rD is a nonzero vector, so [F4] gives Pr⁡s[rDs=1]=1/2. Since GV(r⊗s)+Fu(r)Fu(s)=rDs by [F1] and [F3], the rejection probability of the ideal test in [F2] is at least 1/4.

1.2F1F5givenalgebra

For any fixed requested point q and any fixed table h at relative distance η from a linear form L, the points a and q+a are both uniform when a is uniform. Unless either lies in the error set, [F5] returns h(a)+h(q+a)=L(a)+L(q+a)=L(q). The union bound therefore gives corrector error at most 2η, uniformly in q, including q=0.

2.1F2F6step 1.1step 1.2algebra

Apply step 1.2 to the two requests r,s for f and to request r⊗s for g. The probability that any of the three corrected values is wrong is at most 2δf+2δf+2δg=4δf+2δg. Outside that union, the self-corrected predicate in [F6] equals the ideal predicate in [F2]. Hence its rejection probability is at least the ideal rejection probability from step 1.1 minus 4δf+2δg, which is the claimed bound; no independence of the correction errors is used.

3.1F5F6step 2.1constructdischarge-construct∎

The test samples r,s,y,y′ using 4N unbiased bits and Y using N2 more, computes all six query locations before receiving any table value, and makes exactly six queries as stated in [F6]. Repeated locations are permitted by [F5]; for N=0, all domains are singletons and the hypothesis is impossible.

LemmaStatement: Literature-sourcedProof: AI-adaptedprecheck passaudited 2026-09-30Open item page →

A random subsum checks all quadratic equations at once

Statement

Let (Aj,bj)j=1M be a canonical QUADEQ instance over N variables and let u∈F2N fail at least one equation. For uniform z∈F2M, define A(z)=∑j=1MzjAj,b(z)=∑j=1Mzjbj. Then the combined equation A(z)⋅(u⊗u)=b(z) fails with probability exactly 1/2.

More generally, let g:F2N×N→F2 and set G=WH⁡N2(u⊗u) and δ=2−N2∣{Y:g(Y)≠G(Y)}∣. The nonadaptive test that chooses z and y independently and uniformly, queries g(y) and g(y+A(z)) (using the row-major tensor coordinates), and rejects when their sum differs from b(z) has rejection probability at least 12−2δ. It uses M+N2 unbiased random bits and two symbol queries.

Facts & Assumptions

Given: A canonical QUADEQ instance, a fixed candidate vector u, and the fixed oracle table g.

[F1]

Each equation is Aj⋅(u⊗u)=bj after flattening its canonical coefficient matrix in row-major order. (Quadratic equations and tensor-code oracle tables)

[F2]

The intended tensor oracle is G=WH⁡N2(u⊗u); for every tensor coordinate q, it satisfies G(q)=q⋅(u⊗u). (Quadratic equations and tensor-code oracle tables)

[F3]

For every nonzero d∈F2M and uniform z, Pr⁡[z⋅d=1]=1/2. (Random binary subsums detect every nonzero discrepancy)

[F4]

The two-query self-corrector at request q chooses uniform y and returns g(y)+g(q+y). (Two-query linear self-correction)

Proof

1.1F1F3givenalgebra

Put dj=Aj⋅(u⊗u)+bj. Since u fails at least one equation, d≠0. Linearity gives A(z)⋅(u⊗u)+b(z)=z⋅d, so the combined equation fails exactly when z⋅d=1; by [F3] this occurs with probability exactly 1/2.

1.2F2F4givenalgebra

Fix any requested tensor coordinate q. Let E={y:g(y)≠G(y)}, so ∣E∣/2N2=δ. Both y and q+y are uniform, and by [F4] the corrector returns g(y)+g(q+y). Unless one of these two points lies in E, this equals G(y)+G(q+y)=G(q) by linearity of the intended oracle in [F2]; a union bound therefore gives correction failure probability at most 2δ, uniformly for every q, including q=0.

2.1F1F2F4step 1.1step 1.2algebra

For the test, condition on each z and set q=A(z). By [F2] and [F1], on the event from step 1.1 the ideal value G(q)=A(z)⋅(u⊗u) differs from b(z); whenever the correction in step 1.2 returns G(q), the test rejects. Its failure probability conditional on each z is at most 2δ, so averaging gives Pr⁡[reject]≥Pr⁡[z⋅d=1]−2δ=12−2δ, without any independence assumption between rejection and correction errors.

3.1F2F4step 2.1constructdischarge-construct∎

The test samples M bits for z and N2 bits for y, computes both query locations before reading g, and makes exactly two symbol queries; thus it is nonadaptive and uses one combined equation instead of querying all M original equations. If M=0, its premise is impossible; if N=0, the tensor domain is a singleton and the corrector queries that same coordinate twice, as allowed by [F4].

TheoremStatement: Literature-sourcedProof: AI-adaptedprecheck passaudited 2026-09-30Open item page →

An exponential-length constant-query PCP for quadratic equations

Statement

For an N-variable, M-equation QUADEQ instance, represented with N in unary and its row-major coefficient matrices listed explicitly, there is a uniform nonadaptive verifier for a fixed binary proof of length 2N+2N2. It uses O(N2+M) random bits and at most six bit queries. Satisfiable instances have perfect completeness; every proof for an unsatisfiable instance is rejected with probability at least 1/400.

Facts & Assumptions

Given: A QUADEQ instance (Aj,bj)j=1M over N variables in the explicit encoding stated above, and an arbitrary fixed binary proof string.

[F1]

The instance is satisfied by u exactly when Aj⋅(u⊗u)=bj for every j. Replacing each Aj by its canonical upper-triangular representative, with the same diagonal entries and upper entries Aj,ik+Aj,ki for i<k, preserves that quadratic form. (Quadratic equations and tensor-code oracle tables)

[F2]

When M=0 the equation list is empty and every u satisfies it; when N=0 the vector and tensor are empty and each equation has left-hand side zero. (Quadratic equations and tensor-code oracle tables)

[F3]

The intended pair of truth tables has lengths 2N and 2N2, in that order when concatenated into one proof. (Quadratic equations and tensor-code oracle tables)

[F4]

WH⁡n(u) is the truth table of r↦u⋅r; when n=0 it is the one-entry zero table. (Walsh–Hadamard encoding and relative Hamming distance)

[F5]

Each BLR test samples independent uniform x,y, queries h(x),h(y),h(x+y), and accepts exactly when h(x)+h(y)=h(x+y); its probability is over these samples for fixed h. (The BLR linearity test over F_2)

[F6]

If a table's BLR rejection probability ϵ<1/2, the lemma's lexicographically first Fourier maximizer gives a linear decoder within distance ϵ; if ϵ<1/4, that nearby word is unique. (The BLR test supplies a nearby unique linear decoder)

[F7]

The tensor test independently samples r,s,y,y′ and Y, corrects the three requested values with two queries each, and rejects if the corrected g(r⊗s) differs from the product of corrected f(r),f(s). It makes six nonadaptive queries and rejects a wrong decoded tensor with probability at least 14−4δf−2δg. (Tensor consistency rejects a wrong decoded tensor)

[F8]

The equation test samples independent uniform z,y, queries g(y),g(y+A(z)), and rejects when their sum differs from b(z). When the decoded assignment violates an equation, its rejection probability is at least 12−2δg; it uses M+N2 random bits and two queries. (A random subsum checks all quadratic equations at once)

Proof

Given: Fix the input instance and the proof string before the verifier's random bits are sampled.

1.1F1F3F4F5F7F8givenconstruct

First replace each input matrix Aj by its canonical upper-triangular representative: keep its diagonal entries, put Aj,ik+Aj,ki in position (i,k) for i<k, and put zero below the diagonal. By [F1] this preserves every value Aj⋅(u⊗u) and therefore the solution set; scanning the explicit matrices costs O(MN2) time. In the rest of the proof Aj denotes this canonical representative, so [F8] applies. Split the proof, using [F3], into fixed tables f:F2N→F2 and g:F2N2→F2. Unless N=M=0, use two selector bits to choose uniformly among one BLR test on f, one BLR test on g, the six-query tensor test in [F7], and the two-query equation test in [F8]; all test coins are independent and their query locations are computed before reading answers.

1.2F1F2F4F5F7F8givenalgebra

If u satisfies the instance, use the proof f=WH⁡N(u) and g=WH⁡N2(u⊗u). By [F4], both tables are linear, so their BLR tests always pass. For any auxiliary point a, f(a)+f(a+r)=u⋅a+u⋅(a+r)=u⋅r, and similarly g(Y)+g(Y+Z)=(u⊗u)⋅Z. Hence the tensor test passes because (u⋅r)(u⋅s)=(u⊗u)⋅(r⊗s). Also g(y)+g(y+A(z))=g(A(z))=A(z)⋅(u⊗u)=b(z) for every equation mask z, so the equation test passes. If N=M=0, this proof has f=0 and the deterministic dimension-zero BLR test accepts by [F2,F4].

1.3F5givenalgebra

For an arbitrary fixed proof, let ϵf and ϵg be the rejection probabilities of its two BLR tests in [F5]. If either is at least 1/100, its selected branch contributes at least (1/4)(1/100)=1/400 to the mixture's rejection probability.

2.1F6step 1.3construct

Otherwise both ϵf,ϵg<1/100<1/4. By [F6], the lemma's lexicographically first decoders are unique linear words u∈F2N and w∈F2N2 at distances δf≤ϵf<1/100 and δg≤ϵg<1/100. Reshape w into the row-major matrix V.

2.2F2F3F5F7F8step 1.1algebra

Each selected branch uses respectively 2N, 2N2, 4N+N2, or M+N2 random bits and at most 3, 3, 6, or 2 queries. Thus for N2+M>0 the verifier uses at most 2+max⁡(2N,2N2,4N+N2,M+N2)≤7(N2+M) random bits and at most six queries. If N=M=0, the empty equation list is satisfiable by [F2]; run the deterministic dimension-zero BLR test on f without selector bits, preserving completeness and using three queries.

3.1F7step 2.1algebra

If V≠u⊗u, [F7] makes the tensor branch reject with probability at least 14−4δf−2δg>14−6100=19100. Since this branch is chosen with probability 1/4, the mixture rejects with probability greater than 19/400, hence at least 1/400.

3.2F1F2F8step 2.1step 2.2algebra

If V=u⊗u, unsatisfiability and [F1] imply that the decoded u violates at least one equation. The equation branch then rejects with probability at least 12−2δg>12−2100=48100. With one equation the random mask detects its failed residual with probability 1/2; with N=0, the unique decoded vector is empty and the same test detects any right-hand side b(z)=1. Its mixture contribution is greater than 12/100, so again the verifier rejects with probability at least 1/400. Coincident query locations are still counted among the at most six calls.

4.1F3givenconstructdischarge-construct∎

Under the stated encoding, the instance length is at least N+M+MN2. Computing the selected test's addresses, tensor products, and XOR-sums A(z),b(z) takes polynomial time in that length; every query address is fixed from the input and random tape before an answer is read. The proof length is exactly 2N+2N2 by [F3], while only the selected branch's at most six bits are read. The verifier is therefore uniform and nonadaptive with the claimed resources.

DefinitionDefinition: AI-adaptedProof: Not applicableaudited 2026-09-30Open item page →

Two-piece PCP of proximity and concatenation check

Definition

Let C be a Boolean circuit with s primary inputs and m non-input nodes. Let X1,X2 be disjoint ordered lists of its input wires, of lengths n1,n2, and put n=n1+n2. The named pair (a1,a2) is satisfying if some assignment to the other input wires makes C output one when the wires in X1,X2 receive a1,a2. Reorder the explicit input list by the deterministic permutation (X1,X2,remaining inputs). The fixed-prefix reduction Boolean circuits become quadratic systems with a fixed input prefix then puts the named bits in the first n variables of its QUADEQ instance. Write N=s+m for the number of reduced variables. The reduction says exactly that a satisfying named pair extends to a solution of that instance.

Fix an absolute constant 0<η≤1 and set δ0=1/100. An (η,δ0) two-piece PCP of proximity for (C,X1,X2) is a uniform, nonadaptive verifier with a fixed proof tuple (π1,π2,ζ) satisfying the following interface:

  1. πi is a bit table on F2ni, so its length is 2ni. The private string ζ has length at most 2p(s+m) and the verifier uses at most r(s+m) unbiased random bits for fixed polynomials p,r. It makes at most six bit queries. Query locations are determined by the circuit, the fixed proof tuple and the random tape, before any answer is read; repeated locations count toward the query bound.
  2. (Perfect completeness) For every satisfying named pair (a1,a2), there is one fixed private string ζ such that the verifier accepts (WH⁡n1(a1),WH⁡n2(a2),ζ) on every random tape. The Walsh–Hadamard tables use the convention in Walsh–Hadamard encoding and relative Hamming distance.
  3. (Proximity soundness) For every fixed proof tuple, if its rejection probability is less than η, there is a satisfying named pair (a1,a2) for which dist⁡(πi,WH⁡ni(ai))≤δ0(i=1,2).

Here probability is only over the verifier's random tape; all three proof parts are fixed first. If the circuit has no satisfying named pair, proximity soundness therefore says that every fixed proof tuple is rejected with probability at least η. The private string used in our construction is the fixed QUADEQ proof from An exponential-length constant-query PCP for quadratic equations: it consists of tables F=WH⁡N(w) and G=WH⁡N2(w⊗w) for a reduced-instance witness w.

For the input prefix, define the two coordinate injections j1(r)=(r,0N−n1),j2(r)=(0n1,r,0N−n)(r∈F2ni). The second piece is thus compared with the offset slice, not with the initial coordinates. On exact linear tables the raw concatenation check for piece i samples uniform r∈F2ni and compares πi(r) with F(ji(r)); this is the two-query check in the cited source. For arbitrary tables, the four-query self-corrected check samples independent uniform r,y∈F2ni and Y∈F2N, then compares Corr⁡πi(r;y)=πi(y)+πi(y+r) with Corr⁡F(ji(r);Y)=F(Y)+F(Y+ji(r)), using the two-query corrector of Two-query linear self-correction. The check is nonadaptive.

If ni=0, the mask space and short-table domain are singletons, ji(0)=0, and the self-corrected short value is πi(0)+πi(0)=0. Thus the slice check is defined without a positive-dimension exception. The source Corollary 18.26 uses the same two named pieces and a two-query exact-codeword check; the four-query form above is the explicit local extension used for arbitrary fixed proof tables. Corollary 18.26 states proximity when acceptance is at least 1/2, which is stronger than the local η-gap interface here. The definition records the local interface; it does not assert that every circuit has such a verifier.

LemmaStatement: Literature-sourcedProof: AI-adaptedprecheck passaudited 2026-09-30Open item page →

Concatenation testing enforces the same decoded prefix

Statement

Let 0≤n≤N, let j:[n]↪[N] be a fixed injection, and let Jj:F2n→F2N insert a vector's kth coordinate at position j(k) and put zero in every other coordinate. Write w∣j=(wj(1),…,wj(n)).

For the exact tables WH⁡n(a) and WH⁡N(w), the two-query slice check on a uniform r∈F2n compares their entries at r and Jj(r). It accepts every mask if and only if a=w∣j; if a≠w∣j, it rejects on exactly half of the masks.

More generally, let fixed tables π:F2n→F2 and F:F2N→F2 have relative distances δ1,δ2∈[0,1] from WH⁡n(a) and WH⁡N(w). The four-query self-corrected slice check rejects with probability at least 12−2δ1−2δ2 whenever a≠w∣j. The proof tables are fixed before the independent uniform choices of masks and correction offsets. Both checks are nonadaptive; the raw check uses two bit queries and the corrected check uses four, counting repeated locations.

Facts & Assumptions

Given: the fixed injection j, vectors a,w, and (for the robust bound) fixed tables π,F at the stated distances.

[F1]

The raw slice check compares the short table at r with the longer table at its embedded coordinate. Its corrected form compares Corr⁡π(r;y) and Corr⁡F(Jj(r);Y) using independent uniform correction offsets. (Two-piece PCP of proximity and concatenation check)

[F2]

WH⁡k(v) is the truth table x↦v⋅x on F2k, and relative distance is normalized disagreement on that cube. (Walsh–Hadamard encoding and relative Hamming distance)

[F3]

For every nonzero d and a uniform binary mask r of the same dimension, Pr⁡[r⋅d=1]=1/2. (Random binary subsums detect every nonzero discrepancy)

[F4]

For a fixed table h, the corrector at x chooses uniform y and returns h(y)+h(x+y). (Two-query linear self-correction)

Proof

Given: fix j,a,w and, where applicable, π,F independently of all test randomness.

1.1F1givenconstructalgebra

Define Jj(r) by the stated coordinate insertion. Then w⋅Jj(r)=∑k=1nwj(k)rk=(w∣j)⋅r for every r∈F2n. All query locations below are determined by j and the sampled masks and offsets before any table answer is read.

1.2F2F4givenalgebra

Fix any mask r. In the short-table correction, each of y and y+r is uniform on F2n. Each queried value therefore differs from its corresponding codeword value with probability exactly δ1. A union bound shows that the corrected short value differs from a⋅r with probability at most 2δ1. Likewise Y and Y+Jj(r) are each uniform on F2N, so the corrected long value differs from w⋅Jj(r) with probability at most 2δ2. These bounds hold conditional on every fixed r and require no independence between the two errors within either correction.

2.1F2F3step 1.1algebra

On the exact tables, the two queried bits are a⋅r and (w∣j)⋅r by [F2] and step 1.1. Their sum is (a+w∣j)⋅r. If a=w∣j, this is zero for every mask, so every raw check accepts. If a≠w∣j, their sum vector is nonzero and [F3] gives probability exactly 1/2 that the two bits differ; hence exactly half the masks reject. This proves both directions of the asserted “accepts every mask iff” statement.

2.2F3step 1.1step 1.2algebra

Suppose a≠w∣j. By [F3] and step 1.1, the ideal corrected values a⋅r and w⋅Jj(r) differ with probability exactly 1/2. Conditional on each r, the probability that at least one corrected value is wrong is at most 2δ1+2δ2 by step 1.2. Whenever the ideal values differ and neither correction errs, the actual test rejects. Subtracting the possible error event from the ideal disagreement event gives Pr⁡[reject]≥12−2δ1−2δ2. This remains a valid lower bound if its right side is negative.

2.3F1step 1.1givenalgebra

The raw test samples n mask bits. The corrected test samples r,y using 2n bits and Y using N bits, then makes the four queries listed in [F1]. Repeated query locations still count as calls, so the bounds hold for n=0 and for any coordinate coincidences. Since every query location is fixed before answers are obtained, both procedures are nonadaptive.

3.1F1F2F4step 2.3algebra

If n=0, both messages are the unique empty vector, Jj(0)=0, and a=w∣j necessarily; the differing-slice case cannot occur. The raw exact tables both have value 0 at their zero mask. The self-corrected short value is π(0)+π(0)=0, so the definition still makes sense with the singleton mask and table. If also N=0, the long correction is likewise a repeated query at the singleton coordinate. No positive-dimension assumption is needed.

4.1step 2.1step 2.2step 2.3step 3.1algebra∎

Steps 2.1 and 2.2 prove the exact and noisy rejection claims; step 2.3 proves the query, randomness, and nonadaptivity bounds, including repeated locations; step 3.1 handles the zero-dimensional slice. Therefore the raw check accepts every mask exactly when the decoded slices agree and otherwise rejects on half the masks, while the corrected check has the stated rejection lower bound whenever they differ.

Remarks

The injection may be the initial named block or the offset second block in Two-piece PCP of proximity and concatenation check. The same calculation applies to any fixed coordinate injection. No axiom of choice is used: the injection is given, and the nonzero-mask conclusion is the finite random-subsum lemma.

TheoremStatement: Literature-sourcedProof: AI-adaptedprecheck passaudited 2026-09-30Open item page →

A two-piece constant-query PCP of proximity

Statement

Let C be an explicit topologically ordered Boolean circuit over constants, NOT, AND and OR, with s input wires and m non-input nodes. Let X1,X2 be disjoint ordered lists of input wires of lengths n1,n2, put n=n1+n2 and N=s+m≥1, and call (a1,a2) satisfying when it extends to an input on which C outputs one. There is a deterministic uniform construction of a nonadaptive two-piece proximity verifier with external tables πi:F2ni→F2 and private tables F:F2N→F2 and G:F2N2→F2. It makes at most six bit queries and at most 3+5N2 unbiased random-bit choices. Its total proof length is 2n1+2n2+2N+2N2≤4⋅2N2. It has perfect completeness, and rejection probability below η=1/800 implies that both external tables are within relative distance δ0=1/100 of the Walsh–Hadamard encodings of one satisfying named pair.

For the combined named list X1∥X2, adding comparisons with the two-query self-correctors of the corresponding external tables at unit vectors gives an explicit Boolean assignment tester of arity at most six and rejection ratio ρ0=1/1000, including the empty accepted-set and zero-named-input conventions. Its finite constraint list can be enumerated with at most 27N2+4 constraints.

Facts & Assumptions

Given: A circuit and two fixed disjoint ordered lists of named input wires, with all verifier proofs fixed before its random tape is sampled.

[F1]

The input variables can be ordered with the named coordinates first, and the fixed-prefix QUADEQ reduction has N=s+m variables and m+1 equations; extending a named prefix to a solution is equivalent to completing the circuit input to one on which the output is one. (Boolean circuits become quadratic systems with a fixed input prefix)

[F2]

A QUADEQ solution w satisfies every equation Aj⋅(w⊗w)=bj in row-major coordinates. (Quadratic equations and tensor-code oracle tables)

[F3]

WH⁡k(v)(r)=v⋅r, including the singleton zero table at dimension zero. (Walsh–Hadamard encoding and relative Hamming distance)

[F14]

The intended QUADEQ oracle tables have lengths 2N and 2N2, with the vector table preceding the tensor table. (Quadratic equations and tensor-code oracle tables)

[F4]

The BLR family samples independent uniform x,y, queries h(x),h(y),h(x+y), and accepts exactly when h(x)+h(y)=h(x+y); it uses 2k random bits and three calls for a table on F2k. (The BLR linearity test over F_2)

[F5]

If a table's BLR rejection probability is below 1/4, the lemma's lexicographically first decoder is the unique Walsh–Hadamard word within distance less than 1/4, and its distance is at most that rejection probability. (The BLR test supplies a nearby unique linear decoder)

[F6]

For fixed tables near decoded words u,V, the six-query tensor test rejects when V≠u⊗u with probability at least 1/4−4δF−2δG. (Tensor consistency rejects a wrong decoded tensor)

[F7]

For a decoded vector u failing a QUADEQ equation and a table G at distance δG from WH⁡N2(u⊗u), the nonadaptive two-query equation test rejects with probability at least 1/2−2δG and uses m+1+N2 random bits. (A random subsum checks all quadratic equations at once)

[F8]

For fixed tables near decoded words whose named slices differ, the four-query corrected slice test rejects with probability at least 1/2−2δ1−2δ2; it is nonadaptive and counts repeated locations. (Concatenation testing enforces the same decoded prefix)

[F9]

A two-piece proximity verifier uses fixed external tables on F2ni; its soundness conclusion is conditional on rejection strictly below η, and its pair is satisfying when it extends to a full circuit input accepted by C. (Two-piece PCP of proximity and concatenation check)

[F10]

An assignment tester's variables include its named input bits, and its soundness compares every labeling's violated-constraint fraction with ρ times relative distance to the accepted named inputs. (Assignment tester and rejection ratio)

[F11]

A Boolean circuit is a finite acyclic graph of input wires, constants, NOT gates, two-input AND and OR gates, with one designated output evaluated in topological order. (Boolean circuits: basis, fan-in, size, and depth)

[F12]

The two-query corrector at request q chooses uniform y and returns h(y)+h(q+y), with repeated locations permitted. (Two-query linear self-correction)

[F13]

A finite constraint list may contain ordered tuples with repeated variables, and every tuple carries an explicit relation. (Assignment tester and rejection ratio)

[F15]

The distance to an empty accepted set is defined as one; when there are zero named inputs the input cube is a singleton. (Assignment tester and rejection ratio)

Proof

Given: Fix C,X1,X2 and then fix any proof tuple before sampling verifier randomness.

1.1F1F11givenconstruct

Deterministically reorder the primary input list as X1∥X2∥(remaining inputs); this relabeling preserves circuit evaluation. Apply [F1] with named prefix length n=n1+n2, obtaining a QUADEQ instance with N=s+m variables and M=m+1 equations. Its first n1 variables are X1, and the next n2 are X2, so the coordinate injections are j1(r)=(r,0N−n1) and j2(r)=(0n1,r,0N−n). The two designated slices are disjoint and have the prescribed order.

1.2F2F3F4F6F7F8F9F14givenconstruct

Split the fixed proof into external tables π1,π2 and private tables F,G of lengths 2n1,2n2,2N,2N2. Choose uniformly among eight families: BLR on each table, the six-query tensor test, the two-query equation test, and the four-query corrected slice test for each ji. Each family samples only its own independent uniform coins, and every query location is computed before any answer is read.

1.3F1F2F3F4F6F7F8F12givenchoosealgebra

If (a1,a2) is satisfying, choose a completion of the other input wires on which C outputs one. By [F1] it gives a QUADEQ solution w. Set πi=WH⁡ni(ai), F=WH⁡N(w), and G=WH⁡N2(w⊗w). Every BLR family accepts because its table is linear. The tensor family accepts since (w⋅r)(w⋅s)=(w⊗w)⋅(r⊗s), and each equation family accepts since w solves every equation. The named slices of w are ai, so the corrected slice tests compare equal linear values on every tape. If ni=0, both requests are zero and both corrected values are zero. Thus all eight families accept on every tape.

2.1F1F2F4F6F7F8F14step 1.2algebra

The branch coin counts are 2n1,2n2,2N,2N2,4N+N2,M+N2,2n1+N,2n2+N; three selector bits choose the branch. Since ni≤N, M=m+1≤N+1, and N≥1, every branch uses at most 5N2 bits, so the verifier uses at most 3+5N2 bits and at most six queries. Its proof length is the sum of the four table lengths in step 1.2 and is at most 4⋅2N2 because ni≤N≤N2. The circuit reduction, sample addresses, tensor products, and equation subsums are computable in time polynomial in the explicit circuit description, giving a deterministic uniform construction.

2.2F4F5step 1.2givenconstructalgebra

For an arbitrary fixed proof, let ϵj be the rejection probability of each of the eight families and R=18∑j=18ϵj the verifier's rejection probability. If R<1/800, then every ϵj≤8R<1/100. By [F5] the four BLR tables have deterministically selected unique decoders ai∈F2ni, w∈F2N, and v∈F2N2, each at distance at most its BLR rejection rate and therefore below 1/100. Denote these distances by δπ1,δπ2,δF,δG, and reshape v in row-major order as a matrix V.

2.3F4F6F7F8F9F10F12F13step 1.2givenconstruct

Make variables from the raw named input bits and every coordinate of π1,π2,F,G. For each random tape in each core family, list the ordered tuple of queried table variables with the Boolean relation that accepts exactly the answers accepted by that test. The relations are explicit: BLR accepts b1+b2=b3; the tensor test accepts q1+q2=(p1+p2)(p3+p4) on ordered answers p1,p2,p3,p4,q1,q2; the equation test accepts when the queried sum equals its fixed b(z); and a slice test accepts when its corrected sums agree. Repeated query locations yield repeated variables, allowed by [F13]. If n>0, add comparisons indexed by each named coordinate i and each t∈F2L, L=max⁡(n1,n2): take the first ni coordinates of t as y in the piece containing i, and use the tuple (xi,πi(y),πi(y+ei)) with relation xi=πi(y)+πi(y+ei) from [F12]. This comparison has arity three.

3.1F2F6F7step 2.2algebra

If V≠w⊗w, [F6] gives tensor-family rejection at least 14−4δF−2δG>14−6100=19100, hence R>19/800>1/800, a contradiction. Thus V=w⊗w. If w failed any QUADEQ equation, [F7] gives equation-family rejection at least 12−2δG>48100 and hence R>48/800>1/800, also impossible. Thus w solves the reduced instance.

3.2F10step 2.1step 2.3algebraconstruct

Let K be the maximum coin count of a core family and D=n2L when n>0. The comparison list has D constraints, and each core family has 2cj tapes with cj≤K. For n>0, duplicate rows until each of the nine families has P=D2K constraints; P/2cj and P/D are integers. For n=0, omit comparisons and duplicate the eight core families to P=2K constraints each. Therefore the violated fraction is the average of the core-family rejection rates and, when present, the comparison rejection rate. If n>0, D=n2L and L≤n≤N imply log⁡2D≤log⁡2n+L≤2N2; step 2.1 gives K≤5N2. Hence P≤27N2 and there are at most 9⋅27N2≤27N2+4 constraints. If n=0, there are at most 8⋅25N2≤27N2+4. Direct enumeration takes time polynomial in the output length.

3.3F3F9F10F12step 1.3step 2.3algebra

If x is accepted by C, use the satisfying completion and exact tables from step 1.3 as the auxiliary labeling. Every core constraint accepts. For each named coordinate i, πi(y)+πi(y+ei)=ai⋅ei=xi for every y by [F3, F12], so every comparison accepts and the tester has perfect completeness.

4.1F1F5F8step 2.2step 3.1algebra

If either decoded external word ai differed from the corresponding slice of w, [F8] gives that slice family's rejection at least 12−2δπi−2δF>12−4100=46100, hence R>46/800>1/800, impossible. Each ai therefore equals its designated slice. By [F1] the pair is satisfying, and by [F5] dist⁡(πi,WH⁡ni(ai))<1/100 for each i. This proves proximity soundness with η=1/800 and δ0=1/100; if no satisfying pair exists, every fixed proof has rejection at least 1/800.

5.1F3F9F10F12F15step 4.1step 2.3step 3.2algebracases

Suppose n>0, fix any raw named input x and any auxiliary labeling, and let R be the rejection rate of its eight core families. If R≥1/800, the nine-family system rejects at least 89R≥1900>11000δ(x,SAT⁡(C)), since the defined distance is at most one by [F15]. Otherwise step 4.1 supplies a satisfying pair a with each external table at distance below 1/100 from its Walsh–Hadamard word. Put d=∣{i:xi≠ai}∣/n. For a mismatched coordinate, the two queried locations y,y+ei are each uniform in their piece's mask space, so each hits a table-error position with probability δπi<1/100. By [F3, F12] and a union bound, the corrector at ei returns ai with probability greater than 1−2/100=49/50, and the comparison-family rejection is at least (49/50)d. The full system rejects with probability at least (49/450)d≥(1/1000)δ(x,SAT⁡(C)), since d≥δ(x,SAT⁡(C)). If the accepted set is empty, the low-R case is impossible by step 4.1, so the high-R case proves soundness using [F15]. For n=1, the unique named coordinate receives equal weight across its 2L tapes, so the same estimate holds.

5.2F9F10F15step 4.1step 3.2algebracases

If n=0, there is one raw named input. If C accepts it, the distance to the accepted set is zero. Otherwise the accepted set is empty by [F15], and step 4.1 implies every proof tuple has core rejection at least 1/800; the eight-family system therefore has violated fraction at least 1/800>1/1000. A piece with ni=0 contributes no comparison coordinates; its table domain is a singleton and its corrected value at zero is zero, as in step 1.3. A valid circuit has N≥1 because it has a designated output wire, so no separate N=0 verifier case is needed.

6.1step 2.1step 4.1step 3.2step 3.3step 5.1step 5.2algebradischarge-construct∎

The eight-family verifier satisfies the claimed proximity completeness, soundness, query, proof-length, and randomness bounds; the finite constraint construction has the named variables, explicit Boolean relations, arity at most six, perfect completeness, and rejection-ratio inequality for every named input and auxiliary labeling. This proves both assertions.

Remarks

Arora–Barak Corollary 18.26 states the two-piece proximity result when the pieces concatenate to a satisfying full circuit input; its soundness premise is acceptance probability at least 1/2, and the text says that its proof is similar to Corollary 18.25 without giving the details. The named-sublist extension, the constants 1/800 and 1/1000, and the equal-sized constraint construction above are proved here from the local test lemmas. No axiom of choice is used: each decoder is selected by the lexicographic rule in [F5], and a satisfying completion is chosen only for the fixed pair in question.

DefinitionDefinition: Literature-sourcedProof: Not applicablejudge pass (gpt-6-sol)audited 2026-09-30Open item page →

Composition of an edge system with an assignment tester

Definition

Fix a finite binary constraint graph G over an alphabet Σ of size W≥2, and form its blocks and ordered robust edge circuits using Shared codeword blocks and edge acceptance circuits. Each active vertex v has a block Bv=((v,1),…,(v,ℓ)), where ℓ=2⌈log⁡2W⌉. For an edge e=(v,w), let Ce(Xe,Ye) be its robust circuit, with its two formal input pieces Xe=(xe,1(1),…,xe,ℓ(1)) and Ye=(xe,1(2),…,xe,ℓ(2)) in the specified endpoint order.

Let P be the deterministic two-piece assignment-tester construction of A two-piece constant-query PCP of proximity. Apply P to Ce with these two named input lists. Write its Boolean constraint system as Te=(Ve,Ce), let Xe∗=Xe∪Ye be its named raw input variables, and put qe=∣Ce∣. The system has arity at most six; all variables in Ve∖Xe∗, including the verifier's external and private proof-table variables, are local auxiliary variables.

For every edge, qe is a positive integer. Indeed, W≥2 gives ℓ≥2, so this local instance has n=2ℓ>0. In the construction in A two-piece constant-query PCP of proximity, the comparison family then has D=n2L≥1 rows, and each of the nine test families is padded to U=D2K≥1 rows. Thus qe=9U>0. If the edge set is nonempty, set M=lcm⁡{qe:e∈E(G)}. This is a well-defined positive integer because the edge set is finite and each qe>0. If E(G)=∅, define G∘P to have no variables and no constraints.

Suppose E(G)≠∅. The output variable set consists of the active vertex blocks together with a fresh private copy (e,z) of every z∈Ve∖Xe∗ for each edge e. Map the first named piece of Te coordinatewise to Bv and the second coordinatewise to Bw. When e is a loop, v=w, so both formal pieces map coordinatewise to the same block. Map each auxiliary variable z to its private copy (e,z). Call the resulting map on gadget variables ϕe. Thus endpoint bits are shared across all incident edge gadgets, while every other gadget variable is private to one edge.

For each ordered constraint (z1,…,zr,R)∈Ce, with R⊆{0,1}r, put exactly M/qe copies of (ϕe(z1),…,ϕe(zr),R) in the output constraint list. The composition G∘P is the Boolean constraint system on the variables just described and the multiset union of these lists. It has arity at most six. Repetitions in tuples and duplicate constraints are retained, as allowed by Assignment tester and rejection ratio. Every edge contributes exactly M constraints, so the total list has ∣E(G)∣M constraints.

For any labeling τ of the output variables, let τe be its pullback to Ve along ϕe. Since duplicating every row of Te by the same factor preserves its violated fraction, for nonempty E(G) UNSAT⁡τ(G∘P)=1∣E(G)∣∑e∈E(G)UNSAT⁡τe(Te). Conversely, any collection of local gadget labelings that agrees on every variable identification made by the maps ϕe, including the two formal pieces of a loop, combines into a unique output labeling, because all other variables have edge-private names. If the original graph is edgeless, the output has the empty constraint list and unsatisfiability zero under the empty-system convention of Assignment tester and rejection ratio.

Remarks

Dinur's §5.1 Definition 5.1 introduces edge circuits, shares their endpoint variables across assignment-tester outputs, keeps local auxiliary variables private, and assumes equal gadget constraint counts; Lemma 1.8 analyzes that composition. This definition uses the same sharing pattern with the local two-piece Boolean assignment tester and arity-six constraint systems. It achieves equal counts explicitly by taking the least common multiple of the positive finite gadget sizes. Arora–Barak Corollary 18.35 gives the qCSP view of a PCP of proximity, and the proof of Lemma 18.30 uses shared codeword blocks and edge-private proof variables. Those citations motivate this construction; its local assignment-tester properties are supplied by A two-piece constant-query PCP of proximity.

The construction is choice-free: the local tester and robust circuits are deterministic, and the least common multiple and all variable renamings are computed from finite explicit lists. No axiom of choice is used.

LemmaStatement: Literature-sourcedProof: AI-adaptedprecheck passjudge pass (gpt-6-sol)audited 2026-09-30Open item page →

Composition preserves perfect satisfiability

Statement

Let G be a finite binary constraint graph over a finite alphabet Σ with ∣Σ∣≥2, and let H=G∘P be the Boolean arity-six composition defined in Composition of an edge system with an assignment tester. For this finite Boolean constraint system, write val⁡(H) for the maximum satisfied fraction, with value one when the constraint list is empty; equivalently, val⁡(H)=1−UNSAT⁡(H) under the convention of Assignment tester and rejection ratio. If val⁡(G)=1, then val⁡(H)=1, including the edgeless case.

Facts & Assumptions

Given: Fix G and its robust ordered edge circuits, with the local two-piece assignment tester P and composition H fixed as in the definition.

[F1]

The graph has finite vertex and edge sets and a finite nonempty alphabet, so its labeling set is finite; its value is the maximum over labelings, and an edgeless graph has value one. (Constraint graph and labeling value)

[F2]

The code C is injective, so every valid block has a unique decoded label. (Shared codeword blocks and edge acceptance circuits)

[F3]

The robust edge circuit accepts exactly when both blocks are valid and their decoded ordered labels satisfy the edge relation; on a loop it tests the diagonal pair. (Shared codeword blocks and edge acceptance circuits)

[F4]

The two-piece construction supplies an explicit Boolean assignment tester, of arity at most six, for the combined named list of the two pieces. (A two-piece constant-query PCP of proximity)

[F5]

By perfect completeness of an assignment tester, every accepted named input extends to an auxiliary labeling satisfying every local constraint. (Assignment tester and rejection ratio)

[F6]

Composition identifies the first and second named pieces coordinatewise with their endpoint blocks, including both pieces of a loop, and gives every other gadget variable a private edge name. (Composition of an edge system with an assignment tester)

[F7]

If the original graph is edgeless, the composition has the empty constraint list. (Composition of an edge system with an assignment tester)

[F8]

Local gadget labelings that agree on all identifications combine into one output labeling. (Composition of an edge system with an assignment tester)

[F9]

Each local constraint is copied uniformly, so an accepted local constraint remains accepted in every copy. (Composition of an edge system with an assignment tester)

[F10]

For each labeling, constraint-system value is its satisfied fraction and UNSAT⁡τ=1−val⁡τ; the overall unsatisfiability is the minimum over labelings, and the empty list has value one. (Assignment tester and rejection ratio)

Proof

Given: Assume val⁡(G)=1.

1.1F1F7F10givencases

If E(G)=∅, then G has value one by [F1], while the composition has an empty constraint list by [F7] and therefore val⁡(H)=1 by [F10] and the stated convention. It remains to consider E(G)≠∅.

1.2F1givenalgebrachoose

Because G has finitely many vertices and Σ is finite and nonempty, its set of labelings is finite and nonempty, so the maximum in [F1] is attained. Choose σ:V(G)→Σ with val⁡σ(G)=val⁡(G)=1. Since the edge set is nonempty, every edge relation is satisfied by its ordered pair of endpoint labels.

2.1F2F3step 1.2constructalgebra

For each active vertex v, assign its shared block the codeword Bv=C(σ(v)). By [F2] this is valid and decodes uniquely to σ(v). If e=(v,w), then σ satisfies its ordered relation, so [F3] says the robust circuit Ce accepts (Bv,Bw). If e is a loop, both pieces are the same block and the satisfied diagonal pair is accepted as well.

3.1F4F5step 2.1chooseconstruct

For each edge e, [F4] supplies the assignment tester on the combined named input list of its two raw pieces. The fixed input (Bv,Bw) is accepted by Ce by step 2.1. Its accepted-input clause in [F5] therefore gives at least one Boolean assignment be to the gadget's auxiliary variables satisfying every local constraint. Order that finite variable list as in the explicit tester output and take the lexicographically first such be. The edge set and each Boolean search space are finite, so this specifies the witnesses without an axiom of choice.

4.1F6F8F9step 2.1step 3.1constructalgebra

Assign each shared vertex block its fixed codeword and assign each edge-private variable its value from be. By [F6], the named pieces take the already fixed endpoint blocks, including the same block in both positions of a loop; all other variables are private to their edge. These local labelings agree on every identification, so [F8] combines them into an output labeling τ. Every local constraint accepts under its be, and [F9] preserves acceptance in every uniform copy. Thus every constraint of H accepts under τ.

5.1F10step 1.1step 4.1algebradischarge-construct∎

Every constraint of H is satisfied by τ, so val⁡τ(H)=1 and UNSAT⁡τ(H)=0 by [F10]. Hence UNSAT⁡(H)=0, and the stated convention gives val⁡(H)=1. Together with the edgeless case, this proves the claim.

Remarks

Dinur's proof of Lemma 1.8 extends each satisfied original edge to a satisfying assignment of its local gadget and uses equal gadget sizes to average the local fractions. This lemma is its perfect-completeness direction specialized to a fully satisfiable input graph. The present composition uses the two-piece Boolean tester and the explicit least-common-multiple padding in Composition of an edge system with an assignment tester. The Arora–Barak proof of Lemma 18.30 makes the same witness extension for each satisfiable qCSP cluster. Both source arguments support the construction pattern; the local tester completeness used here is supplied and proved by A two-piece constant-query PCP of proximity.

LemmaStatement: Literature-sourcedProof: AI-adaptedprecheck passjudge pass (gpt-6-sol)audited 2026-09-30Open item page →

Composition transfers a constant fraction of unsatisfaction

Statement

Let G be a finite binary constraint graph over a finite ordered alphabet Σ with ∣Σ∣≥2, and let H=G∘P be its Boolean arity-six composition with the two-piece assignment tester. Put δ=1/2 for the relative distance of the shared Walsh–Hadamard block code and ρ0=1/1000 for the local assignment-tester rejection ratio. If E(G)≠∅, then for every Boolean labeling τ of H, decode each shared vertex block to its nearest codeword, breaking ties by the fixed alphabet order, and extend that decoded labeling to isolated vertices by the first alphabet symbol; call the result στ. Then UNSAT⁡τ(H)≥ρ0δ4UNSAT⁡στ(G)≥ρ0δ4UNSAT⁡(G). Consequently, UNSAT⁡(H)≥ρ0δ4UNSAT⁡(G)=18000UNSAT⁡(G). If G is edgeless, both unsatisfaction values are zero and the same global inequality holds. Edge multiplicities are counted as separate edge records.

Facts & Assumptions

Given: Fix the finite graph and its defined composition. For the nonempty-edge case, fix an arbitrary labeling τ of the output variables.

[F1]

For any named input a and auxiliary labeling b, an assignment tester of ratio ρ guarantees UNSAT⁡a∪b(P(C,X))≥ρ δ(a,SAT⁡(C)). (Assignment tester and rejection ratio)

[F2]

The two-piece construction applied to the combined named input list is an explicit Boolean assignment tester with rejection ratio ρ0=1/1000. (A two-piece constant-query PCP of proximity)

[F3]

If the labels decoded from the physical endpoint blocks violate an edge, their formal two-piece input is at relative distance at least δ/4=1/8 from the circuit's accepting set; this holds for loops and for an empty accepting set. (A violated decoded edge is far from edge-circuit acceptance)

[F4]

Composition shares the two formal named pieces with the endpoint blocks (the same block in both positions of a loop) and gives every remaining gadget variable a private edge name. (Composition of an edge system with an assignment tester)

[F5]

For nonempty E(G) and every output labeling, composition's unsatisfaction is the average of the local gadget unsatisfactions after uniform row duplication. (Composition of an edge system with an assignment tester)

[F6]

Graph unsatisfaction for a labeling is the fraction of violated ordinary edge records, global UNSAT⁡(G) is the minimum over labelings, and isolated vertices do not affect value. (Constraint graph and labeling value)

[F7]

A constraint-system labeling has nonnegative unsatisfaction equal to its violated fraction; global unsatisfaction is the minimum over all labelings and is zero for an empty constraint list. (Assignment tester and rejection ratio)

[F8]

For an edgeless input, the composition has no variables or constraints. (Composition of an edge system with an assignment tester)

Proof

Given: Use the constants and arbitrary output labeling from the statement.

1.1F6F7F8givencases

If E(G)=∅, then UNSAT⁡(G)=0 by [F6]. The composition has an empty constraint list by [F8], so UNSAT⁡(H)=0 by [F7]. The claimed global inequality follows.

1.2F3F4F6givenconstruct

Suppose E(G)≠∅. For each active vertex v, let Bv be its physical block under τ and decode it by the nearest-codeword rule of [F3]. Each vertex has one shared block by [F4], so this gives one label at that vertex for every incident edge, including both formal positions of a loop. Assign the first symbol of Σ to any isolated vertex; by [F6] this extension does not change graph unsatisfaction. Denote the resulting global graph labeling by στ.

1.3F5givenalgebra

For each edge e, let τe be the pullback of τ to its local gadget under the composition map. The equal-row construction in [F5] gives UNSAT⁡τ(H)=1∣E(G)∣∑e∈E(G)UNSAT⁡τe(Te).

2.1F1F2F3F4F7step 1.2step 1.3constructalgebra

Let Fτ be the edge records violated by στ. For each e=(v,w)∈Fτ, the named input to its local tester is the formal pair (Bv,Bw), with (Bv,Bv) for a loop. By [F3] this input is at relative distance at least δ/4 from the edge circuit's accepting set. By [F2] and [F4], the local gadget is the assignment tester for that circuit on both named pieces; applying [F1] to the pullback labeling τe therefore gives UNSAT⁡τe(Te)≥ρ0δ/4. For an edge outside Fτ, its local unsatisfaction is at least zero by [F7].

3.1F6step 1.3step 2.1algebra

Combine the identity of step 1.3 with the local bounds of step 2.1. Since ∣Fτ∣/∣E(G)∣=UNSAT⁡στ(G) by [F6], and UNSAT⁡(G) is the minimum over graph labelings, it follows that UNSAT⁡τ(H)≥ρ0δ4∣Fτ∣∣E(G)∣=ρ0δ4UNSAT⁡στ(G)≥ρ0δ4UNSAT⁡(G).

4.1F7step 1.1step 3.1algebradischarge-construct∎

Step 3.1 holds for every Boolean labeling τ of the finite output system. Taking the minimum over those labelings gives the asserted inequality for UNSAT⁡(H). The edgeless case was handled in step 1.1, and ρ0δ/4=(1/1000)(1/2)/4=1/8000.

Remarks

Dinur's proof of Lemma 1.8 decodes each shared block to a closest old-alphabet symbol, uses assignment-tester soundness on every edge whose decoded relation fails, and averages the local violations using equal gadget sizes. The present composition makes those sizes equal by LCM duplication and uses the proved distance bound δ/4 for its shared Walsh–Hadamard blocks. Arora–Barak's proof of Lemma 18.30 uses the same decoded-label and per-cluster soundness pattern. The exact local ratio and robust-distance claim used here are the completed suppliers cited above; neither source is treated as a substitute for those local proofs.

LemmaStatement: Literature-sourcedProof: AI-adaptedprecheck passjudge pass (gpt-6-sol)audited 2026-09-30Open item page →

Bounded-arity Boolean constraints become binary graph constraints

Statement

Fix q≥2. Every finite explicit Boolean constraint system with m listed constraints, each of arity ki satisfying 1≤ki≤q, has a deterministically constructible binary constraint graph over the fixed alphabet Σ^={B(0),B(1)}⊔{T(a):a∈{0,1}q} with at most q edges per listed constraint. The original variables remain shared graph vertices. The graph has perfect completeness, and UNSAT⁡(G′)≥UNSAT⁡(C)q.

Facts & Assumptions

[F1]

A bounded-arity constraint system is a finite list of ordered variable tuples and their relations; repeated variables and repeated constraints are allowed. (Assignment tester and rejection ratio)

[F2]

A binary constraint graph is a finite multigraph whose edges carry explicit relations in specified endpoint order. (Constraint graph and labeling value)

Proof

Given: Let the input constraints be Ci=(xi,1,…,xi,ki) with relations Ri⊆{0,1}ki, for i=1,…,m.

1.1F1F2givenconstruct

Keep one shared vertex for each old variable. For each listed constraint i, add a private tuple vertex zi; for each occurrence j=1,…,ki, add a separate edge from zi to xi,j with relation Si,j={(T(a),B(b)):a∈{0,1}q, (a1,…,aki)∈Ri, b=aj}. Thus suffix coordinates after ki are ignored, and the graph has exactly ∑iki≤qm edge records.

2.1F1step 1.1construct

If σ satisfies the input, label each old vertex x by B(σ(x)) and label zi by T(ai), where ai has first ki coordinates (σ(xi,1),…,σ(xi,ki)) and zero suffix. Then ai's prefix lies in Ri, so every edge relation Si,j is satisfied. This proves perfect completeness.

2.2F1F2step 1.1

For any output labeling, decode an old vertex carrying B(b) as bit b, and decode any other old label as 0. If an input constraint is violated by this decoded assignment, at least one edge in its star must fail: if all its star edges passed, their common tuple label would have an accepted Ri-prefix equal coordinate-by-coordinate to the decoded old labels, contradicting that violation. This argument also covers repeated variable occurrences (they use the same old label on distinct parallel edge records) and Ri=∅.

3.1F1F2step 2.1step 2.2algebradischarge-construct∎

Distinct input constraints have disjoint edge stars because their tuple vertices are private, even when their variable tuples repeat. Thus every output labeling violates at least as many edges as its decoded input assignment violates constraints, hence at least mUNSAT⁡(C). If m>0, the output has at most qm edges, so its violated fraction is at least UNSAT⁡(C)/q. If m=0, both systems have unsatisfaction zero by the empty-list convention, and the inequality still holds.

TheoremStatement: Literature-sourcedProof: AI-adaptedprecheck passaudited 2026-09-30Open item page →

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.

LemmaStatement: Literature-sourcedProof: AI-adaptedprecheck passaudited 2026-09-30Open item page →

Alphabet reduction controls explicit size and degree

Statement

Fix a finite alphabet Σ with ∣Σ∣≥2 and let G be a finite binary constraint graph over Σ with m edge records and maximum degree at most d, where the degree of a vertex counts the incidence slots of its incident edge records and a loop therefore contributes two. Let AΣ be the alphabet reduction of Fixed-alphabet reduction with constant gap retention and let Σ^ be its fixed output alphabet of 66 symbols.

  1. Edges. ∣E(AΣ(G))∣≤6MΣm, where MΣ=lcm⁡(1,…,QΣ) with QΣ=27NΣ2+4 and NΣ=2⌈log⁡2W⌉+1+cW3 for the absolute constant c of Shared codeword blocks and edge acceptance circuits; both MΣ and QΣ depend only on Σ.
  2. Vertices. ∣V(AΣ(G))∣≤(2ℓ+qmax⁡+MΣ)m, where ℓ=2⌈log⁡2W⌉<2W and qmax⁡≤QΣ is the largest local gadget size; hence the vertex count is OΣ(m).
  3. Degree. Every vertex of AΣ(G) has degree at most 6MΣd, a constant depending only on Σ and d.
  4. Uniformity. All relation tables of AΣ(G) use the fixed alphabet Σ^, and AΣ is computable by a deterministic algorithm in time polynomial in the bit length of the explicit encoding of G.

Facts & Assumptions

Given: The fixed alphabet Σ, the input graph G with m edge records and maximum degree d, and the map AΣ of Fixed-alphabet reduction with constant gap retention, applied to G through the composition H=G∘P and the arity-six conversion.

[F1]

The map AΣ is deterministic, binary, runs in polynomial time in the explicit input encoding, uses the fixed alphabet Σ^={B(0),B(1)}⊔{0,1}6 of size 66, and satisfies ∣E(AΣ(G))∣≤CΣm and ∣V(AΣ(G))∣≤CΣm for a constant CΣ depending only on Σ. (Fixed-alphabet reduction with constant gap retention)

[F2]

If E(G)≠∅, every edge of G contributes exactly M constraints of the composition H=G∘P, where M=lcm⁡{qe} over the positive local gadget sizes, so H has ∣E(G)∣M constraints in total. If G is edgeless then H has no variables and no constraints. (Composition of an edge system with an assignment tester)

[F3]

Each active vertex v of G has one shared block Bv=((v,1),…,(v,ℓ)) of ℓ coordinates, shared by all incident edge gadgets, and every non-named gadget variable has a private copy (e,z) used by exactly one edge e. (Composition of an edge system with an assignment tester)

[F4]

The code length satisfies W≤ℓ<2W and each edge circuit has at most O(W2ℓ)=O(W3) gates besides its 2ℓ formal input bits. (Shared codeword blocks and edge acceptance circuits)

[F5]

A two-piece tester applied to a circuit with N wires has a finite constraint list of at most 27N2+4 constraints, each of arity at most six. (A two-piece constant-query PCP of proximity)

[F6]

The conversion keeps one shared vertex per input variable of the Boolean system and adds one private tuple vertex per listed constraint, joining the tuple vertex to the constraint's variables by at most q edge records in total for arities at most q. (Bounded-arity Boolean constraints become binary graph constraints)

[F7]

For each edge circuit, the local tester's total variable count is at most its constraint count qe; this follows from the explicit table-variable and nine-family counts in step 1.3 of Fixed-alphabet reduction with constant gap retention. Hence the private auxiliary variables of one edge gadget are at most qe≤qmax⁡.

Proof

Given: Fix Σ, W=∣Σ∣≥2, ℓ, the input graph G, and the constants NΣ, QΣ, MΣ of the statement.

1.1F2F4F5givenconstruct

Put H=G∘P and A=AΣ(G), the arity-six conversion of H. If E(G)≠∅, then H has Mm constraints by [F2], where each qe is the size of the local gadget of edge e. Every edge circuit has at most 2ℓ+O(W3) wires by [F4], so each qe≤QΣ by [F5], and therefore M divides MΣ=lcm⁡(1,…,QΣ). In particular M≤MΣ, a constant depending only on Σ.

1.2F1F2F6givencases

If E(G)=∅, then H has no variables and no constraints by [F2], and the conversion of an empty system is an edgeless graph, so all three bounds in clauses 1--3 hold with m=0 and every vertex degree zero.

2.1F2F6step 1.1algebra

Assume E(G)≠∅. Each of the Mm constraints of H has arity at most six, so the conversion creates at most six edge records per constraint by [F6]. Hence ∣E(A)∣≤6∣E(H)∣=6Mm≤6MΣm, as asserted in clause 1.

2.2F2F3F6F7step 1.1algebra

The vertex set of A consists of the vertices of H together with one private tuple vertex per constraint of H by [F6], so ∣V(A)∣=∣V(H)∣+Mm. The block coordinates account for at most 2ℓm coordinates, since each of the at most 2m nonisolated vertices contributes ℓ coordinates by [F3]. By [F7], the edge-private auxiliary variables of one gadget number at most qmax⁡, giving ∣V(H)∣≤(2ℓ+qmax⁡)m. Therefore ∣V(A)∣≤(2ℓ+qmax⁡+MΣ)m by step 1.1, proving clause 2.

2.3F2F3F5step 1.1algebra

Consider a vertex of A that comes from a coordinate x of a shared block Bv of H. By [F3] this coordinate appears in the gadgets of exactly the edge records incident to v, and v is incident to at most d edge records by hypothesis. In one copy of the gadget of such an edge, the coordinate occurs in at most qe constraints, each of arity at most six, so at most 6qe times; after the uniform duplication of [F2] it occurs at most 6qe⋅M/qe=6M≤6MΣ times in that gadget. Summing over the at most d incident records gives deg⁡A(x)≤6MΣd.

3.1F3F6step 2.3algebra

A vertex of A that comes from an edge-private auxiliary variable of H belongs to the gadget of exactly one edge, so the same occurrence count gives degree at most 6M≤6MΣ; a private tuple vertex created by the conversion has one edge record per variable occurrence of its constraint, hence degree at most six by [F6]. Since d≥1 whenever E(G)≠∅, all these degrees are at most 6MΣd. This proves clause 3.

3.2F1F6step 2.1step 2.2algebra

The determinism, polynomial running time and fixed output alphabet are inherited from the reduction AΣ by [F1]; the edge and vertex counts of clauses 1 and 2 are polynomial in m by steps 2.1 and 2.2, and all relation tables are the constant-size tables of the 66-symbol conversion.

4.1F1F2F4F5step 1.1step 1.2step 2.1step 2.2step 2.3step 3.1step 3.2algebradischarge-construct∎

Clauses 1, 2, 3 and 4 hold: the edgeless case is step 1.2, the edge and vertex bounds are steps 2.1 and 2.2, the degree bound is steps 2.3 and 3.1, and uniformity is step 3.2. Every constant produced is a function of Σ and d alone, namely 6MΣ, 2ℓ+qmax⁡+MΣ and 6MΣd.

Remarks

The degree bound is what makes the iterated transformation self-contained: after one application the output has constant degree depending only on the fixed input alphabet and the input degree bound, so the next round can use the same reduction with the same constants. The count MΣ is a constant for fixed Σ even though it is enormous, because each local tester has constant size once the alphabet is fixed. The proof is choice-free: the composition, the least common multiple and the conversion are deterministic finite constructions.

DefinitionDefinition: Literature-sourcedProof: Not applicableaudited 2026-09-30Open item page →

One fixed-alphabet Dinur transformation

Definition

Let Σ⋆ denote the fixed alphabet of 66 symbols produced by the alphabet reduction of Fixed-alphabet reduction with constant gap retention, that is, Σ⋆={B(0),B(1)}⊔{0,1}6, and let W⋆=∣Σ⋆∣=66≥2.

Fix the constants of the gap-amplification step of A complete uniform graph gap-amplification step at the input alphabet Σ⋆: its threshold t0 (which depends only on W⋆ and on the absolute constants of that theorem), its output alphabet Σt, its output degree bound dt, its blowup Ct, its gap map gt(ε)=βtmin⁡(ε,c/t) and its completeness and edgeless-input clauses. For every integer t≥t0, denoted in the sequel by t being in the transformation domain, define, for every finite binary constraint graph G over Σ⋆ whose relation tables are explicit and whose degree is arbitrary, Tt(G):=AΣt(Rt(G)), where:

  • Rt(G) is the output of the published complete uniform gap-preserving step of A complete uniform graph gap-amplification step applied to G: first the degree reduction, then the local-view powering. It is a binary constraint graph over the finite alphabet Σt with at most Ct∣E(G)∣ ordinary edges, and it is edgeless whenever G is edgeless;
  • Σt has ∣Σt∣=∣Σ⋆∣(2D)R symbols for the absolute constant D=387 and the view radius R=t+⌈t⌉, so ∣Σt∣≥2 for every t in the domain;
  • AΣt is the alphabet reduction of Fixed-alphabet reduction with constant gap retention instantiated at the input alphabet Σt, a deterministic map sending finite Σt-graphs to finite binary constraint graphs over Σ⋆ again.

Thus Tt is a map from finite binary constraint graphs over Σ⋆ to finite binary constraint graphs over Σ⋆, defined exactly for integers t≥t0. It retains the input edge multiplicities and relation orientations throughout: both stages enumerate their relation tables explicitly and copy edge records, one per occurrence, without merging parallel edges or reversing endpoint order. It is deterministic and polynomial time in the bit length of the explicit encoding of its input, and it satisfies ∣E(Tt(G))∣≤6MΣt Ct ∣E(G)∣ for the constant MΣt of Alphabet reduction controls explicit size and degree attached to the input alphabet Σt, while every output degree is bounded by the constant 6MΣtdt, which depends only on Σ⋆ and t. By the two cited edgeless clauses, Tt maps an edgeless graph to the edgeless graph over Σ⋆. The definition asserts nothing about unsatisfaction; the amplification and completeness properties of Tt are separate results.

Remarks

The alphabet is fixed before the powering parameter is chosen: Σ⋆ is used as the input alphabet of Rt, the intermediate alphabet Σt is a function of t alone, and the alphabet reduction returns to the same absolute alphabet Σ⋆. This is what lets the same map Tt be iterated without changing the alphabet between rounds; the later iteration fixes one integer t in the domain once and for all.

The construction is choice-free. The degree reduction, the powering, the edge-circuit construction and the alphabet reduction are all deterministic finite constructions, and no selection from a varying family of nonempty sets occurs.

LemmaStatement: Literature-sourcedProof: AI-adaptedprecheck passjudge pass (gpt-6-sol)audited 2026-09-30Open item page →

One Dinur transformation preserves perfect satisfiability

Statement

Let Σ⋆ be the fixed 66-symbol alphabet of Fixed-alphabet reduction with constant gap retention and let Tt be the fixed-alphabet transformation of One fixed-alphabet Dinur transformation, defined for every integer t≥t0 and mapping finite Σ⋆-graphs to finite Σ⋆-graphs. For every such t and every finite binary constraint graph G over Σ⋆, val⁡(G)=1  ⟹  val⁡(Tt(G))=1, including the case in which G is edgeless.

Facts & Assumptions

Given: Fix an integer t≥t0 in the transformation domain and a finite binary constraint graph G over Σ⋆ with val⁡(G)=1.

[F1]

Tt(G)=AΣt(Rt(G)) is a finite binary constraint graph over Σ⋆, and Tt maps an edgeless input to an edgeless output. (One fixed-alphabet Dinur transformation)

[F2]

The gap-amplification step has perfect completeness: for every integer t≥t0, val⁡(G)=1 implies val⁡(Rt(G))=1, and edgeless inputs are mapped to edgeless outputs. (A complete uniform graph gap-amplification step)

[F3]

For every fixed alphabet Σ with ∣Σ∣≥2, val⁡(G)=1 if and only if val⁡(AΣ(G))=1; in particular the alphabet reduction is defined at the nondegenerate intermediate alphabet Σt and preserves the value-one property in the forward direction. (Fixed-alphabet reduction with constant gap retention)

[F4]

An edgeless graph has value one and unsatisfaction zero for every labeling, so the premise val⁡(G)=1 holds in the edgeless case. (Constraint graph and labeling value)

Proof

Given: Use the fixed t and the graph G with val⁡(G)=1.

1.1F1F2F3F4givenassume-case edgeless

Assume first that E(G)=∅. Then val⁡(G)=1 by [F4]. The completeness clause of [F2] applied to this input gives val⁡(Rt(G))=1, and Tt(G) is edgeless by [F1] and [F2]. Applying the forward value-one direction of [F3] at Σ=Σt to the graph Rt(G) therefore gives val⁡(Tt(G))=val⁡(AΣt(Rt(G)))=1.

1.2F1F2givenassume-case nonempty

Assume now that E(G)≠∅. The identity Tt(G)=AΣt(Rt(G)) of [F1] rewrites the goal as val⁡(AΣt(Rt(G)))=1. The intermediate graph Rt(G) is a finite binary constraint graph over the alphabet Σt supplied by [F2] and [F1].

1.3F2givenalgebra

The completeness clause of [F2] applies to the input G because val⁡(G)=1, so val⁡(Rt(G))=1.

2.1F1F2F3step 1.2step 1.3algebra

Apply the forward direction of [F3] with the fixed alphabet Σt, whose size is at least two, to the graph Rt(G). Since val⁡(Rt(G))=1, it gives val⁡(AΣt(Rt(G)))=1, that is, val⁡(Tt(G))=1 by the identity of [F1].

3.1F1step 1.1step 2.1cases-exhaustive∎

Step 1.1 proves the edgeless case and step 2.1 proves the case of a nonempty edge set; these two cases exhaust all finite inputs, so for the arbitrarily fixed t≥t0, val⁡(G)=1 implies val⁡(Tt(G))=1. No random sampling or selection from a varying family occurs: the two maps are deterministic and the cases are decided by whether the finite edge set is empty.

Remarks

This is the completeness half of Dinur's transformation: a satisfying labeling survives the degree reduction, the powering and the alphabet reduction, because each stage has an explicit extension or lift of satisfying labelings. The present lemma composes the published completeness clauses of A complete uniform graph gap-amplification step and Fixed-alphabet reduction with constant gap retention rather than reproving them, and records the edgeless branch separately so that the value convention is used only where it is needed.

LemmaStatement: Literature-sourcedProof: AI-adaptedprecheck passaudited 2026-09-30Open item page →

One fixed-alphabet transformation doubles small gaps

Statement

Let Σ⋆ be the fixed 66-symbol alphabet of Fixed-alphabet reduction with constant gap retention, let β>0, c:=DK=7740/7 and t0 be the constants that A complete uniform graph gap-amplification step attaches to the finite alphabet Σ⋆, and let κ=1/48000 be the absolute constant of Fixed-alphabet reduction with constant gap retention. Put t:=max⁡(t0, ⌈4(κβ)−2⌉),α:=min⁡(1/2, κβc/t), and let T:=Tt be the transformation of One fixed-alphabet Dinur transformation at this fixed t. Then t≥t0 is an integer in the transformation domain, α>0, and both depend only on the absolute constants κ,β,c and t0, never on an input graph. For every finite binary constraint graph G over Σ⋆, UNSAT⁡(T(G)) ≥ min⁡(2UNSAT⁡(G), α). Moreover T is a deterministic map from finite Σ⋆-graphs to finite Σ⋆-graphs, so the same transformation and the same t can be used in every round of an iteration.

Facts & Assumptions

Given: Fix the alphabet Σ⋆ and the constants β,c,t0 of A complete uniform graph gap-amplification step and κ of Fixed-alphabet reduction with constant gap retention attached to it.

[F1]

Tt(G)=AΣt(Rt(G)) for every finite Σ⋆-graph G and every integer t≥t0, and Tt is a deterministic map from finite Σ⋆-graphs to finite Σ⋆-graphs, defined exactly for integers t≥t0. (One fixed-alphabet Dinur transformation)

[F2]

Σt has ∣Σt∣=∣Σ⋆∣(2D)R symbols for the absolute constant D=387 and the view radius R=t+⌈t⌉, so ∣Σt∣≥2 for every t in the domain and the alphabet reduction AΣt of [F4] can be instantiated at this input alphabet. (One fixed-alphabet Dinur transformation)

[F3]

The gap-amplification step at the alphabet Σ⋆ has a gap map gt(ε)=βt min⁡(ε,c/t) with c=DK=7740/7 and β>0 depending only on ∣Σ⋆∣=66 and the absolute constants of that theorem, and UNSAT⁡(Rt(G))≥βt min⁡(UNSAT⁡(G),c/t) for every t≥t0 and every finite Σ⋆-graph G. (A complete uniform graph gap-amplification step)

[F4]

For every finite alphabet Σ with ∣Σ∣≥2 and every finite Σ-graph H, UNSAT⁡(AΣ(H))≥κUNSAT⁡(H),κ=ρ0δ4⋅6=148000, so the retention factor is the absolute constant κ. (Fixed-alphabet reduction with constant gap retention)

[F5]

For a labeling σ the number val⁡σ(G) is the fraction of ordinary edges satisfied, or 1 when E(G)=∅; hence 0≤val⁡σ(G)≤1 and 0≤UNSAT⁡(G)≤1 for every finite graph G. (Constraint graph and labeling value)

Proof

Given: Use the fixed alphabet Σ⋆ and the constants β,c,t0,κ of [F3] and [F4].

1.1F1F3F4algebra

The numbers κ=1/48000>0 and β>0 are fixed constants, so t:=max⁡(t0,⌈4(κβ)−2⌉) is a well-defined integer with t≥t0; it therefore lies in the transformation domain of [F1], and t≥4(κβ)−2 gives t≥2/(κβ), that is, κβt≥2.

1.2F3F5given

Let G be an arbitrary finite Σ⋆-graph and put ε:=UNSAT⁡(G); by [F5], ε≥0. The gap-amplification step [F3] gives UNSAT⁡(Rt(G))≥βt min⁡(ε,c/t).

2.1F3step 1.1algebra

With c=7740/7>0 from [F3], set α:=min⁡(1/2,κβc/t). Then α>0 and α≤κβc/t, and both t and α depend only on κ,β,c,t0.

2.2F1F2F4step 1.1

Put T:=Tt. By [F1], T is a deterministic map from finite Σ⋆-graphs to finite Σ⋆-graphs with T(G)=AΣt(Rt(G)) for every finite Σ⋆-graph G; by [F2] the alphabet Σt is finite of size at least two, so the reduction AΣt of [F4] applies to Σt-graphs.

2.3F1F2F3F4step 1.2algebra

The graph Rt(G) is a finite graph over the alphabet Σt, which has at least two symbols by [F2]. Applying [F4] with Σ:=Σt and H:=Rt(G) gives UNSAT⁡(AΣt(Rt(G)))≥κUNSAT⁡(Rt(G)), and multiplying the inequality of step 1.2 by κ>0 yields UNSAT⁡(AΣt(Rt(G)))≥κβt min⁡(ε,c/t).

3.1F1step 1.1step 1.2step 2.1step 2.3algebra

Since κβt≥2 (step 1.1) and ε≥0 (step 1.2), κβt min⁡(ε,c/t)=min⁡(κβt ε,κβc/t)≥min⁡(2ε,α), because κβt ε≥2ε while κβc/t≥α by step 2.1. Hence UNSAT⁡(T(G))=UNSAT⁡(AΣt(Rt(G)))≥min⁡(2ε,α)=min⁡(2UNSAT⁡(G),α).

4.1step 1.1step 2.1step 2.2step 3.1∎

The graph G was arbitrary and the numbers t,α and the map T were fixed in steps 1.1–2.2 without reference to G; hence there are a fixed integer t≥t0, a fixed α>0 and the fixed map T=Tt with UNSAT⁡(T(G))≥min⁡(2UNSAT⁡(G),α) for every finite Σ⋆-graph G, and T is again a finite Σ⋆-graph transformation, so the same t serves in every round.

Remarks

This is the soundness clause of Dinur's gap-amplification step in the fixed-alphabet form: the powering alone multiplies small unsatisfaction values by βt but enlarges the alphabet to Σt, and the alphabet reduction returns to Σ⋆ at the absolute cost κ. Fixing one t with κβt≥2 therefore restores the factor two, with the cap α for large inputs. The threshold t and the cap α are computed from absolute constants alone, so no input-dependent choice or sampling is involved and the map can be iterated. The lemma asserts only the lower bound on unsatisfaction; it makes no claim about value one, which is supplied separately by One Dinur transformation preserves perfect satisfiability.

LemmaStatement: Literature-sourcedProof: AI-adaptedprecheck passjudge pass (gpt-6-sol)audited 2026-09-30Open item page →

One fixed transformation has constant-factor growth

Statement

Let t be the integer fixed in One fixed-alphabet transformation doubles small gaps and let T:=Tt be the transformation of One fixed-alphabet Dinur transformation at this t. Then there are constants CE,CV,CD≥1, depending only on Σ⋆ and on this fixed t (and therefore fixed before any input graph is given), such that for every finite binary constraint graph G over Σ⋆ with m=∣E(G)∣ edge records ∣E(T(G))∣≤CE m,∣V(T(G))∣≤CV m, every vertex of T(G) has degree at most CD, and T is deterministic and computable in time polynomial in the bit length of the explicit encoding of G; explicitly one may take CE=6MΣtCt, CV=(2ℓt+qmax⁡,t+MΣt)Ct and CD=6MΣtdt, where MΣt,ℓt,qmax⁡,t are the constants attached to the input alphabet Σt by Alphabet reduction controls explicit size and degree. In particular the growth factor is bounded by constants independent of m, and T maps edgeless inputs to the empty graph.

Facts & Assumptions

Given: Fix the alphabet Σ⋆ and the integer t of One fixed-alphabet transformation doubles small gaps, with T:=Tt.

[F1]

For every integer t≥t0 and every finite binary Σ⋆-graph G one has Tt(G)=AΣt(Rt(G)), and Tt is a deterministic map from finite Σ⋆-graphs to finite Σ⋆-graphs. (One fixed-alphabet Dinur transformation)

[F2]

The alphabet Σt is finite of size ∣Σt∣=∣Σ⋆∣(2D)R≥2 with D=387 and R=t+⌈t⌉. (One fixed-alphabet Dinur transformation)

[F3]

The intermediate graph Rt(G) is a binary constraint graph over Σt with at most Ct∣E(G)∣ ordinary edges, and it is edgeless whenever G is edgeless. (One fixed-alphabet Dinur transformation)

[F4]

The gap-amplification step at Σ⋆ has output degree bound dt:=2(2D)2t+1=DO(t) and blowup Ct:=D⋅(2D)2t+1=DO(t). (A complete uniform graph gap-amplification step)

[F5]

The map Rt is deterministic and runs in time polynomial in the bit length of the explicit encoding of G, and the parameters Σt,dt,Ct depend only on ∣Σ∣ and t, never on ∣V(G)∣ or ∣E(G)∣. (A complete uniform graph gap-amplification step)

[F6]

For every finite alphabet Σ with ∣Σ∣≥2 and every finite Σ-graph H with m′ edge records, ∣E(AΣ(H))∣≤6MΣm′, where MΣ=lcm⁡(1,…,QΣ) depends only on Σ. (Alphabet reduction controls explicit size and degree)

[F7]

For the same input H, ∣V(AΣ(H))∣≤(2ℓ+qmax⁡+MΣ)m′, where ℓ=2⌈log⁡2W⌉<2W and qmax⁡≤QΣ are the length and largest gadget size attached to Σ. (Alphabet reduction controls explicit size and degree)

[F8]

Every vertex of AΣ(H) has degree at most 6MΣd when the input has maximum degree at most d, and AΣ is computable by a deterministic algorithm in time polynomial in the bit length of the explicit encoding of H. (Alphabet reduction controls explicit size and degree)

[F9]

The integer t satisfies t≥t0 and depends only on the absolute constants κ,β,c,t0, never on an input graph. (One fixed-alphabet transformation doubles small gaps)

Proof

Given: Use the fixed alphabet Σ⋆, the fixed integer t of [F9] and the map T=Tt.

1.1F1F2F3F4F9given

By [F9] the integer t≥t0 lies in the transformation domain, so by [F1] and [F2] the map T sends finite Σ⋆-graphs to finite Σ⋆-graphs by G↦AΣt(Rt(G)), with Σt a finite alphabet of size at least two; by [F3] the graph Rt(G) has at most Ct∣E(G)∣ edge records and is edgeless when G is edgeless, and by [F4] its degrees are at most dt.

1.2F4F5F6F7F8algebra

Let MΣt,ℓt,qmax⁡,t be the constants attached to the alphabet Σt by [F6]–[F8], and set CE:=6MΣtCt, CV:=(2ℓt+qmax⁡,t+MΣt)Ct and CD:=6MΣtdt. These are constants depending only on Σ⋆ and t, because Σt,dt,Ct do by [F4] and [F5], while MΣt,ℓt,qmax⁡,t do by their definition at the input alphabet Σt.

2.1F1F2F3F6step 1.1step 1.2algebra

Let G be an arbitrary finite Σ⋆-graph with m=∣E(G)∣ edge records. Applying [F6] with Σ:=Σt and H:=Rt(G), which is a finite Σt-graph by [F1]–[F3], gives ∣E(T(G))∣=∣E(AΣt(Rt(G)))∣≤6MΣt∣E(Rt(G))∣≤6MΣtCt m=CE m, the last inequality using [F3].

2.2F1F2F3F7step 1.1step 1.2algebra

Applying [F7] to the same input H=Rt(G) gives ∣V(T(G))∣≤(2ℓt+qmax⁡,t+MΣt)∣E(Rt(G))∣≤(2ℓt+qmax⁡,t+MΣt)Ct m=CV m, again using the edge bound of [F3].

2.3F1F2F4F8step 1.1step 1.2algebra

Applying [F8] to H=Rt(G) with degree parameter d=dt, which bounds the degrees of Rt(G) by [F4], shows that every vertex of T(G)=AΣt(Rt(G)) has degree at most 6MΣtdt=CD.

2.4F1F5F8step 1.1

By [F5] the first stage computes Rt(G) deterministically in time polynomial in the bit length of the explicit encoding of G, so the explicit encoding of Rt(G) has polynomially bounded length; by [F8] the second stage computes AΣt(Rt(G)) deterministically in time polynomial in the bit length of that encoding. Composing the two deterministic polynomial-time algorithms exhibits a deterministic algorithm computing T(G) in time polynomial in the bit length of the explicit encoding of G.

3.1F1F3F6F7step 2.1step 2.2step 2.3step 2.4∎

The graph G was arbitrary, the constants CE,CV,CD depend only on Σ⋆ and t by step 1.2, and all three output bounds and the uniformity clause were established in steps 2.1–2.4; hence T has the claimed constant-factor growth. If G is edgeless, then Rt(G) is edgeless by [F3], and [F6] and [F7] applied with m′=0 give ∣E(T(G))∣=0 and ∣V(T(G))∣=0: the output is the empty graph and all bounds hold as 0≤0.

Remarks

The constants are enormous — CE and CV are built from the least common multiple MΣt of the local gadget sizes — but they are fixed before any input is read, which is all the later iteration needs. Degree reduction, powering and alphabet reduction each blow up the graph by a constant factor once t and the alphabet are frozen, and the composition of the three maps stays deterministic polynomial time because each stage's explicit output encoding has polynomial length. No choice principle is used.

LemmaStatement: Literature-sourcedProof: AI-adaptedprecheck passaudited 2026-09-30Open item page →

Logarithmic iteration reaches a constant unsatisfaction gap

Statement

Let t be the fixed integer of One fixed-alphabet transformation doubles small gaps, let α=min⁡(1/2,κβc/t)>0 be its cap, let T:=Tt and let C:=CE≥1 be the edge-growth constant of One fixed transformation has constant-factor growth. For every finite binary constraint graph G0 over Σ⋆ with m=∣E(G0)∣≥1 edge records and UNSAT⁡(G0)>0, the iterates Gk:=Tk(G0) at k:=⌈log⁡2m⌉ satisfy UNSAT⁡(Gk)≥α,∣E(Gk)∣≤Ckm=mO(1). If instead UNSAT⁡(G0)=0, then UNSAT⁡(Gk)=0 for every k≥0: all iterates of a satisfiable graph are satisfiable.

Facts & Assumptions

Given: Fix the fixed integer t, the map T=Tt and the constants α>0 and C=CE≥1.

[F1]

For every finite binary constraint graph G over Σ⋆, UNSAT⁡(T(G))≥min⁡(2UNSAT⁡(G),α). (One fixed-alphabet transformation doubles small gaps)

[F2]

T is a deterministic map from finite Σ⋆-graphs to finite Σ⋆-graphs, the same transformation may be used in every round, and α=min⁡(1/2,κβc/t)>0. (One fixed-alphabet transformation doubles small gaps)

[F3]

For every finite Σ⋆-graph G with m=∣E(G)∣ edge records, ∣E(T(G))∣≤C m, where C=CE≥1 is a constant fixed before any input graph is given. (One fixed transformation has constant-factor growth)

[F4]

For every finite Σ⋆-graph G with val⁡(G)=1, val⁡(T(G))=1; equivalently UNSAT⁡(G)=0 implies UNSAT⁡(T(G))=0. (One Dinur transformation preserves perfect satisfiability)

[F5]

For a labeling σ the number val⁡σ(G) is the fraction of ordinary edges satisfied when E(G)≠∅, and UNSAT⁡(G)=min⁡σ(1−val⁡σ(G)); hence for a graph with m≥1 edges and UNSAT⁡(G)>0 every labeling violates at least one edge, so UNSAT⁡(G)≥1/m. (Constraint graph and labeling value)

Proof

Given: Use the fixed T, α and C, and let G0 be an arbitrary finite Σ⋆-graph with m=∣E(G0)∣≥1 edge records and UNSAT⁡(G0)>0.

1.1F2given

Put k:=⌈log⁡2m⌉ and ui:=UNSAT⁡(Ti(G0)) for 0≤i≤k, where T0 is the identity. By [F2] every iterate Ti(G0) is again a finite Σ⋆-graph, so all ui are defined and [F1] and [F3] can be applied to each of them.

1.2F5givenalgebra

Since m≥1 and u0=UNSAT⁡(G0)>0, every labeling of G0 violates at least one of the m edge records, so by [F5] u0≥1/m.

2.1F1F2step 1.1algebra

We prove ui≥min⁡(2iu0,α) for all 0≤i≤k by induction on i. For i=0 this reads u0≥min⁡(u0,α), which holds because α>0. For the induction step, assume ui≥min⁡(2iu0,α); then [F1] applied to the finite Σ⋆-graph Ti(G0) of step 1.1 gives ui+1≥min⁡(2ui,α)≥min⁡(2min⁡(2iu0,α),α)=min⁡(2i+1u0,α), using that x↦min⁡(2x,α) is nondecreasing and min⁡(2a,2α,α)=min⁡(2a,α) for α>0.

2.2F3step 1.1algebra

We prove ∣E(Ti(G0))∣≤Cim for all 0≤i≤k by induction on i: for i=0 this is ∣E(G0)∣=m; for the step, [F3] applied to the finite graph Ti(G0) gives ∣E(Ti+1(G0))∣≤C∣E(Ti(G0))∣≤Ci+1m. In particular ∣E(Gk)∣≤Ckm.

2.3F4F5step 1.1algebra

If UNSAT⁡(G0)=0, then equivalently val⁡(G0)=1 by [F5], and [F4] applied to G=Ti(G0) for i=0,… gives val⁡(Ti+1(G0))=1 whenever val⁡(Ti(G0))=1; inductively UNSAT⁡(Ti(G0))=0 for every i≥0, so every iterate of a satisfiable graph is satisfiable.

3.1F2step 1.2step 2.1step 2.2step 2.3algebra∎

Since k=⌈log⁡2m⌉ gives 2k≥m, step 1.2 yields 2ku0≥2k/m≥1, and step 2.1 yields uk≥min⁡(2ku0,α)≥min⁡(1,α)=α because α≤1/2<1 by [F2]. Moreover k≤log⁡2m+1 and C≥1, so Ck≤Clog⁡2m+1=C mlog⁡2C and therefore ∣E(Gk)∣≤Ckm≤C m1+log⁡2C=mO(1) by step 2.2. With step 2.3 this proves both clauses for the arbitrary graph G0.

Remarks

The point of the iteration is that the doubling lemma's cap α is reached after only ⌈log⁡2m⌉ rounds once the initial unsatisfaction is positive, because a positive value on an m-edge graph is at least 1/m; the growth lemma keeps the size polynomial, mO(1), so no round is ever applied to an exponential-size object. The same fixed t, the same α and the same map T are used in every round, and the satisfiable case is preserved separately by the completeness lemma. No choice principle is used: all iterates are determined by the fixed deterministic map T.

LemmaStatement: Literature-sourcedProof: AI-adaptedprecheck passjudge pass (gpt-6-sol)audited 2026-09-30Open item page →

A three-CNF formula as a fixed-alphabet binary constraint graph

Statement

For a three-CNF formula F with m clauses, each having exactly three literal occurrences, there is a polynomial-time binary constraint graph over the fixed alphabet Σ^={B(0),B(1)}⊔{T(a):a∈{0,1}3} with exactly 3m edges. Its value is one exactly when F is satisfiable. If F is unsatisfiable and m≥1, then UNSAT⁡(GF)≥13m. The zero-clause formula maps to an edgeless graph.

Facts & Assumptions

[F1]

A CNF clause is a disjunction of literals, and each literal is a variable or its negation. (Boolean formulas, conjunctive normal form, and the satisfiability language SAT)

[F2]

A binary constraint graph carries a finite nonempty alphabet, explicit binary edge relations, and has value one when it is edgeless. (Constraint graph and labeling value)

Proof

Given: Write each clause as Ci=ℓi1∨ℓi2∨ℓi3, where each ℓij is a literal on an old Boolean variable.

1.1F1F2givenconstruct

For each old variable add one shared bit vertex. For each clause Ci add a private tuple vertex zi and put Ai={a∈{0,1}3:Ci evaluates to true on (a1,a2,a3)}. For each occurrence j=1,2,3, add a separate edge from zi to the old variable in ℓij with relation Sij={(T(a),B(aj)):a∈Ai}. Thus every clause contributes exactly three edges, including parallel edges when variables repeat, for a total of 3m.

2.1F1step 1.1construct

If F is satisfied by an assignment σ, label each old vertex by B(σ(x)) and each zi by the tuple of the three variable values at its occurrences. That tuple lies in Ai, so all three edges of every clause star pass and val⁡(GF)=1.

2.2F1F2step 1.1

Conversely, if all graph edges pass, each clause tuple vertex has a label T(a) with a∈Ai, and each edge forces its occurrence coordinate to equal the corresponding old bit label. A repeated variable uses the same old vertex on every occurrence edge, so the equalities are consistent. Therefore each original clause is true under the old bit labels; hence F is satisfiable.

3.1F2step 1.1step 2.1step 2.2algebradischarge-construct∎

The two implications prove val⁡(GF)=1 exactly when F is satisfiable. If m=0, the graph is edgeless, has value one by convention, and the empty conjunction is true. If m≥1 and F is unsatisfiable, step 2.2 shows no graph labeling can satisfy all 3m edges, so every labeling violates at least one and UNSAT⁡(GF)≥1/(3m). The alphabet and each edge table have constant size, so the explicit construction is polynomial time.

TheoremStatement: Literature-sourcedProof: AI-adaptedprecheck passjudge pass (gpt-6-sol)audited 2026-09-30Open item page →

Constant-gap binary CSP is NP-hard

Statement

Let Σ⋆ be the fixed 66-symbol alphabet of One fixed-alphabet Dinur transformation, let T=Tt be the fixed transformation of One fixed-alphabet transformation doubles small gaps and let α=min⁡(1/2,κβc/t)>0 be its cap. Then GapCSP⁡(1,1−α) on explicit binary constraint graphs over Σ⋆, in the promise sense of Gap csp, is NP-hard under deterministic polynomial-time many-one promise reductions: for every language L∈NP there is a total function fL on instances, computable by a deterministic polynomial-time algorithm, such that fL(x) is an explicit binary constraint graph over Σ⋆ satisfying val⁡(fL(x))≥1for x∈L,val⁡(fL(x))≤1−αfor x∉L.

Facts & Assumptions

Given: Use the fixed alphabet Σ⋆, the fixed map T and the fixed cap α>0.

[F1]

For a three-CNF formula F with m clauses, each having exactly three literal occurrences, there is a polynomial-time binary constraint graph over the fixed alphabet Σ^={B(0),B(1)}⊔{T(a):a∈{0,1}3} with exactly 3m edges. Its value is one exactly when F is satisfiable. If F is unsatisfiable and m≥1, then UNSAT⁡(GF)≥13m. The zero-clause formula maps to an edgeless graph. (A three-CNF formula as a fixed-alphabet binary constraint graph)

[F2]

The language 3-SAT of satisfiable CNF formulas with exactly three literals per clause is NP-complete. (3-SAT is NP-complete)

[F3]

For every finite binary constraint graph G0 over Σ⋆ with m=∣E(G0)∣≥1 edge records and UNSAT⁡(G0)>0, the iterates Gk:=Tk(G0) at k:=⌈log⁡2m⌉ satisfy UNSAT⁡(Gk)≥α,∣E(Gk)∣≤Ckm=mO(1). (Logarithmic iteration reaches a constant unsatisfaction gap)

[F4]

If instead UNSAT⁡(G0)=0, then UNSAT⁡(Gk)=0 for every k≥0: all iterates of a satisfiable graph are satisfiable. (Logarithmic iteration reaches a constant unsatisfaction gap)

[F5]

The cap is α=min⁡(1/2,κβc/t)>0, a constant fixed before any input. (One fixed-alphabet transformation doubles small gaps)

[F6]

T is a deterministic map from finite Σ⋆-graphs to finite Σ⋆-graphs, so the same transformation can be used in every round. (One fixed-alphabet transformation doubles small gaps)

[F7]

GapCSP⁡(c,s) is the disjoint yes/no pair Y={G:val⁡(G)≥c},N={G:val⁡(G)≤s}, and for 0<ε≤1 the pair GapCSP⁡(1,1−ε) distinguishes satisfiability from UNSAT⁡(G)≥ε. (Gap csp)

[F8]

A polynomial-time many-one reduction from a language A to a language B is a total function f computable by a deterministic Turing machine in polynomial time with x∈A  ⟺  f(x)∈B for every instance x. (Polynomial-time many-one reductions)

[F9]

For a labeling σ the number val⁡σ(G) is the fraction of ordinary edges satisfied, and val⁡(G)=max⁡σval⁡σ(G), UNSAT⁡(G)=min⁡σ(1−val⁡σ(G)). (Constraint graph and labeling value)

[F10]

The transformation alphabet is the fixed alphabet of 66 symbols Σ⋆={B(0),B(1)}⊔{0,1}6. (One fixed-alphabet Dinur transformation)

[F11]

There are constants CE,CV≥1, fixed before any input, such that every finite Σ⋆-graph G with m=∣E(G)∣ edge records satisfies ∣E(T(G))∣≤CEm, ∣V(T(G))∣≤CVm, and T is deterministic and computable in time polynomial in the bit length of the explicit encoding of G. (One fixed transformation has constant-factor growth)

Proof

Given: Use the fixed alphabet Σ⋆, the fixed map T and α>0, and let x be an arbitrary instance of a language L∈NP.

1.1F1F2F6F8F10givenconstruct

By [F2] and [F8] there is a deterministic polynomial-time total reduction g from L to 3-SAT, which we fix; put φ:=g(x), with m clauses, each of exactly three literal occurrences. By [F1] the formula φ has a polynomial-time computable graph Gφ over Σ^={B(0),B(1)}⊔{T(a):a∈{0,1}3} with exactly 3m edges, and by [F10] the transformation alphabet is Σ⋆={B(0),B(1)}⊔{0,1}6. Let f be the fixed injection f:Σ^→Σ⋆ with f(B(i))=B(i) and f(T(a))=(a,0,0,0), and let G^ be the graph with the same vertices, incidence slots and endpoint orders as Gφ and relations f(Re)={(f(a),f(b)):(a,b)∈Re}; then G^ is an explicit binary constraint graph over Σ⋆ with exactly 3m edges. Put K:=⌈log⁡2(3m)⌉ if m≥1, and define h(φ):=TK(G^) for m≥1 (a finite Σ⋆-graph by [F6]) while h(φ) is the edgeless graph over Σ⋆ for m=0.

2.1F1F9step 1.1algebra

For a labeling σ of G^, define σ0(v):=f−1(σ(v)) if σ(v)∈f(Σ^) and σ0(v):=B(0) otherwise. If an edge e is satisfied by σ in G^, then (σ(u),σ(v))∈f(Re), so both labels lie in f(Σ^) and (σ0(u),σ0(v))=(f−1σ(u),f−1σ(v))∈Re: the same edge is satisfied by σ0 in Gφ. Hence val⁡σ(G^)≤val⁡σ0(Gφ)≤val⁡(Gφ) for every σ by [F9], so val⁡(G^)≤val⁡(Gφ); conversely the labelings f∘τ of G^ for τ:V→Σ^ realize the same satisfied edges, so val⁡(G^)≥val⁡(Gφ). Thus val⁡(G^)=val⁡(Gφ) and UNSAT⁡(G^)=UNSAT⁡(Gφ).

2.2F1F8F11step 1.1algebra

For the size and time bound, each iterate multiplies the number of edge records by at most CE and has at most CV times the previous number of edge records vertices by [F11], so after i≤K=O(log⁡m) rounds ∣E(Ti(G^))∣≤CEi⋅3m and, for i≥1, ∣V(Ti(G^))∣≤CV∣E(Ti−1(G^))∣≤CVCEi−1⋅3m, both of size mO(1). Each of the K+1 applications of T runs in deterministic polynomial time in the bit length of its input by [F11], and that input has size mO(1) throughout, so the computation of h(φ) from φ is deterministic polynomial time; the relabeling Gφ↦G^ and the reduction g are also polynomial time.

3.1F1F4F9step 1.1step 2.1

Suppose x∈L, so φ∈3-SAT. If m=0, then h(φ) is edgeless, so val⁡(h(φ))=1 by [F9]. If m≥1, then val⁡(Gφ)=1 by [F1], hence val⁡(G^)=1 by step 2.1, and the zero-unsatisfaction clause [F4] of the iteration lemma applied to G0=G^ with ∣E(G^)∣=3m gives UNSAT⁡(h(φ))=0, that is, val⁡(h(φ))=1. In both cases val⁡(h(φ))≥1.

3.2F1F3F9step 1.1step 2.1

Suppose x∉L, so φ∉3-SAT is unsatisfiable; a formula with no clauses is satisfiable, so m≥1. By [F1], UNSAT⁡(Gφ)≥1/(3m)>0 and ∣E(Gφ)∣=3m≥1, and step 2.1 transfers both to G^, whose edge count is 3m. The positive-gap clause [F3] of the iteration lemma applied to G0=G^ with ∣E(G^)∣=3m and K=⌈log⁡2(3m)⌉ gives UNSAT⁡(h(φ))≥α, hence val⁡(h(φ))≤1−α by [F9].

4.1F2F5F7F8step 1.1step 2.2step 3.1step 3.2discharge-construct∎

The map fL:x↦h(g(x)) is total, deterministic and polynomial time by steps 1.1 and 2.2, and it sends instances of L to graphs of value at least 1 by step 3.1 and instances outside L to graphs of value at most 1−α by step 3.2. By [F7] the target pair is GapCSP⁡(1,1−α) with c=1 and s=1−α, and by [F8] this is a deterministic polynomial-time many-one promise reduction in the two-sided sense. Since L∈NP was arbitrary, GapCSP⁡(1,1−α) is NP-hard.

Remarks

The route is the classical one: 3-SAT is reduced to a fixed-alphabet binary constraint graph, the fixed transformation T is iterated logarithmically many times, and the Dinur transformation turns the 1/(3m) unsatisfaction gap of an unsatisfiable instance into the absolute gap α, while satisfiable instances stay satisfiable. The relabeling of the ten-symbol gadget alphabet into the 66-symbol alphabet Σ⋆ preserves value because a labeling that uses a symbol outside the image satisfies no edge incident to that vertex, so the clamped labeling satisfies at least as many edges. The reduction is deterministic and runs in polynomial time because the intermediate graphs have polynomially many edges and vertices. No choice principle is used: all constructions are fixed by the input and by absolute constants.

TheoremStatement: Literature-sourcedProof: AI-adaptedprecheck passjudge pass (gpt-6-sol)audited 2026-09-30Open item page →

The PCP theorem: NP equals PCP(log n, O(1))

Statement

NP=PCP⁡(log⁡n,O(1)) in the shorthand of PCP classes with completeness and soundness: a language K⊆{0,1}∗ belongs to NP if and only if there are a constant s<1, a bound r(n)=O(log⁡n) and a constant bound q with K∈PCP⁡(r,q;1,s) over the binary proof alphabet. In particular every language in the class has a verifier with perfect completeness, soundness at most the fixed constant s<1, one fixed polynomial-length proof per input, O(log⁡n) random bits and a constant number of nonadaptive bit queries.

Facts & Assumptions

Given: Use the shorthand convention of PCP classes with completeness and soundness and the fixed GapCSP⁡(1,1−α) promise problem of Constant-gap binary CSP is NP-hard.

[F1]

For every language L∈NP there is a total function fL, computable by a deterministic polynomial-time algorithm, such that fL(x) is an explicit binary constraint graph over Σ⋆ with val⁡(fL(x))≥1 for x∈L and val⁡(fL(x))≤1−α for x∉L, where α>0 is the fixed gap constant. (Constant-gap binary CSP is NP-hard)

[F2]

For every explicit binary constraint multigraph G over a finite alphabet Σ with m≥1 edges there is a nonadaptive verifier whose proof is a labeling σ:V(G)→Σ, which uses exactly ⌈log⁡2m⌉ random bits and reads at most two symbols, such that for every fixed labeling Pr⁡[Vσ rejects]=m2⌈log⁡2m⌉ UNSAT⁡σ(G)≥12UNSAT⁡σ(G); it has perfect completeness on satisfiable graphs, and if UNSAT⁡(G)≥δ then every proof is rejected with probability at least δ/2. (Two-query PCPs and binary constraint graphs)

[F3]

If a binary proof convention is required, encoding each Σ symbol by a fixed number of bits changes two symbol queries to a constant number of nonadaptive bit queries without changing the best acceptance probability. (Two-query PCPs and binary constraint graphs)

[F4]

A language K belongs to PCP⁡(r,q;c,s) exactly when there are a verifier V with randomness bound r(n) and query bound q(n), a fixed finite proof alphabet, and a polynomial p such that its addressable proof length LV(n) is at most p(n) and: if x∈K, there is one fixed proof π with Pr⁡[Vπ(x) accepts]≥c; if x∉K, every fixed proof π satisfies Pr⁡[Vπ(x) accepts]≤s. (PCP classes with completeness and soundness)

[F5]

In the shorthand PCP⁡(log⁡n,O(1)) the proof alphabet is {0,1}, the randomness is O(log⁡n), the number of bit queries is bounded by a constant, completeness is perfect (c=1), and soundness is at most some fixed constant s<1. (PCP classes with completeness and soundness)

[F6]

For a fixed input x and a fixed proof π, the acceptance probability is the proportion of the 2r(n) coin strings on which Vπ(x) accepts, and the proof is not resampled when the verifier runs. (PCP verifier resources and deterministic proof strings)

[F7]

The class NP is the set of languages that admit a polynomial-time verifier with polynomially bounded certificates in the sense of Polynomial-time verifiers with polynomially bounded certificates. (The class NP via polynomial-time verifiers)

[F8]

A polynomial-time verifier with polynomially bounded certificates for L consists of a relation R whose paired language LR={⟨x,u⟩:(x,u)∈R} belongs to P and a polynomial p with x∈L if and only if there is u with ∣u∣≤p(∣x∣) and (x,u)∈R. (Polynomial-time verifiers with polynomially bounded certificates)

[F9]

For a labeling σ of a binary constraint graph G with E(G)≠∅, val⁡σ(G) is the fraction of ordinary edges satisfied, and the definitions give UNSAT⁡(G)=1−val⁡(G) with val⁡(G)=max⁡σval⁡σ(G). (Constraint graph and labeling value)

[F10]

Between any two real numbers lies a rational (The rationals embed densely in the reals).

Proof

Given: Use the shorthand class convention of [F5] and the fixed gap problem [F1].

1.1F4F5F10givenconstruct

Suppose K∈PCP⁡(log⁡n,O(1)). By [F4] and [F5] there are a constant s<1, bounds r(n)=O(log⁡n) and q(n)=O(1), a verifier V with binary proof alphabet, and an integer-valued polynomial p with LV(n)≤p(n) such that on every input x of length n: if x∈K some fixed proof is accepted with probability at least 1, and if x∉K every fixed proof is accepted with probability at most s. Fix once and for all a rational constant s′ with s<s′<1; [F10] supplies one, and the certificate machine can hardcode it without computing s. Use the same query algorithm on proofs of length p(n); its query locations remain in [LV(n)]⊆[p(n)], so the added suffix is never read. Call this fixed-length interface V^. Define the binary relation R:={(x,π):∣π∣=p(∣x∣) and Pr⁡[V^π(x) accepts]>s′}. Thus every invocation in the relation has a valid fixed-length proof string.

1.2F1given

Suppose L∈NP and fix the reduction fL of [F1]. For an input x of length n put Gx:=fL(x) and M:=∣E(Gx)∣; then x∈L implies val⁡(Gx)≥1 and x∉L implies val⁡(Gx)≤1−α, and Gx together with its explicit encoding is computable in deterministic polynomial time in n, so M≤poly(n) and the encoding length of Gx is poly(n).

2.1F6step 1.1algebra

The paired language LR={⟨x,π⟩:(x,π)∈R} belongs to P: a deterministic machine checks ∣π∣=p(∣x∣), enumerates the 2r(n) coin strings of V^ on x (there are 2O(log⁡n)=poly(n) of them), simulates V^π(x) deterministically on each, counts the accepting runs, and compares the exact rational acceptance probability with the fixed rational s′ by integer arithmetic.

2.2F1F9step 1.2

If M=0 define the verifier V0 that makes no queries and accepts on every coin string: it has perfect completeness, and it is used only when val⁡(Gx)=1, which by [F9] is the value of an edgeless graph and by step 1.2 forces x∈L (otherwise val⁡(Gx)≤1−α<1), so its soundness clause is vacuous.

2.3F1F2F3step 1.2algebra

If M≥1, apply [F2] to the graph Gx over the alphabet Σ⋆ and then the binary encoding of [F3] with a fixed 7-bit code for the 66 symbols of Σ⋆. This yields a nonadaptive verifier Vx whose proof is the concatenation of the 7-bit blocks of a vertex labelling, which uses exactly ⌈log⁡2M⌉=O(log⁡n) random bits by step 1.2, reads at most two 7-bit blocks, that is at most 14 bit queries, and whose proof length is 7∣V(Gx)∣=poly(n) because the explicit encoding of Gx has polynomial length.

3.1F4F7F8step 1.1step 2.1algebra

By step 2.1 and [F7] it remains to verify the certificate condition of [F8] for R. If x∈K, pad its fixed LV(n)-bit completeness proof to length p(n); V^ ignores the padding, so this proof has acceptance probability at least 1>s′ and belongs to R. Conversely, if (x,π)∈R, the original verifier's queries are all in [LV(n)], so the prefix of π of length LV(n) is an original fixed proof with the same acceptance probability. If x∉K, soundness would bound that probability by s<s′, contrary to membership in R. The certificate length is exactly p(∣x∣), hence at most p(∣x∣), so K∈NP by [F7] and [F8].

3.2F2F3F9step 1.2step 2.2step 2.3

Completeness for L: if x∈L then val⁡(Gx)≥1. For M=0 the verifier of step 2.2 accepts every coin string, so its one fixed proof is accepted with probability 1. For M≥1, [F2] gives a labelling satisfying all M edges, whose 7-bit encoding is a fixed binary proof accepted with probability 1 by the verifier of step 2.3, the binary encoding of [F3] preserving the acceptance probability.

3.3F2F3F9step 1.2step 2.3algebra

Soundness for L: if x∉L then step 1.2 and [F9] give UNSAT⁡(Gx)≥α, so M≥1 and the verifier of step 2.3 is used. Fix any binary proof π of the verifier's addressable length 7∣V(Gx)∣. Decode every consecutive 7-bit block by the fixed surjection D:{0,1}7→Σ⋆ from [F3]; this gives a full graph labeling σ. Each real-edge index is accepted exactly when its edge relation is satisfied by σ, so the number S of accepted indices satisfies S≤Mval⁡(Gx)≤M(1−α). The verifier accepts the 2⌈log⁡2M⌉−M surplus indices, so Pr⁡[Vxπ(x) accepts]≤2⌈log⁡2M⌉−M+M(1−α)2⌈log⁡2M⌉≤1−α2, because M/2⌈log⁡2M⌉≥1/2. Hence every fixed binary proof is accepted with probability at most 1−α/2<1.

4.1F4F5step 1.2step 2.2step 2.3step 3.2step 3.3

Steps 2.2, 2.3, 3.2 and 3.3 exhibit, for the arbitrary language L∈NP, a uniform deterministic polynomial-time verifier computing Gx and then running the described test, with O(log⁡n) random bits, a constant number of nonadaptive bit queries, binary proof alphabet, polynomial addressable proof length, perfect completeness and soundness at most s:=1−α/2<1. By [F4] and [F5], L∈PCP⁡(r,q;1,s) for r(n)=O(log⁡n) and constant q, hence L∈PCP⁡(log⁡n,O(1)); L was arbitrary, so NP⊆PCP⁡(log⁡n,O(1)).

5.1step 3.1step 4.1∎

Step 3.1 gives PCP⁡(log⁡n,O(1))⊆NP and step 4.1 gives the reverse inclusion, so NP=PCP⁡(log⁡n,O(1)) in the shorthand sense, with perfect completeness, constant soundness below one, one fixed polynomial-length proof per input, O(log⁡n) random bits and a constant number of nonadaptive bit queries.

Remarks

The two inclusions use different faces of the same gap: soundness of the fixed-alphabet gap problem supplies the constant rejection probability α/2 for a randomly sampled constraint, while the enumeration of the 2O(log⁡n) coin strings turns any PCP verifier into a polynomial-time certificate checker. Both quantifications are over one fixed proof: the verifier never resamples the proof, and the NP machine guesses it once. The gap problem is the one produced by the Dinur transformation of Constant-gap binary CSP is NP-hard, so no additional hardness assumption enters, and no choice principle is used: the reduction, the sampled edge and the guessed certificate are all explicit finite objects.

TheoremStatement: Literature-sourcedProof: AI-adaptedprecheck passjudge pass (gpt-6-sol)audited 2026-09-30Open item page →

PCP soundness amplification by independent repetition

Statement

Let V be a nonadaptive PCP verifier with addressable proof length L(n), randomness bound r(n), query bound q(n), fixed finite proof alphabet, and completeness at least the constant c and soundness at most the constant s, where 0≤s<c≤1. For every fixed integer k≥1, repeat V on k independent random tapes, using the same fixed proof in every run, and accept if and only if all k runs accept. The repeated verifier has proof length L(n), randomness bound kr(n), query bound kq(n), completeness at least ck, and soundness at most sk. If c=1, perfect completeness remains perfect. For every fixed target τ∈(0,1), a fixed k can be chosen so that sk≤τ; if s=0, take k=1. No claim of reaching target 0 is made when s>0.

Facts & Assumptions

Given: A verifier satisfying the fixed-proof completeness and soundness conditions of the statement, and a fixed positive integer k.

[F1]

PCP completeness uses one fixed proof on a yes input, while soundness holds for every fixed proof on a no input; the proof alphabet and resource bounds are fixed for the verifier. (PCP classes with completeness and soundness)

[F2]

A finite product of finite probability spaces has product outcomes and product weights. (The finite product of finite probability spaces)

[F3]

In a finite product space, events determined by distinct coordinates are mutually independent. (Product weights normalize, and coordinate events are mutually independent)

[F4]

Independence of event classes means that every finite choice of one event from each of distinct classes has intersection probability equal to the product of its probabilities. (Independent families of event classes)

Proof

1.1F1givenconstruct

Define V(k) to use k independent blocks of r(n) random bits, run V once on each block with the original fixed proof, and accept exactly when every run accepts. Concatenating the query lists gives at most kq(n) symbol queries, all determined by the input and full random tape before answers are read; the proof length and alphabet are unchanged, and the verifier remains uniform polynomial time for fixed k.

1.2F2F3F4algebra

Fix an input x and proof π, let p=Pr⁡[Vπ(x) accepts], and let Ai be the event that run i accepts. The k coin blocks form the product space in [F2], each Ai depends only on coordinate i, and [F3] makes them mutually independent in the sense of [F4]. Therefore Pr⁡[V(k),π(x) accepts]=Pr⁡[⋂i=1kAi]=∏i=1kp=pk. This remains valid for zero random bits, where each coordinate space is a singleton.

2.1F1step 1.2algebra

If x is a yes input, [F1] supplies one fixed proof with p≥c, so step 1.2 gives acceptance pk≥ck. If x is a no input, every fixed proof has p≤s, so every repeated run on that same proof has acceptance pk≤sk. In particular c=1 gives completeness one.

3.1step 2.1algebradischarge-construct∎

For 0<s<1, put u=1−s>0. For each k≥1, s−k=(1+u/s)k≥1+ku/s≥1+ku, hence sk≤(1+ku)−1. Choosing a fixed integer k≥(τ−1−1)/u gives sk≤τ; when s=0, step 2.1 already gives soundness zero with k=1. Because s,τ are constants independent of n, this k is fixed, so multiplying r(n) and q(n) by k preserves logarithmic randomness and constant query bounds.

False statementConstruction: Literature-sourcedVerification: AI-adaptedprecheck passjudge pass (gpt-6-sol)audited 2026-09-30Open item page →

False: graph powering alone keeps the alphabet fixed

Statement

False claim: the local-view graph-powering step used for gap amplification keeps the input alphabet unchanged for every graph and every positive powering parameter.

Facts & Assumptions

[F1]

In the published powering convention, the view alphabet has cardinality ∣Σt∣=∣Σ∣(2d)R, where R=t+⌈t⌉. (Constraint graph powering with local-view labels)

[F2]

A loop contributes two incidence slots and is tested on the diagonal pair (a,a). (Constraint graph and labeling value)

Refutation

Given: A binary constraint graph has finite nonempty alphabet and each of its loop relations is tested on its single vertex label.

1.1F2given

Take one vertex v, alphabet Σ={0,1}, and two loop edges e0,e1 with relations {(0,0)} and {(1,1)}. Label 0 passes e0 and fails e1; label 1 passes e1 and fails e0. These are all labels, so every labeling violates exactly one of the two edges and UNSAT⁡(G)=1/2. Each loop contributes two incidence slots, hence d=4.

2.1F1step 1.1algebra∎

Set the positive powering parameter to t=1. Then R=1+⌈1⌉=2 and 2d=8, so there are 82=64 length-two patterns. By [F1], the full view alphabet has size ∣Σ1∣=264≠2. This one graph and positive parameter refute the universal fixed-alphabet claim; the example does not assert that every powered instance has a larger alphabet.

False statementConstruction: Literature-sourcedVerification: AI-adaptedprecheck passjudge pass (gpt-6-sol)audited 2026-09-30Open item page →

False: a PCP proof is itself a random string

Statement

False claim: in the PCP theorem the proof string must be sampled at random separately on each verifier execution.

Facts & Assumptions

[F1]

For each fixed input and fixed proof, acceptance probability is over the verifier's coins, with the same proof used on every coin string. (PCP verifier resources and deterministic proof strings)

[F2]

A yes input has one fixed proof achieving completeness, while soundness quantifies over every fixed proof for each no input. (PCP classes with completeness and soundness)

Refutation

Given: Let K={ε}⊆{0,1}∗, where ε is the empty input string. Use proof alphabet Γ={0,1} and proof length L(n)=1.

1.1F1F2givenconstruct

Define V to toss one unbiased coin bit, query the sole proof symbol π1, and accept exactly when x=ε and π1=1; it ignores the coin. This is a uniform polynomial-time nonadaptive verifier with r(n)=q(n)=L(n)=1. For the yes input ε, the fixed proof π=1 is accepted on both coin outcomes. For every no input x≠ε, every fixed proof is rejected on both outcomes. Hence K∈PCP⁡(1,1;1,0) by [F2].

2.1F1step 1.1algebradischarge-construct∎

In this explicit PCP, π=1 is the same deterministic one-bit string for both verifier coin outcomes; only the verifier tosses a random bit, and that bit is unused. Thus the proof need not be resampled on each execution, contradicting the claim.

5 · Examples, counterexamples and false statements

None yet.

Sources