ILP-Based Local Repairs in Optimization

Updated 11 November 2025

Integer-linear-program-based local repairs are algorithmic frameworks that decompose complex optimization problems into tractable, localized ILP/MIP subproblems.
They employ a destroy-and-repair strategy using local branching, LP-relaxations, and structured move operators like tight-move and lift-move to enhance feasibility and objective performance.
These methods are applied across domains such as combinatorial optimization, error correction coding, and generative model repairs, demonstrating proven efficiency and scalability.

Integer-linear-program-based local repairs refer to a family of algorithmic frameworks, methodologies, and theory-driven heuristics that employ integer linear programming (ILP), mixed integer programming (MIP), or their relaxations to incrementally or locally modify candidate solutions to meet additional constraints, correct infeasibilities, or optimize combinatorial objectives. Local repair approaches are central to modern combinatorial optimization, with prominent applications in error correction codes, large-scale integer programming, heuristic search, and post hoc repair of generative models.

1. Foundational Formulations and Repair Mechanisms

Integer-linear-program-based local repair frameworks reduce large, global combinatorial problems to a sequence of tractable local subproblems (the repair neighborhoods), each expressed as an ILP or MIP, that modify only a small subset of the current solution (the repair set). The key properties of these methods are:

Boundary and Neighborhood Restriction: Solution updates are confined to the combinatorial or LP polyhedral boundary (set of boundary-lattice points or local Hamming balls), ensuring the new candidate remains "close" to the incumbent configuration (Lin et al., 2023, Huang et al., 2022).
Destructive and Constructive Steps: Many repair heuristics use a "destroy-and-repair" paradigm, first perturbing or partially destroying part of the solution (e.g., via variable fixing or relaxation), then re-optimizing the affected components via a (MI)LP or similar subroutine (Huang et al., 2022).
Objective-Guided Local Search: Moves within each repair neighborhood are guided by scoring functions tied to the original objective and infeasibility metrics, often leveraging tight-move and lift-move update operators that exploit ILP structure (Lin et al., 2023).

A core advantage of these techniques is their ability to handle complex combinatorial and constraint-laden search spaces while leveraging the maturity and efficiency of modern ILP/MIP solvers.

2. Main Methodological Paradigms

Several distinct ILP-based local repair paradigms have emerged, each suited to different problem classes and requirements:

a) Local Branching and Relaxed Variant

Exact Local Branching (LB): For a binary ILP, LB defines a neighborhood as the set of all points within a given Hamming radius $k$ of the incumbent $x^0$ . The repair subproblem is then an ILP with all constraints of the original problem plus a local branching constraint. Each iteration finds the best feasible point within this local neighborhood (Huang et al., 2022).
LP-Relaxed Local Branching (LB-RELAX): To reduce computational overhead, LB-RELAX solves an LP relaxation of the local branching subproblem to identify the most "promising" variables to perturb, then re-optimizes over just this subset—yielding orders-of-magnitude speedups in practice (Huang et al., 2022).

Method	Repair Neighborhood	Solved Subproblem
LB	Hamming ball, $k$ flips	Full-size ILP with local constraint
LB-RELAX	LP-relaxed guidance	Reduced ILP on selected variables

b) Structured Local Move Operators

The "Local-ILP" method exploits two move operators:

Tight-move (TM): Adjusts a variable to make a constraint as tight as possible without violating bounds, focusing on constraint satisfaction or objective improvement.
Lift-move (LM): From a feasible point, pushes a variable toward its bound within the local feasible domain to improve the objective while preserving feasibility.

Modes (Search, Improve, Restore) are orchestrated based on solution feasibility and guided by scoring/infeasibility weights for focused exploration (Lin et al., 2023).

c) Progressive Integrality and Local Repair (PIP)

For nonconvex programs with complementarity or disjunctive constraints (notably LPCCs and indefinite QPs), the Progressive Integer Programming (PIP) method begins from an incumbent feasible solution, incrementally increases the fraction of variables treated as integer, and repairs various sub-blocks via MILPs—guaranteeing monotonic descent and terminating at a local minimum (Zhang et al., 16 Sep 2024).

3. Theoretical Guarantees and Solution Quality

Integer-linear-program-based local repair methods often provide rigorous guarantees on the structure and properties of the search space and visited solutions:

Completeness of the Boundary Lattice: All global optima of an ILP occur on the boundary lattice $\delta(P)$ of the LP feasible region; restricting search to $\delta(P)$ excludes no optimum (Lin et al., 2023).
No Interior Wasted Search: The Local-ILP algorithm ensures all feasible solutions visited lie on the boundary, avoiding exploration deep in the interior of $P$ , which would be suboptimal for integer objectives (Lin et al., 2023).
Finite and Monotonic Convergence: The PIP framework guarantees finite termination due to the strictly nonincreasing objective and finitely many possible subsets of complementarity constraints fixed or left binary. Each local repair subproblem is a valid improvement step or expansion of the search region (Zhang et al., 16 Sep 2024).

