Relativized hyperequivalence of logic programs for modular programming

A recent framework of relativized hyperequivalence of programs offers a unifying generalization of strong and uniform equivalence. It seems to be especially well suited for applications in program optimization and modular programming due to its flexibility that allows us to restrict, independently of each other, the head and body alphabets in context programs. We study relativized hyperequivalence for the three semantics of logic programs given by stable, supported and supported minimal models. For each semantics, we identify four types of contexts, depending on whether the head and body alphabets are given directly or as the complement of a given set. Hyperequivalence relative to contexts where the head and body alphabets are specified directly has been studied before. In this paper, we establish the complexity of deciding relativized hyperequivalence with respect to the three other types of context programs. To appear in Theory and Practice of Logic Programming (TPLP).

💡 Research Summary

The paper introduces and thoroughly investigates the notion of relativized hyperequivalence for logic programs, a concept that generalizes both strong equivalence and uniform equivalence while allowing independent restrictions on the head and body alphabets of context programs. This flexibility makes the framework particularly attractive for program optimization and modular programming, where developers often need to control which atoms may appear in the heads of added rules and which may appear in their bodies.

Three well‑known semantics of logic programs are considered: stable model semantics, supported model semantics, and supported minimal model semantics. For each semantics the authors define four families of context programs, determined by whether the head alphabet H and the body alphabet B are given directly (as an explicit set of atoms) or as the complement of a given set (i.e., all atoms except those listed). Consequently the four context types are (direct, direct), (direct, complement), (complement, direct), and (complement, complement). Prior work had only addressed the (direct, direct) case, establishing that the decision problem is Π₂^P‑complete for stable and supported‑minimal semantics, and coNP‑complete for supported semantics.

The main contribution of the paper is to determine the exact computational complexity of relativized hyperequivalence for the remaining three context families under each of the three semantics. The results can be summarized as follows:

• Stable model semantics
  – (direct, complement) and (complement, direct) are Π₂^P‑complete.
  – (complement, complement) is also Π₂^P‑complete, although in certain degenerate situations (e.g., empty head alphabet) the problem drops to coNP‑complete.

• Supported model semantics
  – Both (direct, complement) and (complement, direct) are coNP‑complete.
  – (complement, complement) remains coNP‑complete, showing that allowing only “non‑specified” atoms does not simplify the problem.

• Supported minimal model semantics
  – (direct, complement) and (complement, direct) are Π₂^P‑complete.
  – (complement, complement) is Π₂^P‑complete as well; the authors note that for restricted subclasses such as Horn programs the complexity may shift to Σ₂^P‑complete, suggesting a nuanced landscape.

The complexity proofs consist of two complementary parts. For the upper bounds, the authors construct polynomial‑time reductions from the relativized hyperequivalence problem to quantified Boolean formulas (QBF) of appropriate quantifier depth, or to previously studied equivalence problems whose complexity is already known. For the lower bounds, they perform reductions from known Π₂^P‑hard or coNP‑hard problems (e.g., QBF‑SAT, minimal model checking) to specially crafted logic programs that encode the original instance while respecting the head/body alphabet restrictions. The handling of complement alphabets is particularly delicate: the reduction must ensure that atoms not allowed in a given position are effectively blocked, which is achieved by adding “guard” rules that force any forbidden atom to lead to inconsistency.

Beyond the theoretical results, the paper discusses the practical implications for modular programming. When a module’s interface specifies a set of output atoms (head alphabet) and a set of permissible input atoms (body alphabet), the relevant context type is often (direct, complement). The Π₂^P‑completeness for stable semantics indicates that any automated tool for checking module replacement or optimization must contend with a second‑level polynomial hierarchy problem, typically requiring SAT‑solver based techniques, QBF solvers, or heuristic approximations. Conversely, for supported semantics the problem stays in coNP, which is more amenable to standard SAT‑based model checking.

The authors also explore the effect of the most restrictive context, (complement, complement), which corresponds to “no external atoms may appear at all”. Even in this extreme case the decision problem does not become easier, underscoring that the difficulty stems from the interaction between the program’s own rules and the quantifier structure imposed by the equivalence definition, rather than merely from the size of the alphabet.

In the concluding section, several avenues for future work are outlined: (i) refining the complexity landscape for specific syntactic subclasses such as Horn, stratified, or head‑cycle‑free programs; (ii) implementing prototype tools that exploit the identified complexity bounds and evaluating them on real‑world answer‑set programming benchmarks; (iii) extending the relativized hyperequivalence framework to non‑monotonic extensions that incorporate preferences, aggregates, or external atoms; and (iv) investigating whether the framework can be integrated into existing modular development environments to provide automated verification of module replacements.

Overall, the paper makes a substantial contribution by completing the complexity picture for relativized hyperequivalence across all meaningful context configurations and three central semantics. It bridges a gap between abstract equivalence theory and the concrete needs of modular logic programming, offering both rigorous theoretical insights and a roadmap for practical tool development.