9 research outputs found
Problem solving in ID-logic with aggregates: some experiments
The goal of the LP+ project at the K.U.Leuven is to design an expressive
logic, suitable for declarative knowledge representation, and to develop
intelligent systems based on Logic Programming technology for solving
computational problems using the declarative specifications. The ID-logic is an
integration of typed classical logic and a definition logic. Different
abductive solvers for this language are being developed. This paper is a report
of the integration of high order aggregates into ID-logic and the consequences
on the solver SLDNFA.Comment: 9 pages conference: NMR2000, special track on abductive reasonin
Answer Sets for Logic Programs with Arbitrary Abstract Constraint Atoms
In this paper, we present two alternative approaches to defining answer sets
for logic programs with arbitrary types of abstract constraint atoms (c-atoms).
These approaches generalize the fixpoint-based and the level mapping based
answer set semantics of normal logic programs to the case of logic programs
with arbitrary types of c-atoms. The results are four different answer set
definitions which are equivalent when applied to normal logic programs. The
standard fixpoint-based semantics of logic programs is generalized in two
directions, called answer set by reduct and answer set by complement. These
definitions, which differ from each other in the treatment of
negation-as-failure (naf) atoms, make use of an immediate consequence operator
to perform answer set checking, whose definition relies on the notion of
conditional satisfaction of c-atoms w.r.t. a pair of interpretations. The other
two definitions, called strongly and weakly well-supported models, are
generalizations of the notion of well-supported models of normal logic programs
to the case of programs with c-atoms. As for the case of fixpoint-based
semantics, the difference between these two definitions is rooted in the
treatment of naf atoms. We prove that answer sets by reduct (resp. by
complement) are equivalent to weakly (resp. strongly) well-supported models of
a program, thus generalizing the theorem on the correspondence between stable
models and well-supported models of a normal logic program to the class of
programs with c-atoms. We show that the newly defined semantics coincide with
previously introduced semantics for logic programs with monotone c-atoms, and
they extend the original answer set semantics of normal logic programs. We also
study some properties of answer sets of programs with c-atoms, and relate our
definitions to several semantics for logic programs with aggregates presented
in the literature
Recursive Rules with Aggregation: A Simple Unified Semantics
Complex reasoning problems are most clearly and easily specified using
logical rules, especially recursive rules with aggregation such as counts and
sums for practical applications. Unfortunately, the meaning of such rules has
been a significant challenge, leading to many different conflicting semantics.
This paper describes a unified semantics for recursive rules with
aggregation, extending the unified founded semantics and constraint semantics
for recursive rules with negation. The key idea is to support simple expression
of the different assumptions underlying different semantics, and orthogonally
interpret aggregation operations straightforwardly using their simple usual
meaning
Weakening the stable semantics
We report our research on semantics for normal/disjunctive programs. One of the most well known semantics for logic programming is the stable semantics (STABLE). However, it is well known that very often STABLE has no models. In this paper we study the stable semantics and present some new results about it. Furthermore, we introduce a new semantics (that we call D3-WFS-DCOMP) and compare it with STABLE. For normal programs, this semantics is based on a suitable integration of WFS and the Clark's Completion. D3-WFS-DCOM has the following appealing properties: First, it agrees with STABLE in the sense that it never defines a non minimal model or a non minimal supported model. Second, for normal programs it extends WFS. Third, every stable model of a disjunctive program P is a D3-WFS-DCOM model of . Fourth, it is constructed using transformations accepted by STABLE. We also introduce a second semantics that we call D2-WFS-DCOMP. We show that D2-WFS-DCOMP is equivalent to D3-WFS-DCOMP for normal programs but this is not the case for disjunctive programs. We also introduce a third new semantics that insists in the use of implicit disjunctions. We briefly sketch how these semantics can be extended to programs including: explicit negation, default negation in the head of a clause, as well as a lub operator ( which is the generalization of setof over arbitrary complete lattices). We sketch how to model this lub operator using standard disjunctive clauses. However, we can not use the STABLE semantics but instead any of our suggested semantics. We emphasizes that the ultimate goal of our research is to understand better the STABLE semantics and to suggest solutions to the drawbacks of the stable semantics (that becomes undefined very often).Postprint (published version
Theory of partial-order programming
This paper shows the use of partial-order program clauses and lattice domains for declarative programming. This paradigm is particularly useful for expressing concise solutions to problems from graph theory, program analysis, and database querying. These applications are characterized by a need to solve circular constraints and perform aggregate operations, a capability that is very clearly and efficiently provided by partial-order clauses. We present a novel approach to their declarative and operational semantics, as well as the correctness of the operational semantics. The declarative semantics is model-theoretic in nature, but the least model for any function is not the classical intersection of all models, but the greatest lower bound/least upper bound of the respective terms defined for this function in the different models. The operational semantics combines top-down goal reduction with memo-tables. In the partial-order programming framework, however, memoization is primarily needed in order to detect circular circular function calls. In general we need more than simple memoization when functions are defined circularly in terms of one another through monotonic functions. In such cases, we accumulate a set of functional-constraint and solve them by general fixed-point-finding procedure. In order to prove the correctness of memoization, a straightforward induction on the length of the derivation will not suffice because of the presence of the memo-table. However, since the entries in the table grow monotonically, we identify a suitable table invariant that captures the correctness of the derivation. The partial-order programming paradigm has been implemented and all examples shown in this paper have been tested using this implementation
Better Together: Unifying Datalog and Equality Saturation
We present egglog, a fixpoint reasoning system that unifies Datalog and
equality saturation (EqSat). Like Datalog, it supports efficient incremental
execution, cooperating analyses, and lattice-based reasoning. Like EqSat, it
supports term rewriting, efficient congruence closure, and extraction of
optimized terms.
We identify two recent applications--a unification-based pointer analysis in
Datalog and an EqSat-based floating-point term rewriter--that have been
hampered by features missing from Datalog but found in EqSat or vice-versa. We
evaluate egglog by reimplementing those projects in egglog. The resulting
systems in egglog are faster, simpler, and fix bugs found in the original
systems.Comment: PLDI 202
28th International Symposium on Temporal Representation and Reasoning (TIME 2021)
The 28th International Symposium on Temporal Representation and Reasoning (TIME 2021) was planned to take place in Klagenfurt, Austria, but had to move to an online conference due to the insecurities and restrictions caused by the pandemic. Since its frst edition in 1994, TIME Symposium is quite unique in the panorama of the scientifc conferences as its main goal is to bring together researchers from distinct research areas involving the management and representation of temporal data as well as the reasoning about temporal aspects of information. Moreover, TIME Symposium aims to bridge theoretical and applied research, as well as to serve as an interdisciplinary forum for exchange among researchers from the areas of artifcial intelligence, database management, logic and verifcation, and beyond
ULTRA - A Logic Transaction Programming Language
Rule-based language for the specification of complex database updates and transactions. Formal treatment of the syntax and the declarative semanticsRegelbasierte Sprache zur Spezifikation komplexer Datenbank-Operationen und Transaktionen. Formle Behandlung von Syntax und deklarativer Semantik
The Well-Founded Semantics of Aggregation (Extended Abstract)
Common aggregation predicates have natural definitions in logic, either as rst order sentences (min, max, etc.), or with elementary induction over a data structure that represents the relation (sum, count, etc.). The well-founded semantics for logic programs provides an interpretation of such definitions. The interpretation of rst-order aggregates seems to be quite natural and intuitively satisfying, even in the presence of recursion through aggregation. Care is needed to get useful results on inductive aggregates, however. A basic building block is the "subset" predicate, which states that a data structure represents a subset of an IDB predicate, and which is definable in the well-founded semantics. The analogous "superset" is also definable, and their combination yields a "generic" form of ndall. Surprisingly, findall must be used negatively to obtain useful approximations when the exact relation is not yet known. Extensions to the semantics, restrictions on the input, and other supplementary requirements proposed in earlier studies appear to be unnecessary for the purpose of attaching a meaning to a program that involves recursion through aggregation. For example, any reasonable definition of "shortest paths" tolerates negative weight edges, correctly computes shortest paths that exist, and leaves tuples undefined where negative-weight cycles cause the shortest path not to exist. Other examples exhibit similarly robust behavior, when defined carefully. Connections with the generic model of computation are discussed briefly