Tight Logic Programs

This note is about the relationship between two theories of negation as failure -- one based on program completion, the other based on stable models, or answer sets. Francois Fages showed that if a logic program satisfies a certain syntactic condition, which is now called ``tightness,'' then its stable models can be characterized as the models of its completion. We extend the definition of tightness and Fages' theorem to programs with nested expressions in the bodies of rules, and study tight logic programs containing the definition of the transitive closure of a predicate.Comment: To appear in Special Issue of the Theory and Practice of Logic Programming Journal on Answer Set Programming, 200

Cmodels for Tight Disjunctive Logic Programs

Disjunctive logic programming under the stable model semantics [GL91] is a new answer set programming (ASP) methodology for solving combinatorial search problems. It is a form of declarative programming related to logic programming languages, such as Prolog, where the solutions to a problem are represented by answer sets, and not by answer substitutions produced in response to a query as in convential logic programming. Instead of Prolog systems, this programming method uses answer set solvers, such as smodels1, smodelscc2, cmodels3, dlv4, and gnt1. These systems made it possible for ASP to be successfully applied in such areas as planning, bounded model checking, and space shuttle control. dlv and gnt are more general as they work with the class of disjunctive logic programs, while other systems cover nondisjunctive programs. System cmodels uses SAT solvers as search engines, which allows it to take advantage of rapid progress in the area of SAT. cmodels proved to be an efficient system in providing the solution to the wire-routing problem [EW04], and to the problem of reconstructing probable phylogenies in the area of historical linguistics [BEMR05]. In this work we extend cmodels [GLM04] to tight disjunctive programs. Complexity of finding a solution for such programs is NP, as in the case of nondisjunctive programs. Extending the syntax of the input language of cmodels to tight disjunctive programs permits the knowledge engineer to be more flexible with the encoding of the problems in the NP complexity class. Experimental analyses demonstrate that the approach is computationally promising and may advance applications of disjunctive logic programming

Computing Answer Sets of a Logic Program via-enumeration of SAT certificates

Answer set programming is a new programming paradigm proposed based on the answer set semantics of Prolog. It is well known that an answer set for a logic program is also a model of the program\u27s completion. The converse is true when the logic program is tight . Lin and Zhao showed that for non-tight programs the models of completion which do not correspond to answer sets can be eliminated by adding to the completion what they called loop formulas . Nevertheless, their solver ASSAT 1 has some disadvantages: it can work only with basic rules, and it can compute only one answer set. Answer set solver CMODELS-1 is a system that computes answer sets for logic programs that are tight or can be transformed into tight programs, and does not suffer from these limitations. We are going to present a new system CMODELS-2 , that is able to fix ASSAT\u27s disadvantages. Another attractive feature of the new system is that it organizes the search process more efficiently then ASSAT, because it does not explore the same part of the search tree more than once. In the rest of the paper we will omit number 2 in the name of the system

Maximizing Foundation Effectiveness: Aligning Program Strategy, Organizational Capacity, Strategic Planning, and Performance Assessment to Achieve Success

This paper outlines a framework for increasing the philanthropic performance of an organization by focusing on strategic planning and development of tight logic models for the organization's programs. Strategic planning gets broken down into five steps: meta-planning, evaluation of the internal/external environment, establishment of priorities and vision, development of the strategic plan, and implementation/refinement. Though this paper stresses evaluation and meticulous planning, it finishes by imploring organizations to "allow room for serendipity, improvisation, and intuition in the process, too.

Properties and Applications of Programs with Monotone and Convex Constraints

We study properties of programs with monotone and convex constraints. We extend to these formalisms concepts and results from normal logic programming. They include the notions of strong and uniform equivalence with their characterizations, tight programs and Fages Lemma, program completion and loop formulas. Our results provide an abstract account of properties of some recent extensions of logic programming with aggregates, especially the formalism of lparse programs. They imply a method to compute stable models of lparse programs by means of off-the-shelf solvers of pseudo-boolean constraints, which is often much faster than the smodels system

Stratified Negation in Limit Datalog Programs

There has recently been an increasing interest in declarative data analysis, where analytic tasks are specified using a logical language, and their implementation and optimisation are delegated to a general-purpose query engine. Existing declarative languages for data analysis can be formalised as variants of logic programming equipped with arithmetic function symbols and/or aggregation, and are typically undecidable. In prior work, the language of $\mathit{limit\ programs}$ was proposed, which is sufficiently powerful to capture many analysis tasks and has decidable entailment problem. Rules in this language, however, do not allow for negation. In this paper, we study an extension of limit programs with stratified negation-as-failure. We show that the additional expressive power makes reasoning computationally more demanding, and provide tight data complexity bounds. We also identify a fragment with tractable data complexity and sufficient expressivity to capture many relevant tasks.Comment: 14 pages; full version of a paper accepted at IJCAI-1

Deciding Entailments in Inductive Separation Logic with Tree Automata

Separation Logic (SL) with inductive definitions is a natural formalism for specifying complex recursive data structures, used in compositional verification of programs manipulating such structures. The key ingredient of any automated verification procedure based on SL is the decidability of the entailment problem. In this work, we reduce the entailment problem for a non-trivial subset of SL describing trees (and beyond) to the language inclusion of tree automata (TA). Our reduction provides tight complexity bounds for the problem and shows that entailment in our fragment is EXPTIME-complete. For practical purposes, we leverage from recent advances in automata theory, such as inclusion checking for non-deterministic TA avoiding explicit determinization. We implemented our method and present promising preliminary experimental results

On the Complexity of Verifying Timed Golog Programs over Description Logic Actions: Extended Version

Golog programs allow to model complex behaviour of agents by combining primitive actions defined in a Situation Calculus theory using imperative and non-deterministic programming language constructs. In general, verifying temporal properties of Golog programs is undecidable. One way to establish decidability is to restrict the logic used by the program to a Description Logic (DL), for which recently some complexity upper bounds for verification problem have been established. However, so far it was open whether these results are tight, and lightweight DLs such as EL have not been studied at all. Furthermore, these results only apply to a setting where actions do not consume time, and the properties to be verified only refer to the timeline in a qualitative way. In a lot of applications, this is an unrealistic assumption. In this work, we study the verification problem for timed Golog programs, in which actions can be assigned differing durations, and temporal properties are specified in a metric branching time logic. This allows to annotate temporal properties with time intervals over which they are evaluated, to specify for example that some property should hold for at least n time units, or should become specified within some specified time window. We establish tight complexity bounds of the verification problem for both expressive and lightweight DLs. Our lower bounds already apply to a very limited fragment of the verification problem, and close open complexity bounds for the non-metrical cases studied before