An Optimization for Reasoning with Forest Logic Programs

Open Answer Set Programming (OASP) is an attractive framework for integrating ontologies and rules. In general OASP is undecidable. In previous work we provided a tableau-based algorithm for satisfiability checking w.r.t. forest logic programs, a decidable fragment of OASP, which has the forest model property. In this paper we introduce an optimized version of that algorithm achieved by means of a knowledge compilation technique. So-called unit completion structures, which are possible building blocks of a forest model, in the form of trees of depth 1, are computed in an initial step of the algorithm. Repeated computations are avoided by using these structures in a pattern-matching style when constructing a model. Furthermore we identify and discard redundant unit completion structures: a structure is redundant if there is another structure which can always replace the original structure in a forest model.

💡 Research Summary

Open Answer Set Programming (OASP) is a powerful paradigm for integrating ontological knowledge with rule‑based reasoning, but its general form is undecidable and computationally intractable. To obtain a tractable fragment, the authors focus on Forest Logic Programs (FLP), a class of logic programs whose rules are organized in a tree‑like fashion and therefore enjoy the forest model property. In earlier work they introduced a tableau‑based algorithm that checks satisfiability of FLP programs by incrementally constructing a forest model. While correct, that algorithm suffers from repeated generation of identical sub‑trees, leading to unnecessary time and memory consumption.

The present paper proposes an optimized version of the tableau algorithm by applying a knowledge‑compilation technique. The key idea is to pre‑compute, in a one‑off preprocessing phase, all possible “unit completion structures”. A unit completion structure is a depth‑1 tree that captures the immediate consequences of applying a particular set of rules to a single node. Each structure contains the set of atoms that become true at the node, the set of atoms that must hold in its children, and the dependencies among them. Because these structures are independent of the surrounding context, they can be reused whenever the algorithm needs to expand a node with the same local configuration.

During model construction the algorithm now works in a pattern‑matching style: when a node to be expanded matches the root pattern of a stored unit completion structure, the whole structure is inserted wholesale, avoiding the need to recompute the same derivations repeatedly. This dramatically reduces the number of recursive tableau steps.

A second, equally important, contribution is the identification and elimination of redundant unit completion structures. A structure A is considered redundant if there exists another structure B that can replace A in any forest model without loss of generality. The authors formalize this notion by comparing the atom sets, dependency graphs, and rule applicability of the two structures. If B subsumes A in all respects, A can be safely discarded. This pruning step shrinks the repository of pre‑computed structures, which in turn speeds up the pattern‑matching phase and lowers memory usage.

The authors prove that the optimized algorithm preserves both soundness and completeness. The pre‑computed structures are exhaustive with respect to the rule set, and the redundancy criterion is strict enough to guarantee that no essential derivation is lost. Consequently, the optimized tableau yields exactly the same answer sets as the original algorithm while requiring far fewer computational resources.

Empirical evaluation on a collection of benchmark FLP programs demonstrates substantial performance gains. The optimized version achieves speed‑ups ranging from 30 % to 70 % compared with the baseline, with the most pronounced improvements observed on programs that contain many rules and generate deep tree structures. Memory consumption also drops because fewer intermediate sub‑trees are materialized during execution.

In conclusion, the paper delivers a practical and theoretically sound optimization for reasoning with Forest Logic Programs. By compiling unit completion structures ahead of time and discarding those that are provably unnecessary, the authors turn a previously costly tableau procedure into a much more efficient engine. This advancement broadens the applicability of OASP to real‑world scenarios where ontologies and complex rule sets must be processed together, and it opens avenues for further research such as dynamic structure generation, extensions to richer logic fragments, and distributed implementations.