Michael Kifer

Logical foundations of object-oriented and frame-based languages

We propose a novel formalism, called Frame Logic (abbr., F-logic), that accounts in a clean and declarative fashion for most of the structural aspects of object-oriented and frame-based languages. These features include object identity, complex objects, inheritance, polymorphic types, query methods, encapsulation, and others. In a sense, F-logic stands in the same relationship to the object-oriented paradigm as classical predicate calculus stands to relational programming. F-logic has a model-theoretic semantics and a sound and complete resolution-based proof theory. A small number of fundamental concepts that come from object-oriented programming have direct representation in F-logic; other, secondary aspects of this paradigm are easily modeled as well. The paper also discusses semantic issues pertaining to programming with a deductive object-oriented language based on a subset of F-logic.

Theory of generalized annotated logic programming and its applications

Abstract 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 Fittings bilattice-based logic programming, which until now has not been characterized model-theoretically. This is accompanied by a corresponding proof theory.

F-logic: a higher-order language for reasoning about objects, inheritance, and scheme

We propose a database logic which accounts in a clean declarative fashion for most of the “object-oriented” features such as object identity, complex objects, inheritance, methods, etc. Furthermore, database schema is part of the object language, which allows the user to browse schema and data using the same declarative formalism. The proposed logic has a formal semantics and a sound and complete resolution-based proof procedure, which makes it also computationally attractive.

HILOG: a foundation for higher-order logic programming

Abstract We describe a novel logic, called HiLog, and show that it provides a more suitable basis for logic programming than does traditional predicate logic. HiLog has a higher-order syntax and allows arbitrary terms to appear in places where predicates, functions, and atomic formulas occur in predicate calculus. But its semantics is first-order and admits a sound and complete proof procedure. Applications of HiLog are discussed, including DCG grammars, higher-order and modular logic programming, and deductive databases.

Querying object-oriented databases

1 Introduction Recent yeara saw several proposals for languages for querying object-oriented databases [2, 3, 4, 5, 13, 6]. None of them, however , captures (or even attempts to deal with) all the aspects of the object-oriented model. In this paper, we present a new query language, henceforth referred to as XSQL, that incorporates fea tures not found in earlier languages. XSQL is easier to use and it has more expressive power than previous languages. It is not our goal here to give the full-fledged syntax and semantics of XSQL. Rather, we use the familiar SQL-like syntax to illustrate certain philosophy in designing object-oriented languages-a philosophy put forward in [12, 10, 13, 8]. Before discussing the novelties found in XSQL, we should point out some of the differences between the object-oriented model and the relational model. The different features of these two models induce different modes of representing information and querying it. Suppose that a database includes information about engines and their types (e.g., turbo engines, diesel engines, etc.). In a relational database, there would likely be an attribute Eragin e Type having the various engine types aa its possible values. In an object-oriented database, there would likely be a class Engines having the various engine types as subclasses. This is a fundamental difference, because it shifts the information about engine types from the data to the schema. For example, suppose we want to know what are all the engine types. In the relational model, we simply project onto the attribute Engine Type. In the object-oriented model, we have to interrogate the schema rather than the data (and there is hardly any language for doing that). This shows the need for features not available in relational query languages. Jh particular, as an object-oriented schema is likely to have much more information than a relational schema, querying the schema (as well aa data without a complete knowledge of the schema) becomes an important issue. We also need to deal easily with nested structures. XSQL provides these (and other) features through path expressions. Although the idea of path expressions is not new (it first *Work supported in part by the NSF grants IRI-8903507 sad CCR-9102159. On sabbatical leave from Stony Brook University, Permission to copy without fee all or part of this material is granted provided that the copies are not made or distributed for direct commercial advantage, the ACM copyright notice …

Taming the infinite chase: query answering under expressive relational constraints

The chase algorithm is a fundamental tool for query evaluation and for testing query containment under tuple-generating dependencies (TGDs) and equality-generating dependencies (EGDs). So far, most of the research on this topic has focused on cases where the chase procedure terminates. This paper introduces expressive classes of TGDs defined via syntactic restrictions: guarded TGDs (GTGDs) and weakly guarded sets of TGDs (WGT-GDs). For these classes, the chase procedure is not guaranteed to terminate and thus may have an infinite outcome. Nevertheless, we prove that the problems of conjunctive-query answering and query containment under such TGDs are decidable. We provide decision procedures and tight complexity bounds for these problems. Then we show how EGDs can be incorporated into our results by providing conditions under which EGDs do not harmfully interact with TGDs and do not affect the decidability and complexity of query answering. We show applications of the aforesaid classes of constraints to the problem of answering conjunctive queries in F-Logic Lite, an object-oriented ontology language, and in some tractable Description Logics.

RI: a logic for reasoning with inconsistency

Most known computational approaches to reasoning have problems when facing inconsistency, so they assume that a given logical system is consistent. Unfortunately, the latter is difficult to verify and very often is not true. It may happen that addition of data to a large system makes it inconsistent, and hence destroys the vast amount of meaningful information. We present a logic, called APC (annotated predicate calculus; cf. annotated logic programs of [4, 5]), that treats any set of clauses, either consistent or not, in a uniform way. In this logic, consequences of a contradiction are not nearly as damaging as in the standard predicate calculus, and meaningful information can still be extracted from an inconsistent set of formulae. APC has a resolution-based sound and complete proof procedure. We also introduce a novel notion of ‘epistemic entailment’ and show its importance for investigating inconsistency in predicate calculus as well as its application to nonmonotonic reasoning. Most importantly, our claim that a logical theory is an adequate model of human perception of inconsistency, is actually backed by rigorous arguments.

Logic based modeling and analysis of workflows

WC propose Concurrent Transaction Logic (C7X) as the language for specifying, analyzing, and scheduling of workflows. We show that both local and global properties of worktlows can be naturally represented as C7X formulas and reasoning can be done with the use of the proof theory and the semantics of this logic, We describe a transformation that leads to an eilicicnt algorithm for scheduling worldlows in the presencc of global temporal constraints, which leads to decision proccdurcs for dealing with several safety related properties such as whether every valid execution of the workflow satisfits a particular property or whether a worlcfiow execution is consistent with some given global constraints on the ordering of events in a workflow. We also provide tight complexity results on the running times of these algorithms.

An overview of transaction logic

Abstract This paper presents an overview of Transaction Logic —a new formalism recently introduced in Bonner and Kifer (1992, 1993) and designed to deal with the phenomenon of state changes in logic programming, databases, and AI. Transaction Logic has a natural model theory and a sound and complete proof theory. Unlike many other logics, however, it is suitable for programming procedures that accomplish state transitions in a logically sound manner. Transaction logic amalgamates such features as hypothetical and committed updates, dynamic constraints on transaction execution, nondeterminism, and bulk updates. Transaction Logic also appears to be suitable as a logical model of hitherto nonlogical phenomena, including so-called procedural knowledge in AI, and the behavior of object-oriented databases, especially methods with side effects.

FLORA-2: A rule-based knowledge representation and inference infrastructure for the Semantic Web

\(\mathcal{F}\) lora-2 is a rule-based object-oriented knowledge base system designed for a variety of automated tasks on the Semantic Web, ranging from meta-data management to information integration to intelligent agents. The \(\mathcal{F}\) lora-2 system integrates F-logic, HiLog, and Transaction Logic into a coherent knowledge representation and inference language. The result is a flexible and natural framework that combines rule-based and object-oriented paradigms. This paper discusses the principles underlying the design of the \(\mathcal{F}\) lora-2 system and describes its salient features, including meta-programming, reification, logical database updates, encapsulation, and support for dynamic modules.