2,218 research outputs found
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
ASP(AC): Answer Set Programming with Algebraic Constraints
Weighted Logic is a powerful tool for the specification of calculations over
semirings that depend on qualitative information. Using a novel combination of
Weighted Logic and Here-and-There (HT) Logic, in which this dependence is based
on intuitionistic grounds, we introduce Answer Set Programming with Algebraic
Constraints (ASP(AC)), where rules may contain constraints that compare
semiring values to weighted formula evaluations. Such constraints provide
streamlined access to a manifold of constructs available in ASP, like
aggregates, choice constraints, and arithmetic operators. They extend some of
them and provide a generic framework for defining programs with algebraic
computation, which can be fruitfully used e.g. for provenance semantics of
datalog programs. While undecidable in general, expressive fragments of ASP(AC)
can be exploited for effective problem-solving in a rich framework. This work
is under consideration for acceptance in Theory and Practice of Logic
Programming.Comment: 32 pages, 16 pages are appendi
Rewriting recursive aggregates in answer set programming: back to monotonicity
Aggregation functions are widely used in answer set programming for representing and reasoning on knowledge involving sets of objects collectively. Current implementations simplify the structure of programs in order to optimize the overall performance. In particular, aggregates are rewritten into simpler forms known as monotone aggregates. Since the evaluation of normal programs with monotone aggregates is in general on a lower complexity level than the evaluation of normal programs with arbitrary aggregates, any faithful translation function must introduce disjunction in rule heads in some cases. However, no function of this kind is known. The paper closes this gap by introducing a polynomial, faithful, and modular translation for rewriting common aggregation functions into the simpler form accepted by current solvers. A prototype system allows for experimenting with arbitrary recursive aggregates, which are also supported in the recent version 4.5 of the grounder gringo, using the methods presented in this paper
- …