Direct Local Search for SMT(IA)

• Local search for SMT(IA) is an approach that directly modifies a complete assignment over Boolean and integer variables, bypassing traditional DPLL(T) decomposition.
• It employs specialized operators—critical, boundary-aware, and pairwise moves—to rapidly satisfy arithmetic constraints with dynamic, clause-weighted heuristics.
• Empirical results show that local search techniques excel with pure integer problems and effectively complement standard CDCL(T) solvers in mixed instances.

Satisfiability Modulo Theories over Integer Arithmetic (SMT(IA)) is the problem of deciding satisfiability of formulas in quantifier-free first-order logic, augmented with background theories including both linear and nonlinear integer arithmetic. While dominant solvers rely on combinations of conflict-driven clause learning (CDCL) SAT solvers and specialized theory reasoning (“DPLL(T)”), recent advances have established the viability and competitiveness of local search frameworks that operate directly over both Boolean and integer variables. New developments include literal-level integer moves, two-level operation selection heuristics, pairwise integer updates, and hybrid samplers for generating diverse solution sets.

1. From CDCL(T) to Direct Local Search for SMT(IA)

Conventional SMT(IA) solvers adopt the DPLL(T) paradigm, separating the Boolean abstraction (handled by CDCL SAT) from arithmetic theory propagation and conflict analysis. This architecture yields strong proofs and model completeness, but is heavily engineered for partial-model construction and clause exchange. In contrast, LocalSMT (or LS-IA) maintains a global total assignment $\alpha$ over all Boolean and integer variables and traverses the assignment space by applying “local moves” to individual variables—propositional flips or integer value modifications—without recourse to Boolean-theory separation (Cai et al., 2022).

A two-mode engine alternates between Boolean flip operations:

• $\mathrm{flip}(x)$ for $x\in P$ (sets $x := \lnot x$), and integer critical moves:
• $\mathrm{cm}(x, \ell)$ for $x\in X$, $\ell$ a falsified arithmetic literal containing $x$.

Modes switch based on the fraction of falsified literals attributable to each type, with counters for non-improving steps. This unified local search in assignment space can exploit arithmetic structure more directly and yields strong performance especially when Boolean variables are absent or rare.

2. Integer Move Operators: Critical Moves, Boundary-Aware Moves, and Pairwise Updates

Three major families of integer move operators have been introduced:

• Critical Move (LS-IA): For falsified linear (or non-linear under certain restrictions) integer constraints, $\mathrm{cm}(x, \ell)$ instantly “jumps” a selected variable $x$ to the integer boundary required for $\ell$ to become true (Cai et al., 2022). In the linear case, for $\ell: \sum_i a_i x_i \leq k$, the variable $x_j$ is assigned the minimal value to make the inequality satisfied given all others fixed, via integer division. In nonlinear settings, with all other variables fixed, $x$ is moved to a root interval flipping the polynomial’s sign. Disequalities are handled by minimal increment/decrement.
• Boundary-Aware Move (HighDiv): In the sampling framework HighDiv, the operator $\mathrm{bam}(x_j, \ell)$ selects any value within the satisfaction interval for $x_j$ (not just the minimal) uniformly at random, given all other variables as context (Lai et al., 25 Feb 2025). This supports high-diversity generation of solutions and randomizes search trajectories.
• Pairwise Operator (LS-LIA-Pair): To escape local optima unreached by single-variable moves, the operator $p(v_1, v_2, \mathit{val}_1, \mathit{val}_2)$ simultaneously modifies two integer variables. Candidate pairwise moves are constructed by “compensating” for literals that would be flipped from true to false by the first move, enabling joint repair of clauses that otherwise cannot be improved via independent steps (He et al., 2024).

3. Operation Selection Heuristics and Scoring

