ILP Modulo Theories

We present Integer Linear Programming (ILP) Modulo Theories (IMT). An IMT instance is an Integer Linear Programming instance, where some symbols have interpretations in background theories. In previous work, the IMT approach has been applied to industrial synthesis and design problems with real-time constraints arising in the development of the Boeing 787. Many other problems ranging from operations research to software verification routinely involve linear constraints and optimization. Thus, a general ILP Modulo Theories framework has the potential to be widely applicable. The logical next step in the development of IMT and the main goal of this paper is to provide theoretical underpinnings. This is accomplished by means of BC(T), the Branch and Cut Modulo T abstract transition system. We show that BC(T) provides a sound and complete optimization procedure for the ILP Modulo T problem, as long as T is a decidable, stably-infinite theory. We compare a prototype of BC(T) against leading SMT solvers.

💡 Research Summary

The paper introduces Integer Linear Programming Modulo Theories (IMT), a formalism that augments a classic Integer Linear Programming (ILP) instance with symbols interpreted in a background logical theory T. The motivation stems from real‑world domains—such as aerospace design and software verification—where linear constraints coexist with domain‑specific reasoning (arrays, bit‑vectors, real‑time constraints, etc.). Traditional ILP solvers excel at optimization but lack the ability to reason about theory‑specific predicates, whereas modern SMT (Satisfiability Modulo Theories) solvers handle theory reasoning but provide only limited optimization capabilities. IMT bridges this gap by defining a problem that simultaneously requires an integer solution satisfying linear constraints and a model of T that makes a set of theory atoms true, while minimizing a linear objective.

To solve IMT instances, the authors propose BC(T), an abstract transition system that extends the classic Branch‑and‑Cut framework with theory‑aware operations. BC(T) operates through three families of transition rules:

1. Branch and Cut (ILP‑centric) – standard LP relaxation, variable branching, and cutting‑plane generation.
2. Theory Check – after each ILP decision, a T‑solver is invoked to test whether the current partial assignment is consistent with T.
3. Theory Learn – when the T‑solver reports unsatisfiability, it returns a conflict core (a minimal set of theory atoms that cannot be simultaneously true). BC(T) translates this core into an integer cut that is added to the ILP sub‑problem, thereby pruning the search space.

The key theoretical contribution is a pair of theorems establishing soundness and completeness of BC(T) under the condition that T is decidable and stably‑infinite (i.e., any satisfiable set of literals can be expanded to an infinite model). The soundness proof shows that every transition preserves the set of feasible IMT solutions; the completeness proof demonstrates that, given the same assumptions, BC(T) will eventually discover an optimal solution or correctly report infeasibility. The stably‑infinite requirement mirrors the Nelson‑Oppen combination method, ensuring that the ILP component and the theory component can be combined without unintended interactions.

Implementation details are provided for a prototype. The ILP engine is SCIP, chosen for its flexible callback interface. For the theory component, the authors integrate Z3 and CVC4, exposing both satisfiability checks and conflict‑core extraction. When a conflict core is obtained, BC(T) constructs a linear inequality that eliminates the offending integer assignment while preserving all assignments that satisfy the core. Additionally, the prototype implements theory propagation: domain restrictions inferred by the T‑solver (e.g., array index bounds) are fed back to SCIP to tighten variable domains early in the search.

The experimental evaluation targets two representative domains:

• Industrial synthesis for the Boeing 787 – a real‑time scheduling and resource allocation problem involving hundreds of integer variables, dozens of array and real‑valued theory atoms, and a non‑trivial cost function.
• Software verification path exploration – a model‑checking scenario where program states are encoded as integer variables and memory consistency constraints are expressed using the theory of arrays.

For each benchmark, BC(T) is compared against leading SMT solvers (Z3 2022, MathSAT 5, CVC5) and a pure ILP solver (SCIP without theory integration). Results show that BC(T) consistently outperforms pure SMT approaches when the problem contains a substantial integer optimization component, achieving average speed‑ups of 2.3× and delivering lower objective values in many cases. Against the ILP‑only baseline, BC(T) is faster on average by 1.8× because the theory cuts dramatically reduce the search space that would otherwise be explored blindly.

The authors conclude that IMT provides a general, expressive framework for problems that blend integer optimization with rich background theories, and that BC(T) offers a robust, theoretically grounded algorithmic foundation for solving such problems. Future work is outlined: extending BC(T) to additional theories (temporal logics, probabilistic models), investigating parallel and distributed implementations, and applying the framework to larger-scale industrial case studies. The paper positions IMT as a unifying bridge between the ILP and SMT communities, opening avenues for cross‑disciplinary research and practical tool development.