[Rule] Knapsack to QUBO

[zazabap]

Source: Knapsack
Target: QUBO
Motivation: Enables solving Knapsack on quantum annealers (D-Wave) and via QUBO solvers; the penalty-based formulation embeds the capacity constraint into the quadratic objective.
Reference: Lucas, 2014, Ising formulations of many NP problems; Glover et al., 2019

Reduction Algorithm

Notation:

• Source: $n$ items with weights $w_0, \ldots, w_{n-1}$, values $v_0, \ldots, v_{n-1}$, capacity $C$
• Target: QUBO with $n + B$ binary variables, where $B = \lfloor \log_2 C \rfloor + 1$

Step 1 — Introduce slack variables:

Convert the inequality $\sum_i w_i x_i \leq C$ to equality by adding $B$ slack bits:

$$\sum_{i=0}^{n-1} w_i x_i + \sum_{j=0}^{B-1} 2^j s_j = C$$

The slack bits encode the unused capacity in binary.

Step 2 — Construct QUBO objective:

$$\text{minimize} \quad H = -\sum_{i=0}^{n-1} v_i x_i + P \left( \sum_{i=0}^{n-1} w_i x_i + \sum_{j=0}^{B-1} 2^j s_j - C \right)^2$$

where $P > \sum_i v_i$ is a penalty coefficient ensuring that any infeasible solution has higher cost than any feasible one.

Variable mapping:

• Item variables: $x_0, \ldots, x_{n-1}$ (same as source)
• Slack variables: $s_0, \ldots, s_{B-1}$ (auxiliary, discarded after solving)

Solution extraction: Take the $x_i$ values from the QUBO solution; ignore the slack variables $s_j$.

Size Overhead

Target metric (code name)	Polynomial (using symbols above)
num_vars	$n + B$ where $B = \lfloor \log_2 C \rfloor + 1$

Validation Method

Closed-loop testing: solve Knapsack by brute-force, solve the reduced QUBO, and verify that both give the same optimal value. Verify that the penalty $P$ is large enough by checking that no infeasible QUBO solution has lower cost than the optimal feasible one.

Example

Source instance: $n = 4$ items, capacity $C = 7$.

Item	Weight	Value
0	2	3
1	3	4
2	4	5
3	5	7

QUBO formulation:

• 7 binary variables: $x_0, x_1, x_2, x_3$ (items) + $s_0, s_1, s_2$ (slack, $B = \lfloor\log_2 7\rfloor + 1 = 3$)
• Penalty: $P > 3 + 4 + 5 + 7 = 19$, so set $P = 20$
• Equality constraint: $2x_0 + 3x_1 + 4x_2 + 5x_3 + s_0 + 2s_1 + 4s_2 = 7$

$$H = -(3x_0 + 4x_1 + 5x_2 + 7x_3) + 20(2x_0 + 3x_1 + 4x_2 + 5x_3 + s_0 + 2s_1 + 4s_2 - 7)^2$$

Optimal QUBO solution: $x = (1,0,0,1)$, $s = (0,0,0)$.

• Penalty: $(2 + 5 + 0 - 7)^2 = 0$ (feasible)
• Objective: $H = -10 + 0 = -10$

Suboptimal feasible: $x = (0,1,1,0)$, $s = (0,0,0)$, $H = -9$ (worse).

Infeasible: $x = (1,1,0,1)$, weight $= 10 > 7$, best slack gives penalty $\geq 20 \cdot 9 = 180$, so $H = -14 + 180 = 166$ (rejected).

[zazabap]

Issue Quality Check — Rule

Check	Result	Details
Usefulness	✅ Pass	No existing path from Knapsack to QUBO
Non-trivial	✅ Pass	Slack variables + penalty term + quadratic expansion
Correctness	⚠️ Warn	Glover et al. DOI is wrong — points to unrelated paper
Well-written	⚠️ Warn	Overhead uses log₂ which may not be expressible in overhead macro

Overall: 2 passed, 0 failed, 2 warnings

---

Usefulness

Knapsack has zero outgoing or incoming reductions. This would connect an isolated node to the QUBO hub, enabling solving on quantum annealers and Ising machines.

Non-trivial

Introduces B = ⌊log₂(C)⌋ + 1 auxiliary slack variables to convert inequality to equality, constructs a quadratic penalty term squaring a linear combination of item and slack variables, and expands into pairwise QUBO matrix entries. Not a simple relabeling.

Correctness — WARN

Reference	Status	Notes
Lucas (2014), "Ising formulations of many NP problems", Frontiers in Physics 2:5	✅ Verified	Covers Knapsack-to-Ising explicitly. Already in project bibliography as lucas2014.
Glover et al. (2019), "Quantum Bridge Analytics I"	⚠️ Wrong DOI	Issue cites 10.1007/s10479-018-2843-x which resolves to an unrelated paper about air transportation networks. Correct DOI: 10.1007/s10288-019-00424-y (4OR journal). Already in project bibliography as glover2019.

The mathematical content (penalty-based Knapsack-to-QUBO via slack variables) is correct and matches both cited papers. Example verified by manual calculation.

Well-written — WARN

All sections present. Algorithm is step-by-step and implementable. Example (4 items, capacity 7) shows optimal, suboptimal, and infeasible cases with full arithmetic.

