RECOGNIZING NON-FLOUNDERING LOGIC PROGRAMS AND GOALS

1990 ◽  
Vol 01 (02) ◽  
pp. 151-163 ◽  
Author(s):  
ROBERTO BARBUTI ◽  
MAURIZIO MARTELLI
Keyword(s):  
Logic Programming ◽  
Abstract Interpretation ◽  
Logic Programs ◽  
Negation As Failure ◽  
Proof Procedure ◽  
Resolution Proof

The introduction of negation in Logic Programming using the Negation as Failure Rule causes some problems regarding the completeness of the SLDNF-Resolution proof procedure. One of the causes of incompleteness arises when evaluating a non-ground negative literal. This is solved by forbidding these evaluations. Obviously, there is the possibility of having only non-ground negative literals in the goal (the floundering of the goal). There is a class of programs and goals (allowed) that has been proved to have the non-floundering property. In this paper an algorithm is proposed which recognizes a wider class of programs with this property and which is based on abstract interpretation techniques.

A PROOF PROCEDURE FOR TEMPORAL LOGIC PROGRAMMING

2004 ◽  
Vol 15 (02) ◽  
pp. 417-443 ◽  
Author(s):  
MANOLIS GERGATSOULIS ◽  
CHRISTOS NOMIKOS
Keyword(s):  
Logic Programming ◽  
Programming Languages ◽  
Temporal Logic ◽  
Programming Language ◽  
Branching Time ◽  
Logic Programs ◽  
Temporal Logic Programming ◽  
Time Logic ◽  
Proof Procedure ◽  
Resolution Proof

In this paper, we propose a new resolution proof procedure for the branching-time logic programming language Cactus. The particular strength of the new proof procedure, called CSLD-resolution, is that it can handle, in a more general way, open-ended queries, i.e. goal clauses that include atoms which do not refer to specific moments in time, without the need of enumerating all their canonical instances. We also prove soundness, completeness and independence of the computation rule for CSLD-resolution. The new proof procedure overcomes the limitations of a family of proof procedures for temporal logic programming languages, which were based on the notions of canonical program and goal clauses. Moreover, it applies directly to Chronolog programs and it can be easily extended to apply to multi-dimensional logic programs as well as to Chronolog(MC) programs.

scholarly journals Optimality in goal-dependent analysis of Sharing

2009 ◽  
Vol 9 (05) ◽  
pp. 617-689 ◽  
Author(s):  
GIANLUCA AMATO ◽  
FRANCESCA SCOZZARI
Keyword(s):  
Logic Programming ◽  
Static Analysis ◽  
Abstract Interpretation ◽  
Logic Programs ◽  
Semantic Operators

AbstractWe face the problems of correctness, optimality, and precision for the static analysis of logic programs, using the theory of abstract interpretation. We propose a framework with a denotational, goal-dependent semantics equipped with two unification operators for forward unification (calling a procedure) and backward unification (returning from a procedure). The latter is implemented through a matching operation. Our proposal clarifies and unifies many different frameworks and ideas on static analysis of logic programming in a single, formal setting. On the abstract side, we focus on the domainsharingby Jacobs and Langen (The Journal of Logic Programming, 1992, vol. 13, nos. 2–3, pp. 291–314) and provide the best correct approximation of all the primitive semantic operators, namely, projection, renaming, and forward and backward unifications. We show that the abstract unification operators are strictly more precise than those in the literature defined over the same abstract domain. In some cases, our operators are more precise than those developed for more complex domains involving linearity and freeness.

Negation as Failure, Completion and Stratification

1998 ◽  
Author(s):  
J. C. Shepherdson
Keyword(s):  
Logic Programming ◽  
Logical Consequence ◽  
Complete Proof ◽  
Negation As Failure ◽  
Closed World ◽  
Classical Negation ◽  
Declarative Semantics ◽  
Proof Procedure ◽  
The Given ◽  
Ground Atom

The usual way of introducing negation into Horn clause logic programming is by ‘negation as failure’: if A is a ground atom . . . the goal ¬A succeeds if A fails the goal ¬A fails if A succeeds. . . . This is obviously not classical negation, at least not relative to the given program P; the fact that A fails from P does not mean that you can prove ¬A from P, e.g. if P is . . . a ← ¬b . . . then ? - b fails so, using negation as failure, ? – a succeeds, but a is not a logical consequence of P. You could deal with classical negation by using a form of resolution which gave a complete proof procedure for full first order logic. To a logician this would be the natural thing to do. Two reasons are commonly given for why this is not done. The first is that it is believed by most, but not all, practitioners, that this would be infeasible because it would lead to a combinatorial explosion, whereas negation as failure does not, since it is not introducing any radically new methods of inference, just turning the old ones round. The second is that, in practical logic programming, negation as failure is often more useful than classical negation. This is the case when the program is a database, e.g. an airline timetable. You list all the flights there are. If there is no listed flight from Zurich to London at 12.31, then you conclude that there is no such flight. The implicit use of negation as failure here saves us the enormous labour of listing all the non-existent flights. This implicit usage is made precise in the closed world assumption, one of the two commonest declarative semantics given for negation as failure. This was introduced by Reiter [1978] and formalises the idea that the database contains all the positive information about objects in the domain, that any positive ground literal which is not implied by the program is assumed to be false.

