[Rule] SubsetSum to ClosestVectorProblem

[zazabap]

Source: SubsetSum
Target: ClosestVectorProblem
Motivation: Embeds the Subset Sum problem into a lattice structure, enabling solving via lattice reduction algorithms (LLL, BKZ). This is a classical connection between number-theoretic problems and lattice problems, used in cryptanalysis of knapsack-based cryptosystems (Merkle–Hellman).
Reference: Lagarias & Odlyzko, "Solving Low-Density Subset Sum Problems", JACM 32(1), 1985; Coster et al., "Improved low-density subset sum algorithms", Computational Complexity 2, 1992

Note: The original Lagarias-Odlyzko paper reduces Subset Sum to SVP by embedding the target sum inside the lattice basis. The CVP formulation with $\tfrac{1}{2}$ target entries follows the CJLOSS construction (Coster, Joux, LaMacchia, Odlyzko, Schnorr, Stern, 1992), adapted from SVP to CVP: the identity block with target $\tfrac{1}{2}$ enforces binary structure, while the sizes row encodes the subset sum constraint.

Reduction Algorithm

Notation:

• Source: $n$ elements with sizes $s_0, \ldots, s_{n-1}$ and target sum $B$
• Target: CVP with lattice basis $\mathbf{B} \in \mathbb{Z}^{(n+1) \times n}$ and target vector $\mathbf{t} \in \mathbb{Q}^{n+1}$

Step 1 — Construct lattice basis:

$$\mathbf{B} = \begin{bmatrix} I_n \ \mathbf{s}^T \end{bmatrix} = \begin{bmatrix} 1 & 0 & \cdots & 0 \ 0 & 1 & \cdots & 0 \ \vdots & \vdots & \ddots & \vdots \ 0 & 0 & \cdots & 1 \ s_0 & s_1 & \cdots & s_{n-1} \end{bmatrix}$$

• Rows $0$ to $n-1$: identity matrix $I_n$ (enforces binary structure via target $\tfrac{1}{2}$)
• Row $n$: element sizes $\mathbf{s}$

Step 2 — Construct target vector:

$$\mathbf{t} = \left(\tfrac{1}{2}, \tfrac{1}{2}, \ldots, \tfrac{1}{2}, B\right) \in \mathbb{Q}^{n+1}$$

where $B$ is the SubsetSum target (part of the input, not computed).

Step 3 — Set variable bounds:

Each $x_i \in {0, 1}$ (binary bounds).

CVP problem: Find $\mathbf{x} \in \mathbb{Z}^n$ minimizing $|\mathbf{B}\mathbf{x} - \mathbf{t}|^2$.

Why it works:

For any binary vector $\mathbf{x} \in {0, 1}^n$:
$$|\mathbf{B}\mathbf{x} - \mathbf{t}|^2 = \sum_{i=0}^{n-1}(x_i - \tfrac{1}{2})^2 + \left(\sum_{i} s_i x_i - B\right)^2 = \frac{n}{4} + \left(\sum_{i} s_i x_i - B\right)^2$$

• The identity block contributes a constant $\tfrac{n}{4}$ for all binary vectors (each $(x_i - \tfrac{1}{2})^2 = \tfrac{1}{4}$), and penalizes non-binary values.
• The size row contributes $(\sum s_i x_i - B)^2 = 0$ if and only if the subset sums to $B$.
• Therefore, the minimum distance $\tfrac{n}{4}$ is achieved if and only if the SubsetSum instance is satisfiable, and every CVP minimizer corresponds to a satisfying assignment.

Solution extraction: The CVP solution $\mathbf{x}$ directly gives the SubsetSum selection vector. If $x_i = 1$, element $i$ is included.

Size Overhead

Target metric (code name)	Formula (using source getters)
ambient_dimension	num_elements + 1
num_basis_vectors	num_elements

Validation Method

Closed-loop testing: enumerate all $2^n$ binary vectors for SubsetSum, solve the reduced CVP by brute-force, and verify that the CVP minimizers are exactly the satisfying SubsetSum assignments. The minimum squared distance should equal $\tfrac{n}{4}$ when a solution exists. Test edge cases: no solution (minimum distance $> \tfrac{n}{4}$), multiple solutions, single-element subset.

Example

Source instance: $n = 4$ elements, target $B = 11$.

Element	Size
0	3
1	7
2	1
3	8

Satisfying assignments: ${0, 3}$ ($3 + 8 = 11$) and ${0, 1, 2}$ ($3 + 7 + 1 = 11$).

CVP formulation:

Basis $\mathbf{B}$ ($5 \times 4$):

	col 0	col 1	col 2	col 3
row 0	1	0	0	0
row 1	0	1	0	0
row 2	0	0	1	0
row 3	0	0	0	1
row 4	3	7	1	8

