scholarly journals Modeling and Language Extensions

AI Magazine ◽  
2016 ◽  
Vol 37 (3) ◽  
pp. 33-44 ◽  
Author(s):  
Martin Gebser ◽  
Torsten Schaub
Keyword(s):  
Expressive Language ◽  
Logic Program ◽  
Answer Set Programming ◽  
Stable Model ◽  
Logic Programs ◽  
First Order ◽  
High Level Modeling ◽  
High Level ◽  
Answer Sets ◽  
First Order Variables

Answer set programming (ASP) has emerged as an approach to declarative problem solving based on the stable model semantics for logic programs. The basic idea is to represent a computational problem by a logic program, formulating constraints in terms of rules, such that its answer sets correspond to problem solutions. To this end, ASP combines an expressive language for high-level modeling with powerful low-level reasoning capacities, provided by off-the-shelf tools. Compact problem representations take advantage of genuine modeling features of ASP, including (first-order) variables, negation by default, and recursion. In this article, we demonstrate the ASP methodology on two example scenarios, illustrating basic as well as advanced modeling and solving concepts. We also discuss mechanisms to represent and implement extended kinds of preferences and optimization. An overview of further available extensions concludes the article.

scholarly journals Knowledge Forgetting in Answer Set Programming

2014 ◽  
Vol 50 ◽  
pp. 31-70 ◽  
Author(s):  
Y. Wang ◽  
Y. Zhang ◽  
Y. Zhou ◽  
M. Zhang
Keyword(s):  
Logic Program ◽  
Answer Set Programming ◽  
Irrelevant Information ◽  
Semantic Knowledge ◽  
Decision Problems ◽  
Stable Model ◽  
Logic Programs ◽  
Knowledge Based ◽  
Substitution Principle ◽  
Answer Set

The ability of discarding or hiding irrelevant information has been recognized as an important feature for knowledge based systems, including answer set programming. The notion of strong equivalence in answer set programming plays an important role for different problems as it gives rise to a substitution principle and amounts to knowledge equivalence of logic programs. In this paper, we uniformly propose a semantic knowledge forgetting, called HT- and FLP-forgetting, for logic programs under stable model and FLP-stable model semantics, respectively. Our proposed knowledge forgetting discards exactly the knowledge of a logic program which is relevant to forgotten variables. Thus it preserves strong equivalence in the sense that strongly equivalent logic programs will remain strongly equivalent after forgetting the same variables. We show that this semantic forgetting result is always expressible; and we prove a representation theorem stating that the HT- and FLP-forgetting can be precisely characterized by Zhang-Zhou's four forgetting postulates under the HT- and FLP-model semantics, respectively. We also reveal underlying connections between the proposed forgetting and the forgetting of propositional logic, and provide complexity results for decision problems in relation to the forgetting. An application of the proposed forgetting is also considered in a conflict solving scenario.

scholarly journals Optimizing Answer Set Computation via Heuristic-Based Decomposition

2019 ◽  
Vol 19 (04) ◽  
pp. 603-628 ◽  
Author(s):  
FRANCESCO CALIMERI ◽  
SIMONA PERRI ◽  
JESSICA ZANGARI
Keyword(s):  
Logic Programming ◽  
Logic Program ◽  
Answer Set Programming ◽  
Decomposition Techniques ◽  
Logic Programs ◽  
Experimental Activity ◽  
Performance Of Systems ◽  
Answer Sets ◽  
The Impact ◽  
Answer Set

AbstractAnswer Set Programming (ASP) is a purely declarative formalism developed in the field of logic programming and non-monotonic reasoning: computational problems are encoded by logic programs whose answer sets, corresponding to solutions, are computed by an ASP system. Different, semantically equivalent, programs can be defined for the same problem; however, performance of systems evaluating them might significantly vary. We propose an approach for automatically transforming an input logic program into an equivalent one that can be evaluated more efficiently. One can make use of existing tree-decomposition techniques for rewriting selected rules into a set of multiple ones; the idea is to guide and adaptively apply them on the basis of proper new heuristics, to obtain a smart rewriting algorithm to be integrated into an ASP system. The method is rather general: it can be adapted to any system and implement different preference policies. Furthermore, we define a set of new heuristics tailored at optimizing grounding, one of the main phases of the ASP computation; we use them in order to implement the approach into the ASP systemDLV, in particular into its grounding subsystemℐ-DLV, and carry out an extensive experimental activity for assessing the impact of the proposal.

