Reasoning with Infinite stable models

1. Reasoning with Infinite stable models Piero A. Bonatti presented by Axel Polleres http://sansone.crema.unimi.it/~bonatti/pub/ijcai01.pdf (IJCAI 2001, full version to appear in AIJ)

2. Finitary normal logic programs • A class of normal logic programs (logic programs with negation in the bodies), such that: • Domain may be infinite • But: credulous and skeptical entailment under the stable semantics is still computable • A form of compactness holds • Problem solving below the second level of the polynomial hierarchy (answer set programming with finite domains) to all semi-decidable problems

3. Answer Set Programming • Here: logic programming with negation as failure under the stable model semantics • Answer set solvers currently successfully used to solve search problems (with finite domains) but deal only with function-free programs • Aim of the paper: How to overcome limitations by introducing function symbols • But: Unlimited use of function symbols leads to undecidability…

4. In this paper: finitary programs • Identify a very expressive fragment of normal logic programs whose non-ground credulous and skeptical consequences under stable semantics are r.e.-complete and a form of compactness holds • This fragment generalizes acyclic programs and can effectively deal with function symbols and recursion • Existing reasoners only need slight modifications! • Since the theory underlying finitary programs shows how to answer queries using only a strict subset of the program’s ground instantiation, and since program instantiation is one of the most expensive computations for existing engines, the techniques developed for finitary programs may increase performance of solvable problems, even in the absence of function symbols.

5. Overview • Preliminaries • Conditions for finitary programs • Example • Theoretical Properties • Recognizing finitary programs • How to apply existing inference engines • Conclusions • Relevant for us?

6. Preliminaries (1) • A normal Logic Program is a set of rules: where A is an (FO) atom and Liare literals. • The GL-Reduct PIof a program P wrt. a Herbrand Interpretation I is the program obtained by removing from Ground(P) all rules with negative body literals which are in I and removing negative body literals from all remaining rules. • M is a stable model of P if M is a minimal model of PM • A formula F is credulously (sceptically) true if it is true in some (any) stable model. Head Body

7. Preliminaries (2) • Dependency Graph: Graph over the ground atoms of P with edges from A to B labeled "+" ("-") if B appears positively (negatively) in some rule of Ground (P) • A ≥+ B respectively A ≥−B if there is a directed path from A to B in the dependency graph with an even (respectively odd) number of negative edges • each atom depends positively on itself (A ≥+ A) • we write A ≥B if either A ≥+B or A ≥−B • we write A ≥±B if A ≥+B and A ≥−B Particularly, programs with odd-cycles, that is, cycles with an odd number of negative edges, are problematic, since they may "kill" stability of models: Simplest odd-cycle: p(X) :- not p(X).

8. Finitary programs: What makes inferences hard Inference/query answering for normal programs is not r.e. because of two factors: Unrestricted recursion with function symbols makes positive programs Turing equivalent Odd-cycles in the dep. Graph play a nasty role in query answering: the stable model semantics does not enjoy the property of relevance, that is, a goal G cannot be answered using only the rules which G depends syntactically on: example: and there can be (due to function symbols) infinitely many odd-cycles. Idea: If odd-cycles are finitely many and recursion is terminating, then queries can be answered using a finite program of the program instantiation!

9. Finitary programs: Definition In other words, the cardinality of {B | A ≥B} must be finite for all A. This typically holds for most classical definitions of predicates on recursive structures such as lists, where each terms of body literals also occur in the head, often as strict sub-terms of the head's arguments, e.g.: The class of finitary programs can now be defined as follows:

10. Example: QBF Satisfiability: QBFs are propositional formulae where quantifiers are allowed over propositions, e.g.: Defines satisfiability of a QBF Defines an infinite set of constants Given a QBF q and an environment I defining all free variables in q, I satisfies q iff qbf(q,I) is in the unique stable model of the above program, where q is encoded accordingly.

11. Theoretical Properties: For finitary programs, all queries can be correctly answered by reasoning with a finite portion of Ground(P ), called the relevant subprogram!

12. Theoretical Properties: What follows: 1) whether a ground formula F is a credulous or skeptically consequence of a program P depends only on R(P,F). 2) Compactness, i.e. if you find a finite inconsistent subprogram in P, then there is no stable model:

13. Theoretical Properties: • For ground goals and finitary programs deciding skeptical/credulous entailment is decidable • For non-ground goals and finitary programs deciding skeptical/credulous existential entailment is semi-decidable • Note that existential entailment CAN be undecidable, i.e. not rec. enumerable if the program is not finitary!

14. Recognizing finitary programs • Here comes the bad news: Deciding whether a program is finitary is undecidable by itself  (each condition by itself is undecidable) • But: We know that we can safely extend pure Datalog with things like list operators (membership, appending, etc.) • Idea: Tool to recognize "typical recursion patterns" at least (sound, but incomplete of course…)

15. Recognizer & Reasoner, roughly: Finitary program recognizer: • Identify potentially cyclic atom dependencies • Recursive domain predicate identification (similar to notion of safety of rules, but identifying "safety" in terms of recursion) • Check for potential odd-cycles on potentially recursive rules Reasoner: • There's an XSB based implementation of a skeptical resolution calculus algorithm. • The author proposes how to integrate with current Stable Model semantics Engines (by beforehand computing R(F,P))

16. Relevant for WSMO Reasoner? • When taking Horn rules or well-founded semantics, only the first part of the definition of finitary is relevant. • Might increase efficiency of Stable Model Semantics Reasoners in general (sounds in this sense related/combinable with techniques such as magic sets? Didn't think that through in detail) • The recognizer for finitary programs seems interesting!