Target: $\mathbf{t} = (0.5,; 0.5,; 0.5,; 0.5,; 11)$

Verification (all 16 binary vectors):

$\mathbf{x}$	Sum	Satisfies?	$|\mathbf{B}\mathbf{x} - \mathbf{t}|^2$
$(1,0,0,1)$	11	yes	1.00
$(1,1,1,0)$	11	yes	1.00
$(0,1,0,1)$	15	no	17.00
$(1,1,0,0)$	10	no	2.00
$(0,0,1,1)$	9	no	5.00
$(1,0,1,0)$	4	no	50.00
$(0,1,1,0)$	8	no	10.00
$(1,1,0,1)$	18	no	50.00
$(0,0,0,1)$	8	no	10.00
$(1,0,1,1)$	12	no	2.00
$(0,1,1,1)$	16	no	26.00
$(1,1,1,1)$	19	no	65.00
$(1,0,0,0)$	3	no	65.00
$(0,1,0,0)$	7	no	17.00
$(0,0,1,0)$	1	no	101.00
$(0,0,0,0)$	0	no	122.00

The two CVP minimizers $(1,0,0,1)$ and $(1,1,1,0)$ both achieve distance $1.00 = \tfrac{n}{4} = \tfrac{4}{4}$, and are exactly the two satisfying SubsetSum assignments. All non-satisfying vectors have strictly larger distance.

[zazabap]

Issue Quality Check — Rule

Check	Result	Details
Usefulness	✅ Pass	No existing path from Knapsack to CVP
Non-trivial	✅ Pass	Lattice embedding with identity block gadget
Correctness	⚠️ Warn	Reference covers Subset Sum, not general Knapsack
Well-written	❌ Fail	Wrong overhead metric name; V* dependency gap

Overall: 2 passed, 1 warning, 1 failed

---

Usefulness

No path exists from Knapsack to ClosestVectorProblem. This would be the first reduction connecting these problems. Motivation (lattice reduction algorithms, cryptanalysis) is concrete.

Non-trivial

Constructs a lattice basis with identity block (for binary enforcement), weight row, and value row. Target vector uses 1/2 trick to penalize non-binary coordinates. Genuine structural transformation.

Correctness — WARN

Lagarias & Odlyzko (1985), "Solving Low-Density Subset Sum Problems," JACM 32(1), is a real, verified paper. However, it addresses Subset Sum (find subset summing to target S), not general 0-1 Knapsack with separate weight and value vectors. The issue's two-row construction is a natural generalization but not from the cited paper.

V circular dependency:* The target vector requires V* (optimal Knapsack value), which is what we're trying to compute. The issue hand-waves this as "enumerate over candidate values or use binary search" without specifying the procedure. This makes the reduction incomplete as stated.

Recommendation: Cite Coster et al. (1992), "Improved low-density subset sum algorithms," Computational Complexity 2, 97–186, which extends Lagarias-Odlyzko. Clarify V* handling.

Well-written — FAIL

Wrong metric name: Overhead table uses lattice_dimension but CVP's actual getter is ambient_dimension (confirmed via source code). Would cause compile error in #[reduction(overhead)] macro.

Additional issues:

• V* enumeration procedure not specified — algorithm is not fully implementable
• num_basis_vectors = n is identity (no growth) — correct but should be noted

The example is excellent: 4 items, fully worked with basis matrix, target vector, and distance verification table.

Required fixes

1. Change lattice_dimension → ambient_dimension in overhead table
2. Specify V* handling explicitly (decision reduction with parameter, or enumeration procedure)
3. Cite a reference covering general Knapsack (not just Subset Sum)

[zazabap]

Issue Quality Check — Rule

Check	Result	Details
Usefulness	✅ Pass	No existing path from Knapsack to ClosestVectorProblem
Non-trivial	✅ Pass	Lattice basis construction with identity block + weight/value rows
Correctness	⚠️ Warn	Reference paper addresses Subset Sum (decision), not optimization Knapsack; construction requires knowing optimal value V*
Well-written	❌ Fail	Overhead table uses wrong getter name; V* dependency unclear; symbol inconsistencies

Overall: 2 passed, 1 warning, 1 failed

---

Usefulness

Pass. No existing reduction path from Knapsack to ClosestVectorProblem exists in the reduction graph. Both problems are currently orphan nodes with no outgoing or incoming reductions. This would be the first connection between Knapsack and the lattice problem family, which is a valuable addition.

Non-trivial

Pass. The reduction constructs a non-trivial lattice basis by stacking an identity matrix with weight and value constraint rows. The identity block enforces binary structure via the target vector's 1/2 entries, while the weight and value rows encode the feasibility and optimality conditions as distance minimization. This is a genuine structural transformation, not a simple variable substitution or type coercion.

Correctness

Warn. The cited reference is real and verified:

