Ordered Logic Programs Research Articles

Dedekind–MacNeille completion and Cartesian product of multi-adjoint lattices

Fuzzy logic programming tries to introduce fuzzy logic into logic programming in order to provide new generation computer languages which incorporate comfortable programming resources for helping the development of applications where uncertainty could play an important role. In this sense, the mathematical concept of multi-adjoint lattice has been successfully exploited into the so-called Multi-Adjoint Logic Programming approach, MALP in brief, for modelling flexible notions of truth-degrees beyond the simpler case of true and false. In this paper, we focus on two relevant mathematical concepts for this kind of domains useful for evaluating MALP. On the one side, we adapt the classical notion of Dedekind–MacNeille completion in order to relax some usual hypothesis on such kind of ordered sets, and next we study the advantages of generating multi-adjoint lattices as the Cartesian product of previous ones. On the practical side, we show that the formal mechanisms described before have direct correspondences with interesting debugging tasks into the ‘Fuzzy Logic Programming Environment for Research’, FLOPER in brief, developed in our research group.

Strong order equivalence

Recently, strong equivalence for Answer Set Programming has been studied intensively, and was shown to be beneficial for modular programming and automated optimization. In this paper we define the novel notion of strong order equivalence for logic programs with preferences (ordered logic programs). Based on this definition we give, for several semantics for preference handling, necessary and sufficient conditions for programs to be strongly order equivalent. These results allow us also to associate a so-called SOE structure to each ordered logic program, such that two ordered logic programs are strongly order equivalent if and only if their SOE structures coincide. We also present the relationships among the studied semantics with respect to strong order equivalence, which differs considerably from their relationships with respect to preferred answer sets. Furthermore, we study the computational complexity of several reasoning tasks associated to strong order equivalence. Finally, based on the obtained results, we present --- for the first time --- simplification methods for ordered logic programs.

Preferred answer sets for ordered logic programs

We extend answer set semantics to deal with inconsistent programs (containing classical negation), by finding a “best” answer set. Within the context of inconsistent programs, it is natural to have a partial order on rules, representing a preference for satisfying certain rules, possibly at the cost of violating less important ones. We show that such a rule order induces a natural order on extended answer sets, the minimal elements of which we call preferred answer sets. We characterize the expressiveness of the resulting semantics and show that it can simulate negation as failure, disjunction and some other formalisms such as logic programs with ordered disjunction. The approach is shown to be useful in several application areas, e.g. repairing database, where minimal repairs correspond to preferred answer sets.

Learning Rules for Conceptual Structure on the Web

This paper presents an infrastructure and methodology to extract conceptual structure from Web pages, which are mainly constructed by HTML tags and incomplete text. Human beings can easily read Web pages and grasp an idea about the conceptual structure of underlying data, but cannot handle excessive amounts of data due to lack of patience and time. However, it is extremely difficult for machines to accurately determine the content of Web pages due to lack of understanding of context and semantics. Our work provides a methodology and infrastructure to process Web data and extract the underlying conceptual structure, in particular relationships between ontological concepts using Inductive Logic Programming in order to help with automating the processing of the excessive amount of Web data by capturing its conceptual structures.

A HiLog Journey from a Classical Dictionary to Hypertext Structure (via the Grammar, of course)

The long evolution of everyday life brought to our heritage the "mountains" of relatively structured data (dictionaries, phone books, hospital data files, government data files, driving licence data, crime data, etc.)). New information "media", physical (such as CD-ROM or DVD-ROM) as well as logical (organizational), such as hypertext, simply crave for mapping these old-fashioned information sources into new shape. This article shows how to achieve that shape automatically using the paradigm of higher order logic programming and particularly the HiLog language.

Efficient evaluation of a class of ordered logic programs

