Program completion in the input language of GRINGO

In the twenty years since the creation of the stable model semantics[4] for logic programs and inclusion of both classical and negation as failure, answer set programming (ASP)[1] has grown from a small fledgeling field within logic programming to a maturing field of its own. In this extended abstract we discuss some future application areas for ASP and theoretic and implementational problems that need to be addressed in order to make them feasible. With the increase in efficiency of the answer set solvers and a better understanding of the formalism, its advantages and disadvantages, more applications areas for ASP are found. While traditional application domains were mainly in the knowledge representation and reasoning area, we now also see more and more applications in areas were competitors like SAT or CSP were considered better alternatives. We believe, these current applications are just the tip of the iceberg. In years to come, we will see more and more successful applications plus further expansion and improvements on existing applications. In recent years we have seen a lot of ASP activity in the fields of the semantic web and web-services with specific workshops dedicated to the topic1. We believe that these fields hold more potential for years to come. For example, ASP could also be used for match-making and service coordination and orchestration. Another application area of ASP is multi-agent systems. In most cases this was always on the more theoretical side of applications. To our knowledge, nobody has used ASP to construct a running multi-agent system where the agents use ASP for reasoning purposes. With our current solvers, we should be able to provide such a system. ASP has also be applied in wide variety of other domains like planning, diagnosis, language-evolution, policy-design, bio-informatics, compiler optimisation, music composition, security, cryptography and game design. Most of these application are in a prototype phase, demonstrating that ASP could be of value in this domain and are slowly making their way to conferences and journals in the domain they are addressing. By doing some domain experts will get to know ASP and its capabilities. In time this will lead to them pointing ASP researchers to similar problems in the same domain. So in the medium term, we believe we can look forward to more ASP applications in bio-informatics, e-health, medicine, e-government and engineering. Normally we refer to ASP as a problem solving paradigm. We model the problem as an ASP program such that the answer sets correspond to the solutions of this problem.

Logic programming, as exemplified by datalog, defines the meaning of a program as its unique smallest model: the deductive closure of its inference rules. However, many problems call for an enumeration of models that vary along some set of choices while maintaining structural and logical constraints—there is no single canonical model. The notion of stable models for logic programs with negation has successfully captured programmer intuition about the set of valid solutions for such problems, giving rise to a family of programming languages and associated solvers known as answer set programming. Unfortunately, the definition of a stable model is frustratingly indirect, especially in the presence of rules containing free variables. We propose a new formalism, finite-choice logic programming, that uses choice, not negation, to admit multiple solutions. Finite-choice logic programming contains all the expressive power of the stable model semantics, gives meaning to a new and useful class of programs, and enjoys a least-fixed-point interpretation over a novel domain. We present an algorithm for exploring the solution space and prove it correct with respect to our semantics. Our implementation, the Dusa logic programming language, has performance that compares favorably with state-of-the-art answer set solvers and exhibits more predictable scaling with problem size.

In this article, we consider Answer Set Programming (ASP). It is a declarative problem solving paradigm that can be used to encode a problem as a logic program whose answer sets correspond to the solutions of the problem. It has been widely applied in various domains in AI and beyond. Given that answer sets are supposed to yield solutions to the original problem, the question of “why a set of atoms is an answer set” becomes important for both semantics understanding and program debugging. It has been well investigated for normal logic programs. However, for the class of disjunctive logic programs, which is a substantial extension of that of normal logic programs, this question has not been addressed much. In this article, we propose a notion of reduct for disjunctive logic programs and show how it can provide answers to the aforementioned question. First, we show that for each answer set, its reduct provides a resolution proof for each atom in it. We then further consider minimal sets of rules that will be sufficient to provide resolution proofs for sets of atoms. Such sets of rules will be called witnesses and are the focus of this article. We study complexity issues of computing various witnesses and provide algorithms for computing them. In particular, we show that the problem is tractable for normal and headcycle-free disjunctive logic programs, but intractable for general disjunctive logic programs. We also conducted some experiments and found that for many well-known ASP and SAT benchmarks, computing a minimal witness for an atom of an answer set is often feasible.

Answer Set Programming (ASP) is a framework in artificial intelligence and knowledge representation for declarative modeling and problem solving. Modern ASP solvers focus on the computation or enumeration of answer sets. However, a variety of probabilistic applications in reasoning or logic programming require counting answer sets. While counting can be done by enumeration, simple enumeration becomes immediately infeasible if the number of solutions is high. On the other hand, approaches to exact counting are of high worst-case complexity. In fact, in propositional model counting, exact counting becomes impractical. In this work, we present a scalable approach to approximate counting for answer set programming. Our approach is based on systematically adding XOR constraints to ASP programs, which divide the search space. We prove that adding random XOR constraints partitions the answer sets of an ASP program. In practice, we use a Gaussian elimination-based approach by lifting ideas from SAT to ASP and integrating it into a state of the art ASP solver, which we call ApproxASP. Finally, our experimental evaluation shows the scalability of our approach over the existing ASP systems.