scholarly journals On the existence of stable models of non-stratified logic programs

2006 ◽  
Vol 6 (1-2) ◽  
pp. 169-212 ◽  
Author(s):  
STEFANIA COSTANTINI
Keyword(s):  
Canonical Form ◽  
Logic Program ◽  
Practical Importance ◽  
The Body ◽  
Fundamental Result ◽  
Stable Model ◽  
Logic Programs ◽  
Truth Value ◽  
Answer Sets ◽  
Stable Models

In this paper we analyze the relationship between cyclic definitions and consistency in Gelfond-Lifschitz's answer sets semantics (originally defined as ‘stable model semantics’). This paper introduces a fundamental result, which is relevant for Answer Set programming, and planning. For the first time since the definition of the stable model semantics, the class of logic programs for which a stable model exists is given a syntactic characterization. This condition may have a practical importance both for defining new algorithms for checking consistency and computing answer sets, and for improving the existing systems. The approach of this paper is to introduce a new canonical form (to which any logic program can be reduced to), to focus the attention on cyclic dependencies. The technical result is then given in terms of programs in canonical form (canonical programs), without loss of generality: the stable models of any general logic program coincide (up to the language) to those of the corresponding canonical program. The result is based on identifying the cycles contained in the program, showing that stable models of the overall program are composed of stable models of suitable sub-programs, corresponding to the cycles, and on defining the Cycle Graph. Each vertex of this graph corresponds to one cycle, and each edge corresponds to one handle, which is a literal containing an atom that, occurring in both cycles, actually determines a connection between them. In fact, the truth value of the handle in the cycle where it appears as the head of a rule, influences the truth value of the atoms of the cycle(s) where it occurs in the body. We can therefore introduce the concept of a handle path, connecting different cycles. Cycles can be even, if they consist of an even number of rules, or vice versa they can be odd. Problems for consistency, as it is well-known, originate in the odd cycles. If for every odd cycle we can find a handle path with certain properties, then the existence of stable model is guaranteed. We will show that based on this results new classes of consistent programs can be defined, and that cycles and cycle graphs can be generalized to components and component graphs.

scholarly journals Inconsistency Proofs for ASP: The ASP - DRUPE Format

2019 ◽  
Vol 19 (5-6) ◽  
pp. 891-907
Author(s):  
MARIO ALVIANO ◽  
CARMINE DODARO ◽  
JOHANNES K. FICHTE ◽  
MARKUS HECHER ◽  
TOBIAS PHILIPP ◽  
...  
Keyword(s):  
Logic Program ◽  
Answer Set Programming ◽  
Boolean Satisfiability ◽  
Logic Programs ◽  
Disjunctive Logic Programs ◽  
Normal Logic ◽  
Consistency Problem ◽  
Unit Propagation ◽  
Answer Sets ◽  
Answer Set

AbstractAnswer Set Programming (ASP) solvers are highly-tuned and complex procedures that implicitly solve the consistency problem, i.e., deciding whether a logic program admits an answer set. Verifying whether a claimed answer set is formally a correct answer set of the program can be decided in polynomial time for (normal) programs. However, it is far from immediate to verify whether a program that is claimed to be inconsistent, indeed does not admit any answer sets. In this paper, we address this problem and develop the new proof format ASP-DRUPE for propositional, disjunctive logic programs, including weight and choice rules. ASP-DRUPE is based on the Reverse Unit Propagation (RUP) format designed for Boolean satisfiability. We establish correctness of ASP-DRUPE and discuss how to integrate it into modern ASP solvers. Later, we provide an implementation of ASP-DRUPE into the wasp solver for normal logic programs.

scholarly journals Temporal logic programs with variables

