Modularity Aspects of Disjunctive Stable Models
Practically all programming languages allow the programmer to split a program into several modules which brings along several advantages in software development. In this paper, we are interested in the area of answer-set programming where fully declarative and nonmonotonic languages are applied. In this context, obtaining a modular structure for programs is by no means straightforward since the output of an entire program cannot in general be composed from the output of its components. To better understand the effects of disjunctive information on modularity we restrict the scope of analysis to the case of disjunctive logic programs (DLPs) subject to stable-model semantics. We define the notion of a DLP-function, where a well-defined input/output interface is provided, and establish a novel module theorem which indicates the compositionality of stable-model semantics for DLP-functions. The module theorem extends the well-known splitting-set theorem and enables the decomposition of DLP-functions given their strongly connected components based on positive dependencies induced by rules. In this setting, it is also possible to split shared disjunctive rules among components using a generalized shifting technique. The concept of modular equivalence is introduced for the mutual comparison of DLP-functions using a generalization of a translation-based verification method.
💡 Research Summary
The paper addresses the longstanding challenge of achieving modularity in answer‑set programming (ASP), especially for disjunctive logic programs (DLPs) under stable‑model semantics. Traditional modular techniques from imperative or monotonic logic programming do not carry over straightforwardly because the global answer set of a program cannot, in general, be assembled from the answer sets of its parts. To bridge this gap, the authors introduce the concept of a DLP‑function, a syntactic unit equipped with an explicit input set I, an output set O, and a rule set R. This interface makes the flow of information between modules precise and enables formal reasoning about composition.
The central contribution is a new Module Theorem that generalizes the classic splitting‑set theorem. The theorem states that if two DLP‑functions F₁ and F₂ are “compatible” – i.e., the output atoms of one do not appear as inputs of the other – then the stable models of the combined program F₁ ∪ F₂ are exactly the unions of stable models of the individual modules. This compositional property holds even when the modules share disjunctive rules, thanks to a technique called generalized shifting. Generalized shifting transforms a rule with a disjunction in the head into several rules each with a single head atom, while preserving the stable‑model semantics under the positive‑dependency restriction.
The paper further shows how the positive‑dependency graph of a DLP‑function can be decomposed into strongly connected components (SCCs). Each SCC forms a natural submodule, and the Module Theorem guarantees that the overall semantics can be built incrementally by solving SCCs in a topological order. This SCC‑based decomposition is algorithmically useful: it yields a systematic method for breaking down large DLPs into smaller, more tractable pieces.
Beyond compositionality, the authors define modular equivalence: two DLP‑functions are equivalent if, for every admissible input, they produce identical output answer sets. To verify this property, they extend a translation‑based verification approach originally devised for ordinary logic programs. The method translates the equivalence question into a single ASP program whose unsatisfiability (or the absence of a stable model) certifies equivalence. This translation is amenable to existing ASP solvers, making the verification process automated.
The theoretical results are illustrated with concrete examples, including a graph‑coloring problem and a scheduling scenario. By applying SCC decomposition and generalized shifting, the authors demonstrate that the modular approach dramatically reduces memory consumption and solving time compared with monolithic solving.
In conclusion, the paper establishes a robust framework for modular reasoning in disjunctive ASP. It provides formal definitions, a powerful compositional theorem, practical decomposition techniques, and an automated equivalence‑checking procedure. These contributions open the door to more scalable ASP development, easier program maintenance, and the possibility of building large‑scale, distributed ASP systems where modules can be developed, verified, and replaced independently.