In recent years, answer set programming (ASP) has been extended to deal with multivalued predicates. The resulting formalismsallow for the modeling of continuous problems as elegantly as ASP allows for the modeling of discrete problems, by combining thestable model semantics underlying ASP with fuzzy logics. However, contrary to the case of classical ASP where manyefficient solvers have been constructed, to date there is no efficient fuzzy ASP solver. A well-knowntechnique for classical ASP consists of translating an ASP programPto a propositional theory whose models exactlycorrespond to the answer sets ofP. In this paper, we show how this idea can be extended to fuzzy ASP, paving the wayto implement efficient fuzzy ASP solvers that can take advantage of existing fuzzy logic reasoners.

Adapting techniques from database theory in order to optimize Answer Set Programming (ASP) systems, and in particular the grounding components of ASP systems, is an important topic in ASP. In recent years, the Magic Set method has received some interest in this setting, and a variant of it, called Dynamic Magic Set, has been proposed for ASP. However, this technique has a caveat, because it is not correct (in the sense of being query-equivalent) for all ASP programs. In a recent work, a large fragment of ASP programs, referred to assuper-coherent programs, has been identified, for which Dynamic Magic Set is correct. The fragment contains all programs which possess at least one answer set, no matter which set of facts is added to them. Two open question remained: How complex is it to determine whether a given program is super-coherent? Does the restriction to super-coherent programs limit the problems that can be solved? Especially the first question turned out to be quite difficult to answer precisely. In this paper, we formally prove that deciding whether a propositional program is super-coherent is Π3P-complete in the disjunctive case, while it is Π2P-complete for normal programs. The hardness proofs are the difficult part in this endeavor: We proceed by characterizing the reductions by the models and reduct models which the ASP programs should have, and then provide instantiations that meet the given specifications. Concerning the second question, we show that all relevant ASP reasoning tasks can be transformed into tasks over super-coherent programs, although this transformation is more of theoretical than practical interest.

Controlled experiments in Process Mining primarily rely on synthetic event logs generated from declarative or procedural process modeling languages, which often lack the flexibility needed for precise experimental setups. In this paper, we introduce a novel log generator designed to address this gap by enabling fine-tuned customization of synthetic logs. The log generator, implemented using the declarative language Answer Set Programming (ASP), allows researchers to define sophisticated scenarios that are impossible to express with standard log generators to create specific experimental conditions. • Fine-grained and flexible event log generation with a new position-based modeling language ( PosLan ) and Answer-Set Programming. • Support for synthetic logs with characteristics that mimic complex real-world patterns. • Variability control of the generated event log via Answer-Set Programming.

We present a prototypical system, plasp, implementing Planning by compilation to Answer Set Programming (ASP). Our approach is inspired by Planning as Satisfiability, yet it aims at keeping the actual compilation simple in favor of modeling planning techniques by meta-programming in ASP. This has several advantages. First, ASP modelings are easily modifiable and can be studied in a transparent setting. Second, we can take advantage of available ASP grounders to obtain propositional representations. Third, we can harness ASP solvers providing incremental solving mechanisms. Finally, the ASP community gains access to a wide range of planning problems, and the planning community benefits from the knowledge representation and reasoning capacities of ASP.KeywordsPlanning ProblemOperator SplittingConcurrent ActionPropositional RepresentationAutomate PlanningThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

We introduce a new flexible paradigm of grounding and solving in Answer Set Programming (ASP), which we refer to as multi-shot ASP solving, and present its implementation in the ASP systemclingo. Multi-shot ASP solving features grounding and solving processes that deal with continuously changing logic programs. In doing so, they remain operative and accommodate changes in a seamless way. For instance, such processes allow for advanced forms of search, as in optimization or theory solving, or interaction with an environment, as in robotics or query answering. Common to them is that the problem specification evolves during the reasoning process, either because data or constraints are added, deleted, or replaced. This evolutionary aspect adds another dimension to ASP since it brings about state changing operations. We address this issue by providing an operational semantics that characterizes grounding and solving processes in multi-shot ASP solving. This characterization provides a semantic account of grounder and solver states along with the operations manipulating them. The operative nature of multi-shot solving avoids redundancies in relaunching grounder and solver programs and benefits from the solver's learning capacities.clingoaccomplishes this by complementing ASP's declarative input language with control capacities. On the declarative side, a new directive allows for structuring logic programs into named and parameterizable subprograms. The grounding and integration of these subprograms into the solving process is completely modular and fully controllable from the procedural side. To this end,clingooffers a new application programming interface that is conveniently accessible via scripting languages. By strictly separating logic and control,clingoalso abolishes the need for dedicated systems for incremental and reactive reasoning, likeiclingoandoclingo, respectively, and its flexibility goes well beyond the advanced yet still rigid solving processes of the latter.