2016 ◽  
Vol 17 (2) ◽  
pp. 226-243 ◽  
Author(s):  
FELICIDAD AGUADO ◽  
PEDRO CABALAR ◽  
GILBERTO PÉREZ ◽  
CONCEPCIÓN VIDAL ◽  
MARTÍN DIÉGUEZ
Keyword(s):  
Temporal Logic ◽  
Linear Time ◽  
Logic Program ◽  
Answer Set Programming ◽  
Logic Programs ◽  
First Order ◽  
Linear Time Temporal Logic ◽  
Definition Of ◽  
Stable Models ◽  
Answer Set

AbstractIn this note, we consider the problem of introducing variables in temporal logic programs under the formalism of Temporal Equilibrium Logic, an extension of Answer Set Programming for dealing with linear-time modal operators. To this aim, we provide a definition of a first-order version of Temporal Equilibrium Logic that shares the syntax of first-order Linear-time Temporal Logic but has different semantics, selecting some Linear-time Temporal Logic models we call temporal stable models. Then, we consider a subclass of theories (called splittable temporal logic programs) that are close to usual logic programs but allowing a restricted use of temporal operators. In this setting, we provide a syntactic definition of safe variables that suffices to show the property of domain independence – that is, addition of arbitrary elements in the universe does not vary the set of temporal stable models. Finally, we present a method for computing the derivable facts by constructing a non-temporal logic program with variables that is fed to a standard Answer Set Programming grounder. The information provided by the grounder is then used to generate a subset of ground temporal rules which is equivalent to (and generally smaller than) the full program instantiation.

scholarly journals Automated Verification of Weak Equivalence within thesmodelsSystem

2007 ◽  
Vol 7 (6) ◽  
pp. 697-744 ◽  
Author(s):  
TOMI JANHUNEN ◽  
EMILIA OIKARINEN
Keyword(s):  
Search Engine ◽  
Logic Program ◽  
General Setting ◽  
Answer Set Programming ◽  
Weak Equivalence ◽  
Logic Programs ◽  
Meta Level ◽  
Level Problem ◽  
Answer Sets ◽  
Answer Set

AbstractIn answer set programming (ASP), a problem at hand is solved by (i) writing a logic program whose answer sets correspond to the solutions of the problem, and by (ii) computing the answer sets of the program using ananswer set solveras a search engine. Typically, a programmer creates a series of gradually improving logic programs for a particular problem when optimizing program length and execution time on a particular solver. This leads the programmer to a meta-level problem of ensuring that the programs are equivalent, i.e., they give rise to the same answer sets. To ease answer set programming at methodological level, we propose a translation-based method for verifying the equivalence of logic programs. The basic idea is to translate logic programsPandQunder consideration into a single logic program EQT(P,Q) whose answer sets (if such exist) yield counter-examples to the equivalence ofPandQ. The method is developed here in a slightly more general setting by taking thevisibilityof atoms properly into account when comparing answer sets. The translation-based approach presented in the paper has been implemented as a translator calledlpeqthat enables the verification of weak equivalence within thesmodelssystem using the same search engine as for the search of models. Our experiments withlpeqandsmodelssuggest that establishing the equivalence of logic programs in this way is in certain cases much faster than naive cross-checking of answer sets.

scholarly journals Resilient Logic Programs: Answer Set Programs Challenged by Ontologies

2020 ◽  
Vol 34 (03) ◽  
pp. 2917-2924
Author(s):  
Sanja Lukumbuzya ◽  
Magdalena Ortiz ◽  
Mantas Šimkus
Keyword(s):  
Description Logic ◽  
Logic Program ◽  
Large Fragment ◽  
Logic Programs ◽  
First Order ◽  
Complexity Results ◽  
Answer Sets ◽  
Answer Set