Closed-form performance bounds are possible in specialized applications, such as the explicit minimum distance bound for locally repairable codes via integer programming formulations (Wang et al., 2014).

4. Applications Across Domains

a) Large-Scale Combinatorial Optimization

Mixed-integer optimization in industry/management: Local-ILP achieves competitive solution quality and runtime compared to both commercial (Gurobi) and non-commercial (SCIP, FJ) solvers on MIPLIB benchmarks, often finding more feasible solutions and recording new bests on challenging open instances (Lin et al., 2023).
State-of-the-art in LNS frameworks: LB-RELAX and its variants set new bests for anytime performance in Minimum Vertex Cover, Maximum Independent Set, Set Covering, and Multiple Knapsack ILPs; LB-RELAX is up to 117 $\times$ faster than full LB with minimal quality loss (Huang et al., 2022).

b) Error-Correction Coding

Distance-optimality for LRCs: Integer-program-based local repair characterizations have yielded tight upper bounds and explicit code constructions for the largest possible minimum distance of $[n, k]$ -locally repairable codes, settling open questions for $(r \le \sqrt{n}-1)$ regimes (Wang et al., 2014).

c) Constraint Repair in Generative Models

Procedural content generation repairs: Mixed-integer programs, cast as minimum-cost network flow problems, successfully repair GAN-generated video game levels by minimizing edit-cost under playability and style constraints. The MIP achieves 100% playability and uniqueness, preserves stylistic features, and efficiently edits large levels in milliseconds (Zhang et al., 2020).

d) Nonconvex Program Local Improvement

LPCC and indefinite QP: PIP exploits ILP-based local repair to iteratively refine feasible solutions for LPCCs, yielding locally optimal points with practical computational gains over fully integer-encoded formulations (Zhang et al., 16 Sep 2024).

5. Benchmark Results and Comparative Empirics

Empirical results across benchmarks underline the practical efficacy and versatility of ILP-based local repairs:

On 121 MIPLIB instances (hard+open), Local-ILP finds feasible solutions fastest among non-commercial heuristics and outperforms Gurobi’s default heuristics at short/medium time scales (10s, 60s), while remaining competitive in overall best solution rates (Lin et al., 2023).
LB-RELAX matches or exceeds LB quality on hard instances where full LB times out (e.g., ~ $+29\%$ on Set Covering), reaching competitive or best-known gaps in orders-of-magnitude less time (Huang et al., 2022).
The GAN+MIP repair for Zelda/Pac-Man achieves $100\%$ playability and up to $85.1\%$ unique levels, with performance (0.13–3.22 s/level) well suited for real-time content generation (Zhang et al., 2020).
PIP improves upon stationary solutions produced by nonlinear programming solvers for indefinite QPs/LPCCs and empirically outpaces full-MILP global search for many practical instances (Zhang et al., 16 Sep 2024).

6. Limitations, Challenges, and Extensions

Despite their successes, integer-linear-program-based local repair techniques face certain limitations:

Locality of Guarantees: For complex nonconvex or complementarity-constrained problems, local repair methods (e.g., PIP) guarantee only local, not global, optimality absent enumeration over all variable combinations. Global optimality would require solving the full combinatorial program, which may be prohibitive (Zhang et al., 16 Sep 2024).
Dependence on Incumbents and Repair Neighborhoods: The quality and diversity of final solutions can be sensitive to the choice of repair neighborhood and initialization (e.g., the starting feasible point provided to PIP).
Parameter Tuning: Algorithmic parameters (e.g., repair neighborhood size $k$ , relaxation fraction $p$ , and step size $\alpha$ ) often require empirical tuning per problem and instance class for maximal performance (Zhang et al., 16 Sep 2024, Huang et al., 2022).
Computational Scalability of ILP/MIP Solvers: While local repair neighborhoods are generally far smaller than the global problem, solving even these ILPs/MIPs may remain nontrivial for very large or tightly constrained blocks.

Extensions under current investigation include adaptive neighborhood sizing, parallel or beam search of local repairs, learning-guided destroy heuristics, and integration with combinatorial structure exploitation (e.g., via relaxations, flow formulations, or domain decomposition) (Huang et al., 2022).

7. Broader Significance and Outlook

Integer-linear-program-based local repairs formalize and unify a wide class of robust, high-performance techniques for combinatorial optimization, code design, and constraint satisfaction. By reducing global complexity to a sequence of tractable, solver-friendly subproblems and systematically leveraging mathematical structure, these methods are broadly adaptable and empirically effective across domains ranging from theoretical coding theory (Wang et al., 2014) to real-world planning, scheduling, and content generation (Zhang et al., 2020, Huang et al., 2022, Lin et al., 2023, Zhang et al., 16 Sep 2024). A plausible implication is that as ILP/MIP solvers and large neighborhood search heuristics continue to develop, ILP-based local repair will remain a central paradigm for scalable combinatorial problem solving and for the post hoc correction or improvement of solutions found by black-box or learning-based models.