MODULARITY AND CORRECTNESS FOR LOGIC PROGRAMS AND KNOWLEDGE BASES

1994 ◽  
Vol 04 (02) ◽  
pp. 257-275
Author(s):  
GRIGORIS ANTONIOU
Keyword(s):  
Logic Programming ◽  
Programming Languages ◽  
Formal Semantics ◽  
Knowledge Bases ◽  
Algebraic Specification ◽  
Equational Logic ◽  
Logic Programs ◽  
Horn Logic ◽  
Large Systems ◽  
The One

A modularity concept for structuring and developing large logic programs and logical knowledge bases is presented. The concept is motivated from work in the field of algebraic specification, and enforces an extreme modularity discipline that goes beyond the one found in imperative or logic programming languages. As concrete programming languages (respectively knowledge representation formalisms), we consider Horn logic and equational logic programming. We give formal semantics for single modules and discuss correctness and verification issues. Large systems are constructed as interconnections of single modules. We introduce the so-called module operations of composition, actualization, and union, and give results concerning compositionality of semantics and correctness preservation.

Equational Logic Programming

1998 ◽  
Author(s):  
Michael J. O’Donnell
Keyword(s):  
Normal Form ◽  
Logic Programming ◽  
Programming Languages ◽  
Question Answering ◽  
Normal Forms ◽  
Equational Logic ◽  
Consequence Relation ◽  
Logic Programming Languages ◽  
Semantic Consequence

Sections 2.3.4 and 2.3.5 of the chapter ‘Introduction: Logic and Logic Programming Languages’ are crucial prerequisites to this chapter. I summarize their relevance below, but do not repeat their content. Logic programming languages in general are those that compute by deriving semantic consequences of given formulae in order to answer questions. In equational logic programming languages, the formulae are all equations expressing postulated properties of certain functions, and the questions ask for equivalent normal forms for given terms. Section 2.3.4 of the ‘Introduction . . .’ chapter gives definitions of the models of equational logic, the semantic consequence relation . . . T |=≐(t1 ≐ t2) . . . (t1 ≐ t2 is a semantic consequence of the set T of equations, see Definition 2.3.14), and the question answering relation . . . (norm t1,…,ti : t) ?- ≐ (t ≐ s) . . . (t ≐ s asserts the equality of t to the normal form s, which contains no instances of t1, . . . , ti, see Definition 2.3.16).

Introduction: Logic and Logic Programming Languages

1998 ◽  
Author(s):  
Michael J. O’Donnell
Keyword(s):  
Logic Programming ◽  
Programming Languages ◽  
Historical Development ◽  
Theoretical Computer Science ◽  
Equational Logic ◽  
Computer Scientists ◽  
General Schema ◽  
Similarities And Differences ◽  
Logic Programming Languages ◽  
Order Predicate Calculus

Logic, according to Webster’s dictionary [Webster, 1987], is ‘a science that deals with the principles and criteria of validity of inference and demonstration: the science of the formal principles of reasoning.' Such 'principles and criteria’ are always described in terms of a language in which inference, demonstration, and reasoning may be expressed. One of the most useful accomplishments of logic for mathematics is the design of a particular formal language, the First Order Predicate Calculus (FOPC). FOPC is so successful at expressing the assertions arising in mathematical discourse that mathematicians and computer scientists often identify logic with classical logic expressed in FOPC. In order to explore a range of possible uses of logic in the design of programming languages, we discard the conventional identification of logic with FOPC, and formalize a general schema for a variety of logical systems, based on the dictionary meaning of the word. Then, we show how logic programming languages may be designed systematically for any sufficiently effective logic, and explain how to view Prolog, Datalog, λProlog, Equational Logic Programming, and similar programming languages, as instances of the general schema of logic programming. Other generalizations of logic programming have been proposed independently by Meseguer [Meseguer, 1989], Miller, Nadathur, Pfenning and Scedrov [Miller et al., 1991], Goguen and Burstall [Goguen and Burstall, 1992]. The purpose of this chapter is to introduce a set of basic concepts for understanding logic programming, not in terms of its historical development, but in a systematic way based on retrospective insights. In order to achieve a systematic treatment, we need to review a number of elementary definitions from logic and theoretical computer science and adapt them to the needs of logic programming. The result is a slightly modified logical notation, which should be recognizable to those who know the traditional notation. Conventional logical notation is also extended to new and analogous concepts, designed to make the similarities and differences between logical relations and computational relations as transparent as possible. Computational notation is revised radically to make it look similar to logical notation.

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.

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.

scholarly journals CP-logic: A language of causal probabilistic events and its relation to logic programming

2009 ◽  
Vol 9 (3) ◽  
pp. 245-308 ◽  
Author(s):  
JOOST VENNEKENS ◽  
MARC DENECKER ◽  
MAURICE BRUYNOOGHE
Keyword(s):  
Logic Programming ◽  
Formal Semantics ◽  
Probabilistic Logic ◽  
Logic Programs ◽  
Causal Knowledge ◽  
Fundamental Study ◽  
Logical Language ◽  
Logical Representation ◽  
Causal Laws ◽  
Probability Trees