Knowledge Representation to Empower Expert Systems

2011 ◽  
pp. 576-583
Author(s):  
James D. Jones
Keyword(s):  
Knowledge Representation ◽  
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.

Proof Procedures for Logic Programming

1998 ◽  
Author(s):  
Donald W. Loveland ◽  
Gopalan Nadathur
Keyword(s):  
Logic Programming ◽  
Theorem Proving ◽  
Automated Theorem Proving ◽  
Order Logic ◽  
First Order Logic ◽  
First Order ◽  
Proof Procedure ◽  
Sld Resolution ◽  
Work Done ◽  
Resolution Proof

A proof procedure is an algorithm (technically, a semi-decision procedure) which identifies a formula as valid (or unsatisfiable) when appropriate, and may not terminate when the formula is invalid (satisfiable). Since a proof procedure concerns a logic the procedure takes a special form, superimposing a search strategy on an inference calculus. We will consider a certain collection of proof procedures in the light of an inference calculus format that abstracts the concept of logic programming. This formulation allows us to look beyond SLD-resolution, the proof procedure that underlies Prolog, to generalizations and extensions that retain an essence of logic programming structure. The inference structure used in the formulation of the logic programming concept and first realization, Prolog, evolved from the work done in the subdiscipline called automated theorem proving. While many proof procedures have been developed within this subdiscipline, some of which appear in Volume 1 of this handbook, we will present a narrow selection, namely the proof procedures which are clearly ancestors of the first proof procedure associated with logic programming, SLD-resolution. Extensive treatment of proof procedures for automated theorem proving appear in Bibel [Bibel, 1982], Chang and Lee [Chang and Lee, 1973] and Loveland [Loveland, 1978]. Although the consideration of proof procedures for automated theorem proving began about 1958 we begin our overview with the introduction of the resolution proof procedure by Robinson in 1965. We then review the linear resolution procedures, model elimination and SL-resolution procedures. Our exclusion of other proof procedures from consideration here is due to our focus, not because other procedures are less important historically or for general use within automated or semi-automated theorem process. After a review of the general resolution proof procedure, we consider the linear refinement for resolution and then further restrict the procedure format to linear input resolution. Here we are no longer capable of treating full first-order logic, but have forced ourselves to address a smaller domain, in essence the renameable Horn clause formulas. By leaving the resolution format, indeed leaving traditional formula representation, we see there exists a linear input procedure for all of first-order logic.

scholarly journals Evaluation of the Implementation of an Abstract Interpretation Algorithm using Tabled CLP

2019 ◽  
Vol 19 (5-6) ◽  
pp. 1107-1123
Author(s):  
JOAQUÍN ARIAS ◽  
MANUEL CARRO
Keyword(s):  
Logic Programming ◽  
Abstract Interpretation ◽  
Constraint Logic Programming ◽  
Additional Cost ◽  
Logic Programs ◽  
Semantic Equivalence ◽  
Constraint Solver ◽  
Abstract Domains ◽  
Interpretation Algorithm ◽  
Branch Switching

AbstractCiaoPP is an analyzer and optimizer for logic programs, part of the Ciao Prolog system. It includes PLAI, a fixpoint algorithm for the abstract interpretation of logic programs which we adapt to use tabled constraint logic programming. In this adaptation, the tabling engine drives the fixpoint computation, while the constraint solver handles the LUB of the abstract substitutions of different clauses. That simplifies the code and improves performance, since termination, dependencies, and some crucial operations (e.g., branch switching and resumption) are directly handled by the tabling engine. Determining whether the fixpoint has been reached uses semantic equivalence, which can decide that two syntactically different abstract substitutions represent the same element in the abstract domain. Therefore, the tabling analyzer can reuse answers in more cases than an analyzer using syntactical equality. This helps achieve better performance, even taking into account the additional cost associated to these checks. Our implementation is based on the TCLP framework available in Ciao Prolog and is one-third the size of the initial fixpoint implementation in CiaoPP. Its performance has been evaluated by analyzing several programs using different abstract domains.

