On the Semantics of Logic Programs with Preferences

AbstractIn this paper, we present a framework for the semantics and the computation of aggregates in the context of logic programming. In our study, an aggregate can be an arbitrary interpreted second order predicate or function. We define extensions of the Kripke-Kleene, the well-founded and the stable semantics for aggregate programs. The semantics is based on the concept of a three-valuedimmediate consequence operatorof an aggregate program. Such an operatorapproximatesthe standard two-valued immediate consequence operator of the program, and induces a unique Kripke-Kleene model, a unique well-founded model and a collection of stable models. We study different ways of defining such operators and thus obtain a framework of semantics, offering different trade-offs betweenprecisionandtractability. In particular, we investigate conditions on the operator that guarantee that the computation of the three types of semantics remains on the same level as for logic programs without aggregates. Other results show that, in practice, even efficient three-valued immediate consequence operators which are very low in the precision hierarchy, still provide optimal precision.

Download Full-text

A Model-Theoretic Reconstruction of the Operational Semantics of Logic Programs

Information and Computation ◽

10.1006/inco.1993.1015 ◽

1993 ◽

Vol 103 (1) ◽

pp. 86-113 ◽

Cited By ~ 41

Author(s):

M. Falaschi ◽

G. Levi ◽

M. Martelli ◽

C. Palamidessi

Keyword(s):

Operational Semantics ◽

Logic Programs ◽

Semantics Of Logic Programs

Download Full-text

Safe Inductions: An Algebraic Study

Proceedings of the Twenty-Sixth International Joint Conference on Artificial Intelligence ◽

10.24963/ijcai.2017/119 ◽

2017 ◽

Cited By ~ 1

Author(s):

Bart Bogaerts ◽

Joost Vennekens ◽

Marc Denecker

Keyword(s):

Knowledge Representation ◽

Logic Programming ◽

Logic Programs ◽

Intended Meaning ◽

Safety Criterion ◽

Autoepistemic Logic ◽

Semantics Of Logic Programs ◽

Do So

In many knowledge representation formalisms, a constructive semantics is defined based on sequential applications of rules or of a semantic operator. These constructions often share the property that rule applications must be delayed until it is safe to do so: until it is known that the condition that triggers the rule will remain to hold. This intuition occurs for instance in the well-founded semantics of logic programs and in autoepistemic logic. In this paper, we formally define the safety criterion algebraically. We study properties of so-called safe inductions and apply our theory to logic programming and autoepistemic logic. For the latter, we show that safe inductions manage to capture the intended meaning of a class of theories on which all classical constructive semantics fail.

Download Full-text

Logic programming with social features

Theory and Practice of Logic Programming ◽

10.1017/s1471068408003463 ◽

2008 ◽

Vol 8 (5-6) ◽

pp. 643-690 ◽

Cited By ~ 3

Author(s):

FRANCESCO BUCCAFURRI ◽

GIANLUCA CAMINITI

Keyword(s):

Logic Programming ◽

Everyday Life ◽

Mental State ◽

Mental States ◽

Stable Model ◽

Logic Programs ◽

Social Features ◽

Knowledge Representation Language ◽

Representation Language ◽

Semantics Of Logic Programs

AbstractIn everyday life it happens that a person has to reason out what other people think and how they behave, in order to achieve his goals. In other words, an individual may be required to adapt his behavior by reasoning about the others' mental state. In this paper we focus on a knowledge-representation language derived from logic programming which both supports the representation of mental states of individual communities and provides each with the capability of reasoning about others' mental states and acting accordingly. The proposed semantics is shown to be translatable into stable model semantics of logic programs with aggregates.

Download Full-text

Contributions to the Stable Model Semantics of Logic Programs with Negation

Logic Programming and Non-Monotonic Reasoning ◽

10.7551/mitpress/4307.003.0017 ◽

1993 ◽

Keyword(s):

Stable Model ◽

Logic Programs ◽

Semantics Of Logic Programs

Download Full-text

Checking termination of bottom-up evaluation of logic programs with function symbols

Theory and Practice of Logic Programming ◽

10.1017/s1471068414000623 ◽

2014 ◽

Vol 15 (6) ◽

pp. 854-889 ◽

Cited By ~ 5

Author(s):

MARCO CALAUTTI ◽

SERGIO GRECO ◽

FRANCESCA SPEZZANO ◽

IRINA TRUBITSYNA

Keyword(s):

Evaluation Procedure ◽

Extended Version ◽

Logic Programs ◽

Safety Criterion ◽

Bottom Up ◽

Program Termination ◽

Termination Criteria ◽

Safety Function ◽

Semantics Of Logic Programs ◽

Termination Problem

AbstractRecently, there has been an increasing interest in the bottom-up evaluation of the semantics of logic programs with complex terms. The presence of function symbols in the program may render the ground instantiation infinite, and finiteness of models and termination of the evaluation procedure, in the general case, are not guaranteed anymore. Since the program termination problem is undecidable in the general case, several decidable criteria (called program termination criteria) have been recently proposed. However, current conditions are not able to identify even simple programs, whose bottom-up execution always terminates. The paper introduces new decidable criteria for checking termination of logic programs with function symbols under bottom-up evaluation, by deeply analyzing the program structure. First, we analyze the propagation of complex terms among arguments by means of the extended version of the argument graph calledpropagation graph. The resulting criterion, calledacyclicity, generalizes most of the decidable criteria proposed so far. Next, we study how rules may activate each other and define a more powerful criterion, calledsafety. This criterion uses the so-calledsafety functionable to analyze how rules may activate each other and how the presence of some arguments in a rule limits its activation. We also study the application of the proposed criteria to bound queries and show that the safety criterion is well-suited to identify relevant classes of programs and bound queries. Finally, we propose a hierarchy of classes of terminating programs, calledk-safety, where thek-safe class strictly includes the (k-1)-safe class.

Download Full-text