Parameter Retuning in the Direct Reduction for the
Euclidean Closest Vector Problem
-Hardness and a Retained-Parameter Frontier
Expanded reading edition · 5 September 2026
Improving a hardness bound by balancing the costs
A lattice is the set of all integer combinations of some basis vectors. The closest vector problem asks how near a given target lies to that set. In its approximate decision form, the task is to distinguish a nearby target from one that is farther away by a specified factor. A hardness theorem says that solving this promised distinction efficiently would also solve a problem such as Boolean satisfiability efficiently.
The exponent in a dimension-dependent factor matters. A factor of grows faster than , so hardness for the former excludes a broader approximation guarantee as the dimension grows. Neither statement promises a practical instance generator: the polynomial degrees in the construction here are enormous.
This article revisits the parameter choices in OpenAI’s -Hardness of the Euclidean Closest Vector Problem. That reduction encodes Boolean assignments into a binary system and then converts binary Hamming weight into squared Euclidean distance. We retain that construction and its algebraic reconstruction lemmas. The change is in how its numerical costs are balanced.
Why does squaring matter? Suppose the lattice distance must exceed times the yes-instance radius. Since the lift turns binary weight into squared distance, its binary soundness statement needs a factor . Losing the factor two at this interface would give the wrong approximation exponent.
The construction has three adjustable scales. A larger field provides room to avoid exceptional evaluation points. A larger support cutoff permits more candidate values at a point. A larger moment horizon gives the algebraic reconstruction more equations. Increasing one scale may make another obligation harder, so the parameters must be chosen together.
Write their polynomial exponents as . The retained proof obligations become
We can see the limiting exponent without carrying the whole reduction at once. The last two inequalities force . Substituting this into the first gives
so . For this is impossible. Below that value, sufficiently large choices with slack work. This proves a boundary for these retained inequalities. It does not prove that some different reduction cannot achieve a larger exponent.
For the concrete value , choose . The three margins are respectively , , and . These positive margins leave room for finite coefficients, which must still be checked. For example, the discarded-support estimate reduces to , valid already at the construction’s baseline . An asymptotic exponent comparison alone would not establish that finite claim.
The rest of the article explains where each inequality comes from and follows it through the reduction. Its formal-verification statements refer to the archived development identified below: the concrete reduction and the general parameter-feasibility theorem have different scopes. The argument for the full range of exponents is written out mathematically; the archived concrete executable specialization is .
1 Introduction
OpenAI’s paper -Hardness of the Euclidean Closest Vector Problem gives a deterministic polynomial-time many-one reduction from SAT to Euclidean CVP with approximation factor [1]. Its main technical step is a binary affine system whose low-weight solutions encode satisfying assignments. The system uses one-hot evaluation tables over a characteristic-two field. Its soundness proof reconstructs algebraic root sets from polynomial moments, recovers Boolean values by valuations, and matches a common root across the clause tables. A dimension-preserving parity lift converts binary weight into squared Euclidean distance.
This note changes the numerical specialization of that construction. It is written as a companion to the OpenAI paper: the notation and the order of the encoding, reconstruction, soundness, and transfer arguments are kept so that the two proofs can be read in parallel.
The parameterization and elimination were developed in FPRD Lab—Finitely Presented Recognition Dynamics—an Insight Forge Boxlab project. Its mathematical contribution was to recast the source’s fixed hierarchy as a system of coupled resource coordinates and then eliminate the internal coordinates to expose the feasible exponent range. Section 7.2 states this procedure explicitly and distinguishes it from the source lemmas retained unchanged.
1.1 Main result
For a nonsingular integer matrix , write . An instance of consists of , a target , and a positive rational radius . The promise is to distinguish
Theorem 1 (Retuned direct reduction). For every fixed real number with , there is a deterministic polynomial-time mapping that assigns to each SAT formula a nonsingular matrix , a target , and a radius such that Consequently, is NP-hard under deterministic polynomial-time many-one reductions. The same construction gives approximation factor for binary nearest codeword and binary syndrome decoding.
For , the proof has the explicit specialization where , , and . The resulting binary block length and lattice rank satisfy
The strict retained resource inequalities have no solution at . This establishes a frontier for the present one-hot representation and the present reconstruction and valuation bounds. It is not a lower bound on the exponent attainable by a different reduction.
1.2 Proof overview and relation to the source paper
The reduction continues to factor through binary nearest codeword: The comparison with the OpenAI proof is as follows.
Encoding and completeness (Section 3). The table types, one-hot coordinates, ordinary and shifted power-sum constraints, and satisfying-assignment solution are unchanged. The retuning changes only the fixed field, support, and moment exponents in the source’s Section 3.5.
Algebraic reconstruction (Section 4). OpenAI’s Lemma 10 is invoked without alteration. The retuning verifies its three numerical hypotheses with a larger support cutoff and moment horizon.
Nearest-codeword soundness (Section 5). As in the source, large pointwise support fibers are discarded separately for each table type. The available field is divided explicitly between those fibers and the anchor and Hankel-discriminant losses. The shifted-moment valuation and clause-root matching arguments are then unchanged.
Transfer to CVP (Section 6). The source parity lift identifies minimum binary weight with squared Euclidean distance. Thus binary exponent becomes Euclidean exponent , with lattice rank equal to binary block length.
1.3 Scope of the formal verification
The complete executable Lean reduction is checked for the concrete exponent , including the physical binary system, integer target, polynomial-time machines, and final NP-hardness statements. A separate Lean module proves that the retained resource inequalities admit natural-number witnesses for every real and admit none at or above . The complete reduction has not been uniformly parameterized in Lean for arbitrary ; the general statement in theorem 1 is the mathematical retuning proved below.
2 Retuned parameters and retained construction
After the preprocessing used in the source, let the formula have symbols, variables, and clauses, and put Choose the least integer for which , and let The support cutoff and moment horizon are Here denotes the field and the integer support cutoff.
Let be distinct anchors and . Let be the set consisting of the global table type and the satisfying local assignment types for each clause. As in the source,
| Quantity | Meaning | OpenAI specialization | Concrete retuning |
|---|---|---|---|
| field size | |||
| support cutoff | |||
| moment horizon | |||
| binary block length | |||
| binary factor | nearest codeword | ||
| Euclidean factor | closest vector |
For a desired Euclidean exponent , four asymptotic costs control the retuning: The first line is the dense one-hot cost. The second makes dominate the support discarded from a binary solution of weight . The third provides all shifted moments used by the valuation argument. The fourth keeps the cleared reconstruction degree below the field size. The exact constants needed in addition to these exponent inequalities are recorded in section 5.
3 Encoding Boolean assignments by Reed–Solomon codes
For every table type , evaluation point , and value , the source construction has a binary coordinate . Its ordinary and shifted power-sum constraints, expanded in an -basis of , form the same explicit affine system No coefficient or equation in this system is changed by the retuning.
3.1 Completeness
OpenAI’s Lemma 8 applies verbatim. If is satisfiable, the one-hot graph of its interpolation polynomial, together with one active local table for each clause, gives a solution of weight Because equation (3) gives and , For the Euclidean reduction, set . Since , This exact estimate is used in the finite- soundness calculation.
3.2 Dimension and construction size
From and , The source’s row count becomes For fixed and , both the system and the field construction remain deterministic polynomial time. At equation (1), the two exponents in equation (15) are and , respectively.
4 Algebraic reconstruction of bounded polynomial-moment families
OpenAI’s Lemma 10 is independent of the Boolean encoding. For a family of sets with , it reconstructs a separable polynomial over from power sums through degree . We use that lemma exactly as stated.
For a retained evaluation set , its numerical hypotheses are The term bounds the zeros of the Hankel determinant. The term is the degree range needed after clearing denominators. These are the only places where the retuned values enter Lemma 10’s application. The lemma’s construction of a common splitting field and its root-moment identities are unchanged.
5 Soundness of the nearest-codeword reduction
Suppose that solves equation (10) and For each type and point , let The proof follows the five parts of the source’s Section 5.
5.1 Pointwise support sets of a low-weight solution
For each table type separately, retain Markov’s inequality and equations (12) and (17) give Thus the exact sufficient condition makes the discarded set smaller than . The sets may differ; they are never intersected over all table types.
At the concrete parameters, equation (19) follows from Raising both sides to the fifteenth power reduces this to which holds already at and remains true for larger .
5.2 Applying the reconstruction lemma
Reserve a second quarter of the field for the anchors and the zeros of the Hankel determinant. It is enough that Together with equations (18) and (19), this gives The remaining reconstruction and interpolation requirements follow from Indeed, equations (23) and (24) imply all three conditions in equation (16).
For equation (1), using and , the exact checks are All hold for . Hence Lemma 10 reconstructs the root sets by the same per-table argument as in the source proof and places them in one common splitting field.
5.3 Valuative recovery of local assignments
OpenAI’s Lemma 12 studies, for a reconstructed root and a clause bit , If is the number of roots of the table polynomial, the proof defines The unchanged estimates give Thus supplies every shifted moment required by the valuation argument. At the concrete values, for . The conclusion of Lemma 12, that each local root recovers the prescribed bit at the corresponding anchor valuation, is therefore unchanged.
5.4 Clause matching
The source parity argument uses ordinary moments to match every global root to at least one satisfying local root set for each clause. Since a clause has at most eight satisfying local assignments, the Vandermonde system has size at most The sufficient condition is . At the concrete parameters the stronger inequality holds. OpenAI’s Lemma 13 therefore applies without alteration.
5.5 Completing soundness and exact constants
The preceding bounds give the retuned form of OpenAI’s Proposition 14.
Proposition 2 (Retuned binary soundness). Under the exact conditions above, if equation (10) has a solution satisfying then is satisfiable.
Proof. For each table type, equation (16) permits the source reconstruction lemma to be applied to the retained support family. The global root set is nonempty by the source’s zeroth-moment parity argument. Lemma 13 matches a chosen global root to a satisfying local root set for each clause. Lemma 12, applied with the same anchor valuation across all clauses containing a variable, shows that the local Boolean values agree. They therefore assemble into a satisfying assignment. This is the proof of the source proposition with only its numerical hypotheses replaced. ◻
The exponent inequalities control growth rates; the finite coefficients enter through the quarter-field allocation in equations (19) and (22) and the exact source estimate equation (13). Together they give the coefficient- condition in equation (20), which equation (21) verifies already at . This exact bookkeeping does not change the affine system, reconstruction lemma, valuation argument, or parity lift.
The OpenAI paper states Proposition 14 with coefficient . The imported Lean snapshot exposed coefficient at one binary wrapper, although its factor- output theorem only needed coefficient . This is a source/interface discrepancy, not a failure of OpenAI’s final theorem. The retuned formalization carries coefficient through the explicit and physical binary interfaces so that proposition 2 is available for the Euclidean transfer.
6 Transfer to CVP and complexity
OpenAI’s parity lift maps a consistent affine system to an integer lattice and a binary target with The lattice has rank . The preprocessing and inconsistent-system branches use the same fixed one-dimensional instances as the source.
If is satisfiable, equations (11) and (32) give distance at most . If is unsatisfiable and the distance were at most , then By equation (32), this would give a binary solution excluded by proposition 2. Hence with the strict inequality required by the promise problem.
At the concrete values, the field extension degree is , the affine system has variables and rows, and the square parity-lift basis has fixed-polynomial encoding length. Field construction, Reed–Solomon checks, Gaussian elimination, serialization, and basis construction therefore remain deterministic polynomial-time operations. The exponents are large, but none depends on the input.
This proves the concrete case of theorem 1. The binary gap in proposition 2 also gives the following source-parallel consequence.
Corollary 3. Binary nearest codeword and binary syndrome decoding are NP-hard to approximate within under deterministic polynomial-time many-one reductions.
7 Further consequences and verification
7.1 The retained parameter frontier
Eliminating and from equations (7), (8), and (9) gives and therefore For and , the left side is nonpositive and the right side is positive. Thus the retained strict inequalities are infeasible at and above .
Conversely, fix . For sufficiently large integer , the interval contains an integer . Set . Then These choices leave at least one full power of in the support, valuation, and reconstruction comparisons. Since and for , the exact support coefficient is also absorbed. The lower-order anchor, Hankel, interpolation, and parity conditions then follow. This proves theorem 1 for every fixed .
7.2 FPRD method and provenance
The resource decomposition and frontier calculation are the specific mathematical contribution of FPRD Lab—Finitely Presented Recognition Dynamics. They form a parameter audit of the OpenAI construction, not a new construction. OpenAI supplies the one-hot encoding, moment reconstruction, valuation argument, clause matching, and parity lift. FPRD Lab supplied the resource decomposition, the elimination argument, and the concrete specialization. Exact and formal audits verify these outputs. In the lab’s terminology, this is an algebraic-sewing and resource-compression audit: local proof obligations are retained, while their shared resource coordinates are composed and then eliminated according to the final readout.
Resource-audit procedure.
The analysis is organized as the following reusable procedure.
Fix the external readout. State the desired approximation factor in the final dimension, then propagate it backward through every transfer. Here the squared-distance parity lift turns the Euclidean factor into a binary weight scale .
Expose independent coordinates. Replace the source’s chosen powers by one coordinate for each proof budget. Here measures the available evaluation field, bounds each retained support, is the moment horizon, and is the external representation size. No relation among their growth rates is assumed at this stage.
Extract the source obligations. Read the proof in dependency order and record every quantitative premise that connects two coordinates. Keep leading exponents separate from fixed constants and from losses at the smallest input size.
Eliminate and instantiate. Write , , and . Eliminate the internal coordinates to obtain the feasible range for , then choose an integral tuple with explicit slack.
Certify the endpoint. Restore the finite constants, check the smallest allowed , and push the tuple through the actual executable construction. Report the verified concrete endpoint separately from the symbolic frontier.
Application to this reduction.
The first step gives the low-weight threshold in equation (17). The next two steps extract the leading dependency chain The suppressed powers of become the constant terms in equations (7), (8), and (9). Eliminating and makes visible. It gives the retained range and guides the choice at .
The certification step uses the quarter-field allocation in equations (19) and (22) and the exact radius estimate in equation (13) to obtain the coefficient- margin. The Lean development checks the complete concrete endpoint. It separately checks the symbolic retained frontier, without claiming one uniformly parameterized executable reduction for every .
The same elimination also identifies which retained costs control the answer. If a related construction has the same leading-exponent elimination gives The present values are , , and . The factor therefore records three separate costs: squaring in the Euclidean transfer, the dense one-hot representation, and the combined seventh power of in valuation and reconstruction. This also separates three attack seams. A more economical representation reduces ; a sharper valuation lemma reduces ; and a lower-degree cleared-reconstruction identity reduces .
FPRD Lab is an Insight Forge Boxlab project (https://gitlab.com/insight-forge/boxlab) that begins with recognition-theoretic constructions and asks how their structural and resource tradeoffs transfer to other settings. Here that lens was applied to the parameter dependencies in the direct GapCVP reduction; no source reconstruction or valuation lemma was changed.
The lab also served as a testing and training bed for Sidecat (https://gitlab.com/sidecat-dev/sidecat), the agent-work system used to coordinate the AI-assisted work and preserve its evidence and publication record. That operational provenance affected the mathematical outcome. The FPRD parameter search produced the specialization and frontier. The retained dependency record, exact arithmetic audit, and independent Lean development established the finite- margins and verified the complete concrete endpoint.
7.3 Lean verification
The independent formal audit uses OpenAI source commit 94bc0feb6a9f and is published at fork commit 3ac608981eb4 [3]. The bibliography gives the complete immutable fork revision. The complete retuned build reaches the physical integer-target theorem and the two factor- binary endpoints. The frontier module proves natural-number witnesses below and impossibility at and above it.
The principal axiom probes report only propext, Classical.choice, and Quot.sound. The modified proof files contain no sorry, admit, sorryAx, or new axiom declaration. The principal source-to-check correspondence is shown in table 2.
| OpenAI paper | Retuned obligation | Checked endpoint |
|---|---|---|
| Section 3.5, equations (4)–(5) | field, dimension, and row bounds | and |
| Section 5.1, equations (13)–(14) | per-table retained sets and finite constants | quarter-field heavy and anchor/Hankel bounds |
| Lemma 10 | cleared reconstruction and moment range | |
| Lemma 12, (17)–(21) | shifted valuation window | |
| Lemma 13 | clause-root parity window | |
| Proposition 14 | coefficient-four binary soundness | explicit and physical factor- interfaces |
| Lemma 7 and Section 6 | parity lift and strict CVP promise | gapCVP30IsNPHard |
7.4 Limits of the conclusion
The audit establishes that the selected parameters satisfy every numerical hypothesis encountered in the source proof and its executable Lean specialization. It does not replace the source reconstruction and valuation lemmas with an independent proof. The complete formal reduction is presently instantiated only at ; the formal result for arbitrary real concerns the retained resource inequalities. A uniformly parameterized Lean version of the complete reduction would narrow this remaining distinction.
The value is correspondingly an unattained supremum of the retained parameter system. It should not be interpreted as an optimal hardness exponent for Euclidean CVP or as an obstruction to a different direct construction.
Reproducibility
The exact integer-arithmetic certificate and its canonical output are published in the FPRD Lab reproduction package [2]. The independent Lean fork records the imported source revision, modified paths, complete build logs, source hashes, and axiom output [3]. These two checks are complementary: the small certificate evaluates the seven concrete finite- side conditions reported in its output, while Lean checks that the concrete values reach the actual executable reduction and final promises.
References
[1] OpenAI, -Hardness of the Euclidean Closest Vector Problem, in Ten Advances in Mathematics and Theoretical Computer Science, pp. 183–218, 2026. https://cdn.openai.com/pdf/ten-proofs-oai.pdf.
[2] Joshua Gay, FPRD Lab: GapCVP Parameter-Retuning Reproduction Package, source code and recorded output, FPRD Lab GitLab repository, commit 013f5eec, 8 August 2026. https://gitlab.com/insight-forge/boxlab/fprd-lab/-/tree/013f5eec822c6f7b474991bfa6ac76e1cef2d0fe/evidence/gapcvp-parameter-audit.
[3] Insight Forge Boxlab, ten-proofs-gapcvp-retuning, independent audit fork of OpenAI’s ten-proofs, commit 3ac608981eb48c432e77b42b899689260351ca7d, 13 August 2026. https://gitlab.com/insight-forge/boxlab/ten-proofs-gapcvp-retuning/-/tree/3ac608981eb48c432e77b42b899689260351ca7d.
Reading-edition notes
This expanded web edition preserves the mathematical statements and proofs of the earlier publication, with the corrections recorded in the publication audit. The PDF is the earlier edition. Historical computational and formal-verification reports retain their original scope; they have not all been rerun for this revision.
Afterword: FPRD Lab’s contribution
9 September 2026 · Methodological and contribution addendum. The paper’s mathematical scope and review status remain as stated in the paper.
The Lab’s approach
FPRD means Finitely Presented Recognition Dynamics. Its starting point is to distinguish a finite description, the possibly infinite process it generates, and what an observer can learn from that process. Equal answers need not come from equal internal structures. Conversely, an infinite state space may have a short, exact description and useful coordinates; failure to compress it into finitely many states need not end the investigation.
A small example: balanced parentheses
The grammar S → (S)S | ε presents the language of
balanced parentheses. To recognize a prefix, keep the number of
unmatched opening parentheses, or a failure state if a closing
parenthesis arrived too early. An opening parenthesis increments the
count. A closing parenthesis decrements a positive count; at zero it
enters failure. Failure persists. At the end, accept exactly when the
count is zero.
The prefixes ( and ()( leave the same
future task: any suffix that completes one completes the other. The
prefix (( leaves a different task: ) completes
the first two prefixes but not this one. These future tasks are
residuals. There are infinitely many counts, yet a
finite set of update rules generates their dynamics. This is a classical
automata example, not a discovery of FPRD Lab. It illustrates the
research question: which coordinates preserve all relevant futures, and
what does updating or reading those coordinates cost?
From viewpoint to proof
In practice, the Lab fixes the observable and the allowed operations, compares presentations of the same problem, and seeks an exact translation or invariant. A failed shortcut is useful when a counterexample identifies the missing coordinate or hypothesis. Small computations test particular uncertainties; a proof must explain why the result holds beyond those tests. Costs, relation sides, boundary conditions, and the direction of each translation remain explicit.
AI-assisted exploration, source comparison, executable checks, and adversarial reconstruction support this work. Their agreement is not automatically independent evidence: shared assumptions must be exposed. A formal development certifies its stated formal theorem, not every interpretation attached to it. Each paper retains its own evidence and review status.
The approach is most useful when a poor representation hides a reusable construction, a compatibility condition, or a sharp obstruction. Outside recognition theory, it can guide the search for a structural reformulation without producing a literal residual dynamical system. The account below distinguishes that methodological influence from the ingredients of the proof.
FPRD’s contribution to this paper
Here the useful change of presentation was numerical. The source reduction fixed several large parameters. The Lab treated them instead as coupled resource coordinates: field size, support cutoff, and moment horizon. It then asked which inequalities the retained proof actually needed, rather than changing a displayed exponent in isolation.
Eliminating those internal coordinates exposed a frontier at 1/28 for the retained strict inequalities. The paper gives a concrete 1/30 specialization and checks the finite constants as well as asymptotic exponents. These numbers describe different claims: feasibility below the retained frontier, an explicit specialization, and a barrier for this particular system of obligations. The frontier is not an impossibility theorem for other reductions.
The representation audit mattered at several interfaces. Binary Hamming weight becomes squared Euclidean distance, so the approximation exponents differ by a factor of two. Support must be discarded separately for each table type, rather than by taking an unjustified common intersection. The coefficient needed in binary soundness must survive into the Euclidean wrapper. A discrepancy between one imported formal wrapper and the paper’s coefficient requirement was addressed explicitly instead of assuming a literal substitution preserved the proof.
Inherited ingredients and the boundary of the contribution
OpenAI’s direct reduction supplies the one-hot encoding, reconstruction from polynomial moments, valuation and clause-matching arguments, and parity lift. The Lab did not replace those constructions. Its contribution is the resource parameterization, elimination, finite-constant bookkeeping, and corresponding retuning of the verification interfaces.
This is an application of the Lab’s habit of separating representation costs and proof obligations. It is not a construction of a new language-residual system or an independent derivation of every imported lemma. The general written retuning and the archived executable Lean specialization also have different scopes: the latter establishes the concrete 1/30 reduction, while a separate formal result treats feasibility of the parameter inequalities. The full reduction is not uniformly formalized for every exponent below 1/28.
Where to inspect the contribution: the paper, Sections 1.2–1.3, 2, 5.5, and 7. These distinguish retained source mathematics, the repaired interfaces, and the exact formalization boundary.