Issues:

• Overhead implementability: The formula num_vars = n + B where B = ⌊log₂(C)⌋ + 1 uses log₂ and floor, which the #[reduction(overhead)] macro may not support directly. The macro supports log() (natural log) but not log2() or floor(). An approximation like num_items + log(capacity) / log(2) + 1 may be needed.
• QUBO weight variant: Not specified — should clarify target is QUBO<f64> (consistent with all existing QUBO reductions).

Required fixes

1. Fix Glover et al. DOI to 10.1007/s10288-019-00424-y
2. Specify target variant as QUBO<f64>
3. Address log₂ in overhead expression for macro compatibility

[zazabap]

Implementation Status — PR #172

All concerns from the quality check have been addressed:

Concern	Resolution
Glover et al. wrong DOI	Issue body has wrong DOI, but implementation only cites Lucas (2014). The project's references.bib already has the correct glover2019 entry (10.1007/s10288-019-00424-y). No action needed in code.
Overhead uses log₂	Solved by adding num_slack_bits() getter on Knapsack struct. Overhead expression is num_items + num_slack_bits — no log₂ in the macro.
Target variant QUBO<f64>	Implemented as ReduceTo<QUBO<f64>> throughout.
Float precision in num_slack_bits() (Copilot)	Fixed: now uses u64::BITS - (capacity as u64).leading_zeros() instead of (capacity as f64).log2().floor().
Signed overflow 1i64 << j (Copilot)	Fixed: changed to 1u64 << j.
KS alias (reviewer)	Removed — only lowercase "knapsack" alias remains.
Plan files (reviewer)	Deleted from PR.

[zazabap]

Issue Quality Check — Rule

Check	Result	Details
Usefulness	✅ Pass	No existing path from Knapsack to QUBO
Non-trivial	✅ Pass	Penalty-based formulation with binary slack encoding
Correctness	⚠️ Warn	Incorrect DOI for Glover et al. 2019; paper itself is valid
Well-written	⚠️ Warn	Minor notation and overhead table issues

Overall: 2 passed, 0 failed, 2 warnings

---

Usefulness

No direct or indirect reduction path currently exists from Knapsack to QUBO in the reduction graph. Knapsack has zero outgoing reductions (reduces_to: []). This is a novel, useful connection that enables solving Knapsack on quantum annealers and QUBO solvers.

Non-trivial

The reduction is non-trivial: it introduces auxiliary slack variables with binary encoding to convert an inequality constraint into an equality, then embeds the constraint via a quadratic penalty term into the QUBO objective. This involves genuine structural transformation (gadget construction with penalty terms), not a simple variable relabeling or type coercion.

Correctness

Lucas 2014 — Correctly cited. DOI 10.3389/fphy.2014.00005 resolves to "Ising formulations of many NP problems" by Andrew Lucas, Frontiers in Physics, 2014. This paper covers Knapsack as one of Karp's 21 NP-complete problems and discusses inequality-to-equality conversion with slack variables. The reference is already in the project bibliography as lucas2014. ✅

Glover et al. 2019 — The paper itself is real and relevant, BUT the DOI in the issue is wrong. The cited DOI 10.1007/s10479-018-2843-x (Annals of Operations Research) resolves to an unrelated paper: "Reliability evaluation of a multi-state air transportation network" by Lin, Nguyen, and Yeng. The correct DOI for "Quantum Bridge Analytics I: a tutorial on formulating and using QUBO models" by Glover, Kochenberger, and Du is 10.1007/s10288-019-00424-y (4OR journal), which is already in the project bibliography as glover2019. ⚠️

Mathematical correctness — The penalty-based Knapsack-to-QUBO construction (binary slack for inequality, quadratic penalty with P > sum of values) is standard and correct. The example is verified: items {0,3} give weight 2+5=7=C (feasible) and value 3+7=10 (optimal).

Well-written

Information Completeness — All required sections are present and substantive: Source, Target, Motivation, Reference, Reduction Algorithm, Size Overhead, Validation Method, and Example. ✅

Algorithm Completeness — The reduction algorithm is a clear, step-by-step procedure with explicit construction of the QUBO objective. Variable mapping and solution extraction are well-defined. ✅

Symbol and Notation Consistency — Minor issues:

• The overhead table uses num_vars (matching QUBO's size_fields), which is correct. ✅
• The formula n + B uses the symbols n and B from the Notation section, which is consistent. ✅
• For the actual #[reduction(overhead = {...})] macro implementation, the formula would need to reference source getter methods (num_items, capacity). The expression would be approximately num_items + log(capacity) + 1. This is not stated explicitly in the issue, but can be inferred. ⚠️

Example Quality — The example is excellent: 4 items with capacity 7, fully worked showing the QUBO formulation, optimal solution verification (penalty = 0), a suboptimal feasible solution, and an infeasible solution demonstrating the penalty mechanism. ✅

Recommendations

1. Fix the Glover et al. DOI: Replace 10.1007/s10479-018-2843-x with 10.1007/s10288-019-00424-y. The current DOI points to a completely unrelated paper.
2. Clarify overhead in terms of source getters: The overhead table could explicitly state the formula in terms of num_items and capacity (the actual getter methods on Knapsack): num_vars = num_items + floor(log2(capacity)) + 1.