Safe Inductions: An Algebraic Study

Logic Programming ◽

Logic Programs ◽

Intended Meaning ◽

Safety Criterion ◽

Autoepistemic Logic ◽

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.

Truth versus information in logic programming

10.1017/s1471068413000069 ◽

2013 ◽

Vol 14 (6) ◽

pp. 803-840 ◽

Cited By ~ 2

Author(s):

LEE NAISH ◽

HARALD SØNDERGAARD

Keyword(s):

Logic Programming ◽

Program Analysis ◽

Logic Program ◽

Logic Programs ◽

Intended Meaning ◽

Truth Values ◽

The Third ◽

Multiple Valued Logic ◽

Truth Value ◽

Semantics Of Logic Programs

AbstractThe semantics of logic programs was originally described in terms of two-valued logic. Soon, however, it was realised that three-valued logic had some natural advantages, as it provides distinct values not only for truth and falsehood but also for “undefined”. The three-valued semantics proposed by Fitting (Fitting, M. 1985. A Kripke–Kleene semantics for logic programs. Journal of Logic Programming 2, 4, 295–312) and Kunen (Kunen, K. 1987. Negation in logic programming. Journal of Logic Programming 4, 4, 289–308) are closely related to what is computed by a logic program, the third truth value being associated with non-termination. A different three-valued semantics, proposed by Naish, shared much with those of Fitting and Kunen but incorporated allowances for programmer intent, the third truth value being associated with underspecification. Naish used an (apparently) novel “arrow” operator to relate the intended meaning of left and right sides of predicate definitions. In this paper we suggest that the additional truth values of Fitting/Kunen and Naish are best viewed as duals. We use Belnap's four-valued logic (Belnap, N. D. 1977. A useful four-valued logic. In Modern Uses of Multiple-Valued Logic, J. M. Dunn and G. Epstein, Eds. D. Reidel, Dordrecht, Netherlands, 8–37), also used elsewhere by Fitting, to unify the two three-valued approaches. The truth values are arranged in a bilattice, which supports the classical ordering on truth values as well as the “information ordering”. We note that the “arrow” operator of Naish (and our four-valued extension) is essentially the information ordering, whereas the classical arrow denotes the truth ordering. This allows us to shed new light on many aspects of logic programming, including program analysis, type and mode systems, declarative debugging and the relationships between specifications and programs, and successive execution states of a program.

Well-founded and stable semantics of logic programs with aggregates

10.1017/s1471068406002973 ◽

2007 ◽

Vol 7 (3) ◽

pp. 301-353 ◽

Cited By ~ 57

Author(s):

NIKOLAY PELOV ◽

MARC DENECKER ◽

MAURICE BRUYNOOGHE

Keyword(s):

Logic Programming ◽

Second Order ◽

Logic Programs ◽

Consequence Operator ◽

Trade Offs ◽

Stable Semantics ◽

Consequence Operators ◽

Stable Models

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.

Logic programming with social features

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.

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

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 ◽

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.

Fuzzy linguistic logic programming and its applications

10.1017/s1471068409003779 ◽

2009 ◽

Vol 9 (3) ◽

pp. 309-341 ◽

Cited By ~ 19

Author(s):

VAN HUNG LE ◽

FEI LIU ◽

DINH KHANG TRAN

Keyword(s):

Logic Programming ◽

Logic Programs ◽

Linguistic Terms ◽

Natural Languages ◽

Procedural Semantics ◽

Declarative Semantics ◽

Linguistic Hedges ◽

Fuzzy Linguistic ◽

Different Levels

