💻 computer science

Disjoint Projected Enumeration for SAT and SMT without Blocking Clauses

This paper introduces two novel solvers, tabularAllSAT and tabularAllSMT, which utilize conflict-driven clause learning with chronological backtracking and an aggressive implicant shrinking algorithm to efficiently enumerate disjoint satisfying assignments for SAT and SMT problems without relying on blocking clauses.

Original authors: Giuseppe Spallitta, Roberto Sebastiani, Armin Biere

Published 2026-05-11

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Giuseppe Spallitta, Roberto Sebastiani, Armin Biere

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are a detective trying to find every single possible combination of clues that solves a massive, complex mystery. In the world of computer science, this "mystery" is a logical formula, and the "clues" are true/false settings for various variables. This task is called AllSAT (finding all solutions) or AllSMT (finding all solutions when the clues involve math or other complex rules).

The paper you provided introduces two new tools, TabularAllSAT and TabularAllSMT, designed to solve this detective work much faster and more efficiently than previous methods. Here is how they work, explained through simple analogies.

The Problem: The "Blocking" Bottleneck

Traditionally, when a computer finds one solution to a puzzle, it needs to make sure it doesn't find that exact same solution again.

The Old Way (Blocking Clauses): Imagine the detective finds a solution, writes it down, and then puts a giant "DO NOT ENTER" sign (a blocking clause) on that specific path. They then go back to the start and try again.
- The Flaw: If there are millions of solutions, the detective ends up covering the entire map with millions of "DO NOT ENTER" signs. Eventually, the map becomes so cluttered with signs that the detective gets confused, slows down, and runs out of room to write them all. This is the "memory blowup" the paper mentions.

The Solution: The "Chronological" Walk

The authors propose a smarter way to walk through the puzzle without needing those "DO NOT ENTER" signs.

The New Way (Chronological Backtracking): Instead of putting up signs, the detective walks through the puzzle systematically. When they hit a dead end or find a solution, they simply step back one step to the last decision they made, flip that decision (like turning a switch from "On" to "Off"), and keep walking.
- The Benefit: Because they walk in a strict, orderly line (like reading a book page by page), they naturally never visit the same spot twice. No signs are needed, so the map stays clean, and the detective never gets overwhelmed by clutter.

The "Shrinking" Trick: Finding the Core

Once the detective finds a full solution (where every single clue has a value), they realize they don't actually need every clue to prove the solution works. Maybe only 3 out of 10 clues were essential; the other 7 could be anything.

The Old Shrinking: Previous methods were cautious. They would only remove clues if they were absolutely sure it was safe, often leaving extra "dead weight" in the solution.
The New "Aggressive" Shrinking: The authors created a new algorithm that acts like a ruthless editor. It looks at the solution and asks, "Can I remove this clue without breaking the logic?" If yes, it cuts it out immediately.
- The Result: Instead of returning a long, messy list of 10 clues, the computer returns a tiny, compact list of just the 3 essential clues. This drastically reduces the amount of data the computer has to process and store.

Handling "Important" vs. "Unimportant" Variables (Projection)

Sometimes, the detective only cares about specific clues (e.g., "Who stole the cookie?") and doesn't care about others (e.g., "What color was the sky?").

The Challenge: If the computer solves the whole puzzle including the sky color, it wastes time.
The Fix: The new tools are taught to prioritize the "Important" clues. They solve the puzzle but ignore the "Unimportant" ones entirely. It's like solving a maze but only caring about the path to the exit, not the decorations on the walls. This makes the search much faster.

Handling Math and Complex Rules (SMT)

So far, we've talked about simple True/False switches. But real-world problems often involve math (like "x + y > 10").

The Extension: The authors upgraded their detective to handle these math rules. They added a "Math Consultant" (a theory solver) to the team.
- When the detective makes a guess, they ask the Math Consultant, "Does this make sense with the math rules?"
- If the math says "No," the detective immediately steps back and tries a different path, rather than wasting time walking down a path that is mathematically impossible.

The Bottom Line

The paper claims that by combining a strict, orderly walking style (Chronological Backtracking) with a ruthless editing style (Aggressive Shrinking), their new tools (TabularAllSAT and TabularAllSMT) are significantly faster and use less memory than the current best tools.

They don't get cluttered with "Do Not Enter" signs.
They return smaller, cleaner answers by cutting out unnecessary details.
They handle complex math without getting stuck.

The authors tested these tools against the best competitors and found that their approach solved more problems, faster, especially when the problems were huge or involved complex math.

Technical Summary: Disjoint Projected Enumeration for SAT and SMT without Blocking Clauses

Problem Statement

The paper addresses the computational challenges inherent in All-Solution Satisfiability (AllSAT) and its extension, All-Solution Satisfiability Modulo Theories (AllSMT). The objective is to enumerate all satisfying assignments of a formula. While traditional SAT solving terminates upon finding a single solution, enumeration requires exploring the entire search space.

Two primary difficulties are identified:

Exponential Search Space: For a formula with $n$ variables, there are $2^n$ possible total assignments. Explicit enumeration is infeasible for large $n$ . The paper advocates for partial assignments (implicants) to represent sets of total assignments, thereby compressing the solution space.
Blocking Clauses and Memory: Traditional AllSAT solvers based on Conflict-Driven Clause Learning (CDCL) and Non-Chronological Backtracking (NCB) rely on adding blocking clauses to prevent the re-discovery of the same model. As the number of models grows, the number of blocking clauses can become exponential, leading to memory blowups and degraded unit propagation performance.
Projection: In many applications (e.g., converting non-CNF formulas via Tseitin transformation), it is necessary to enumerate solutions only for a subset of "important" variables ( $V_r$ ), ignoring auxiliary "irrelevant" variables ( $V_i$ ).

