Lift-One Algorithm in Binary Knapsack Lifting

• Lift-One Algorithm is an exact sequential lifting method for binary knapsack inequalities that computes coefficients one at a time via knapsack subproblems.
• It employs techniques such as dynamic programming and dominance-list representations to update variables in a precise, order-dependent manner.
• The method preserves the facetness of seed inequalities while overcoming computational limitations through refined state reduction and scalability improvements.

The Lift-One Algorithm usually denotes the standard sequential lifting method used in practical mixed-integer programming for binary knapsack inequalities: coefficients are determined one-by-one, typically by solving knapsack subproblems with dynamic programming on capacities or equivalent exact subproblems (Wang et al., 26 Feb 2026). In the material summarized here, the term is practical rather than canonical: the 2026 paper on binary knapsack lifting does not name the classical array-based procedure “Lift-One Algorithm” explicitly in its main text, but it identifies that procedure as exactly the implementation commonly associated with Lift-One-style exact sequential lifting (Wang et al., 26 Feb 2026). The same corpus also makes clear that “lifting” is heavily overloaded across optimization, program synthesis, MCMC, and semidefinite relaxation; those uses are related only by analogy, not by a shared algorithmic definition (Li et al., 28 Apr 2025).

1. Binary knapsack setting and lifted inequalities

The principal setting is the binary knapsack set

$$\mathcal{X}=\left\{\boldsymbol{x}\in\{0,1\}^n:\sum_{i=1}^n a_i x_i\le b\right\},$$

with $a_i\in\mathbb{Q}_+$, $b\in\mathbb{Q}_+$, $0<a_i\le b$, and $\sum_i a_i>b$. Its convex hull is the binary knapsack polytope

$\mathcal{P}=\operatorname{conv}(\mathcal{X}).$

Sequential lifting begins from a lower-dimensional valid inequality defined on a fixed set of variables. The index set $N=\{1,\dots,n\}$ is partitioned as $(C,N_0,N_1)$, where $C$ contains variables kept in the seed inequality, $N_0$ contains variables fixed to $a_i\in\mathbb{Q}_+$0, and $a_i\in\mathbb{Q}_+$1 contains variables fixed to $a_i\in\mathbb{Q}_+$2 (Wang et al., 26 Feb 2026).

The corresponding fixed knapsack set is

$a_i\in\mathbb{Q}_+$3

equivalently

$a_i\in\mathbb{Q}_+$4

A seed inequality is assumed in the form

$a_i\in\mathbb{Q}_+$5

valid for $a_i\in\mathbb{Q}_+$6, where $a_i\in\mathbb{Q}_+$7. After lifting, the resulting inequality on the original knapsack set has the form

$a_i\in\mathbb{Q}_+$8

This formulation is the core object to which Lift-One-style procedures apply (Wang et al., 26 Feb 2026).

A central structural property is that sequential lifting means lifting projected or fixed variables one at a time in a chosen order. The order is not incidental: the result depends on the lifting order, and each new coefficient is obtained from a knapsack optimization problem. The same source states that if the seed inequality is facet-defining for the lower-dimensional fixed set, then exact sequential lifting preserves facetness in the original space (Wang et al., 26 Feb 2026).

2. Exact sequential lifting: one coefficient at a time

Let the lifting order be $a_i\in\mathbb{Q}_+$9. Suppose variables up to $b\in\mathbb{Q}_+$0 have already been lifted, and the current valid inequality is

$b\in\mathbb{Q}_+$1

for the current fixed set $b\in\mathbb{Q}_+$2, with

$b\in\mathbb{Q}_+$3

The knapsack value function is

$b\in\mathbb{Q}_+$4

Lift-One-style exact sequential lifting computes each new coefficient through this value function (Wang et al., 26 Feb 2026).

If $b\in\mathbb{Q}_+$5, the procedure performs up lifting: $b\in\mathbb{Q}_+$6 If $b\in\mathbb{Q}_+$7, the problem is infeasible and the coefficient is set to $b\in\mathbb{Q}_+$8. The update is

$b\in\mathbb{Q}_+$9