AbstractThe paper introduces fuzzy linguistic logic programming, which is a combination of fuzzy logic programming, introduced by P. Vojtáš, and hedge algebras in order to facilitate the representation and reasoning on human knowledge expressed in natural languages. In fuzzy linguistic logic programming, truth values are linguistic ones, e.g., VeryTrue, VeryProbablyTrue and LittleFalse, taken from a hedge algebra of a linguistic truth variable, and linguistic hedges (modifiers) can be used as unary connectives in formulae. This is motivated by the fact that humans reason mostly in terms of linguistic terms rather than in terms of numbers, and linguistic hedges are often used in natural languages to express different levels of emphasis. The paper presents: (a) the language of fuzzy linguistic logic programming; (b) a declarative semantics in terms of Herbrand interpretations and models; (c) a procedural semantics which directly manipulates linguistic terms to compute a lower bound to the truth value of a query, and proves its soundness; (d) a fixpoint semantics of logic programs, and based on it, proves the completeness of the procedural semantics; (e) several applications of fuzzy linguistic logic programming; and (f) an idea of implementing a system to execute fuzzy linguistic logic programs.

On the Semantics of Logic Programs with Preferences

Journal of Artificial Intelligence Research ◽

10.1613/jair.2371 ◽

2007 ◽

Vol 30 ◽

pp. 501-523 ◽

Cited By ~ 4

Author(s):

S. Greco ◽

I. Trubitsyna ◽

E. Zumpano

Keyword(s):

Logic Programming ◽

Complexity Analysis ◽

Structural Information ◽

Logic Program ◽

Set Optimization ◽

Logic Programs ◽

Preference Relations ◽

New Interpretation ◽

Stable Models

This work is a contribution to prioritized reasoning in logic programming in the presence of preference relations involving atoms. The technique, providing a new interpretation for prioritized logic programs, is inspired by the semantics of Prioritized Logic Programming and enriched with the use of structural information of preference of Answer Set Optimization Programming. Specifically, the analysis of the logic program is carried out together with the analysis of preferences in order to determine the choice order and the sets of comparable models. The new semantics is compared with other approaches known in the literature and complexity analysis is also performed, showing that, with respect to other similar approaches previously proposed, the complexity of computing preferred stable models does not increase.

Knowledge Representation to Empower Expert Systems

Encyclopedia of Decision Making and Decision Support Technologies ◽

10.4018/978-1-59904-843-7.ch064 ◽

2011 ◽

pp. 576-583

Author(s):

James D. Jones

Keyword(s):

Expert Systems ◽

Logic Programming ◽

Programming Languages ◽

Default Reasoning ◽

Logic Programs ◽

Specific Domain ◽

Negation As Failure ◽

Complex Forms ◽

Representation Scheme