scholarly journals An effective fixpoint semantics for linear logic programs

2001 ◽  
Vol 2 (1) ◽  
pp. 85-122 ◽  
Author(s):  
MARCO BOZZANO ◽  
GIORGIO DELZANNO ◽  
MAURIZIO MARTELLI
Keyword(s):  
Logic Programming ◽  
Petri Nets ◽  
Abstract Interpretation ◽  
Theoretical Foundation ◽  
Linear Logic ◽  
Sufficient Conditions ◽  
Logic Programs ◽  
Bottom Up ◽  
Interesting Class ◽  
Fixpoint Semantics

In this paper we investigate the theoretical foundation of a new bottom-up semantics for linear logic programs, and more precisely for the fragment of LinLog (Andreoli, 1992) that consists of the language LO (Andreoli & Pareschi, 1991) enriched with the constant 1. We use constraints to symbolically and finitely represent possibly infinite collections of provable goals. We define a fixpoint semantics based on a new operator in the style of TP working over constraints. An application of the fixpoint operator can be computed algorithmically. As sufficient conditions for termination, we show that the fixpoint computation is guaranteed to converge for propositional LO. To our knowledge, this is the first attempt to define an effective fixpoint semantics for linear logic programs. As an application of our framework, we also present a formal investigation of the relations between LO and Disjunctive Logic Programming (Minker et al., 1991). Using an approach based on abstract interpretation, we show that DLP fixpoint semantics can be viewed as an abstraction of our semantics for LO. We prove that the resulting abstraction is correct and complete (Cousot & Cousot, 1977; Giacobazzi & Ranzato, 1997) for an interesting class of LO programs encoding Petri Nets.

scholarly journals Infinite-game semantics for logic programming languages

2014 ◽  
Author(s):  
Χρυσίδα Γαλανάκη
Keyword(s):  
Logic Programming ◽  
Programming Languages ◽  
Intensional Logic ◽  
Unified Theory ◽  
Logic Programs ◽  
Computational Logic ◽  
Game Semantics ◽  
Negation As Failure ◽  
Infinite Game ◽  
Ground Atom

Η διατριβή επικεντρώνεται στη μελέτη της σημασιολογίας λογικών προγραμμάτων και την ανάπτυξη άπειρων παιγνίων πλήρους πληροφόρησης που αποδίδουν αυτή τη σημασιολογία. Αρχικώς, μελετάται ο προτασιακός λογικός προγραμματισμός. Στο άρθρο [M.H. van Emden, Quantitative deduction and its fixpoint theory, Journal of Logic Programming 3(1)(1986) 37-53] περιγράφεται ένα παίγνιο μεταξύ δύο παικτών. Σε αυτό, δεδομένου ενός προτασιακού λογικού προγράμματος χωρίς άρνηση και ενός ατόμου (ground atom) που ανήκει σε αυτό, ο Παίκτης Ι, προσπαθεί να αποδείξει ότι ο ατομικός τύπος είναι αληθής (έχει δηλαδή το ρόλο του Believer), ενώ ο Παίκτης ΙΙ ότι δεν είναι (έχει δηλαδή το ρόλο του Doubter). Έτσι ο στόχος (goal), επιτυγχάνει ως αποτέλεσμα μιας ερώτησης (query) στο πρόγραμμα, αν ο Παίκτης Ι έχει νικηφόρα στρατηγική. Στα πλαίσια της διατριβής, το παίγνιο επεκτείνεται έτσι ώστε να αποδίδει τη σημασιολογία και των προγραμμάτων με άρνηση. Όταν κατά τη διάρκεια του παιχνιδιού εμφανίζεται αρνητικά προσημασμένο άτομο, τότε οι δύο παίκτες αλλάζουν τους μεταξύ τους ρόλους. Ο Believer γίνεται Doubter και το αντίστροφο. Στην περίπτωση άπειρων εναλλαγών ρόλων το παιχνίδι θεωρείται ισόπαλο. Αποδεικνύεται ότι το παίγνιο είναι αποφασισμένο (determined). Στην περίπτωση του παιχνιδιού με τρία δυνατά αποτελέσματα, η ερμηνεία του προγράμματος, η οποία λαμβάνεται χρησιμοποιώντας το παιχνίδι, αποτελεί μοντέλο του και αποδεικνύεται ισοδύναμη με την καλώς θεμελιωμένη σημασιολογία (well-founded semantics) του λογικού προγράμματος. Για την απόδειξη αυτή ορίζεται και χρησιμοποιείται ένα νέο παίγνιο με άπειρα δυνατά αποτελέσματα. Η τιμή του παιχνιδιού εξαρτάται από το πλήθος των εναλλαγών ρόλων (role switches) που λαμβάνουν χώρα κατά τη διάρκειά του. Η ερμηνεία που παίρνουμε χρησιμοποιώντας το παίγνιο αυτό, αποτελεί μοντέλο του λογικού προγράμματος και αποδεικνύεται ισοδύναμη με την απειρότιμη σημασιολογία ελαχίστου μοντέλου, όπως αυτή ορίζεται στο [P. Rondogiannis, W.W.Wadge, Minimum model semantics for logic programs with negation-as-failure, ACM Transactions on Computational Logic 6(2)(2005) 441-467]. Η μελέτη επεκτείνεται στον νοηματικό (intensional) λογικό προγραμματισμό όπως παρουσιαζεται στο [M.A. Orgun, W.W.Wadge, Towards a unified theory of intensional logic programming, 13(4):413-440, 1992] και αποτελεί γενίκευση, μεταξύ άλλων, του χρονικού (temporal) και τροπικού (modal) λογικού προγραμματισμού. Στα πλαίσια της διατριβής αναπτύσσεται ένα νέο παίγνιο πλήρους πληροφόρησης. Και για αυτό, αποδεικνύεται ότι είναι αποφασισμένο (determined) και ότι το αποτέλεσμά του συμπίπτει με τη σημασιολογία ελαχίστου μοντέλου του άρθρου των M.A. Orgun, W.W. Wadge. Στη συνέχεια το παίγνιο επεκτείνεται έτσι ώστε να υποστηρίζει εναλλαγή ρόλων μεταξύ των παικτών και να έχει τρία δυνατά αποτελέσματα (νίκη για τον Παίκτη Ι ή τον Παίκτη ΙΙ ή ισοπαλία). Η ερμηνεία την οποία παίρνουμε χρησιμοποιώντας το παιχνίδι, αποτελεί ελαχιστικό μοντέλο του προγράμματος και αποδίδει τη σημασιολογία νοηματικών λογικών προγραμμάτων με άρνηση και γενικότερα των νοηματικών λογικών προγραμμάτων με οποιoδήποτε μη μονοτονικό τελεστή στο σώμα των κανόνων. Η παιγνιοθεωρητική αυτή προσέγγιση αποτελεί και το πρώτο σημασιολογικό πλαίσιο για τον μη μονοτονικό νοηματικό (intensional) λογικό προγραμματισμό.