AbstractThis paper develops a logical language for representing probabilistic causal laws. Our interest in such a language is two-fold. First, it can be motivated as a fundamental study of the representation of causal knowledge. Causality has an inherent dynamic aspect, which has been studied at the semantical level by Shafer in his framework of probability trees. In such a dynamic context, where the evolution of a domain over time is considered, the idea of a causal law as something which guides this evolution is quite natural. In our formalization, a set of probabilistic causal laws can be used to represent a class of probability trees in a concise, flexible and modular way. In this way, our work extends Shafer's by offering a convenient logical representation for his semantical objects. Second, this language also has relevance for the area of probabilistic logic programming. In particular, we prove that the formal semantics of a theory in our language can be equivalently defined as a probability distribution over the well-founded models of certain logic programs, rendering it formally quite similar to existing languages such as ICL or PRISM. Because we can motivate and explain our language in a completely self-contained way as a representation of probabilistic causal laws, this provides a new way of explaining the intuitions behind such probabilistic logic programs: we can say precisely which knowledge such a program expresses, in terms that are equally understandable by a non-logician. Moreover, we also obtain an additional piece of knowledge representation methodology for probabilistic logic programs, by showing how they can express probabilistic causal laws.

The relation between logic programming and logic specification

1984 ◽  
Vol 312 (1522) ◽  
pp. 345-361 ◽  
Keyword(s):  
Logic Programming ◽  
Programming Languages ◽  
Programming Language ◽  
Specification Language ◽  
Formal Logic ◽  
Automated Deduction ◽  
Logic Programs ◽  
Computing Science ◽  
Complete Specification ◽  
Representation Of Knowledge

Formal logic is widely accepted as a program specification language in computing science. It is ideally suited to the representation of knowledge and the description of problems without regard to the choice of programming language. Its use as a specification language is compatible not only with conventional programming languages but also with programming languages based entirely on logic itself. In this paper I shall investigate the relation that holds when both programs and program specifications are expressed in formal logic. In many cases, when a specification completely defines the relations to be computed, there is no syntactic distinction between specification and program. Moreover the same mechanism that is used to execute logic programs, namely automated deduction, can also be used to execute logic specifications. Thus all relations defined by complete specifications are executable. The only difference between a complete specification and a program is one of efficiency. A program is more efficient than a specification.

The language of epistemic specifications (refined) including a prototype solver

2015 ◽  
Vol 30 (4) ◽  
pp. 953-989 ◽  
Author(s):  
Patrick Kahl ◽  
Richard Watson ◽  
Evgenii Balai ◽  
Michael Gelfond ◽  
Yuanlin Zhang
Keyword(s):  
Logic Programming ◽  
Programming Language ◽  
Epistemic Logic ◽  
Formal Semantics ◽  
Logic Program ◽  
Logic Programs ◽  
Logic Programming Language ◽  
Conformant Planning

Abstract In this article, we present a new version of the language of Epistemic Specifications. The goal is to simplify and improve the intuitive and formal semantics of the language. We describe an algorithm for computing solutions of programs written in this new version of the language. The new semantics is illustrated by a number of examples, including an Epistemic Specifications-based framework for conformant planning. In addition, we introduce the notion of an epistemic logic program with sorts . This extends recent efforts to define a logic programming language that includes the means for explicitly specifying the domains of predicate parameters. An algorithm and its implementation as a solver for epistemic logic programs with sorts is also discussed.

scholarly journals Alternating Fixpoint Operator for Hybrid MKNF Knowledge Bases as an Approximator of AFT

2021 ◽  
pp. 1-30
Author(s):  
FANGFANG LIU ◽  
JIA-HUAI YOU
Keyword(s):  
Knowledge Bases ◽  
Logic Programs ◽  
Negation As Failure ◽  
Algebraic Framework ◽  
The One

Abstract Approximation fixpoint theory (AFT) provides an algebraic framework for the study of fixpoints of operators on bilattices and has found its applications in characterizing semantics for various classes of logic programs and nonmonotonic languages. In this paper, we show one more application of this kind: the alternating fixpoint operator by Knorr et al. for the study of the well-founded semantics for hybrid minimal knowledge and negation as failure (MKNF) knowledge bases is in fact an approximator of AFT in disguise, which, thanks to the abstraction power of AFT, characterizes not only the well-founded semantics but also two-valued as well as three-valued semantics for hybrid MKNF knowledge bases. Furthermore, we show an improved approximator for these knowledge bases, of which the least stable fixpoint is information richer than the one formulated from Knorr et al.’s construction. This leads to an improved computation for the well-founded semantics. This work is built on an extension of AFT that supports consistent as well as inconsistent pairs in the induced product bilattice, to deal with inconsistencies that arise in the context of hybrid MKNF knowledge bases. This part of the work can be considered generalizing the original AFT from symmetric approximators to arbitrary approximators.

scholarly journals Logic programs with monotone abstract constraint atoms

2008 ◽  
Vol 8 (2) ◽  
pp. 167-199 ◽  
Author(s):  
VICTOR W. MAREK ◽  
ILKKA NIEMELÄ ◽  
MIROSŁAW TRUSZCZYŃSKI
Keyword(s):  
Logic Programming ◽  
Logic Programs ◽  
Common Generalization ◽  
One Step ◽  
Normal Logic ◽  
The One ◽  
Operational Concept ◽  
Stable Models

AbstractWe introduce and study logic programs whose clauses are built out of monotone constraint atoms. We show that the operational concept of the one-step provability operator generalizes to programs with monotone constraint atoms, but the generalization involves nondeterminism. Our main results demonstrate that our formalism is a common generalization of (1) normal logic programming with its semantics of models, supported models and stable models, (2) logic programming with weight atoms lparse programs) with the semantics of stable models, as defined by Niemelä, Simons and Soininen, and (3) of disjunctive logic programming with the possible-model semantics of Sakama and Inoue.

Sign in / Sign up

Export Citation Format

Share Document