Knowledge representation is a field of artificial intelligence that has been actively pursued since the 1940s.1 The issues at stake are that given a specific domain, how do we represent knowledge in that domain, and how do we reason about that domain? This issue of knowledge representation is of paramount importance, since the knowledge representation scheme may foster or hinder reasoning. The representation scheme can enable reasoning to take place, or it may make the desired reasoning impossible. To some extent, the knowledge representation depends upon the underlying technology. For instance, in order to perform default reasoning with exceptions, one needs weak negation (aka negation as failure. In fact, most complex forms of reasoning will require weak negation. This is a facility that is an integral part of logic programs but is lacking from expert system shells. Many Prolog implementations provide negation as failure, however, they do not understand nor implement the proper semantics. The companion article to this article in this volume, “Logic Programming Languages for Expert Systems,” discusses logic programming and negation as failure.

Contextual hypotheses and semantics of logic programs

10.1017/s1471068411000378 ◽

2011 ◽

Vol 12 (6) ◽

pp. 843-887 ◽

Cited By ~ 2

Author(s):

ÉRIC A. MARTIN

Keyword(s):

Logic Programming ◽

The Body ◽

Stable Model ◽

Logic Programs ◽

Hypothetical Reasoning ◽

Unique Form ◽

Classical Negation ◽

Unified View ◽

Answer Set Semantics ◽

Semantics Of Logic Programs

AbstractLogic programming has developed as a rich field, built over a logical substratum whose main constituent is a nonclassical form of negation, sometimes coexisting with classical negation. The field has seen the advent of a number of alternative semantics, with Kripke–Kleene semantics, the well-founded semantics, the stable model semantics, and the answer-set semantics standing out as the most successful. We show that all aforementioned semantics are particular cases of a generic semantics, in a framework where classical negation is the unique form of negation and where the literals in the bodies of the rules can be ‘marked’ to indicate that they can be the targets of hypotheses. A particular semantics then amounts to choosing a particular marking scheme and choosing a particular set of hypotheses. When a literal belongs to the chosen set of hypotheses, all marked occurrences of that literal in the body of a rule are assumed to be true, whereas the occurrences of that literal that have not been marked in the body of the rule are to be derived in order to contribute to the firing of the rule. Hence the notion of hypothetical reasoning that is presented in this framework is not based on making global assumptions, but more subtly on making local, contextual assumptions, taking effect as indicated by the chosen marking scheme on the basis of the chosen set of hypotheses. Our approach offers a unified view on the various semantics proposed in logic programming, classical in that only classical negation is used, and links the semantics of logic programs to mechanisms that endow rule-based systems with the power to harness hypothetical reasoning.

Deriving conclusions from non-monotonic cause-effect relations

10.1017/s1471068416000466 ◽

2016 ◽

Vol 16 (5-6) ◽

pp. 670-687 ◽

Cited By ~ 4

Author(s):

JORGE FANDINNO

Keyword(s):

Logic Programming ◽

Causal Effect ◽

Stable Model ◽

Logic Programs ◽

Causal Relations ◽

Initial Approach ◽

Sufficient Cause ◽

Different Types ◽

Normal Logic

AbstractWe present an extension of Logic Programming (under stable models semantics) that, not only allows concluding whether a true atom is a cause of another atom, but alsoderiving new conclusionsfrom these causal-effect relations. This is expressive enough to capture informal rules like “if some agent's actionshave beennecessaryto cause an eventEthen conclude atomcaused(,E),” something that, to the best of our knowledge, had not been formalised in the literature. To this aim, we start from a first attempt that proposed extending the syntax of logic programs with so-calledcausal literals. These causal literals are expressions that can be used in rule bodies and allow inspecting the derivation of some atomAin the program with respect to some query function ψ. Depending on how these query functions are defined, we can model different types of causal relations such as sufficient, necessary or contributory causes, for instance. The initial approach was specifically focused on monotonic query functions. This was enough to cover sufficient cause-effect relations but, unfortunately, necessary and contributory are essentiallynon-monotonic. In this work, we define a semantics for non-monotonic causal literals showing that, not only extends the stable model semantics for normal logic programs, but also preserves many of its usual desirable properties for the extended syntax. Using this new semantics, we provide precise definitions ofnecessaryandcontributorycausal relations and briefly explain their behaviour on a pair of typical examples from the Knowledge Representation literature.

Two results for prioritized logic programming

10.1017/s1471068402001552 ◽

2003 ◽

Vol 3 (2) ◽

pp. 223-242 ◽

Cited By ~ 8

Author(s):

YAN ZHANG

Keyword(s):

Logic Programming ◽

Logic Program ◽

Default Reasoning ◽

Knowledge Representation And Reasoning ◽

Logic Programs ◽

Splitting Technique ◽

Close Relationship ◽

Answer Set Semantics ◽

Answer Set

Prioritized default reasoning has illustrated its rich expressiveness and flexibility in knowledge representation and reasoning. However, many important aspects of prioritized default reasoning have yet to be thoroughly explored. In this paper, we investigate two properties of prioritized logic programs in the context of answer set semantics. Specifically, we reveal a close relationship between mutual defeasibility and uniqueness of the answer set for a prioritized logic program. We then explore how the splitting technique for extended logic programs can be extended to prioritized logic programs. We prove splitting theorems that can be used to simplify the evaluation of a prioritized logic program under certain conditions.