We introduce resilient logic programs (RLPs) that couple a non-monotonic logic program and a first-order (FO) theory or description logic (DL) ontology. Unlike previous hybrid languages, where the interaction between the program and the theory is limited to consistency or query entailment tests, in RLPs answer sets must be ‘resilient’ to the models of the theory, allowing non-output predicates of the program to respond differently to different models. RLPs can elegantly express ∃∀∃-QBFs, disjunctive ASP, and configuration problems under incompleteness of information. RLPs are decidable when a couple of natural assumptions are made: (i) satisfiability of FO theories in the presence of closed predicates is decidable, and (ii) rules are safe in the style of the well-known DL-safeness. We further show that a large fragment of such RLPs can be translated into standard (disjunctive) ASP, for which efficient implementations exist. For RLPs with theories expressed in DLs, we use a novel relaxation of safeness that safeguards rules via predicates whose extensions can be inferred to have a finite bound. We present several complexity results for the case where ontologies are written in some standard DLs.

scholarly journals Grounding and Solving in Answer Set Programming

AI Magazine ◽  
2016 ◽  
Vol 37 (3) ◽  
pp. 25-32 ◽  
Author(s):  
Benjamin Kaufmann ◽  
Nicola Leone ◽  
Simona Perri ◽  
Torsten Schaub
Keyword(s):  
Problem Solving ◽  
Propositional Logic ◽  
Logic Program ◽  
Answer Set Programming ◽  
Key Issues ◽  
Answer Sets ◽  
Answer Set

Answer set programming is a declarative problem solving paradigm that rests upon a workflow involving modeling, grounding, and solving. While the former is described by Gebser and Schaub (2016), we focus here on key issues in grounding, or how to systematically replace object variables by ground terms in a effective way, and solving, or how to compute the answer sets of a propositional logic program obtained by grounding.

scholarly journals Query Answering with Guarded Existential Rules under Stable Model Semantics

2020 ◽  
Vol 34 (03) ◽  
pp. 3017-3024
Author(s):  
Hai Wan ◽  
Guohui Xiao ◽  
Chenglin Wang ◽  
Xianqiao Liu ◽  
Junhong Chen ◽  
...  
Keyword(s):  
Answer Set Programming ◽  
Query Answering ◽  
Prototype System ◽  
Stable Model ◽  
Logic Programs ◽  
Termination Problem ◽  
Answer Set

In this paper, we study the problem of query answering with guarded existential rules (also called GNTGDs) under stable model semantics. Our goal is to use existing answer set programming (ASP) solvers. However, ASP solvers handle only finitely-ground logic programs while the program translated from GNTGDs by Skolemization is not in general. To address this challenge, we introduce two novel notions of (1) guarded instantiation forest to describe the instantiation of GNTGDs and (2) prime block to characterize the repeated infinitely-ground program translated from GNTGDs. Using these notions, we prove that the ground termination problem for GNTGDs is decidable. We also devise an algorithm for query answering with GNTGDs using ASP solvers. We have implemented our approach in a prototype system. The evaluation over a set of benchmarks shows encouraging results.

Action language ℬ𝒞+

2015 ◽  
Vol 30 (4) ◽  
pp. 899-922 ◽  
Author(s):  
Joseph Babb ◽  
Joohyung Lee
Keyword(s):  
Main Idea ◽  
Answer Set Programming ◽  
Stable Model ◽  
Formal Models ◽  
Transition Systems ◽  
Action Languages ◽  
Action Language ◽  
Language Constructs ◽  
High Level ◽  
Answer Set

Abstract Action languages are formal models of parts of natural language that are designed to describe effects of actions. Many of these languages can be viewed as high-level notations of answer set programs structured to represent transition systems. However, the form of answer set programs considered in the earlier work is quite limited in comparison with the modern Answer Set Programming (ASP) language, which allows several useful constructs for knowledge representation, such as choice rules, aggregates and abstract constraint atoms. We propose a new action language called BC +, which closes the gap between action languages and the modern ASP language. The main idea is to define the semantics of BC + in terms of general stable model semantics for propositional formulas, under which many modern ASP language constructs can be identified with shorthands for propositional formulas. Language BC  + turns out to be sufficiently expressive to encompass the best features of other action languages, such as languages B , C , C + and BC . Computational methods available in ASP solvers are readily applicable to compute BC +, which led to an implementation of the language by extending system cplus2asp .

Sign in / Sign up

Export Citation Format

Share Document