LocalSMT and its descendants rank candidate moves with clause-weighted cost functions. Let $w(c)$ be the weight of clause $c$. The cost of assignment $\alpha$ is $$\mathrm{cost}(\alpha) = \sum_{c\text{ falsified}} w(c)$$. For a candidate move $\mathrm{op}$, the score is classical: $$\mathrm{score}(\mathrm{op}) = \mathrm{cost}(\alpha) - \mathrm{cost}(\alpha')$$. Integer-specific refinements distinguish degrees of improvement using “distance to satisfaction” ($\mathrm{dts}$).

A two-level heuristic prioritizes moves that directly satisfy a falsified clause. If such a move is unavailable, the heuristic considers broader candidate sets, possibly involving already satisfied clauses, and ultimately weights are dynamically adjusted (PAWS scheme) to promote escapes from local minima (Cai et al., 2022).

The pairwise operator in LS-LIA-Pair introduces an additional two-layer structure: prioritized “fragile” literals, where joint updates are more likely to fix otherwise stuck clauses, are preferred over “safe” ones, with BMS-based sampling ranking among multiple candidates (He et al., 2024).

4. Algorithmic Workflow and main loop Designs

The main loop of LS-IA and related solvers alternates between Boolean and integer modes, with fixed or dynamically adjusted thresholds governing mode switches and maximum allowed non-improving steps. Integer mode pseudocode follows:

1. Check if current assignment $\alpha$ satisfies all clauses; if yes, return;
2. Seek decreasing single-variable moves; if none found, try pairwise moves (if implemented);
3. If still stuck, increase clause weights and conduct a random step among worst clauses;
4. Apply the selected move, updating assignment, clause status, and tabu/tenure lists;
5. If the move is improving, reset the non-improving counter; otherwise, increment.

HighDiv’s sampler places the local search phase first for seed model extraction, then launches a randomized CDCL(T) search phase, using seeded under-approximations by fixing subsets of variable values (Lai et al., 25 Feb 2025). This two-phase design exploits both local and global search capabilities and maximizes solution diversity.

5. Data Structures and Incremental Evaluation

To efficiently evaluate local moves, solvers maintain for each clause the list of literals and true-literal counts; for each integer literal, the current margin (for inequalities, $\Delta(\ell) = \sum_i a_i \alpha(x_i) - K$); for each variable, the set of incident clauses. These structures enable constant or low-polynomial time incremental updates after each move, supporting rapid search iterations and statistics tracking (He et al., 2024).

6. Empirical Results and Comparative Performance

On benchmarks from the SMT-LIB QF_LIA, QF_IDL, and QF_NIA tracks, local search solvers (notably LS-IA) dominate on instances containing only integer variables, decisively defeating CDCL(T)-based competitors such as Z3, MathSAT5, CVC5, and Yices2 (Cai et al., 2022):

• QF_LIA (no Booleans): LS-IA solves 6478/6670, Z3 6385, MathSAT5 6442.
• QF_IDL (no Booleans): LS-IA 687/841, Z3 653.
• QF_NIA (no Booleans): LS-IA 12,132/16,439, Z3 11,806.

On mixed-variable problems, local search is somewhat weaker but remains highly complementary, forming effective portfolios with CDCL(T) solvers: a portfolio “Z3+LS-IA” (each run for 600s) solved 14,898 QF_NIA instances vs. 13,765 for Z3 alone.

For solution diversity, HighDiv achieves coverage (unique bit-positions among sampled models) of 92–95% versus 44–71% for MeGASampler and 47–64% for SMTSampler(Int); the inclusion of boundary-aware moves, frequency-based initialization, and stochastic CDCL(T) is empirically essential for these gains (Lai et al., 25 Feb 2025).

Pairwise operations in LS-LIA-Pair provide additional improvements, yielding (over the full QF_LIA benchmark) 1082 total solved instances, only slightly lower than LS-LIA (1122) and substantially higher than MathSAT5 (451), Yices2 (856), or Z3 (510), with complementary instances to CVC5 (He et al., 2024).

7. Extensions, Hybridization, and Future Directions

Local search for SMT(IA) is incomplete but fills a crucial niche in the solver ecosystem: superior on pure arithmetic, effective in sampling diverse models, and highly synergistic with DPLL(T)-based engines. Anticipated directions include:

• Enhanced handling of mixed Boolean-integer instances by integrating clause learning with local search (Cai et al., 2022).
• Generalization of critical-move concepts to real arithmetic and other data types.
• Deeper cooperation with DPLL(T), including the exchange of lemmas and variable activity information (Lipparini et al., 3 Mar 2025).
• Fine-tuned solution diversity metrics and sampling methods, as well as more aggressive exploitation of hybrid local search and portfolio techniques (Lai et al., 25 Feb 2025).

Local search also interfaces naturally with trail-driven SAT extensions such as MCSat, where feasible-set jumping and accelerated hill-climbing strategies (with adaptive per-variable step sizes) directly influence theory decisions and clause learning, as realized in Yices2 for nonlinear integer arithmetic (Lipparini et al., 3 Mar 2025).

A plausible implication is that the toolkit introduced by local search-based approaches—critical and pairwise moves, diversified initialization, dynamic weighting, and tight coupling with conflict-based learning—offers a highly modular foundation for further SMT(IA) algorithmic innovation.