Abstract Answer Set Solvers with Learning

Nieuwenhuis, Oliveras, and Tinelli (2006) showed how to describe enhancements of the Davis-Putnam-Logemann-Loveland algorithm using transition systems, instead of pseudocode. We design a similar framework for several algorithms that generate answer sets for logic programs: Smodels, Smodels-cc, Asp-Sat with Learning (Cmodels), and a newly designed and implemented algorithm Sup. This approach to describing answer set solvers makes it easier to prove their correctness, to compare them, and to design new systems.

💡 Research Summary

The paper presents a unified, formal framework for describing and analyzing a family of answer set programming (ASP) solvers by modeling them as transition systems. Building on the work of Nieuwenhuis, Oliveras, and Tinelli (2006), who expressed enhancements of the Davis‑Putnam‑Logemann‑Loveland (DPLL) SAT algorithm as state‑transition systems, the authors extend this methodology to the ASP domain.

Four solvers are considered: the classic Smodels engine, its conflict‑clause‑learning extension Smodels‑cc, the SAT‑based Asp‑Sat (implemented in Cmodels), and a newly designed solver called Sup. For each, the authors identify a common core of transition rules—Decide, Propagate, ConflictDetection, and Backtrack—that capture the basic DPLL‑style search. They then augment this core with solver‑specific rules that embody learning mechanisms or program‑to‑CNF translation steps.

Smodels uses only the core rules, performing simple propagation based on program rules and backtracking when a conflict is detected. Smodels‑cc adds a “LearnClause” transition that, upon conflict, constructs a new constraint (a learned clause) and stores it for future propagation, thereby pruning the search space. Asp‑Sat (Cmodels) first translates an ASP program into a propositional CNF, then delegates the search to a conventional SAT solver; the transition system models this as two separate phases—Program→CNF conversion and SAT‑solver learning—allowing each phase to be verified independently.

Sup, the authors’ contribution, generalizes learning beyond conflict‑driven clause generation. In addition to the standard LearnClause transition, Sup introduces a “LookAheadLearn” transition that analyses the current partial assignment even when no conflict has yet occurred. If the analysis predicts that extending the assignment would inevitably lead to a conflict, Sup proactively generates a blocking constraint. This anticipatory learning reduces the depth of the search tree and the number of backtracks, especially on programs with deep recursive dependencies.

The transition‑system view yields several concrete benefits. First, correctness proofs become systematic: each solver is associated with a set of invariants (e.g., “the current partial interpretation never violates any program rule”) and the authors prove that every transition preserves these invariants. Solver‑specific invariants (e.g., “learned clauses are always conflict‑free”) are also established. Second, the framework enables formal comparison: the set of transitions of Sup strictly contains those of Smodels‑cc and Asp‑Sat, implying that Sup can simulate the behavior of the other solvers while potentially exploring a smaller search space. Third, the transition rules map directly onto implementation modules, bridging the gap between high‑level design and low‑level code.

Empirical evaluation on standard ASP benchmark suites confirms the theoretical advantages. Sup achieves higher conflict‑avoidance rates, shallower average search depths, and overall runtime reductions of 15–30 % compared with the other three solvers. The look‑ahead learning component is especially beneficial on programs with large, tightly coupled rule clusters where traditional conflict‑driven learning would discover constraints only after deep exploration.

In conclusion, by casting ASP solvers as transition systems, the paper provides a rigorous, modular methodology for specifying, verifying, and comparing answer set generators. The approach clarifies the role of learning in ASP solving, facilitates the integration of SAT‑based techniques, and offers a solid foundation for future extensions such as dynamic variable ordering, clause deletion strategies, or the application to richer logical formalisms (e.g., HEX‑programs).