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.
Alphabet Reduction and the PCP Theorem
1 · Prerequisites
- Absolute and Conditional Convergence; Rearrangement; Products
- Algebraic Closure, Embeddings, and Separability
- Algebraic Extensions, Extension Degree, and Finite Fields
- Arithmetization and the Sum-Check Protocol
- Binary Operations, Monoids, Groups and Subgroups
- Boolean Circuits and Nonuniform Complexity
- Compactness in Metric Spaces
- Completeness, Completion, and Uniform Continuity
- Composition Series, the Jordan–Hölder Theorem and Solvable Groups
- Congruences, the Integers Modulo n and the Chinese Remainder Theorem
- Construction of the Natural Numbers
- Construction of the Real Numbers via Cauchy Sequences
- Construction of the Real Numbers via Dedekind Cuts
- Continuity, IVT, EVT, and Uniform Continuity
- Cosets, Index and Lagrange's Theorem
- Countability and Uncountability
- Cyclic Groups and Direct Products
- Determinants of Matrices over a Commutative Ring
- Diagonalisation and the Minimal Polynomial
- Divisibility, Euclidean Domains, Principal Ideal Domains and Unique Factorisation
- Divisibility, Greatest Common Divisors and Bézout's Identity
- Dual Spaces, Bilinear and Quadratic Forms, and Sylvester's Law of Inertia
- Eigenvalues, Eigenvectors and the Characteristic Polynomial
- Expander Graphs and Constraint Graphs
- Finite Counting, Factorials and Binomial Coefficients
- Finite Probability Spaces and Random Variables
- Formal Languages, Encodings, and Decision Problems
- Foundations of the Real Numbers for Analysis
- Gap Amplification and Assignment Testing
- Group Actions, Orbits, Stabilisers and Cayley's Theorem
- Group Homomorphisms and the Isomorphism Theorems
- Ideals, Quotient Rings and the Isomorphism Theorems for Rings
- Independence Borel Cantelli and Zero One Laws
- Inner Product Spaces, Gram-Schmidt, Projections and Adjoints
- Limits of Real Functions
- limsup, liminf, and Subsequential Limits
- Linear Independence, Bases and Dimension
- Linear Recurrences and Rational Generating Functions
- Linear Transformations, Rank-Nullity and Quotient Spaces
- Matrices, the Matrix of a Linear Map, and Change of Basis
- Measures and Their Basic Properties
- Metric Spaces
- Monotone Functions, Discontinuities, and Continuity Sets
- Monotone Sequences, Bolzano-Weierstrass, and Cauchy Completeness
- Normal Subgroups and Quotient Groups
- Order, Zorn's Lemma, and the Axiom of Choice
- P, NP, coNP, and Polynomial Reductions
- pi: the Equivalent Characterizations
- Polynomial Rings, the Division Algorithm and Roots
- Power Series and Real-Analytic Functions
- Primes, Euclid's Lemma and the Fundamental Theorem of Arithmetic
- Properties of the Integral and the Working FTC
- Relations, Functions, and Quotients
- Resource Bounds and Machine Invariance
- Rings, Subrings, Integral Domains and Fields
- Roots, Rational Powers, and Classical Inequalities
- Sequences and Limits
- Sequences and Series of Functions; Uniform Convergence
- Series: Convergence and the Nonnegative Tests
- Sigma Algebras and Borel Sets
- Simple Field Extensions and the Construction of the Complex Numbers
- Sine, Cosine, and the Definition of Pi
- Splitting Fields
- Suprema and Infima
- Sylow's Theorems, p-Groups and Nilpotent Groups
- Symmetric Groups, Cycle Decomposition and the Sign Homomorphism
- The Cook--Levin Theorem
- The Derivative and the Mean Value Theorems
- The Determinant of a Linear Operator, Cofactors and Cramer's Rule
- The Fundamental Theorem of Algebra
- The Fundamental Theorem of Finite Abelian Groups
- The Galois Correspondence
- The Riemann Integral: Definition and Integrability
- The Spectral Theorem, Positive Operators and Singular Value Decomposition
- The ZFC Axioms and the Basic Set Constructions
- Topology of ℝ
- Triangularisation, Generalised Eigenspaces and Jordan Canonical Form
- Turing Machines, Configurations, and Computation
- Vector Spaces, Linear Subspaces, Span and Direct Sums
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 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 -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; 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 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
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 is a uniform polynomial-time randomized oracle algorithm such that, on each input , it uses at most unbiased random bits, reads a fixed proof at at most locations, and outputs accept or reject. For every input and every coin string, the queried locations are computed from and the coins before any proof symbol is read; each lies in . Repeated locations count as repeated queries. The bound is polynomial in and counts addressable symbols, not the bits in their binary addresses. When , the proof is empty and the verifier makes no queries.
For a fixed input and a fixed proof , the acceptance probability is the proportion of the coin strings on which accepts. The coin set is nonempty even when , 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.
PCP classes with completeness and soundness
Definition
Let be resource bounds and let be constants independent of input length. A language belongs to exactly when there are a verifier of the type in PCP verifier resources and deterministic proof strings, with randomness bound and query bound , a fixed finite proof alphabet, and a polynomial such that its addressable proof length is at most and the following hold for every input of length :
- If , there is one fixed proof with .
- If , every fixed proof satisfies .
Both probabilities are over the verifier's coins; the same deterministic proof is used for every coin string. In the shorthand , the proof alphabet is , the randomness is , the number of bit queries is bounded by a constant, completeness is perfect (), and soundness is at most some fixed constant . Here means a constant query bound, not exactly one query.
Two-query PCPs and binary constraint graphs
Statement
Fix a finite nonempty alphabet . First, let be an explicit binary (arity-two) constraint multigraph over with edges. There is a nonadaptive verifier whose proof is a labeling , which uses exactly random bits and reads at most two symbols, such that for every fixed labeling It has perfect completeness on satisfiable graphs, and if then every proof is rejected with probability at least .
Conversely, fix an input and a nonadaptive verifier with proof alphabet , at most two symbol queries, and unbiased random bits. One can construct an explicit binary constraint multigraph over with one edge per random tape (hence at most 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 The graph has vertices and edges for fixed , is constructible in time polynomial in , and is polynomial size when . By the definition of , 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.
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)
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)
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)
has yes instances with value at least and no instances with value at most ; values strictly between the thresholds are outside the promise. (Gap csp)
Proof
For the graph-to-verifier direction, order the edges and use random bits to choose one of indices. For indices below , 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 of the real-edge indices reject, so the rejection probability is . Since , this is at least half the labeling's unsatisfaction; taking the minimum over labelings gives the stated graph-unsatisfiability bound.
For the verifier-to-graph direction, enumerate its 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 ; 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 when that tape accepts and the empty relation when it rejects. Retain parallel edges, including identical tape outcomes, so the graph has exactly edges.
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 . 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 . Since the proof space is finite, this maximum is attained.
At most two proof positions occur on each of tapes, so after removing unused proof positions the graph has at most vertices, and its fixed-size relation tables and endpoint names can be written in polynomial time in . Thus gives a polynomial-size graph. The exact value equality in step 2.1, [F3] and [F4] transfer both threshold directions: value at least iff some fixed proof accepts with probability at least , and value at most iff every fixed proof accepts with probability at most . For binary proofs, choose and a fixed surjection ; 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 bits are queried.
Walsh–Hadamard encoding and relative Hamming distance
Definition
For and , the Walsh–Hadamard encoding is the truth table of the linear function on , with coordinates indexed in lexicographic order by . Thus the table has length , including the one-entry table when . Its entry at a unit vector is .
For two tables with the same nonempty finite coordinate set , their relative Hamming distance is For Walsh–Hadamard tables of dimension , and the denominator is . In particular the 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.
Distinct Walsh–Hadamard words differ on half the cube
Statement
For and distinct , the tables and differ at exactly of their coordinates, so their relative distance is one half. For there are no distinct messages.
Facts & Assumptions
is the truth table of on , indexed by , and the relative distance is the fraction of disagreeing coordinates. (Walsh–Hadamard encoding and relative Hamming distance)
Proof
Given: Fix and distinct .
Put . Since , is nonzero. At a mask , the two table values disagree exactly when .
Choose a coordinate with and let be its unit vector. The map is an involution without fixed points, and . Thus it partitions the masks into pairs, with exactly one mask in each pair satisfying . The coordinate choice exists because is a nonzero finite binary vector.
By step 2.1 and the disagreement criterion in step 1.1, exactly table coordinates differ. Dividing by the coordinates gives relative distance . If , has only its empty vector, so the statement has no distinct-message pair to check.
Shared codeword blocks and edge acceptance circuits
Definition
Fix a finite ordered alphabet with . Put and . Let be the -bit vectors in lexicographic order and define the codeword of to be The map is injective, and every two distinct selected codewords have relative distance by Distinct Walsh–Hadamard words differ on half the cube. Moreover, : the lower bound follows from , and 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 one physical block , shared by all incident edges. A block is valid when it equals for some ; its decoded label is then the unique such . The table order inside each block is that of Walsh–Hadamard encoding and relative Hamming distance.
For each edge with its specified endpoint order and relation , define an edge circuit with formal input pieces . Its Boolean function is where is when holds and otherwise, and the empty disjunction is . Thus exactly when both blocks are valid and their decoded labels form a pair in . 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 comparisons for each allowed pair, then OR the pair tests. The circuit uses gates (or the constant-zero output if ), so at most gates. In the graph, compose its first formal piece with and its second with ; for a loop , both pieces use the same physical block, so the test is exactly the diagonal test 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.
A violated decoded edge is far from edge-circuit acceptance
Statement
Use the code and edge circuit of Shared codeword blocks and edge acceptance circuits, where is finite, ordered, , and distinct codewords have relative distance . For any physical block at each graph vertex, decode to a closest codeword, breaking ties by the fixed alphabet order, and write the decoded label as . Regard the formal input bits of as all named inputs, so its accepting set is . Measure relative Hamming distance on these bits and use distance when the accepting set is empty, as in Assignment tester and rejection ratio.
If edge is violated by the decoded labels, then For a loop , the displayed input is and the same bound holds.
Facts & Assumptions
Given: A finite ordered alphabet with , its Walsh–Hadamard code blocks, an edge circuit, and arbitrary physical blocks at its vertices.
The selected codewords are injective and every two distinct codewords have relative distance . (Shared codeword blocks and edge acceptance circuits)
The edge circuit accepts exactly pairs of valid codewords whose decoded labels lie in the ordered edge relation . (Shared codeword blocks and edge acceptance circuits)
Distance from a named input to a circuit's accepting inputs is relative Hamming distance, with value when the accepting set is empty. (Assignment tester and rejection ratio)
Proof
For each block , the fixed alphabet order makes its nearest valid codeword label deterministic; a minimizer exists because is finite and nonempty. For every , nearestness and the triangle inequality give . Hence every changed decoded label has .
Suppose . By [F2], every accepting formal input is for some , so at least one decoded endpoint changes. By step 1.1, the corresponding formal block differs from the actual block by at least bits; division by the formal input bits gives relative distance at least . If , the actual formal pair is and the violated loop pair is , 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 .
Random binary subsums detect every nonzero discrepancy
Statement
For every nonzero and uniform , The same conclusion applies whenever is a nonzero vector of violated quadratic equations or the difference of two distinct decoded prefixes.
Facts & Assumptions
Given: A nonzero binary vector and the uniform distribution on the finite cube.
Distinct Walsh–Hadamard messages in dimension have tables that disagree on exactly half the coordinates. (Distinct Walsh–Hadamard words differ on half the cube)
Proof
Since , choose the least index with , and let be its unit vector. The map is a fixed-point-free involution of the cube and , so it pairs each outcome with one whose dot product has the opposite bit.
Each pair from step 1.1 has exactly one vector with , hence exactly of the vectors satisfy the event and its uniform probability is . Equivalently these are precisely the coordinates where and 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.
Quadratic equations and tensor-code oracle tables
Definition
For , a QUADEQ instance over is an ordered list , where each is an binary matrix and . Use the row-major order on pairs to identify matrices with vectors in . The instance is in canonical form when for . A vector satisfies the instance when, for every , For canonical instances the sum may equivalently be restricted to . For a general matrix, its canonical representative has diagonal entries and upper entries for , with zero entries below the diagonal; it defines the same quadratic form. Equivalently, after flattening by that row-major order, . Constants in a quadratic equation are moved to the right-hand side, repeated monomials cancel modulo two, and a square is represented by the diagonal coordinate , since in . When the equation list is empty and every satisfies it; when the vector and tensor are empty and each equation has left-hand side .
For , its intended oracle pair is where the second domain is flattened in the same row-major order. Thus and , with the sum interpreted as when . Their truth-table lengths are respectively and ; if stored in one proof string, the table precedes the 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.
Boolean circuits become quadratic systems with a fixed input prefix
Statement
Let be an explicit topologically ordered Boolean circuit with input wires, a designated prefix of inputs where , and non-input nodes. Each non-input node is a constant or , a NOT gate, or a two-input AND or OR gate; represented constant nodes count among the nodes. Its output is one of the resulting wires. There is a deterministic polynomial-time construction of a QUADEQ instance over with wire variables and equations, each with at most four monomials. The variables are ordered with the input wires first and the non-input nodes next in topological order, so the named inputs are the first variables. For every , fixing those first variables to extends to a solution of the QUADEQ instance if and only if there is a completion such that .
Facts & Assumptions
Given: A valid circuit as in the statement and the fixed named-prefix assignment .
In the canonical QUADEQ encoding, constants are moved to the right-hand side, repeated monomials cancel in , and a linear term is represented by the diagonal monomial . (Quadratic equations and tensor-code oracle tables)
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)
Circuit satisfiability asks whether some input assignment makes the designated output one. (Circuit satisfiability)
Proof
Number the primary input wires first, then number the remaining nodes in topological order, and associate a variable to each wire. Thus , and fixing to fixes exactly the named prefix; the other primary input variables remain available for the completion.
For a constant node with variable and value , impose ; for a NOT node with input impose ; for an AND node with inputs impose ; and for an OR node impose . These equations force exactly the indicated Boolean operation: in particular for bits. They remain valid when the two input wires coincide, after reducing repeated monomials using in . Append the output equation . There are 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.
Suppose a solution extends the prefix . Its next coordinates define a completion . 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 .
Conversely, suppose some completion makes . Set the first variables to 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 , proving the reverse implication.
The construction lists one constant-size equation per node and one output equation. Writing each of the coefficient matrices with entries takes time; since the explicit description lists all 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.
The BLR test supplies a nearby unique linear decoder
Statement
Let , , , and . Define its BLR rejection probability by Let be the lexicographically first maximizer of over . If , then . If , this is the unique linear Walsh–Hadamard word at distance less than from . For every requested , the self-corrector , with uniform, returns with probability at least .
Facts & Assumptions
is the truth table of ; relative distance is normalized disagreement on the cube. (Walsh–Hadamard encoding and relative Hamming distance)
For normalized Boolean-cube characters, Fourier inversion is . (Character orthogonality, inversion and Parseval)
Parseval gives . (Character orthogonality, inversion and Parseval)
Distinct linear Walsh–Hadamard words have relative distance exactly (and there are no distinct messages when ). (Distinct Walsh–Hadamard words differ on half the cube)
The two-query corrector chooses uniform and returns . (Two-query linear self-correction)
Proof
Given: Fix and as in the statement; the vectors in the rejection probability are independent and uniform.
The BLR test accepts exactly when in . Thus is on acceptance and on rejection, so . For the only pair is and the test rejects exactly when , so forces .
Write . By Fourier inversion (F2), , and . Expanding the expectation in step 1.1 and using independence of gives .
Parseval (F3) and give . With , step 2.1 yields . Choose the first maximizer in the finite lexicographic order. Since , its Walsh–Hadamard word has distance .
If , the word from step 3.1 is within distance . Any other linear word within distance would, by the triangle inequality for normalized Hamming distance, be at distance from it, contradicting (F4); for there is only one linear word. Thus the nearby word is unique.
By (F5), the corrector returns . Each point and is uniform, so each queried value differs from or with probability . A union bound, without assuming independence of the two error events, shows that with probability at least both values are correct; then their sum is . When , forces , and the singleton-table corrector returns the sole linear value .
Tensor consistency rejects a wrong decoded tensor
Statement
Let , , and with , using row-major tensor coordinates. Put and . The ideal test samples independent uniform and rejects exactly when . Its rejection probability is at least .
Now let fixed tables and have relative distances The six-query self-corrected test samples independent uniform and , forms and rejects exactly when . It makes six nonadaptive table queries, allowing repeated locations, and rejects with probability at least . When the condition is impossible.
Facts & Assumptions
Given: A dimension , a vector , a matrix , and fixed tables at the stated distances from the corresponding linear Walsh–Hadamard tables.
Walsh–Hadamard tables are truth tables of linear forms, so . (Walsh–Hadamard encoding and relative Hamming distance)
The ideal tensor test compares with for independent uniform . (Quadratic tensor consistency test)
Tensor coordinates are in fixed row-major order. (Quadratic tensor consistency test)
For every nonzero binary vector and uniform , . (Random binary subsums detect every nonzero discrepancy)
The two-query corrector for a fixed oracle at request returns for uniform . (Two-query linear self-correction)
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
Let over , choose the first nonzero column of , and view as a row vector. By [F4], with probability at least . For each such , is a nonzero vector, so [F4] gives . Since by [F1] and [F3], the rejection probability of the ideal test in [F2] is at least .
For any fixed requested point and any fixed table at relative distance from a linear form , the points and are both uniform when is uniform. Unless either lies in the error set, [F5] returns . The union bound therefore gives corrector error at most , uniformly in , including .
Apply step 1.2 to the two requests for and to request for . The probability that any of the three corrected values is wrong is at most . 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 , which is the claimed bound; no independence of the correction errors is used.
The test samples using unbiased bits and using 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 , all domains are singletons and the hypothesis is impossible.
A random subsum checks all quadratic equations at once
Statement
Let be a canonical QUADEQ instance over variables and let fail at least one equation. For uniform , define Then the combined equation fails with probability exactly .
More generally, let and set and . The nonadaptive test that chooses and independently and uniformly, queries and (using the row-major tensor coordinates), and rejects when their sum differs from has rejection probability at least . It uses unbiased random bits and two symbol queries.
Facts & Assumptions
Given: A canonical QUADEQ instance, a fixed candidate vector , and the fixed oracle table .
Each equation is after flattening its canonical coefficient matrix in row-major order. (Quadratic equations and tensor-code oracle tables)
The intended tensor oracle is ; for every tensor coordinate , it satisfies . (Quadratic equations and tensor-code oracle tables)
For every nonzero and uniform , . (Random binary subsums detect every nonzero discrepancy)
The two-query self-corrector at request chooses uniform and returns . (Two-query linear self-correction)
Proof
Put . Since fails at least one equation, . Linearity gives , so the combined equation fails exactly when ; by [F3] this occurs with probability exactly .
Fix any requested tensor coordinate . Let , so . Both and are uniform, and by [F4] the corrector returns . Unless one of these two points lies in , this equals by linearity of the intended oracle in [F2]; a union bound therefore gives correction failure probability at most , uniformly for every , including .
For the test, condition on each and set . By [F2] and [F1], on the event from step 1.1 the ideal value differs from ; whenever the correction in step 1.2 returns , the test rejects. Its failure probability conditional on each is at most , so averaging gives , without any independence assumption between rejection and correction errors.
The test samples bits for and bits for , computes both query locations before reading , and makes exactly two symbol queries; thus it is nonadaptive and uses one combined equation instead of querying all original equations. If , its premise is impossible; if , the tensor domain is a singleton and the corrector queries that same coordinate twice, as allowed by [F4].
An exponential-length constant-query PCP for quadratic equations
Statement
For an -variable, -equation QUADEQ instance, represented with in unary and its row-major coefficient matrices listed explicitly, there is a uniform nonadaptive verifier for a fixed binary proof of length . It uses 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 .
Facts & Assumptions
Given: A QUADEQ instance over variables in the explicit encoding stated above, and an arbitrary fixed binary proof string.
The instance is satisfied by exactly when for every . Replacing each by its canonical upper-triangular representative, with the same diagonal entries and upper entries for , preserves that quadratic form. (Quadratic equations and tensor-code oracle tables)
When the equation list is empty and every satisfies it; when the vector and tensor are empty and each equation has left-hand side zero. (Quadratic equations and tensor-code oracle tables)
The intended pair of truth tables has lengths and , in that order when concatenated into one proof. (Quadratic equations and tensor-code oracle tables)
is the truth table of ; when it is the one-entry zero table. (Walsh–Hadamard encoding and relative Hamming distance)
Each BLR test samples independent uniform , queries , and accepts exactly when ; its probability is over these samples for fixed . (The BLR linearity test over F_2)
If a table's BLR rejection probability , the lemma's lexicographically first Fourier maximizer gives a linear decoder within distance ; if , that nearby word is unique. (The BLR test supplies a nearby unique linear decoder)
The tensor test independently samples and , corrects the three requested values with two queries each, and rejects if the corrected differs from the product of corrected . It makes six nonadaptive queries and rejects a wrong decoded tensor with probability at least . (Tensor consistency rejects a wrong decoded tensor)
The equation test samples independent uniform , queries , and rejects when their sum differs from . When the decoded assignment violates an equation, its rejection probability is at least ; it uses 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.
First replace each input matrix by its canonical upper-triangular representative: keep its diagonal entries, put in position for , and put zero below the diagonal. By [F1] this preserves every value and therefore the solution set; scanning the explicit matrices costs time. In the rest of the proof denotes this canonical representative, so [F8] applies. Split the proof, using [F3], into fixed tables and . Unless , use two selector bits to choose uniformly among one BLR test on , one BLR test on , 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.
If satisfies the instance, use the proof and . By [F4], both tables are linear, so their BLR tests always pass. For any auxiliary point , , and similarly . Hence the tensor test passes because . Also for every equation mask , so the equation test passes. If , this proof has and the deterministic dimension-zero BLR test accepts by [F2,F4].
For an arbitrary fixed proof, let and be the rejection probabilities of its two BLR tests in [F5]. If either is at least , its selected branch contributes at least to the mixture's rejection probability.
Otherwise both . By [F6], the lemma's lexicographically first decoders are unique linear words and at distances and . Reshape into the row-major matrix .
Each selected branch uses respectively , , , or random bits and at most , , , or queries. Thus for the verifier uses at most random bits and at most six queries. If , the empty equation list is satisfiable by [F2]; run the deterministic dimension-zero BLR test on without selector bits, preserving completeness and using three queries.
If , [F7] makes the tensor branch reject with probability at least . Since this branch is chosen with probability , the mixture rejects with probability greater than , hence at least .
If , unsatisfiability and [F1] imply that the decoded violates at least one equation. The equation branch then rejects with probability at least . With one equation the random mask detects its failed residual with probability ; with , the unique decoded vector is empty and the same test detects any right-hand side . Its mixture contribution is greater than , so again the verifier rejects with probability at least . Coincident query locations are still counted among the at most six calls.
Under the stated encoding, the instance length is at least . Computing the selected test's addresses, tensor products, and XOR-sums 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 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.
Two-piece PCP of proximity and concatenation check
Definition
Let be a Boolean circuit with primary inputs and non-input nodes. Let be disjoint ordered lists of its input wires, of lengths , and put . The named pair is satisfying if some assignment to the other input wires makes output one when the wires in receive . Reorder the explicit input list by the deterministic permutation . The fixed-prefix reduction Boolean circuits become quadratic systems with a fixed input prefix then puts the named bits in the first variables of its QUADEQ instance. Write 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 and set . An two-piece PCP of proximity for is a uniform, nonadaptive verifier with a fixed proof tuple satisfying the following interface:
- is a bit table on , so its length is . The private string has length at most and the verifier uses at most unbiased random bits for fixed polynomials . 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.
- (Perfect completeness) For every satisfying named pair , there is one fixed private string such that the verifier accepts on every random tape. The Walsh–Hadamard tables use the convention in Walsh–Hadamard encoding and relative Hamming distance.
- (Proximity soundness) For every fixed proof tuple, if its rejection probability is less than , there is a satisfying named pair for which
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 and for a reduced-instance witness .
For the input prefix, define the two coordinate injections 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 samples uniform and compares with ; this is the two-query check in the cited source. For arbitrary tables, the four-query self-corrected check samples independent uniform and , then compares with using the two-query corrector of Two-query linear self-correction. The check is nonadaptive.
If , the mask space and short-table domain are singletons, , and the self-corrected short value is . 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 , 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.
A two-piece constant-query PCP of proximity
Statement
Let be an explicit topologically ordered Boolean circuit over constants, NOT, AND and OR, with input wires and non-input nodes. Let be disjoint ordered lists of input wires of lengths , put and , and call satisfying when it extends to an input on which outputs one. There is a deterministic uniform construction of a nonadaptive two-piece proximity verifier with external tables and private tables and . It makes at most six bit queries and at most unbiased random-bit choices. Its total proof length is It has perfect completeness, and rejection probability below implies that both external tables are within relative distance of the Walsh–Hadamard encodings of one satisfying named pair.
For the combined named list , 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 , including the empty accepted-set and zero-named-input conventions. Its finite constraint list can be enumerated with at most 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.
The input variables can be ordered with the named coordinates first, and the fixed-prefix QUADEQ reduction has variables and 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)
A QUADEQ solution satisfies every equation in row-major coordinates. (Quadratic equations and tensor-code oracle tables)
, including the singleton zero table at dimension zero. (Walsh–Hadamard encoding and relative Hamming distance)
The intended QUADEQ oracle tables have lengths and , with the vector table preceding the tensor table. (Quadratic equations and tensor-code oracle tables)
The BLR family samples independent uniform , queries , and accepts exactly when ; it uses random bits and three calls for a table on . (The BLR linearity test over F_2)
If a table's BLR rejection probability is below , the lemma's lexicographically first decoder is the unique Walsh–Hadamard word within distance less than , and its distance is at most that rejection probability. (The BLR test supplies a nearby unique linear decoder)
For fixed tables near decoded words , the six-query tensor test rejects when with probability at least . (Tensor consistency rejects a wrong decoded tensor)
For a decoded vector failing a QUADEQ equation and a table at distance from , the nonadaptive two-query equation test rejects with probability at least and uses random bits. (A random subsum checks all quadratic equations at once)
For fixed tables near decoded words whose named slices differ, the four-query corrected slice test rejects with probability at least ; it is nonadaptive and counts repeated locations. (Concatenation testing enforces the same decoded prefix)
A two-piece proximity verifier uses fixed external tables on ; its soundness conclusion is conditional on rejection strictly below , and its pair is satisfying when it extends to a full circuit input accepted by . (Two-piece PCP of proximity and concatenation check)
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)
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)
The two-query corrector at request chooses uniform and returns , with repeated locations permitted. (Two-query linear self-correction)
A finite constraint list may contain ordered tuples with repeated variables, and every tuple carries an explicit relation. (Assignment tester and rejection ratio)
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 and then fix any proof tuple before sampling verifier randomness.
Deterministically reorder the primary input list as ; this relabeling preserves circuit evaluation. Apply [F1] with named prefix length , obtaining a QUADEQ instance with variables and equations. Its first variables are , and the next are , so the coordinate injections are and . The two designated slices are disjoint and have the prescribed order.
Split the fixed proof into external tables and private tables of lengths . 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 . Each family samples only its own independent uniform coins, and every query location is computed before any answer is read.
If is satisfying, choose a completion of the other input wires on which outputs one. By [F1] it gives a QUADEQ solution . Set , , and . Every BLR family accepts because its table is linear. The tensor family accepts since , and each equation family accepts since solves every equation. The named slices of are , so the corrected slice tests compare equal linear values on every tape. If , both requests are zero and both corrected values are zero. Thus all eight families accept on every tape.
The branch coin counts are ; three selector bits choose the branch. Since , , and , every branch uses at most bits, so the verifier uses at most 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 because . 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.
For an arbitrary fixed proof, let be the rejection probability of each of the eight families and the verifier's rejection probability. If , then every . By [F5] the four BLR tables have deterministically selected unique decoders , , and , each at distance at most its BLR rejection rate and therefore below . Denote these distances by , and reshape in row-major order as a matrix .
Make variables from the raw named input bits and every coordinate of . 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 ; the tensor test accepts on ordered answers ; the equation test accepts when the queried sum equals its fixed ; and a slice test accepts when its corrected sums agree. Repeated query locations yield repeated variables, allowed by [F13]. If , add comparisons indexed by each named coordinate and each , : take the first coordinates of as in the piece containing , and use the tuple with relation from [F12]. This comparison has arity three.
If , [F6] gives tensor-family rejection at least , hence , a contradiction. Thus . If failed any QUADEQ equation, [F7] gives equation-family rejection at least and hence , also impossible. Thus solves the reduced instance.
Let be the maximum coin count of a core family and when . The comparison list has constraints, and each core family has tapes with . For , duplicate rows until each of the nine families has constraints; and are integers. For , omit comparisons and duplicate the eight core families to constraints each. Therefore the violated fraction is the average of the core-family rejection rates and, when present, the comparison rejection rate. If , and imply ; step 2.1 gives . Hence and there are at most constraints. If , there are at most . Direct enumeration takes time polynomial in the output length.
If is accepted by , use the satisfying completion and exact tables from step 1.3 as the auxiliary labeling. Every core constraint accepts. For each named coordinate , for every by [F3, F12], so every comparison accepts and the tester has perfect completeness.
If either decoded external word differed from the corresponding slice of , [F8] gives that slice family's rejection at least , hence , impossible. Each therefore equals its designated slice. By [F1] the pair is satisfying, and by [F5] for each . This proves proximity soundness with and ; if no satisfying pair exists, every fixed proof has rejection at least .
Suppose , fix any raw named input and any auxiliary labeling, and let be the rejection rate of its eight core families. If , the nine-family system rejects at least , since the defined distance is at most one by [F15]. Otherwise step 4.1 supplies a satisfying pair with each external table at distance below from its Walsh–Hadamard word. Put . For a mismatched coordinate, the two queried locations are each uniform in their piece's mask space, so each hits a table-error position with probability . By [F3, F12] and a union bound, the corrector at returns with probability greater than , and the comparison-family rejection is at least . The full system rejects with probability at least , since . If the accepted set is empty, the low- case is impossible by step 4.1, so the high- case proves soundness using [F15]. For , the unique named coordinate receives equal weight across its tapes, so the same estimate holds.
If , there is one raw named input. If 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 ; the eight-family system therefore has violated fraction at least . A piece with 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 because it has a designated output wire, so no separate verifier case is needed.
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 , and the text says that its proof is similar to Corollary 18.25 without giving the details. The named-sublist extension, the constants and , 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.
Composition of an edge system with an assignment tester
Definition
Fix a finite binary constraint graph over an alphabet of size , and form its blocks and ordered robust edge circuits using Shared codeword blocks and edge acceptance circuits. Each active vertex has a block , where . For an edge , let be its robust circuit, with its two formal input pieces and in the specified endpoint order.
Let be the deterministic two-piece assignment-tester construction of A two-piece constant-query PCP of proximity. Apply to with these two named input lists. Write its Boolean constraint system as , let be its named raw input variables, and put . The system has arity at most six; all variables in , including the verifier's external and private proof-table variables, are local auxiliary variables.
For every edge, is a positive integer. Indeed, gives , so this local instance has . In the construction in A two-piece constant-query PCP of proximity, the comparison family then has rows, and each of the nine test families is padded to rows. Thus . If the edge set is nonempty, set This is a well-defined positive integer because the edge set is finite and each . If , define to have no variables and no constraints.
Suppose . The output variable set consists of the active vertex blocks together with a fresh private copy of every for each edge . Map the first named piece of coordinatewise to and the second coordinatewise to . When is a loop, , so both formal pieces map coordinatewise to the same block. Map each auxiliary variable to its private copy . Call the resulting map on gadget variables . Thus endpoint bits are shared across all incident edge gadgets, while every other gadget variable is private to one edge.
For each ordered constraint , with , put exactly copies of in the output constraint list. The composition 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 constraints, so the total list has constraints.
For any labeling of the output variables, let be its pullback to along . Since duplicating every row of by the same factor preserves its violated fraction, for nonempty Conversely, any collection of local gadget labelings that agrees on every variable identification made by the maps , 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.
Composition preserves perfect satisfiability
Statement
Let be a finite binary constraint graph over a finite alphabet with , and let be the Boolean arity-six composition defined in Composition of an edge system with an assignment tester. For this finite Boolean constraint system, write for the maximum satisfied fraction, with value one when the constraint list is empty; equivalently, under the convention of Assignment tester and rejection ratio. If , then , including the edgeless case.
Facts & Assumptions
Given: Fix and its robust ordered edge circuits, with the local two-piece assignment tester and composition fixed as in the definition.
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)
The code is injective, so every valid block has a unique decoded label. (Shared codeword blocks and edge acceptance circuits)
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)
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)
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)
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)
If the original graph is edgeless, the composition has the empty constraint list. (Composition of an edge system with an assignment tester)
Local gadget labelings that agree on all identifications combine into one output labeling. (Composition of an edge system with an assignment tester)
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)
For each labeling, constraint-system value is its satisfied fraction and ; the overall unsatisfiability is the minimum over labelings, and the empty list has value one. (Assignment tester and rejection ratio)
Proof
Given: Assume .
If , then has value one by [F1], while the composition has an empty constraint list by [F7] and therefore by [F10] and the stated convention. It remains to consider .
Because 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 with . Since the edge set is nonempty, every edge relation is satisfied by its ordered pair of endpoint labels.
For each active vertex , assign its shared block the codeword . By [F2] this is valid and decodes uniquely to . If , then satisfies its ordered relation, so [F3] says the robust circuit accepts . If is a loop, both pieces are the same block and the satisfied diagonal pair is accepted as well.
For each edge , [F4] supplies the assignment tester on the combined named input list of its two raw pieces. The fixed input is accepted by by step 2.1. Its accepted-input clause in [F5] therefore gives at least one Boolean assignment 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 . The edge set and each Boolean search space are finite, so this specifies the witnesses without an axiom of choice.
Assign each shared vertex block its fixed codeword and assign each edge-private variable its value from . 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 , and [F9] preserves acceptance in every uniform copy. Thus every constraint of accepts under .
Every constraint of is satisfied by , so and by [F10]. Hence , and the stated convention gives . 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.
Composition transfers a constant fraction of unsatisfaction
Statement
Let be a finite binary constraint graph over a finite ordered alphabet with , and let be its Boolean arity-six composition with the two-piece assignment tester. Put for the relative distance of the shared Walsh–Hadamard block code and for the local assignment-tester rejection ratio. If , then for every Boolean labeling of , 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 Consequently, If 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.
For any named input and auxiliary labeling , an assignment tester of ratio guarantees . (Assignment tester and rejection ratio)
The two-piece construction applied to the combined named input list is an explicit Boolean assignment tester with rejection ratio . (A two-piece constant-query PCP of proximity)
If the labels decoded from the physical endpoint blocks violate an edge, their formal two-piece input is at relative distance at least 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)
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)
For nonempty 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)
Graph unsatisfaction for a labeling is the fraction of violated ordinary edge records, global is the minimum over labelings, and isolated vertices do not affect value. (Constraint graph and labeling value)
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)
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.
If , then by [F6]. The composition has an empty constraint list by [F8], so by [F7]. The claimed global inequality follows.
Suppose . For each active vertex , let 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 .
For each edge , let be the pullback of to its local gadget under the composition map. The equal-row construction in [F5] gives .
Let be the edge records violated by . For each , the named input to its local tester is the formal pair , with for a loop. By [F3] this input is at relative distance at least 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 therefore gives . For an edge outside , its local unsatisfaction is at least zero by [F7].
Combine the identity of step 1.3 with the local bounds of step 2.1. Since by [F6], and is the minimum over graph labelings, it follows that .
Step 3.1 holds for every Boolean labeling of the finite output system. Taking the minimum over those labelings gives the asserted inequality for . The edgeless case was handled in step 1.1, and .
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 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.
Bounded-arity Boolean constraints become binary graph constraints
Statement
Fix . Every finite explicit Boolean constraint system with listed constraints, each of arity satisfying , has a deterministically constructible binary constraint graph over the fixed alphabet with at most edges per listed constraint. The original variables remain shared graph vertices. The graph has perfect completeness, and
Facts & Assumptions
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)
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 with relations , for .
Keep one shared vertex for each old variable. For each listed constraint , add a private tuple vertex ; for each occurrence , add a separate edge from to with relation . Thus suffix coordinates after are ignored, and the graph has exactly edge records.
If satisfies the input, label each old vertex by and label by , where has first coordinates and zero suffix. Then 's prefix lies in , so every edge relation is satisfied. This proves perfect completeness.
For any output labeling, decode an old vertex carrying as bit , and decode any other old label as . 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 -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 .
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 . If , the output has at most edges, so its violated fraction is at least . If , both systems have unsatisfaction zero by the empty-list convention, and the inequality still holds.
Fixed-alphabet reduction with constant gap retention
Statement
For every finite alphabet with there is a deterministic map sending finite binary constraint graphs over to finite binary constraint graphs over the one fixed alphabet of size , with the following properties for every input with edges.
- Value one. if and only if .
- Size. and for a constant depending only on , never on .
- Gap retention. With and ,
- Uniformity. is computable by a deterministic algorithm in time polynomial in the bit length of the explicit encoding of .
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 , its code length , and an input graph with edge records. Let be the two-piece Boolean assignment tester of A two-piece constant-query PCP of proximity and put .
If , then 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 constraints, where is the least common multiple of the positive local gadget sizes. If , then has no variables and no constraints. (Composition of an edge system with an assignment tester)
The map from to the selected Walsh–Hadamard codewords is injective, and every two distinct selected codewords have relative distance ; the selected block length is with . (Shared codeword blocks and edge acceptance circuits, Distinct Walsh–Hadamard words differ on half the cube)
For an edge relation , the robust edge circuit has the formal input bits and at most gates, so its size is bounded by a constant depending only on . (Shared codeword blocks and edge acceptance circuits)
The local tester is a Boolean assignment tester of arity at most six and rejection ratio ; for a circuit of wires its finite constraint list has at most constraints. (A two-piece constant-query PCP of proximity)
If then , including the edgeless case. (Composition preserves perfect satisfiability)
If then ; if then both unsatisfaction values are zero. (Composition transfers a constant fraction of unsatisfaction)
For , every finite explicit Boolean constraint system whose listed constraints have arities between and has a deterministically constructible binary constraint graph over with at most edge records per listed constraint, perfect completeness, and . 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)
Graph value is the maximum satisfied edge fraction and system value is the maximum satisfied constraint fraction; both are on an empty list, and on each side. (Constraint graph and labeling value, Assignment tester and rejection ratio)
An explicit constraint graph with vertices and edges uses table entries and endpoint names of bits, and a graph with edge records has at most nonisolated vertices. (Constraint graph and labeling value)
For an edge circuit on two formal pieces of length , the two-piece tester has QUADEQ wires, uses local variables, and pads its nine test families to constraints, where and because the BLR test on the tensor table uses random bits. Therefore the local variable count is at most . (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 below by the two cited constructions.
Define to be the binary graph produced by applying Bounded-arity Boolean constraints become binary graph constraints with to the Boolean system when , and to the empty system when . Its output alphabet is the displayed in the statement, independent of : the two bit labels and the tuple labels , .
Suppose first that . Then has no variables and no constraints by [F1], so and by [F8]; the conversion of the empty system is an edgeless graph, so and by [F8] and [F7]. The input also has and , and holds for every constant. This disposes of the edgeless case for all four clauses.
Suppose now that . By [F3] and [F4], for a fixed every edge circuit has at most wires, with the implicit constant of [F3] depending only on ; hence every local gadget size satisfies . The least common multiple of the finitely many numbers therefore divides , a finite integer depending only on . Thus has constraints by [F1], each of arity at most six, and its variable set is the union of the coordinates of each active block and the edge-private auxiliary lists. For the explicit vertex count, [F10] shows that each local gadget has at most variables, so the number of edge-private variables contributed by one edge is at most .
Assume . Then [F5] gives , so has a labeling satisfying every one of its constraints. Applying the perfect-completeness clause of [F7] to that labeling produces a labeling of satisfying every output edge, so .
Assume and apply the gap clause of [F7] to with . Combined with [F6] and the code distance of [F2], the transfer factor gives
Conversely assume . Then by [F8]. If then by [F8]. If , then step 1.5 gives , so and . This proves the reverse direction of clause 1, and step 1.4 proves the forward direction.
For the size clause assume . The conversion adds at most six edge records per constraint of by [F7], so using step 1.3. Its vertex set consists of the vertices of , one per variable, together with one private tuple vertex per constraint of ; by [F1] the number of vertices of is at most , where 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 . Hence by [F1] and [F9]. Both bounds hold with , a constant depending only on ; for the output is edgeless and both quantities are zero.
The map 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 , which is itself polynomial in the input length by clause 2.
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 , and the output alphabet is of size 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 . 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 , the ratio , the arity-six conversion and the constant are proved in the local items cited above, not read off from the source's asymptotic statements.
The bound 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 with the one alphabet 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.
Alphabet reduction controls explicit size and degree
Statement
Fix a finite alphabet with and let be a finite binary constraint graph over with edge records and maximum degree at most , where the degree of a vertex counts the incidence slots of its incident edge records and a loop therefore contributes two. Let be the alphabet reduction of Fixed-alphabet reduction with constant gap retention and let be its fixed output alphabet of symbols.
- Edges. , where with and for the absolute constant of Shared codeword blocks and edge acceptance circuits; both and depend only on .
- Vertices. , where and is the largest local gadget size; hence the vertex count is .
- Degree. Every vertex of has degree at most , a constant depending only on and .
- Uniformity. All relation tables of use the fixed alphabet , and is computable by a deterministic algorithm in time polynomial in the bit length of the explicit encoding of .
Facts & Assumptions
Given: The fixed alphabet , the input graph with edge records and maximum degree , and the map of Fixed-alphabet reduction with constant gap retention, applied to through the composition and the arity-six conversion.
The map is deterministic, binary, runs in polynomial time in the explicit input encoding, uses the fixed alphabet of size , and satisfies and for a constant depending only on . (Fixed-alphabet reduction with constant gap retention)
If , every edge of contributes exactly constraints of the composition , where over the positive local gadget sizes, so has constraints in total. If is edgeless then has no variables and no constraints. (Composition of an edge system with an assignment tester)
Each active vertex of has one shared block of coordinates, shared by all incident edge gadgets, and every non-named gadget variable has a private copy used by exactly one edge . (Composition of an edge system with an assignment tester)
The code length satisfies and each edge circuit has at most gates besides its formal input bits. (Shared codeword blocks and edge acceptance circuits)
A two-piece tester applied to a circuit with wires has a finite constraint list of at most constraints, each of arity at most six. (A two-piece constant-query PCP of proximity)
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 edge records in total for arities at most . (Bounded-arity Boolean constraints become binary graph constraints)
For each edge circuit, the local tester's total variable count is at most its constraint count ; 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 .
Proof
Given: Fix , , , the input graph , and the constants , , of the statement.
Put and , the arity-six conversion of . If , then has constraints by [F2], where each is the size of the local gadget of edge . Every edge circuit has at most wires by [F4], so each by [F5], and therefore divides . In particular , a constant depending only on .
If , then 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 and every vertex degree zero.
Assume . Each of the constraints of has arity at most six, so the conversion creates at most six edge records per constraint by [F6]. Hence , as asserted in clause 1.
The vertex set of consists of the vertices of together with one private tuple vertex per constraint of by [F6], so . The block coordinates account for at most coordinates, since each of the at most nonisolated vertices contributes coordinates by [F3]. By [F7], the edge-private auxiliary variables of one gadget number at most , giving . Therefore by step 1.1, proving clause 2.
Consider a vertex of that comes from a coordinate of a shared block of . By [F3] this coordinate appears in the gadgets of exactly the edge records incident to , and is incident to at most edge records by hypothesis. In one copy of the gadget of such an edge, the coordinate occurs in at most constraints, each of arity at most six, so at most times; after the uniform duplication of [F2] it occurs at most times in that gadget. Summing over the at most incident records gives .
A vertex of that comes from an edge-private auxiliary variable of belongs to the gadget of exactly one edge, so the same occurrence count gives degree at most ; 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 whenever , all these degrees are at most . This proves clause 3.
The determinism, polynomial running time and fixed output alphabet are inherited from the reduction by [F1]; the edge and vertex counts of clauses 1 and 2 are polynomial in by steps 2.1 and 2.2, and all relation tables are the constant-size tables of the -symbol conversion.
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 alone, namely , and .
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 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.
One fixed-alphabet Dinur transformation
Definition
Let denote the fixed alphabet of symbols produced by the alphabet reduction of Fixed-alphabet reduction with constant gap retention, that is, and let .
Fix the constants of the gap-amplification step of A complete uniform graph gap-amplification step at the input alphabet : its threshold (which depends only on and on the absolute constants of that theorem), its output alphabet , its output degree bound , its blowup , its gap map and its completeness and edgeless-input clauses. For every integer , denoted in the sequel by being in the transformation domain, define, for every finite binary constraint graph over whose relation tables are explicit and whose degree is arbitrary, where:
- is the output of the published complete uniform gap-preserving step of A complete uniform graph gap-amplification step applied to : first the degree reduction, then the local-view powering. It is a binary constraint graph over the finite alphabet with at most ordinary edges, and it is edgeless whenever is edgeless;
- has symbols for the absolute constant and the view radius , so for every in the domain;
- is the alphabet reduction of Fixed-alphabet reduction with constant gap retention instantiated at the input alphabet , a deterministic map sending finite -graphs to finite binary constraint graphs over again.
Thus is a map from finite binary constraint graphs over to finite binary constraint graphs over , defined exactly for integers . 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 for the constant of Alphabet reduction controls explicit size and degree attached to the input alphabet , while every output degree is bounded by the constant , which depends only on and . By the two cited edgeless clauses, maps an edgeless graph to the edgeless graph over . The definition asserts nothing about unsatisfaction; the amplification and completeness properties of are separate results.
Remarks
The alphabet is fixed before the powering parameter is chosen: is used as the input alphabet of , the intermediate alphabet is a function of alone, and the alphabet reduction returns to the same absolute alphabet . This is what lets the same map be iterated without changing the alphabet between rounds; the later iteration fixes one integer 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.
One Dinur transformation preserves perfect satisfiability
Statement
Let be the fixed -symbol alphabet of Fixed-alphabet reduction with constant gap retention and let be the fixed-alphabet transformation of One fixed-alphabet Dinur transformation, defined for every integer and mapping finite -graphs to finite -graphs. For every such and every finite binary constraint graph over , including the case in which is edgeless.
Facts & Assumptions
Given: Fix an integer in the transformation domain and a finite binary constraint graph over with .
is a finite binary constraint graph over , and maps an edgeless input to an edgeless output. (One fixed-alphabet Dinur transformation)
The gap-amplification step has perfect completeness: for every integer , implies , and edgeless inputs are mapped to edgeless outputs. (A complete uniform graph gap-amplification step)
For every fixed alphabet with , if and only if ; in particular the alphabet reduction is defined at the nondegenerate intermediate alphabet and preserves the value-one property in the forward direction. (Fixed-alphabet reduction with constant gap retention)
An edgeless graph has value one and unsatisfaction zero for every labeling, so the premise holds in the edgeless case. (Constraint graph and labeling value)
Proof
Given: Use the fixed and the graph with .
Assume first that . Then by [F4]. The completeness clause of [F2] applied to this input gives , and is edgeless by [F1] and [F2]. Applying the forward value-one direction of [F3] at to the graph therefore gives .
Assume now that . The identity of [F1] rewrites the goal as . The intermediate graph is a finite binary constraint graph over the alphabet supplied by [F2] and [F1].
The completeness clause of [F2] applies to the input because , so .
Apply the forward direction of [F3] with the fixed alphabet , whose size is at least two, to the graph . Since , it gives , that is, by the identity of [F1].
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 , implies . 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.
One fixed-alphabet transformation doubles small gaps
Statement
Let be the fixed -symbol alphabet of Fixed-alphabet reduction with constant gap retention, let , and be the constants that A complete uniform graph gap-amplification step attaches to the finite alphabet , and let be the absolute constant of Fixed-alphabet reduction with constant gap retention. Put and let be the transformation of One fixed-alphabet Dinur transformation at this fixed . Then is an integer in the transformation domain, , and both depend only on the absolute constants and , never on an input graph. For every finite binary constraint graph over , Moreover is a deterministic map from finite -graphs to finite -graphs, so the same transformation and the same can be used in every round of an iteration.
Facts & Assumptions
Given: Fix the alphabet and the constants of A complete uniform graph gap-amplification step and of Fixed-alphabet reduction with constant gap retention attached to it.
for every finite -graph and every integer , and is a deterministic map from finite -graphs to finite -graphs, defined exactly for integers . (One fixed-alphabet Dinur transformation)
has symbols for the absolute constant and the view radius , so for every in the domain and the alphabet reduction of [F4] can be instantiated at this input alphabet. (One fixed-alphabet Dinur transformation)
The gap-amplification step at the alphabet has a gap map with and depending only on and the absolute constants of that theorem, and for every and every finite -graph . (A complete uniform graph gap-amplification step)
For every finite alphabet with and every finite -graph , so the retention factor is the absolute constant . (Fixed-alphabet reduction with constant gap retention)
For a labeling the number is the fraction of ordinary edges satisfied, or when ; hence and for every finite graph . (Constraint graph and labeling value)
Proof
Given: Use the fixed alphabet and the constants of [F3] and [F4].
The numbers and are fixed constants, so is a well-defined integer with ; it therefore lies in the transformation domain of [F1], and gives , that is, .
Let be an arbitrary finite -graph and put ; by [F5], . The gap-amplification step [F3] gives .
With from [F3], set . Then and , and both and depend only on .
Put . By [F1], is a deterministic map from finite -graphs to finite -graphs with for every finite -graph ; by [F2] the alphabet is finite of size at least two, so the reduction of [F4] applies to -graphs.
The graph is a finite graph over the alphabet , which has at least two symbols by [F2]. Applying [F4] with and gives , and multiplying the inequality of step 1.2 by yields .
Since (step 1.1) and (step 1.2), , because while by step 2.1. Hence .
The graph was arbitrary and the numbers and the map were fixed in steps 1.1–2.2 without reference to ; hence there are a fixed integer , a fixed and the fixed map with for every finite -graph , and is again a finite -graph transformation, so the same 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 but enlarges the alphabet to , and the alphabet reduction returns to at the absolute cost . Fixing one with therefore restores the factor two, with the cap for large inputs. The threshold 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.
One fixed transformation has constant-factor growth
Statement
Let be the integer fixed in One fixed-alphabet transformation doubles small gaps and let be the transformation of One fixed-alphabet Dinur transformation at this . Then there are constants , depending only on and on this fixed (and therefore fixed before any input graph is given), such that for every finite binary constraint graph over with edge records every vertex of has degree at most , and is deterministic and computable in time polynomial in the bit length of the explicit encoding of ; explicitly one may take , and , where are the constants attached to the input alphabet by Alphabet reduction controls explicit size and degree. In particular the growth factor is bounded by constants independent of , and maps edgeless inputs to the empty graph.
Facts & Assumptions
Given: Fix the alphabet and the integer of One fixed-alphabet transformation doubles small gaps, with .
For every integer and every finite binary -graph one has , and is a deterministic map from finite -graphs to finite -graphs. (One fixed-alphabet Dinur transformation)
The alphabet is finite of size with and . (One fixed-alphabet Dinur transformation)
The intermediate graph is a binary constraint graph over with at most ordinary edges, and it is edgeless whenever is edgeless. (One fixed-alphabet Dinur transformation)
The gap-amplification step at has output degree bound and blowup . (A complete uniform graph gap-amplification step)
The map is deterministic and runs in time polynomial in the bit length of the explicit encoding of , and the parameters depend only on and , never on or . (A complete uniform graph gap-amplification step)
For every finite alphabet with and every finite -graph with edge records, , where depends only on . (Alphabet reduction controls explicit size and degree)
For the same input , , where and are the length and largest gadget size attached to . (Alphabet reduction controls explicit size and degree)
Every vertex of has degree at most when the input has maximum degree at most , and is computable by a deterministic algorithm in time polynomial in the bit length of the explicit encoding of . (Alphabet reduction controls explicit size and degree)
The integer satisfies and depends only on the absolute constants , never on an input graph. (One fixed-alphabet transformation doubles small gaps)
Proof
Given: Use the fixed alphabet , the fixed integer of [F9] and the map .
By [F9] the integer lies in the transformation domain, so by [F1] and [F2] the map sends finite -graphs to finite -graphs by , with a finite alphabet of size at least two; by [F3] the graph has at most edge records and is edgeless when is edgeless, and by [F4] its degrees are at most .
Let be the constants attached to the alphabet by [F6]–[F8], and set , and . These are constants depending only on and , because do by [F4] and [F5], while do by their definition at the input alphabet .
Let be an arbitrary finite -graph with edge records. Applying [F6] with and , which is a finite -graph by [F1]–[F3], gives , the last inequality using [F3].
Applying [F7] to the same input gives , again using the edge bound of [F3].
Applying [F8] to with degree parameter , which bounds the degrees of by [F4], shows that every vertex of has degree at most .
By [F5] the first stage computes deterministically in time polynomial in the bit length of the explicit encoding of , so the explicit encoding of has polynomially bounded length; by [F8] the second stage computes deterministically in time polynomial in the bit length of that encoding. Composing the two deterministic polynomial-time algorithms exhibits a deterministic algorithm computing in time polynomial in the bit length of the explicit encoding of .
The graph was arbitrary, the constants depend only on and by step 1.2, and all three output bounds and the uniformity clause were established in steps 2.1–2.4; hence has the claimed constant-factor growth. If is edgeless, then is edgeless by [F3], and [F6] and [F7] applied with give and : the output is the empty graph and all bounds hold as .
Remarks
The constants are enormous — and are built from the least common multiple 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 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.
Logarithmic iteration reaches a constant unsatisfaction gap
Statement
Let be the fixed integer of One fixed-alphabet transformation doubles small gaps, let be its cap, let and let be the edge-growth constant of One fixed transformation has constant-factor growth. For every finite binary constraint graph over with edge records and , the iterates at satisfy If instead , then for every : all iterates of a satisfiable graph are satisfiable.
Facts & Assumptions
Given: Fix the fixed integer , the map and the constants and .
For every finite binary constraint graph over , . (One fixed-alphabet transformation doubles small gaps)
is a deterministic map from finite -graphs to finite -graphs, the same transformation may be used in every round, and . (One fixed-alphabet transformation doubles small gaps)
For every finite -graph with edge records, , where is a constant fixed before any input graph is given. (One fixed transformation has constant-factor growth)
For every finite -graph with , ; equivalently implies . (One Dinur transformation preserves perfect satisfiability)
For a labeling the number is the fraction of ordinary edges satisfied when , and ; hence for a graph with edges and every labeling violates at least one edge, so . (Constraint graph and labeling value)
Proof
Given: Use the fixed , and , and let be an arbitrary finite -graph with edge records and .
Put and for , where is the identity. By [F2] every iterate is again a finite -graph, so all are defined and [F1] and [F3] can be applied to each of them.
Since and , every labeling of violates at least one of the edge records, so by [F5] .
We prove for all by induction on . For this reads , which holds because . For the induction step, assume ; then [F1] applied to the finite -graph of step 1.1 gives , using that is nondecreasing and for .
We prove for all by induction on : for this is ; for the step, [F3] applied to the finite graph gives . In particular .
If , then equivalently by [F5], and [F4] applied to for gives whenever ; inductively for every , so every iterate of a satisfiable graph is satisfiable.
Since gives , step 1.2 yields , and step 2.1 yields because by [F2]. Moreover and , so and therefore by step 2.2. With step 2.3 this proves both clauses for the arbitrary graph .
Remarks
The point of the iteration is that the doubling lemma's cap is reached after only rounds once the initial unsatisfaction is positive, because a positive value on an -edge graph is at least ; the growth lemma keeps the size polynomial, , so no round is ever applied to an exponential-size object. The same fixed , the same and the same map 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 .
A three-CNF formula as a fixed-alphabet binary constraint graph
Statement
For a three-CNF formula with clauses, each having exactly three literal occurrences, there is a polynomial-time binary constraint graph over the fixed alphabet with exactly edges. Its value is one exactly when is satisfiable. If is unsatisfiable and , then The zero-clause formula maps to an edgeless graph.
Facts & Assumptions
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)
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 , where each is a literal on an old Boolean variable.
For each old variable add one shared bit vertex. For each clause add a private tuple vertex and put . For each occurrence , add a separate edge from to the old variable in with relation . Thus every clause contributes exactly three edges, including parallel edges when variables repeat, for a total of .
If is satisfied by an assignment , label each old vertex by and each by the tuple of the three variable values at its occurrences. That tuple lies in , so all three edges of every clause star pass and .
Conversely, if all graph edges pass, each clause tuple vertex has a label with , 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 is satisfiable.
The two implications prove exactly when is satisfiable. If , the graph is edgeless, has value one by convention, and the empty conjunction is true. If and is unsatisfiable, step 2.2 shows no graph labeling can satisfy all edges, so every labeling violates at least one and . The alphabet and each edge table have constant size, so the explicit construction is polynomial time.
Constant-gap binary CSP is NP-hard
Statement
Let be the fixed -symbol alphabet of One fixed-alphabet Dinur transformation, let be the fixed transformation of One fixed-alphabet transformation doubles small gaps and let be its cap. Then 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 there is a total function on instances, computable by a deterministic polynomial-time algorithm, such that is an explicit binary constraint graph over satisfying
Facts & Assumptions
Given: Use the fixed alphabet , the fixed map and the fixed cap .
For a three-CNF formula with clauses, each having exactly three literal occurrences, there is a polynomial-time binary constraint graph over the fixed alphabet with exactly edges. Its value is one exactly when is satisfiable. If is unsatisfiable and , then The zero-clause formula maps to an edgeless graph. (A three-CNF formula as a fixed-alphabet binary constraint graph)
The language 3-SAT of satisfiable CNF formulas with exactly three literals per clause is NP-complete. (3-SAT is NP-complete)
For every finite binary constraint graph over with edge records and , the iterates at satisfy (Logarithmic iteration reaches a constant unsatisfaction gap)
If instead , then for every : all iterates of a satisfiable graph are satisfiable. (Logarithmic iteration reaches a constant unsatisfaction gap)
The cap is , a constant fixed before any input. (One fixed-alphabet transformation doubles small gaps)
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)
is the disjoint yes/no pair and for the pair distinguishes satisfiability from . (Gap csp)
A polynomial-time many-one reduction from a language to a language is a total function computable by a deterministic Turing machine in polynomial time with for every instance . (Polynomial-time many-one reductions)
For a labeling the number is the fraction of ordinary edges satisfied, and , . (Constraint graph and labeling value)
The transformation alphabet is the fixed alphabet of symbols (One fixed-alphabet Dinur transformation)
There are constants , fixed before any input, such that every finite -graph with edge records satisfies , , and is deterministic and computable in time polynomial in the bit length of the explicit encoding of . (One fixed transformation has constant-factor growth)
Proof
Given: Use the fixed alphabet , the fixed map and , and let be an arbitrary instance of a language .
By [F2] and [F8] there is a deterministic polynomial-time total reduction from to 3-SAT, which we fix; put , with clauses, each of exactly three literal occurrences. By [F1] the formula has a polynomial-time computable graph over with exactly edges, and by [F10] the transformation alphabet is . Let be the fixed injection with and , and let be the graph with the same vertices, incidence slots and endpoint orders as and relations ; then is an explicit binary constraint graph over with exactly edges. Put if , and define for (a finite -graph by [F6]) while is the edgeless graph over for .
For a labeling of , define if and otherwise. If an edge is satisfied by in , then , so both labels lie in and : the same edge is satisfied by in . Hence for every by [F9], so ; conversely the labelings of for realize the same satisfied edges, so . Thus and .
For the size and time bound, each iterate multiplies the number of edge records by at most and has at most times the previous number of edge records vertices by [F11], so after rounds and, for , , both of size . Each of the applications of runs in deterministic polynomial time in the bit length of its input by [F11], and that input has size throughout, so the computation of from is deterministic polynomial time; the relabeling and the reduction are also polynomial time.
Suppose , so -SAT. If , then is edgeless, so by [F9]. If , then by [F1], hence by step 2.1, and the zero-unsatisfaction clause [F4] of the iteration lemma applied to with gives , that is, . In both cases .
Suppose , so -SAT is unsatisfiable; a formula with no clauses is satisfiable, so . By [F1], and , and step 2.1 transfers both to , whose edge count is . The positive-gap clause [F3] of the iteration lemma applied to with and gives , hence by [F9].
The map is total, deterministic and polynomial time by steps 1.1 and 2.2, and it sends instances of to graphs of value at least by step 3.1 and instances outside to graphs of value at most by step 3.2. By [F7] the target pair is with and , and by [F8] this is a deterministic polynomial-time many-one promise reduction in the two-sided sense. Since was arbitrary, is NP-hard.
Remarks
The route is the classical one: 3-SAT is reduced to a fixed-alphabet binary constraint graph, the fixed transformation is iterated logarithmically many times, and the Dinur transformation turns the 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 -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.
The PCP theorem: NP equals PCP(log n, O(1))
Statement
in the shorthand of PCP classes with completeness and soundness: a language belongs to NP if and only if there are a constant , a bound and a constant bound with over the binary proof alphabet. In particular every language in the class has a verifier with perfect completeness, soundness at most the fixed constant , one fixed polynomial-length proof per input, 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 promise problem of Constant-gap binary CSP is NP-hard.
For every language there is a total function , computable by a deterministic polynomial-time algorithm, such that is an explicit binary constraint graph over with for and for , where is the fixed gap constant. (Constant-gap binary CSP is NP-hard)
For every explicit binary constraint multigraph over a finite alphabet with edges there is a nonadaptive verifier whose proof is a labeling , which uses exactly random bits and reads at most two symbols, such that for every fixed labeling it has perfect completeness on satisfiable graphs, and if then every proof is rejected with probability at least . (Two-query PCPs and binary constraint graphs)
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)
A language belongs to exactly when there are a verifier with randomness bound and query bound , a fixed finite proof alphabet, and a polynomial such that its addressable proof length is at most and: if , there is one fixed proof with ; if , every fixed proof satisfies . (PCP classes with completeness and soundness)
In the shorthand the proof alphabet is , the randomness is , the number of bit queries is bounded by a constant, completeness is perfect (), and soundness is at most some fixed constant . (PCP classes with completeness and soundness)
For a fixed input and a fixed proof , the acceptance probability is the proportion of the coin strings on which accepts, and the proof is not resampled when the verifier runs. (PCP verifier resources and deterministic proof strings)
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)
A polynomial-time verifier with polynomially bounded certificates for consists of a relation whose paired language belongs to and a polynomial with if and only if there is with and . (Polynomial-time verifiers with polynomially bounded certificates)
For a labeling of a binary constraint graph with , is the fraction of ordinary edges satisfied, and the definitions give with . (Constraint graph and labeling value)
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].
Suppose . By [F4] and [F5] there are a constant , bounds and , a verifier with binary proof alphabet, and an integer-valued polynomial with such that on every input of length : if some fixed proof is accepted with probability at least , and if every fixed proof is accepted with probability at most . Fix once and for all a rational constant with ; [F10] supplies one, and the certificate machine can hardcode it without computing . Use the same query algorithm on proofs of length ; its query locations remain in , so the added suffix is never read. Call this fixed-length interface . Define the binary relation Thus every invocation in the relation has a valid fixed-length proof string.
Suppose and fix the reduction of [F1]. For an input of length put and ; then implies and implies , and together with its explicit encoding is computable in deterministic polynomial time in , so and the encoding length of is .
The paired language belongs to : a deterministic machine checks , enumerates the coin strings of on (there are of them), simulates deterministically on each, counts the accepting runs, and compares the exact rational acceptance probability with the fixed rational by integer arithmetic.
If define the verifier that makes no queries and accepts on every coin string: it has perfect completeness, and it is used only when , which by [F9] is the value of an edgeless graph and by step 1.2 forces (otherwise ), so its soundness clause is vacuous.
If , apply [F2] to the graph over the alphabet and then the binary encoding of [F3] with a fixed -bit code for the symbols of . This yields a nonadaptive verifier whose proof is the concatenation of the -bit blocks of a vertex labelling, which uses exactly random bits by step 1.2, reads at most two -bit blocks, that is at most bit queries, and whose proof length is because the explicit encoding of has polynomial length.
By step 2.1 and [F7] it remains to verify the certificate condition of [F8] for . If , pad its fixed -bit completeness proof to length ; ignores the padding, so this proof has acceptance probability at least and belongs to . Conversely, if , the original verifier's queries are all in , so the prefix of of length is an original fixed proof with the same acceptance probability. If , soundness would bound that probability by , contrary to membership in . The certificate length is exactly , hence at most , so by [F7] and [F8].
Completeness for : if then . For the verifier of step 2.2 accepts every coin string, so its one fixed proof is accepted with probability . For , [F2] gives a labelling satisfying all edges, whose -bit encoding is a fixed binary proof accepted with probability by the verifier of step 2.3, the binary encoding of [F3] preserving the acceptance probability.
Soundness for : if then step 1.2 and [F9] give , so and the verifier of step 2.3 is used. Fix any binary proof of the verifier's addressable length . Decode every consecutive -bit block by the fixed surjection 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 of accepted indices satisfies . The verifier accepts the surplus indices, so because . Hence every fixed binary proof is accepted with probability at most .
Steps 2.2, 2.3, 3.2 and 3.3 exhibit, for the arbitrary language , a uniform deterministic polynomial-time verifier computing and then running the described test, with random bits, a constant number of nonadaptive bit queries, binary proof alphabet, polynomial addressable proof length, perfect completeness and soundness at most . By [F4] and [F5], for and constant , hence ; was arbitrary, so .
Step 3.1 gives and step 4.1 gives the reverse inclusion, so in the shorthand sense, with perfect completeness, constant soundness below one, one fixed polynomial-length proof per input, 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 for a randomly sampled constraint, while the enumeration of the 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.
PCP soundness amplification by independent repetition
Statement
Let be a nonadaptive PCP verifier with addressable proof length , randomness bound , query bound , fixed finite proof alphabet, and completeness at least the constant and soundness at most the constant , where . For every fixed integer , repeat on independent random tapes, using the same fixed proof in every run, and accept if and only if all runs accept. The repeated verifier has proof length , randomness bound , query bound , completeness at least , and soundness at most . If , perfect completeness remains perfect. For every fixed target , a fixed can be chosen so that ; if , take . No claim of reaching target is made when .
Facts & Assumptions
Given: A verifier satisfying the fixed-proof completeness and soundness conditions of the statement, and a fixed positive integer .
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)
A finite product of finite probability spaces has product outcomes and product weights. (The finite product of finite probability spaces)
In a finite product space, events determined by distinct coordinates are mutually independent. (Product weights normalize, and coordinate events are mutually independent)
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
Define to use independent blocks of random bits, run once on each block with the original fixed proof, and accept exactly when every run accepts. Concatenating the query lists gives at most 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 .
Fix an input and proof , let , and let be the event that run accepts. The coin blocks form the product space in [F2], each depends only on coordinate , and [F3] makes them mutually independent in the sense of [F4]. Therefore . This remains valid for zero random bits, where each coordinate space is a singleton.
If is a yes input, [F1] supplies one fixed proof with , so step 1.2 gives acceptance . If is a no input, every fixed proof has , so every repeated run on that same proof has acceptance . In particular gives completeness one.
For , put . For each , , hence . Choosing a fixed integer gives ; when , step 2.1 already gives soundness zero with . Because are constants independent of , this is fixed, so multiplying and by preserves logarithmic randomness and constant query bounds.
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
In the published powering convention, the view alphabet has cardinality , where . (Constraint graph powering with local-view labels)
A loop contributes two incidence slots and is tested on the diagonal pair . (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.
Take one vertex , alphabet , and two loop edges with relations and . Label passes and fails ; label passes and fails . These are all labels, so every labeling violates exactly one of the two edges and . Each loop contributes two incidence slots, hence .
Set the positive powering parameter to . Then and , so there are length-two patterns. By [F1], the full view alphabet has size . 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: 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
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)
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 , where is the empty input string. Use proof alphabet and proof length .
Define to toss one unbiased coin bit, query the sole proof symbol , and accept exactly when and ; it ignores the coin. This is a uniform polynomial-time nonadaptive verifier with . For the yes input , the fixed proof is accepted on both coin outcomes. For every no input , every fixed proof is rejected on both outcomes. Hence by [F2].
In this explicit PCP, 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
- Irit Dinur, The PCP Theorem by Gap Amplification
- Sanjeev Arora and Boaz Barak, Computational Complexity: A Modern Approach
- Arora and Barak, Computational Complexity: A Modern Approach, §18.2.4, proof of Theorem 18.13 in both directions, printed pp. 358–359
- Arora and Barak, Computational Complexity: A Modern Approach, §18.4.1, printed p. 363
- Arora and Barak, Computational Complexity: A Modern Approach, §18.4.1 and §18.5.2 proof of Lemma 18.30, printed pp. 363–364 and 378–379
- Irit Dinur, The PCP Theorem by Gap Amplification, §5 proof of Lemma 1.8, printed pp. 18–19
- Arora and Barak, Computational Complexity: A Modern Approach, §18.4.2 random subsum principle and its applications, printed pp. 366–367
- Arora and Barak, Computational Complexity: A Modern Approach, §18.4.2, proof of Theorem 18.21, printed pp. 365–366
- Arora and Barak, Computational Complexity: A Modern Approach, §18.4.3, proof of Corollary 18.25, printed p. 368; §18.4.2, QUADEQ encoding, printed pp. 365–366
- Arora and Barak, Computational Complexity: A Modern Approach, §18.4.1 Theorem 18.23 and local decoding, printed pp. 363–365; §19.3.2 proof of Theorem 19.9, printed pp. 390–391
- Arora and Barak, Computational Complexity: A Modern Approach, §18.4.2 proof of Theorem 18.21 Step 2, printed pp. 366–367
- Arora and Barak, Computational Complexity: A Modern Approach, §18.4.2, proof of Theorem 18.21 Step 3, printed p. 367
- Arora and Barak, Computational Complexity: A Modern Approach, §§18.4.1–18.4.2 proof of Theorem 18.21, Steps 1–3, printed pp. 363–367
- Arora and Barak, Computational Complexity: A Modern Approach, §18.4.3, Corollaries 18.25–18.26 and proof of Corollary 18.25, printed pp. 368–369
- Arora and Barak, Computational Complexity: A Modern Approach, §18.4.3, concatenation test and Corollary 18.26, printed pp. 368–369
- Arora and Barak, Computational Complexity: A Modern Approach, §18.4.3, concatenation test and Corollary 18.26, printed pp. 368–369 (PDF pp. 384–385)
- Irit Dinur, The PCP Theorem by Gap Amplification, §5.1, Definition 5.1 (composition), Lemma 1.8 and its proof
- Sanjeev Arora and Boaz Barak, Computational Complexity: A Modern Approach, §18.5.2, Corollary 18.35 and proof of Lemma 18.30
- Irit Dinur, The PCP Theorem by Gap Amplification, §5, Lemma 1.8 and proof (perfect-completeness direction)
- Sanjeev Arora and Boaz Barak, Computational Complexity: A Modern Approach, §18.5.2, Corollary 18.35 and proof of Lemma 18.30 (completeness direction)
- Irit Dinur, The PCP Theorem by Gap Amplification, §5 proof of Lemma 1.8, printed pp. 17–18
- Sanjeev Arora and Boaz Barak, Computational Complexity: A Modern Approach, §18.5.2 Corollary 18.35 and proof of Lemma 18.30, printed pp. 378–379
- Irit Dinur, The PCP Theorem by Gap Amplification, §5, Lemma 1.8 and its proof, printed pp. 17–19
- Sanjeev Arora and Boaz Barak, Computational Complexity: A Modern Approach, §18.5, Lemma 18.30 and §18.5.2, printed pp. 377–379
- Sanjeev Arora and Boaz Barak, Computational Complexity: A Modern Approach, §18.5.2, Lemma 18.30 and its proof, printed pp. 378–379
- Irit Dinur, The PCP Theorem by Gap Amplification, §1.3, Theorems 1.2 and 1.5 and §3 proof of Theorem 1.5, printed pp. 5–8 and 12–15
- Sanjeev Arora and Boaz Barak, Computational Complexity: A Modern Approach, §18.5.1 Lemma 18.29 and §18.5.2 Lemma 18.30, printed pp. 371–379
- Irit Dinur, The PCP Theorem by Gap Amplification, §1.3, Theorems 1.2 and 1.5 (completeness direction), printed pp. 5–8
- Sanjeev Arora and Boaz Barak, Computational Complexity: A Modern Approach, §18.5.1 Lemma 18.29 (completeness), printed pp. 371–373
- Irit Dinur, The PCP Theorem by Gap Amplification, §1.3 Theorem 1.5 (Main), soundness clause and fixed output alphabet, printed pp. 4–5
- Sanjeev Arora and Boaz Barak, Computational Complexity: A Modern Approach, §18.5.1 gap amplification (Lemma 18.29) and §18.5.2 alphabet reduction (Lemma 18.30), printed pp. 370–379
- Irit Dinur, The PCP Theorem by Gap Amplification, §1.3 Theorem 1.5 (size clause size(G′) ≤ C·size(G)), printed pp. 4–5
- Irit Dinur, The PCP Theorem by Gap Amplification, §1.3 Theorem 1.5 and the logarithmic-iteration paragraph, printed pp. 4–5
- Sanjeev Arora and Boaz Barak, Computational Complexity: A Modern Approach, §18.5 (iteration of Lemma 18.28 log m times), printed p. 370
- Irit Dinur, The PCP Theorem by Gap Amplification, §1.3 Theorem 1.2 (inapproximability form, printed p. 3) and Theorem 1.5 (printed pp. 4–5)
- Sanjeev Arora and Boaz Barak, Computational Complexity: A Modern Approach, §18.5 (reduction from qCSP to GAP qCSP), printed pp. 370–371
- Irit Dinur, The PCP Theorem by Gap Amplification, §1.3 Theorems 1.1, 1.2 and 1.5, printed pp. 2–5
- Sanjeev Arora and Boaz Barak, Computational Complexity: A Modern Approach, §18.1–18.2 (PCP and NP) and §18.5 (proof of the PCP theorem), printed pp. 350–379
- Arora and Barak, Computational Complexity: A Modern Approach, §18.1, Note 3 to Theorem 18.2, printed p. 354
- Irit Dinur, The PCP Theorem by Gap Amplification, §1.1, printed pp. 1–2
- Arora and Barak, Computational Complexity: A Modern Approach, §18.1, Definition 18.1, printed pp. 353–354