Ordered Logic ( OL ) enhances logic programming by the capability of modeling complex knowledge, by permitting a natural representation of several forms of non-monotonic reasoning. Both well-founded and stable model semantics for OL programs can be found in the literature [7,20,22]. This paper focuses on the problem of the efficient evaluation of the well-founded semantics of OL programs. First, a class of OL programs, called quasi-stratified programs, is presented. Then, an algorithm for the efficient bottom-up evaluation of the well-founded model of quasi-stratified programs is provided. Quasi-stratified programs evaluation has been implemented in KIWIS, an advanced environment for large database systems, whose query language is based on OL.

Interval propagation to reason about sets: Definition and implementation of a practical language

Local consistency techniques have been introduced in logic programming in order to extend the application domain of logic programming languages. The existing languages based on these techniques consider arithmetic constraints applied to variables ranging over finite integer domains. This makes difficult a natural and concise modelling as well as an efficient solving of a class of N P-complete combinatorial search problems dealing with sets. To overcome these problems, we propose a solution which consists in extending the notion of integer domains to that of set domains (sets of sets). We specify a set domain by an interval whose lower and upper bounds are known sets, ordered by set inclusion. We define the formal and practical framework of a new constraint logic programming language over set domains, called Conjunto. Conjunto comprises the usual set operation symbols( n), and the set inclusion relation (). Set expressions built using the operation symbols are interpreted as relations (s s 1 = s 2 ,...). In addition, Conjunto provides us with a set of constraints called graduated constraints (e.g. the set cardinality) which map sets onto arithmetic terms. This allows us to handle optimization problems by applying a cost function to the quantiiable, i.e., arithmetic, terms which are associated to set terms. The constraint solving in Conjunto is based on local consistency techniques using interval reasoning which are extended to handle set constraints. The main contribution of this paper concerns the formal deenition of the language and its design and implementation as a practical language.

Stable models and their computation for logic programming with inheritance and true negation

Previous researchers have proposed extensions of logic programming to deal with true negation and defeasible reasoning. Ordered Logic ( OL ) achieves both such goals by allowing rules with negated heads in the context of an inheritance hierarchy. As a result, OL is inherently nonmonotonic. Another area of interest in logic programming is that dealing with the semantics of negation. Recent research focuses on both declarative and constructive characterizations of stable models. A peculiarity of this semantics is that a program may have several alternative models (even none), each corresponding to a possible view of the world. This endows logic programming with the power to express don't-care nondeterminism in a purely declarative framework. This paper describes a stable model semantics ( SMS OL ) and its computation for ordered logic programs. SMS OL is given both in a model-theoretic and a constructive fashion. Based on the latter, an effective method is proposed for computing OL stable models. An interesting aspect of the proposed approach is that ordered logic programming can simulate Datalog under the total stable model semantics. This clearly provides solidity to our proposal. Moreover, the SMS OL computation method is an effective way to compute the stable model semantics of Datalog programs. The computational complexity of the main reasoning tasks in SMS OL is also investigated.

Recurrence Domains: Their Unification and Application to Logic Programming

In this paper we present a formalism for finitely representing infinite sets of terms. This formalism, called ρ- terms , enables us to reason finitely about certain recursive types. We present an extension of Horn logic programs, called ρ-Prolog, which allows a finite schematization of infinitely many clauses via predicates with ρ-terms as arguments. We show that for every ρ-Prolog program there is an equivalent Horn logic program. That is, incorporating ρ-terms into first order logic programming does not change its denotational semantics. Computationally, however, ρ-Prolog has the advantages of (1) representing infinitely many answers finitely, (2) avoiding repetition in computation and thus achieving better efficiency, (3) allowing infinite queries, and (4) avoiding certain kinds of non-termination of Prolog programs. The ρ-terms play a similar role to regular-trees and sort-expressions in explicitly defining abstract data types. It differs from the others in that it allows us to define certain non-regular-tree sets such as {( a n , b n , c n ): n ϵ N }. We present a finite and complete algorithm for unification between ρ-terms, with which we can also compute the intersections of the sets defined by ρ-terms.