If $0<a_i\le b$0, the procedure performs down lifting, writing the inequality as

$0<a_i\le b$1

with coefficient

$0<a_i\le b$2

The associated update is

$0<a_i\le b$3

These formulas make precise the “lift one variable at a time” interpretation: each step solves a small exact subproblem and then updates the current inequality and reduced knapsack parameters (Wang et al., 26 Feb 2026).

3. Classical Lift-One implementation via dynamic programming

In the 2026 treatment, the classical exact lifting approach computes $0<a_i\le b$4 by dynamic programming on capacities: $0<a_i\le b$5 and

$0<a_i\le b$6

This is explicitly identified as the Bellman recursion (Wang et al., 26 Feb 2026).

In this context, Lift-One / classical exact sequential lifting is the method that computes one coefficient at a time using full dynamic-programming arrays over capacities. The paper characterizes the approach as exact, but also emphasizes its limitations. When all weights and capacity are integers, the classical array-based DP has complexity

$0<a_i\le b$7

time and

$0<a_i\le b$8

space. The same discussion states that this implementation stores many redundant DP states and is tied to integer capacities and weights (Wang et al., 26 Feb 2026).

This distinction is important because “Lift-One” is sometimes used as though it denoted an abstract lifting principle. In the knapsack literature summarized here, however, it denotes a very concrete computational pattern: compute a coefficient, update the DP representation, then compute the next coefficient. The procedure is exact, sequential, order-dependent, and closely bound to the representation chosen for $0<a_i\le b$9 (Wang et al., 26 Feb 2026).

4. Dominance-list exact lifting as a refinement of classical Lift-One

The main refinement proposed in the 2026 paper replaces the full DP array by a dominance-list representation. A state is a pair $\sum_i a_i>b$0, where

$\sum_i a_i>b$1

for some $\sum_i a_i>b$2. The full state list is

$\sum_i a_i>b$3

A state $\sum_i a_i>b$4 dominates $\sum_i a_i>b$5 if

$\sum_i a_i>b$6

Dominated states can never be optimal for any capacity, so the dominance list

$\sum_i a_i>b$7

stores only the nondominated breakpoints (Wang et al., 26 Feb 2026).

A structural lemma stated in the summary is that any two distinct states in $\sum_i a_i>b$8 satisfy

$\sum_i a_i>b$9

Thus $\mathcal{P}=\operatorname{conv}(\mathcal{X}).$0 forms an increasing staircase. If

$\mathcal{P}=\operatorname{conv}(\mathcal{X}).$1

then the entire DP value function is recovered by

$\mathcal{P}=\operatorname{conv}(\mathcal{X}).$2

The refinement therefore changes only the representation, not the exact lifting coefficients: it computes the same $\mathcal{P}=\operatorname{conv}(\mathcal{X}).$3, but stores only its changes (Wang et al., 26 Feb 2026).

The list update is based on a shifted copy

$\mathcal{P}=\operatorname{conv}(\mathcal{X}).$4

and $\mathcal{P}=\operatorname{conv}(\mathcal{X}).$5 is obtained by merging $\mathcal{P}=\operatorname{conv}(\mathcal{X}).$6 and $\mathcal{P}=\operatorname{conv}(\mathcal{X}).$7, keeping only feasible nondominated states with $\mathcal{P}=\operatorname{conv}(\mathcal{X}).$8. The merge is implemented by a two-pointer scan and runs in time linear in the list length (Wang et al., 26 Feb 2026).

The same paper also introduces a reduction rule. For lifting step $\mathcal{P}=\operatorname{conv}(\mathcal{X}).$9, only certain capacities are needed, and it proves that if $N=\{1,\dots,n\}$0 is known for all

$N=\{1,\dots,n\}$1

then all future lifting coefficients $N=\{1,\dots,n\}$2 can be computed exactly. The restricted lower bound is

$N=\{1,\dots,n\}$3

This leads to reduced variants of both the dominance-list method and the DP-array method (Wang et al., 26 Feb 2026).

