Annotated Logic Research Articles

Annotated Logic Applications for Imperfect Information

Imperfect information is a very general term that comprises different types of information, such as uncertain, vague, fuzzy, inconsistent, possibilistic, probabilistic, partially or totally incomplete information [2]. In the literature of knowledge representation we find a different formal model for each one of these distinct types. For example, annotated logic is a formal model to represent inconsistent information. Annotated logics are non-classical logics introduced in [20] as a logic programming theory. They were proved to be paraconsistent. Based on [5], we present in this work the annotated logic programming theory and some of its applications in Artificial Intelligence (AI). We present it as a formalism to reason with inconsistent information and investigate its possibility to represent other types of imperfect information, such as possibilistic and non-monotonic reasoning. Our main goal is to verify and confirm the importance of annotated logics as a tool for developing knowledge-based and automated reasoning systems in AI.

A Framework for Automated Reasoning in Multiple-Valued Logics

The language of signed formulas offers a first-order classical logic framework for automated reasoning in multiple-valued logics. It is sufficiently general to include both annotated logics and fuzzy operator logics. Signed resolution unifies the two inference rules of annotated logics, thus enabling the development of an SLD-style proof procedure for annotated logic programs. Signed resolution also captures fuzzy resolution. The logic of signed formulas offers a means of adapting most classical inference techniques to multiple-valued logics.

On the Algebraizability of Annotated Logics

Annotated logics were introduced by V.S. Subrahmanian as logical foundations for computer programming. One of the difficulties of these systems from the logical point of view is that they are not structural, i.e., their consequence relations are not closed under substitutions. In this paper we give systems of annotated logics that are equivalent to those of Subrahmanian in the sense that everything provable in one type of system has a translation that is provable in the other. Moreover these new systems are structural. We prove that these systems are weakly congruential, namely, they have an infinite system of congruence 1-formulas. Moreover, we prove that an annotated logic is algebraizable (i.e., it has a finite system of congruence formulas,) if and only if the lattice of annotation constants is finite.

Qualifying Answers According to User Needs and Preferences

This paper presents a rigorous methodology for using annotated logic programming techniques to handle user preferences and needs in answering database queries. Two alternative transformations turn a database program into a new program that returns answers to queries according to qualitative labels. The two transformations have different semantics and are each appropriate in different situations. We have modified the standard definitions of annotated logic programs to handle user needs and preferences in databases. In the formalism, the user provides a lattice of domain-independent values that define preferences and needs and a set of domain specific user constraints qualified with lattice values. After the original database and the user constraints have been transformed into a new annotated deductive database, query-answering procedures for deductive databases are used, with minor modifications, to obtain annotated answers to queries. Because preference declaration is separated from data representation and management, preferences can be easily altered without touching the database. The resulting query language allows users to ask for answers at different preference levels.

Amalgamating knowledge bases, III: Algorithms, data structures and query processing

Integrating knowledge from multiple sources is an important aspect of automated reasoning systems. In the first part of this series of papers, we presented a uniform declarative framework, based on annotated logics, for amalgamating multiple knowledge bases when these knowledge bases (possibly) contain inconsistencies, uncertainties, and nonmonotonic modes of negation. We showed that annotated logics may be used, with some modifications, to mediate between different knowledge bases. The multiple knowledge bases are amalgamated by embedding the individual knowledge bases into a lattice. In this paper, we briefly describe an SLD-resolution-based proof procedure that is sound and complete w.r.t. our declarative semantics. We will then develop an OLDT-resolution-based query processing procedure, MULTI_OLDT, that satisfies two important properties: (1) efficient reuse of previous computations is achieved by maintaining a table—we describe the structure of this table, and show that table operations can be efficiently executed, and (2) approximate, interruptable query answering is achieved, i.e., it is possible to obtain an “intermediate, approximate” answer from the QPP by interrupting it at any point in time during its execution. The design of the MULTI_OLDT procedure will include the development of run-time algorithms to incrementally and efficiently update the table.

Query processing in annotated logic programming: Theory and implementation

Annotated logic is a formalism that has been applied to a variety of situations in knowledge representation, expert database systems, quantitative reasoning, and hybrid databases [6], [13], [19], [20], [21], [22], [23], [24], [30], [33], [35], [36]. Annotated Logic Programming (ALP) is a subset of annotated logics that can be used directly for programming annotated logic applications [22], [23]. A top-down query processing procedure containing elements of constraint solving, called ca-resolution, is developed for ALPs. It simplifies a number of previously proposed procedures, and also improves on their efficiency. The key to its development is in observing that satisfaction, as introduced originally for ALPs, may be naturally generalized. A computer implementation of ca-resolution for ALPs is described which offers important theoretical and practical insights. Strategies for improving its efficiency are discussed.

Hybrid knowledge bases