Applications of logic programming in language analysis: Document reconstruction from existing code

This paper describes the experience of researchers at the University of Naples, over many years, in the application of Logic Programming (LP), to software engineering topics. In particular, the authors have experimented with LP in order to facilitate the activities related to the reconstruction of part(s) of documentation, from existing code. For this reason, a tool called “Language Analyser” (Lan_An) has been implemented, which is able to analyse different programming languages. This tool is supported by a methodology based on logic and is able to analyse existing code, by extracting and abstracting information useful for building up documentation. Currently, Lan_An can reconstruct low-level documentation design such as nesting trees, algebraic forms, and high-level documentation design such as structure charts. These documents represent a basis on which to deal with the activities of comprehension, reuse, reengineering, and maintenance of existing code. Moreover, all documents can be seen in a graphical way by the use of a browsing tool, which enables a user to go through the reconstructed documentation. Lan_An has been implemented in Turbo PROLOG V. 2.0. The latest version of Lan_An works on a PC (IBM-DOS), and analyses programming languages such as FORTRAN 77, ANSI C/Turbo C and PL/1.

Well-founded semantics and stratification for ordered logic programs

This paper present an extension of traditional logic programming, called ordered logic (OL) programming, to support classical negation as well as constructs from the object-oriented paradigm. In particular, such an extension allows to cope with the notions of object, multiple inheritance and non-monotonic reasoning.

Assumption-free Semantics for Ordered Logic Programs: On the Relationship Between Well-founded and Stable Partial Models

Assumption-free Semantics for Ordered Logic Programs: On the Relationship Between Well-founded and Stable Partial Models

Foundations of declarative debugging in arbitrary logic programming

Declarative debugging is an interactive process where the debugger acquires knowledge from an oracle (usually the user) about the intended interpretation of a program to be debugged and uses it to compare with the machine interpretation of the program in order to find the error in that program. The debugging is declarative in the sense that the user need only know the logic aspect of a program (i.e. its declarative meaning) and does not need to consider the computational behaviour of the program. An error is found by checking the validity of the solved goals with respect to their intended interpretation. In this paper, we introduce the basic ideas and concepts of declarative debugging, and provide a theoretical foundation with emphasis on the study of soundness and completeness for declarative debugging in arbitrary (unrestricted) first order logic programming.

Foundations of declarative testing in arbitrary logic programming

Declarative testing is very important in logic program developments, as without testing no one can guarantee that every program is definitely correct, no matter how elegant and high-level the programming languages used. Unfortunately, the activity of declarative testing for logic programs (or even the ordinary testing for conventional programs) has received little attention. There is little formal theory of testing, and attempts to develop a methodology of testing are rare. In this paper, we provide a theoretical foundation for declarative testing in arbitrary first order logic programming using recursion theories. In particular, we present a theoretical analysis of three kinds of declarative testing method: I/O testing, I/Y testing, and X/Y testing for logic programs.

A logico-algebraic approach to the model theory of knowledge

In this paper we combine concepts from algebraic semantics and first-order logic programming in order to build an extended logic programming framework. This framework is applied to obtain a computational formalization of the model theory of knowledge of McCarthy et al. (1978).

Completeness of a top-down declarative error diagnoser

A completeness theorem for a top-down version of a declarative error diagnoser in [1] (also in [2]), which can locate wrong answers and missing answers in arbitrary first order logic programming, has been proved in this paper.

Negative knowledge toward a strategy for asking in logic programming

Rule-based systems that ask the user and that also allow a not operator to be used in the rules have existed for some time; see, for example, the work of Duda, Gasching, Hart, Konolige, Reboh, Barrett & Slocum (1978). This paper briefly explores an idea of Edmonds (1984) for bringing together such recent developments within logic programming in order to provide a logic-based system with an integral, automatic, strategy for asking. The discussion shows that a simple and natural interpretation of PROLOG can provide a step towards logic-based human-computer co-operation.