Speeding up SAT solver by exploring CNF symmetries : Revisited

Boolean Satisfiability solvers have gone through dramatic improvements in their performances and scalability over the last few years by considering symmetries. It has been shown that by using graph symmetries and generating symmetry breaking predicates (SBPs) it is possible to break symmetries in Conjunctive Normal Form (CNF). The SBPs cut down the search space to the nonsymmetric regions of the space without affecting the satisfiability of the CNF formula. The symmetry breaking predicates are created by representing the formula as a graph, finding the graph symmetries and using some symmetry extraction mechanism (Crawford et al.). Here in this paper we take one non-trivial CNF and explore its symmetries. Finally, we generate the SBPs and adding it to CNF we show how it helps to prune the search tree, so that SAT solver would take short time. Here we present the pruning procedure of the search tree from scratch, starting from the CNF and its graph representation. As we explore the whole mechanism by a non-trivial example, it would be easily comprehendible. Also we have given a new idea of generating symmetry breaking predicates for breaking symmetry in CNF, not derived from Crawford’s conditions. At last we propose a backtrack SAT solver with inbuilt SBP generator.

💡 Research Summary

The paper revisits the well‑known technique of exploiting symmetries in Boolean satisfiability (SAT) problems to accelerate solving. It begins by recalling that many CNF formulas, especially those originating from hardware verification or automated theorem proving, contain a substantial amount of structural symmetry: permutations of variables that leave the set of clauses unchanged. Such symmetries cause conventional SAT solvers to explore many redundant assignments, inflating the search tree and runtime.

Traditional symmetry‑breaking predicates (SBPs) are generated by converting the CNF into a colored graph, computing the graph’s automorphism group (e.g., with NAUTY), and then applying the Lex‑leader construction of Crawford et al. (1996). The Lex‑leader method enforces a total order on variables for each generator of the automorphism group and produces a set of clauses that eliminate all but the lexicographically smallest assignment in each orbit. While sound, this approach can become cumbersome for large formulas because it requires a global ordering and often yields a large number of auxiliary clauses.

The authors propose a different, “manual” SBP generation scheme that does not rely on the Lex‑leader ordering. After obtaining the automorphism group of the CNF‑derived graph, each generator is examined for its mapped variable pairs. For every pair (x_i, x_j) that is swapped by a generator, a simple inequality predicate (x_i ≤ x_j) is created. All such predicates for a generator are conjunctively combined to form a partial SBP; the final SBP is the conjunction of the partial SBPs of all generators. This construction is algorithmically straightforward: it iterates over generators, multiplies the corresponding literals, and produces a single conjunctive clause that can be appended to the original CNF. The authors argue that this method requires far fewer arithmetic operations and produces a more compact set of SBPs than the Lex‑leader approach.

To illustrate the whole pipeline, the paper presents a non‑trivial example with five Boolean variables and three clauses. The CNF is first transformed into a bipartite graph where clause vertices are connected to literal vertices; complementary literals are also linked. Using NAUTY, the authors compute the automorphism group, perform partition refinement to identify non‑singleton cells, and select a target cell for further refinement. The resulting automorphisms reveal a symmetry between certain variable pairs. Applying the manual SBP algorithm yields a set of inequality predicates that, when conjoined with the original CNF, prune the search tree dramatically. A truth table is shown where assignments that violate the SBP have value 0; these rows are eliminated from the search. The authors display the original search tree and the pruned tree (rounded‑corner boxes indicate eliminated sub‑trees), demonstrating a clear reduction in explored nodes.

Beyond the example, the paper proposes a backtrack SAT solver that incorporates SBP generation as an internal module. The solver’s workflow is: (1) read the CNF, (2) build the graph, (3) run NAUTY to obtain automorphisms, (4) generate SBPs using the manual algorithm, (5) perform a standard backtrack search on the augmented formula. Because SBP generation is embedded, users need only supply the CNF; the solver automatically handles symmetry detection and breaking.

Experimental data are limited to the five‑variable example. The authors report that without symmetry detection the solver would have to examine up to 2⁵ = 32 assignments, while symmetry breaking reduces the number of necessary assignments to 24 (the exact figure depends on the specific symmetry). They claim that for larger formulas the reduction would be far more significant, as the search tree size shrinks proportionally to the number of eliminated symmetric orbits.

In the conclusion, the authors summarize their contributions: a clear, step‑by‑step exposition of symmetry breaking from graph construction to SBP insertion, a novel manual SBP generation algorithm that avoids the complexity of Lex‑leader clauses, and a design for a backtrack SAT solver with an integrated SBP generator. They acknowledge that the current work is largely illustrative and that future work should include a full implementation of the solver, extensive benchmarking against state‑of‑the‑art SAT solvers, and exploration of techniques to reduce the overhead of automorphism detection on large instances.

Overall, the paper offers a pedagogical walkthrough of symmetry exploitation in SAT and proposes a simpler SBP construction method. While the idea of using inequality predicates is not new in the symmetry‑breaking literature, the presented algorithm is concise and may be attractive for educational purposes or for SAT solvers that prioritize minimal preprocessing overhead. However, the lack of empirical evaluation on realistic benchmark suites limits the ability to assess the practical impact of the proposed method. Future work should address scalability, compare the manual SBPs against Lex‑leader SBPs in terms of clause count and solving time, and integrate the approach into a modern CDCL solver to gauge real‑world benefits.