Deductive databases that interact with, and are accessed by, reasoning agents in the real world (such as logic controllers in automated manufacturing, weapons guidance systems, aircraft landing systems, land-vehicle maneuvering systems, and air-traffic control systems) must have the ability to deal with multiple modes of reasoning. Specifically, the types of reasoning we are concerned with include, among others, reasoning about time, reasoning about quantitative relationships that may be expressed in the form of differential equations or optimization problems, and reasoning about numeric modes of uncertainty about the domain which the database seeks to describe. Such databases may need to handle diverse forms of data structures, and frequently they may require use of the assumption-based nonmonotonic representation of knowledge. A hybrid knowledge base is a theoretical framework capturing all the above modes of reasoning. The theory tightly unifies the constraint logic programming scheme of Jaffar and Lassez (1987), the generalized annotated logic programming theory of Kifer and Subrahmanian (1989), and the stable model semantics of Gelfond and Lifschitz (1988). New techniques are introduced which extend both the work on annotated logic programming and the stable model semantics.

On the relationship between annotated logic programs and nonmonotonic formalisms

Abstract In the past we developed a semantics for a restricted annotated logic language for inheritance reasoning. Here we generalize it to annotated Horn logic programs. We first provide a formal account of the language, describe its semantics, and provide an interpreter written in Prolog for it. We then investigate its relationship to Belnap's 4-valued logic, Gelfond and Lifschitz's semantics for logic programs with negation, Brewka's prioritized default logics and other annotated logics due to Kifer et al.

AMALGAMATING KNOWLEDGE BASES II: DISTRIBUTED MEDIATORS

Integrating knowledge from multiple sources is an important aspect of automated reasoning systems. In [23], we presented a uniform declarative and operational framework, based on annotated logics, for amalgamating multiple knowledge bases and data structures (e.g. relational, object-oriented, spatial, and temporal structures) when these knowledge bases (possibly) contain inconsistencies, uncertainties and non-monotonic modes of negation. We showed that annotated logics may be used, with some modifications, to mediate between different knowledge bases. The multiple knowledge bases are amalgamated by embedding the individual knowledge bases into a lattice. In this paper, we describe how, given a network of sites where the different databases reside, it is possible to define a distributed semantics for amalgamated knowledge bases. More importantly, we study how the mediator may be distributed across multiple sites so that when certain conditions are satisfied, network failures do not affect the end results of queries that a user may pose. We specify different ways of distributing the mediator to protect against different types of network link failures and develop alternative soundness and completeness results.

Amalgamating knowledge bases

The integration of knowledge for multiple sources is an important aspect of automated reasoning systems. When different knowledge bases are used to store knowledge provided by multiple sources, we are faced with the problem of integrating multiple knowledge bases: Under these circumstances, we are also confronted with the prospect of inconsistency. In this paper we present a uniform theoretical framework, based on annotated logics , for amalgamating multiple knowledge bases when these knowledge bases (possibly) contain inconsistencies, uncertainties, and nonmonotonic modes of negation. We show that annotated logics may be used, with some modifications, to mediate between different knowledge bases. The multiple knowledge bases are amalgamated by a transformation of the individual knowledge bases into new annotated logic programs, together with the addition of a new axiom scheme. We characterize the declarative semantics of such amalgamated knowledge bases and study how the semantics of the amalgam is related to the semantics of the individual knowledge bases being combined. —Author's Abstract

A theory of nonmonotonic inheritance based on annotated logic

We propose a logical language for representing networks with nonmonotonic multiple inheritance. The language is based on a variant of annotated logic studied in [5, 6, 17–21]. The use of annotated logic provides a rich setting that allows to disambiguate networks whose topology does not provide enough information to decide how properties are to be inherited. The proposed formalism handles inheritance via strict as well as defeasible links. We provide a formal account of the language, describe its semantics, and show how a unique intended model can be associated with every inheritance specification written in the language. Finally, we present an algorithm that correctly propagates inherited properties according to the given semantics. The algorithm is also complete in the sense that it computes the set of all properties that must be inherited by any given individual object, and then terminates.

The completeness of gp-resolution for annotated logics

The completeness of gp-resolution for annotated logics

Theory of generalized annotated logic programming and its applications

Annotated logics were introduced in [43] and later studied in [5, 7, 31, 32]. In [32], annotations were extended to allow variables and functions, and it was argued that such logics can be used to provide a formal semantics for rule-based expert systems with uncertainty. In this paper, we continue to investigate the power of this approach. First, we introduce a new semantics for such programs based on ideals of lattices. Subsequently, some proposals for multivalued logic programming [5, 7, 18, 32, 40, 47] as well as some formalisms for temporal reasoning [1, 3, 41] are shown to fit into this framework. As an interesting byproduct of the investigation, we obtain a new result concerning multivalued logic programming: a model theory for Fitting's bilattice-based logic programming, which until now has not been characterized model-theoretically. This is accompanied by a corresponding proof theory.

A Standard Pattern for Sequential File Maintenance

The author explores the possibilities of ready-made logic in developing programs and, as an illustration, proposes a standard or prototype approach to file maintenance. The approach illustrated is defined by an annotated program logic chard and a series of checklists, cross-referenced to each other.