In answer set programming, two groups of rules are considered strongly equivalent if they have the same meaning in any context. In some cases, strong equivalence of programs in the input language of the grounder gringo can be established by deriving rules of each program from rules of the other. The possibility of such proofs has been demonstrated for a subset of that language that includes comparisons, arithmetic operations, and simple choice rules, but not aggregates. This method is extended here to a class of programs in which some uses of the #count aggregate are allowed.

The goal of the Nurse Scheduling Problem is to find an assignment of nurses to shifts according to specific requirements. Frequently, a computed schedule may become not usable because of sudden absences of some nurses. In this cases, Nurse Rescheduling amounts to the computation of a new schedule, which has to satisfy the original requirements and the new absences. Additionally, a good solution to the Nurse Rescheduling Problem must be as similar as possible to the original schedule, which practically means that the number of changes has to be minimized. This paper focuses on the requirements specified by an Italian hospital, and recently addressed by an approach based on Answer Set Programming (ASP). Even if promising results have been obtained with ASP, the original encoding presents some intrinsic weaknesses, which are identified and eventually circumvented in this paper. The new encoding is designed by taking into account both intrinsic properties of Nurse Scheduling and internal details of ASP solvers, such as cardinality and weight constraint propagators. The performance gain of clingo and wasp is empirically verified on instances from ASP literature. As an additional contribution, the performance of clingo and wasp is compared to other declarative frameworks, namely SAT and ILP; the best performance is obtained by clingo running the new ASP encoding. The advanced ASP encodings are then extended to solve Nurse Rescheduling, and an empirical evaluation is conducted with clingo and wasp.

Most recently, Answer Set Programming (ASP) has been attracting interest as a new paradigm for problem solving. An important aspect, for which several approaches have been presented, is the handling of preferences between rules. In this paper, we consider the problem of implementing preference handling approaches by means of meta-interpreters in Answer Set Programming. In particular, we consider the preferred answer set approaches by Brewka and Eiter, by Delgrande, Schaub and Tompits, and by Wang, Zhou and Lin. We present suitable meta-interpreters for these semantics using DLV, which is an efficient engine for ASP. Moreover, we also present a meta-interpreter for the weakly preferred answer set approach by Brewka and Eiter, which uses the weak constraint feature of DLV as a tool for expressing and solving an underlying optimization problem. We also consider advanced meta-interpreters, which make use of graph-based characterizations and often allow for more efficient computations. Our approach shows the suitability of ASP in general and of DLV in particular for fast prototyping. This can be fruitfully exploited for experimenting with new languages and knowledge-representation formalisms.

Answer Set Programming (ASP) is a rule-based language rooted in traditional Logic Programming, Databases, Knowledge Representation, and Nonmonotonic Reasoning. It offers a flexible language for declarative problem solving, with support of efficient general-purpose solvers and reasoners. The larger part of this article provides an introduction to ASP, with a historical perspective, a definition of the core language, a guideline to knowledge representation, and an overview of existing ASP solvers. One part focuses on one commonly used feature: aggregates and generalized atoms. The inclusion of aggregates in ASP (and Logic Programming at large) has long been motivated, however there are some issues with semantics to be addressed, in particular when aggregates occur in recursive definitions. Very similar considerations are needed when coupling ASP with other formalisms, which we collectively refer to as “generalized atoms”. An overview of these semantic challenges and proposals for addressing them is provided, along with an overview of complexity results and system support.

Answer Set Programming (ASP) is a powerful paradigm based on logic programming for non-monotonic reasoning. Current ASP implementations are restricted to “grounded range-restricted function-free normal programs” and use an evaluation strategy that is “bottom-up” (i.e., not goal-driven). Recent introduction of coinductive Logic Programming (co-LP) has allowed the development of top-down goal evaluation strategies for ASP. In this paper we present this novel goal-directed, top-down approach to executing predicate answer set programs with co-LP. Our method eliminates the need for grounding, allows functions, and effectively handles a large class of predicate answer set programs including possibly infinite ones.

Answer Set Programming (ASP) is a well established logical approach in artificial intelligence that is widely used for knowledge representation and problem solving. Equilibrium logic extends answer set semantics to more general classes of programs and theories. When intertheory relations are studied in ASP, or in the more general form of equilibrium logic, they are usually understood in the form of comparisons of the answer sets or equilibrium models of theories or programs. This is the case for strong and uniform equivalence and their relativised and projective versions. However, there are many potential areas of application of ASP for which query answering is relevant and a comparison of programs in terms of what can be inferred from them may be important. We formulate and study some natural equivalence and entailment concepts for programs and theories that are couched in terms of inference and query answering. We show that, for the most part, these new intertheory relations coincide with their model-theoretic counterparts. We also extend some previous results on projective entailment for theories and for the new connective called fork.