The experiments compare four implementations: DL, DP, DL-R, and DP-R. The reported findings are that DL beats DP strongly on large capacities, that reduction helps both methods, that DL is more scale invariant, and that when integrated into HiGHS, the exact lifting algorithm solved 4 more instances than default approximate lifting and slightly reduced average time on solved instances (Wang et al., 26 Feb 2026).

5. Conceptual relatives and common confusions

The phrase Lift-One Algorithm is easily confused with other algorithmic uses of “lifting,” but the sources separate these meanings sharply. In one direction, the 2020 paper on Climbing LP Algorithms presents the Dual Matrix Algorithm (DMA) as a climbing-style LP method that is “very much in the same family of ideas” as Lift-One-style LP methods, because it maintains a meaningful intermediate certificate, improves a monotone valuation, and uses local rank-one-like updates rather than recomputing everything from scratch (Levin, 2020).

That LP framework considers feasibility of

$N=\{1,\dots,n\}$4

for an integer matrix $N=\{1,\dots,n\}$5, and maintains a matrix structure $N=\{1,\dots,n\}$6. The core update is a single-entry increment of $N=\{1,\dots,n\}$7: $N=\{1,\dots,n\}$8 with corresponding determinant growth and a guaranteed progress per step of at least

$N=\{1,\dots,n\}$9

yielding an $(C,N_0,N_1)$0-step algorithm (Levin, 2020). The paper explicitly describes this as a conceptual cousin of Lift-One rather than the Lift-One algorithm itself. The relationship is therefore one of style—localized updates, monotone progress, incremental linear-algebraic maintenance—not one of identity.

In other directions, the summarized papers use “lifting” in entirely different senses. Guided Tensor Lifting concerns synthesis of TACO programs from C code via LLM-guided probabilistic grammars and weighted $(C,N_0,N_1)$1-style enumeration; the source explicitly states that it is not about a Lift-One algorithm in the classical sense (Li et al., 28 Apr 2025). The MCMC paper uses lifting to mean enlarging a state space to create nonreversible Markov chains (Vucelja, 2014). The POCS paper uses a one-dimensional lift from $(C,N_0,N_1)$2 to $(C,N_0,N_1)$3 for optimization (Cetin et al., 2013). The sparse-recovery paper introduces auxiliary weights in a lifted $(C,N_0,N_1)$4 model (Rahimi et al., 2022). The STRIDE framework uses lift-round-descend steps between polynomial variables and rank-one moment matrices in semidefinite relaxation (Yang et al., 2021). These are not variants of the knapsack Lift-One procedure; they are separate algorithmic constructions that happen to reuse the word “lifting.”

6. Exactness, limitations, and present significance

Within binary knapsack lifting, the essential properties of Lift-One-style methods are exactness, sequentiality, and order dependence. The method computes one coefficient at a time from a knapsack subproblem, and if the seed inequality is facet-defining, exact sequential lifting preserves facetness in the original knapsack polytope (Wang et al., 26 Feb 2026). This gives the method a precise polyhedral role: it is not merely heuristic coefficient adjustment, but an exact procedure for extending a valid inequality from a restricted face back to the full variable space.

Its main historical limitation, in the formulation summarized here, is computational. The classical DP-array implementation is exact but stores many redundant states and is tied to integer capacities and weights. This is why modern solver practice often relies on approximate lifting: exact DP-based lifting can be too expensive on real-scale instances with large capacities or non-integer coefficients (Wang et al., 26 Feb 2026). The dominance-list implementation directly addresses those limitations. The paper emphasizes that the dominance-list method is scale invariant, can handle non-integer coefficients, is often much faster for large capacities, and is better suited for modern solver implementations (Wang et al., 26 Feb 2026).

A plausible implication is that the current significance of the Lift-One idea lies less in the old array-based dynamic program than in the underlying exact sequential-lifting principle. The 2026 work preserves that principle while replacing the storage and update mechanism. In that sense, the modern form of Lift-One is best understood as an exact sequential lifting framework whose computational realization may vary, with the dominance-list representation emerging in the cited material as the most effective exact implementation for binary knapsack sets (Wang et al., 26 Feb 2026).