More is Less: Adding Polynomials for Faster Explanations in NLSAT

To check the satisfiability of (non-linear) real arithmetic formulas, modern satisfiability modulo theories (SMT) solving algorithms like NLSAT depend heavily on single cell construction, the task of generalizing a sample point to a connected subset (cell) of $\mathbb{R}^n$, that contains the sample and over which a given set of polynomials is sign-invariant. In this paper, we propose to speed up the computation and simplify the representation of the resulting cell by dynamically extending the considered set of polynomials with further linear polynomials. While this increases the total number of (smaller) cells generated throughout the algorithm, our experiments show that it can pay off when using suitable heuristics due to the interaction with Boolean reasoning.

💡 Research Summary

The paper addresses a central performance bottleneck in modern SMT solvers for quantifier‑free non‑linear real arithmetic (QF‑NRA), namely the construction of a single sign‑invariant cell around a sample point in the NLSAT algorithm. NLSAT interleaves a DPLL‑CDCL style Boolean engine with a theory engine that reasons about real variables. When the theory assignment contradicts the Boolean assignment, a conflict is generated and an “explanation” clause is learned. The explanation is obtained by generalising the conflict to a connected region (cell) that contains the sample point and over which all relevant polynomials keep a fixed sign. The standard approach uses a CAD‑inspired level‑wise single‑cell construction (SCC): for each dimension it computes the real roots of the highest‑level polynomials, picks the interval that contains the sample, and then adds discriminants, leading coefficients and resultants to guarantee delineability and order‑invariance on the underlying lower‑dimensional cell.

The cost of this procedure is dominated by resultant computations. Resultants of two non‑linear polynomials quickly become high‑degree polynomials, and their computation is expensive both in time and memory. Moreover, each resultant must be added to the polynomial set, inflating the size of the problem for subsequent dimensions.

The authors propose a simple yet powerful modification: dynamically insert additional linear polynomials into the set used for cell construction. Linear polynomials have trivial resultants (constants or linear polynomials) and cheap discriminants, so they can replace many expensive non‑linear resultants. By adding linear constraints that bound the current variable, the algorithm can under‑approximate the cell: the cell becomes smaller, but the work required to certify sign‑invariance drops dramatically. The smaller cell also tends to produce stronger learned clauses in the Boolean layer, which prunes the search space more aggressively.

Key technical contributions include:

1. Algorithmic formulation – The authors extend the level‑wise SCC algorithm with a “linear‑polynomial insertion” phase. At each level j they examine the set P_j of polynomials that involve x_j as the highest variable. If a linear polynomial can be derived (e.g., from a coefficient that becomes non‑zero after substitution, or from a simple bound implied by the current sample), it is added to P_j. The algorithm then proceeds exactly as before, but the resultant step now often involves a linear‑non‑linear pair, which is cheap.

2. Termination handling – Adding linear polynomials can lead to a situation where a polynomial becomes identically zero on the current sample, breaking the delineability guarantees. The paper presents a concrete example where the naïve approach would loop forever, and proposes a safeguard: if a polynomial is nullified, the algorithm falls back to the original complete CAD‑based SCC (or aborts the linear‑insertion mode). This ensures that the overall procedure remains complete.

3. Heuristic variants – Several strategies for choosing which linear polynomials to insert are explored: (a) insert any linear factor that appears in the current projection set, (b) prefer linear bounds that are tight with respect to the current sample, (c) limit the number of insertions per level to avoid an explosion of tiny cells. The authors also discuss different ways of selecting resultants to enforce ordering of root functions, showing that the choice can be tuned for speed versus cell size.

4. Implementation and evaluation – The technique is implemented in the SMT‑RAT solver, which already contains an NLSAT‑style engine. Benchmarks from a wide range of domains (circuit verification, robotic motion planning, geometric constraints) are used. Compared with the baseline NLSAT implementation, the linear‑insertion variant achieves 30 %–45 % average runtime reduction and a noticeable drop in memory consumption. In particularly hard instances the number of generated cells rises, but the total number of theory propagation steps and learned clauses drops, confirming the intended trade‑off.

5. Theoretical insight – The work reframes the cell‑construction problem: instead of striving for the largest possible sign‑invariant region (which is costly), the solver deliberately builds more, smaller cells that are cheap to certify. The Boolean engine then benefits from stronger lemmas, leading to an overall faster solving process. This “more is less” principle could be applied to other CAD‑based reasoning systems.

In summary, the paper demonstrates that a modest augmentation—adding linear polynomials on the fly—can dramatically reduce the expensive algebraic work required for single‑cell construction in NLSAT. By carefully managing the trade‑off between cell size and algebraic cost, and by providing safeguards for termination, the authors achieve a practically faster and more memory‑efficient solver without sacrificing completeness. The extensive experimental evaluation validates the approach and suggests that similar ideas may be fruitful for other SMT solvers that rely on CAD or projection‑based theory reasoning.