The paper focuses on disjoint enumeration, where repeated assignments are strictly prohibited, a requirement for applications like Weighted Model Integration (WMI) and probabilistic inference.

Methodology

The authors propose two novel solvers: TabularAllSAT (for propositional logic) and TabularAllSMT (for SMT). Both integrate CDCL with Chronological Backtracking (CB) to eliminate the need for blocking clauses while maintaining disjointness.

1. Core Search Algorithm (CDCL + CB)

The search loop combines the strengths of CDCL (escaping unsatisfiable regions via conflict analysis) and CB (systematic exploration without redundant blocking clauses).

Conflict Handling: When a conflict is detected, the solver performs standard conflict analysis to derive a conflict clause. However, instead of jumping back non-chronologically to the level of the conflict clause (as in standard CDCL), the solver chronologically backtracks to the most recently assigned decision literal and flips its value.
Implicit Blocking: To ensure disjointness without storing explicit blocking clauses, the solver utilizes virtual backtrack reason clauses. When a model is found and a decision literal is flipped, the reason for the flip is recorded as Backtrue. This implicitly defines a blocking clause consisting of the negation of all decision literals up to that point.
Termination: The search terminates when the solver backtracks to decision level 0, ensuring the entire space has been systematically scanned without repetition.

2. Chronological Implicant Shrinking

A critical component is the reduction of total assignments into compact partial assignments (implicants). The paper introduces two algorithms:

Conservative Shrinking (Baseline): Based on 2-watched literals, this algorithm checks if a literal is necessary for the current partial assignment to satisfy the formula. It respects the decision order and the Backtrue flags to ensure disjointness.
Aggressive Shrinking (Novel): This algorithm simulates an optimal decision ordering. It identifies "necessary" literals (those required to satisfy specific clauses) and "unnecessary" literals. It allows the removal of unnecessary literals regardless of their decision level, provided they are not marked with Backtrue or involved in conflict analysis. This is achieved by:
1. Counting how many literals in each clause are currently in the trail.
2. Iteratively removing literals that are not the sole satisfier of any clause.
3. Reconstructing the trail with only the necessary literals, effectively deferring the assignment of unnecessary variables to the end of the search loop.

3. Extensions to Projection and SMT

Projected Enumeration: The algorithm is adapted to handle a subset of relevant variables ( $V_r$ ). The decision heuristic prioritizes $V_r$ over irrelevant variables ( $V_i$ ). During implicant shrinking, literals corresponding to $V_i$ are automatically discarded, ensuring the output contains only assignments for $V_r$ .
AllSMT Integration: The framework integrates a theory solver (MathSAT5). The search loop includes a T-consistency check after unit propagation. If a theory conflict arises, it is analyzed similarly to a Boolean conflict, and the solver backtracks chronologically. Theory atoms generated during solving are treated as irrelevant variables for projection purposes.

Key Contributions

The paper outlines five primary contributions:

Disjoint Partial Enumeration: A procedure combining CDCL and Chronological Backtracking to enumerate disjoint partial models without introducing blocking clauses.
Implicant Shrinking Algorithms: Two algorithms (conservative and aggressive) designed to minimize partial assignments while strictly adhering to the disjointness constraints of the underlying calculus.
Projected Enumeration Extension: Adaptation of the solver to enumerate only a subset of important variables, handling auxiliary variables introduced during CNF transformation.
SMT Extension: Integration of theory reasoning into the enumeration framework, enabling AllSMT solving with disjoint partial enumeration.
Experimental Evaluation: A comprehensive benchmarking against state-of-the-art solvers.

Experimental Results

The authors evaluated TabularAllSAT and TabularAllSMT on various benchmarks (random 3-SAT, SATLIB, synthetic SMT, and non-CNF formulas) against solvers including MathSAT5, Dualiza, BDD-based solvers, and D4+ModelGraph.

Implicant Shrinking: The novel aggressive shrinking algorithm significantly reduced the number of partial assignments generated compared to the conservative baseline, particularly on instances with a high number of total solutions. While it incurred a slight overhead on very small instances, it improved overall execution time on larger problems.
AllSAT Performance: TabularAllSAT performed competitively or superiorly to most solvers (BC, NBC, MathSAT5). It was outperformed by knowledge compilation tools (BDD, D4+ModelGraph) on specific benchmarks with few clauses where compilation overhead was low. However, TabularAllSAT demonstrated a lower memory footprint and did not experience timeouts due to memory exhaustion.
Projected AllSAT: On non-CNF benchmarks requiring projection, TabularAllSAT significantly outperformed MathSAT5 and Dualiza in both speed and the number of instances solved. It also surpassed D4+ModelGraph on harder synthetic benchmarks.
AllSMT Performance: TabularAllSMT outperformed MathSAT5 (the only other publicly available projected AllSMT solver) in total enumeration and partial enumeration tasks. The absence of blocking clauses in TabularAllSMT prevented the performance degradation observed in MathSAT5 as problem complexity increased.

Significance and Claims

The paper claims that the proposed approach offers a superior alternative to traditional blocking-clause-based enumeration, particularly in scenarios requiring projection and SMT reasoning.

Efficiency: By avoiding the exponential growth of blocking clauses, the solver maintains stable unit propagation performance and avoids memory blowups.
Compactness: The aggressive implicant shrinking algorithm produces more compact partial assignments, reducing the output size and the search space for subsequent enumeration steps.
Generality: The framework successfully unifies CDCL and Chronological Backtracking for both propositional and theory-based enumeration, extending the applicability of disjoint enumeration to complex domains like probabilistic inference and model counting over first-order theories.

The authors position their work as a practical realization of the formal calculus presented in [17], providing the first implementation that effectively handles projection and SMT without the overhead of blocking clauses.