CUT-PROPERTY AND NEGATION AS FAILURE

1994 ◽  
Vol 05 (02) ◽  
pp. 129-164 ◽  
Author(s):  
ROBERT F. STÄRK
Keyword(s):  
Logic Programming ◽  
Sequent Calculus ◽  
Logic Program ◽  
Logic Programs ◽  
Possible World ◽  
Property A ◽  
Rule Based ◽  
Negation As Failure ◽  
Constructive Proofs

What is the semantics of Negation-as-Failure in logic programming? We try to answer this question by proof-theoretic methods. A rule based sequent calculus is used in which a sequent is provable if, and only if, it is true in all three-valued models of the completion of a logic program. The main theorem is that proofs in the sequent calculus can be transformed into SLDNF-computations if, and only if, a program has the cut-property. A fragment of the sequent calculus leads to a sound and complete semantics for SLDNF-resolution with substitutions. It turns out that this version of SLDNF-resolution is sound and complete with respect to three-valued possible world models of the completion for arbitrary logic programs and arbitrary goals. Since we are dealing with possibly nonterminating computations and constructive proofs, three-valued possible world models seem to be an appropriate semantics.

A Modal Semantics of Negation in Logic Programming

1992 ◽  
Vol 16 (3-4) ◽  
pp. 231-262
Author(s):  
Philippe Balbiani
Keyword(s):  
Modal Logic ◽  
Logic Programming ◽  
Modal Logics ◽  
Kripke Models ◽  
Logic Programs ◽  
Modal Semantics ◽  
Soundness And Completeness ◽  
Modal Completion ◽  
Well Foundedness

The beauty of modal logics and their interest lie in their ability to represent such different intensional concepts as knowledge, time, obligation, provability in arithmetic, … according to the properties satisfied by the accessibility relations of their Kripke models (transitivity, reflexivity, symmetry, well-foundedness, …). The purpose of this paper is to study the ability of modal logics to represent the concepts of provability and unprovability in logic programming. The use of modal logic to study the semantics of logic programming with negation is defended with the help of a modal completion formula. This formula is a modal translation of Clack’s formula. It gives soundness and completeness proofs for the negation as failure rule. It offers a formal characterization of unprovability in logic programs. It characterizes as well its stratified semantics.

Sign in / Sign up

Export Citation Format

Share Document