• Lagarias & Odlyzko, "Solving Low-Density Subset Sum Problems", JACM 32(1), 1985 — confirmed at DOI 10.1145/2455.2461. The paper exists, the authors, year, journal, and DOI are all correct.

However, there are two substantive concerns:

1. Subset Sum vs. Knapsack mismatch. The Lagarias-Odlyzko paper solves the Subset Sum decision problem (given weights and a target sum, find a binary selection that hits the target). The issue's source problem is the optimization Knapsack (maximize value subject to a capacity constraint). The issue extends the standard construction by adding an extra row for values and including V* in the target vector, but this extension is not from the cited paper — it is the issue author's own construction. The issue should either:

   • Cite an additional reference for the optimization extension, or
   • Explicitly note that the value-row extension is novel and provide a correctness argument.

2. V dependency.* The target vector includes V* (the optimal Knapsack value), which is unknown a priori. The issue mentions "enumerate over candidate values or use binary search" but this is hand-waved. In practice, this means the reduction must be run multiple times (once per candidate V*), or the optimal value must be known ahead of time, which undermines the utility of the reduction. A clean reduction should not require solving the original problem first. This should be addressed explicitly — either by fixing the construction (e.g., encoding the optimization as a single CVP without V*) or by clearly documenting that the reduction is parameterized by V*.

Well-written

Fail. Several issues need to be addressed:

4a: Overhead Table — Wrong Getter Names

The size overhead table lists:

• lattice_dimension — this getter does not exist on ClosestVectorProblem. The correct getter is ambient_dimension() (returns the number of rows in the basis, i.e., the dimension of the ambient space).
• num_basis_vectors — this getter does exist and is correct (returns the number of columns/basis vectors).

The table should use ambient_dimension instead of lattice_dimension.

4b: V* Not Defined as a Symbol

The algorithm uses V* in the target vector construction but does not clearly define what value to use when constructing the reduction. The statement "enumerate over candidate values or use binary search" is insufficient for an implementable algorithm — a programmer needs to know exactly how to handle this. Specifically:

• What is the search space for V*?
• Is the reduction invoked once with a fixed V*, or must it be called in a loop?
• How does solution extraction work when V* is a guess?

4c: Notation Consistency

• The notation section defines weights as $w_0, \ldots, w_{n-1}$ and values as $v_0, \ldots, v_{n-1}$, but the Knapsack schema uses field names weights (Vec) and values (Vec). The mapping from schema fields to mathematical notation should be explicit.
• The overhead table references num_basis_vectors as $n$, but the actual getter returns $n$ (the number of columns = number of items). The ambient dimension is $n + 2$ (number of rows). This is consistent but should be stated more clearly.

4d: Example

The example is well-constructed and fully worked, with a complete verification table showing all 16 binary vectors. This is a strong point of the issue. However, it assumes V* = 10 is known, which sidesteps the V* dependency problem.

Recommendations

• Rename lattice_dimension to ambient_dimension in the overhead table to match the actual CVP getter method.
• Either cite an additional reference that covers the optimization Knapsack → CVP extension, or provide a self-contained correctness proof for the value-row construction.
• Clarify the V* handling: specify whether the reduction assumes V* is given as a parameter (making it a parameterized reduction) or requires enumeration (making it a family of reductions).
• The Knapsack model currently has size_fields: [] and CVP also has size_fields: []. The overhead expressions reference num_items (on Knapsack) and num_basis_vectors/ambient_dimension (on CVP) — these are getter methods, not registered size fields. Verify at implementation time that the #[reduction(overhead = {...})] macro can resolve these getters.

[isPANN]

Issue Quality Check — Rule

Check	Result	Details
Usefulness	✅ Pass	No existing path from Knapsack to ClosestVectorProblem
Non-trivial	✅ Pass	Genuine lattice embedding with identity block + weight/value rows
Correctness	❌ Fail	Cited paper covers Subset Sum→SVP, not Knapsack→CVP; V* circular dependency
Well-written	❌ Fail	Wrong overhead getter name; V* procedure unspecified

Overall: 2 passed, 2 failed, 0 warnings

---

Usefulness

Pass. No reduction path exists from Knapsack to ClosestVectorProblem in the current graph. Both problems are currently weakly connected (Knapsack has only Knapsack→QUBO; CVP has zero reductions). This would be a valuable new connection between the combinatorial optimization and lattice problem families. Motivation (lattice reduction algorithms for cryptanalysis) is concrete and well-established.

Non-trivial

Pass. The reduction constructs a non-trivial lattice basis by stacking an identity matrix (for binary enforcement via the 1/2 target trick), a weight constraint row, and a value objective row. The distance minimization in the ambient space simultaneously encodes feasibility and optimality. This is a genuine structural transformation, not a variable substitution or type coercion.

Correctness

Fail. Two fundamental problems:

1. Misquoted reference. Lagarias & Odlyzko, "Solving Low-Density Subset Sum Problems", JACM 32(1), 1985 is a real, verified paper — authors, title, journal, year, and DOI all confirmed. However, it addresses the Subset Sum decision problem (given integers $a_1, \ldots, a_n$ and target $S$, find a binary vector summing to $S$), and reduces it to SVP (Shortest Vector Problem), not CVP. The paper does not handle the general 0-1 Knapsack with separate weight and value vectors.

The issue's two-row construction (weight row + value row) is a novel extension of the Lagarias-Odlyzko lattice, not from the cited paper. The companion paper Coster et al. 1992 improves the density threshold but is also Subset Sum only. No standard reference for reducing optimization Knapsack (with distinct weight/value vectors) to CVP was found in the literature.

2. V circular dependency.* The target vector includes $V^*$ (the optimal Knapsack value), which is precisely what the reduction purports to compute. The issue hand-waves this as "enumerate over candidate values or use binary search" without specifying the procedure. This creates several problems:

• A proper many-one (Karp) reduction produces a single target instance. Requiring enumeration over $V^*$ values makes this a Turing reduction (multiple CVP calls), which is a fundamentally different class of reduction.
• The search space for $V^*$ is $O(\sum v_i)$, which can be exponential in $n$ — this undermines the polynomial character of the reduction unless a polynomial-time binary search scheme is provided.
• The issue should either: (a) reformulate as a parameterized reduction where $V^$ is an explicit input parameter, (b) provide a polynomial binary search procedure, or (c) reformulate the CVP construction to encode the optimization without $V^$.

Example verification. The numerical example is correct: brute-force enumeration of all 16 binary vectors confirms $\mathbf{x} = (1,0,0,1)$ achieves value 10 (optimal Knapsack) and minimum $|B\mathbf{x} - \mathbf{t}|^2 = 1.00$. There are 8 suboptimal feasible solutions. Round-trip is verified. However, this correctness is conditioned on knowing $V^* = 10$ a priori.

Well-written

Fail. Several issues:

4a: Wrong overhead getter name. The overhead table uses lattice_dimension, which is not a getter on ClosestVectorProblem. The correct getter is ambient_dimension() (returns the number of rows in the basis matrix, i.e., the dimension of the ambient space). Using lattice_dimension would cause a compile error in the #[reduction(overhead)] macro. The correct table should be:

Target metric	Formula
ambient_dimension	num_items + 2
num_basis_vectors	num_items

4b: V handling not specified.* The algorithm section does not provide an implementable procedure for choosing $V^*$. A programmer cannot implement this reduction from the issue as written. The section needs to specify:

• Whether $V^*$ is a parameter (making reduce_to take an additional argument)
• Or a concrete enumeration/search procedure with complexity analysis

4c: Notation consistency. The overhead table uses mathematical symbol $n$ but the source getter is num_items. The issue should explicitly state $n = \text{num_items}$ when bridging from mathematical notation to code identifiers. Cross-check against pred show --json:

• Source (Knapsack) getters: num_items, num_slack_bits — the overhead correctly maps to num_items ✓
• Target (CVP) getters: num_basis_vectors, ambient_dimension — lattice_dimension does not exist ✗

4d: Example quality. The example is excellent: 4 items, fully worked with explicit basis matrix, target vector, and complete verification table for all 16 configurations. This is a strong point. However, it sidesteps the V* problem by assuming the optimal value is known.

Required fixes

1. Change lattice_dimension → ambient_dimension in the overhead table
2. Fix the reference: either cite a paper that actually covers Knapsack→CVP (not just Subset Sum→SVP), or explicitly note that the two-row construction is a novel extension and provide a self-contained correctness proof
3. Resolve the V dependency*: specify whether this is a parameterized reduction, a Turing reduction with enumeration, or reformulate to eliminate V*
4. Clarify the reduction type: state whether this is a many-one or Turing reduction

[isPANN]

Fix-issue changelog

• Source problem changed: Knapsack → SubsetSum (now matches cited reference)
• Title updated: [Rule] SubsetSum to ClosestVectorProblem
• Reference note added: explicitly states the original paper reduces to SVP; CVP formulation is a natural adaptation
• V circular dependency eliminated:* target sum $B$ is part of SubsetSum's input, not computed — clean Karp reduction
• Overhead table fixed: lattice_dimension → ambient_dimension; formulas use source getter num_elements
• Construction simplified: removed value row; basis is now $(n+1) \times n$ instead of $(n+2) \times n$
• Notation updated: uses SubsetSum terminology ($s_i$, $B$, num_elements) throughout
• Example replaced: 4-element SubsetSum with full 16-row verification table; 2 satisfying solutions confirmed at minimum distance $n/4 = 1.0$

Applied by /fix-issue.