Subset Of First-order Logic Research Articles

Second order inference in natural language semantics

In this paper I look at a number of apparently trivial validinferences (as well as some invalid and missing inferences) associatedwith the possessive construction and with different types ofadjectival modification of nouns. In the case of possessives, allanalyses I know of, whether implemented or not, systematicallysanction invalid inferences. In the case of adjectives, there are somemodel-theoretic linguistic analyses that are adequate at a theoretical level, but no satisfactory practical computational implementations that I am aware of which capture the correct inference patterns.A common thread between the possessive and the adjectivalconstructions is that to derive the correct inferences we need secondorder quantification. This is an uncontroversial move withinmodel-theoretic formal semantics but a problem for computationalsemantics, since we have no fully automated theorem provers foranything other than first order logic (and only for subsets of firstorder logic do we have provers that are both fully decidable andefficient). I explore what is needed to provide a proof-theoreticaccount of the relevant inference patterns, and suggest some analysesrequiring second order axioms. In order to make this a practicalcomputational possibility I go on to propose two techniques forapproximating such inferences in a first order setting. The suggestedanalyses have been fully implemented, and in an appendix I provide asmall FraCaS-like corpus of relevant examples, all of which arehandled correctly by the implementation.

Description Logics in Information Semantic Integration for Product Design and Manufacturing

In the process of information semantic integration for product design and manufacturing, it is very important to express the product information semantic. Description logics (DLs) are a family of state-of-the-art knowledge representation languages, and a decidable subset of first-order logic. Firstly, by analyzing the characteristics of product information, proposed a semantic information description framework based on description logics for product information integration, which is divided into three levels: basic description logic, classic extended logic and unusual extended logic. Then, in the framework, reducer was taken for example to illustrate the application of their description logic in product design and manufacturing formal semantic information. Finally, based on description logic, discussed reasoning problems of product design and manufacturing information.

Approximate Model Checking Using a Subset of First-order Logic

In order to reduce the computational complexity of model checking, we can use a subset of first-order logic, called EUF, but the model checking problem using EUF is generally undecidable. In our previous work, we proposed a technique for checking invariant property for an over-approximate set of states including all the reachable states. In this paper, we extend this technique for handling not only invariants but also temporal properties written in computational tree logic with EUF extension. We show that model checking becomes possible for designs which are hard to handle without the proposed technique.

Approximate Model Checking Using a Subset of First-order Logic

Approximate Model Checking Using a Subset of First-order Logic

EufDpll - A Tool to Check Satisfiability of Equality Logic Formulas

Decision procedures for subsets of First-Order Logic form the core of many verification tools. Applications include hardware and software verification. The logic of Equality with Uninterpreted Functions (EUF) is a decidable subset of First-Order Logic. The EUF logic and its extensions have been applied for proving equivalence between systems. We present a branch and bound decision procedure for EUF logic based on the generalisation of the Davis-Putnam-Loveland-Logemann procedure (EUF-DPLL). EufDpll is a tool to check satisfiability of EUF formulas based on this procedure.

Filtering Multi-Instance Problems to Reduce Dimensionality in Relational Learning

Attribute-value based representations, standard in today's data mining systems, have a limited expressiveness. Inductive Logic Programming provides an interesting alternative, particularly for learning from structured examples whose parts, each with its own attributes, are related to each other by means of first-order predicates. Several subsets of first-order logic (FOL) with different expressive power have been proposed in Inductive Logic Programming (ILP). The challenge lies in the fact that the more expressive the subset of FOL the learner works with, the more critical the dimensionality of the learning task. The Datalog language is expressive enough to represent realistic learning problems when data is given directly in a relational database, making it a suitable tool for data mining. Consequently, it is important to elaborate techniques that will dynamically decrease the dimensionality of learning tasks expressed in Datalog, just as Feature Subset Selection (FSS) techniques do it in attribute-value learning. The idea of re-using these techniques in ILP runs immediately into a problem as ILP examples have variable size and do not share the same set of literals. We propose here the first paradigm that brings Feature Subset Selection to the level of ILP, in languages at least as expressive as Datalog. The main idea is to first perform a change of representation, which approximates the original relational problem by a multi-instance problem. The representation obtained as the result is suitable for FSS techniques which we adapted from attribute-value learning by taking into account some of the characteristics of the data due to the change of representation. We present the simple FSS proposed for the task, the requisite change of representation, and the entire method combining those two algorithms. The method acts as a filter, preprocessing the relational data, prior to the model building, which outputs relational examples with empirically relevant literals. We discuss experiments in which the method was successfully applied to two real-world domains.

Formula omitted] – a dialog based integration of concept and rule reasoners

Description logics (DLs) are subsets of first-order logic (FOL), designed for reasoning about class-based knowledge. Their expressive power is deliberately restricted, so as to enable efficient inference. A DL reasoner or knowledge base is intended to be embedded as a special purpose component in a heterogeneous knowledge base. Therefore, the development of integration frameworks of DLs and other forms of reasoning is essentially important. In this paper, we introduce a formal scheme for the integration of information sources for which a combined declarative semantics is not available. The integration is defined by a syntactic compositional semantics, and implemented by a dialog process in which the independent reasoners make their failures public. This scheme is used to formalize the integration of a DL reasoner with an expressive rule reasoner (for which a combined declarative semantics is not known). It is implemented in the DFL system, that integrates a DL reasoner and an F-Logic rule reasoner. The integrated system gives rise to a rich dialog between its components, since the DL inferences can trigger new rule inferences, and rule inferences can trigger new DL inferences. The DFL system is the first to support a true dialog between a DL and a rule reasoners, that operate under different semantical policies, e.g., the open world assumption (OWA) for the DL reasoner, and the closed world assumption (CWA) for the rule reasoner. This architecture generalizes all existing hybrids of descriptions and rules.

Bottom-Up Induction of Feature Terms

The aim of relational learning is to develop methods for the induction of hypotheses in representation formalisms that are more expressive than attribute-value representation. Most work on relational learning has been focused on induction in subsets of first order logic like Horn clauses. In this paper we introduce the representation formalism based on feature terms and we introduce the corresponding notions of subsumption and anti-unification. Then we explain INDIE, a heuristic bottom-up learning method that induces class hypotheses, in the form of feature terms, from positive and negative examples. The biases used in INDIE while searching the hypothesis space are explained while describing INDIE's algorithms. The representational bias of INDIE can be summarised in that it makes an intensive use of sorts and sort hierarchy, and in that it does not use negation but focuses on detecting path equalities. We show the results of INDIE in some classical relational datasets showing that it's able to find hypotheses at a level comparable to the original ones. The differences between INDIE's hypotheses and those of the other systems are explained by the bias in searching the hypothesis space and on the representational bias of the hypothesis language of each system.

Unifying Class-Based Representation Formalisms

The notion of class is ubiquitous in computer science and is central in many formalisms for the representation of structured knowledge used both in knowledge representation and in databases. In this paper we study the basic issues underlying such representation formalisms and single out both their common characteristics and their distinguishing features. Such investigation leads us to propose a unifying framework in which we are able to capture the fundamental aspects of several representation languages used in different contexts. The proposed formalism is expressed in the style of description logics, which have been introduced in knowledge representation as a means to provide a semantically well-founded basis for the structural aspects of knowledge representation systems. The description logic considered in this paper is a subset of first order logic with nice computational characteristics. It is quite expressive and features a novel combination of constructs that has not been studied before. The distinguishing constructs are number restrictions, which generalize existence and functional dependencies, inverse roles, which allow one to refer to the inverse of a relationship, and possibly cyclic assertions, which are necessary for capturing real world domains. We are able to show that it is precisely such combination of constructs that makes our logic powerful enough to model the essential set of features for defining class structures that are common to frame systems, object-oriented database languages, and semantic data models. As a consequence of the established correspondences, several significant extensions of each of the above formalisms become available. The high expressiveness of the logic we propose and the need for capturing the reasoning in different contexts forces us to distinguish between unrestricted and finite model reasoning. A notable feature of our proposal is that reasoning in both cases is decidable. We argue that, by virtue of the high expressive power and of the associated reasoning capabilities on both unrestricted and finite models, our logic provides a common core for class-based representation formalisms.

Belief updating from integrity constraints and queries

It is argued that the problems of intensional knowledge base updating and incremental concept-learning—when formulated in a logical framework—can be understood as instances of the more general problem of belief updating. This insight allows interesting cross-fertilization between both areas. To support this claim, we sketch a simple extension of Shapiro's Model Inference System that solves the belief updating problem within a restricted subset of first order logic. This extension uses integrity constraints and allows for the assertion of non-unit clauses. The former generalizes the use of examples in concept-learning whereas the latter generalizes the set of revisions considered in knowledge base updating.

Expressive completeness of temporal logic of trees

ABSTRACT Many temporal and modal logic languages can be regarded as subsets of first order logic, i.e. the semantics of a temporal logic formula is given as a first order condition on points of the underlying models (Kripke structures). Often the set of possible models is restricted to models which are trees. A temporal logic language is (first order) expressively complete, if for every first order condition for a node of a tree there exists an equivalent temporal formula which expresses the same condition. In this paper expressive completeness of the temporal logic language with the set of operators U (until), S (since), and X k (k-next) is proved, and the result is extended to various other tree-like structures.

Formal specification of geographic data processing requirements

A formal foundation for the specification of geographic data processing (GDP) requirements is established. Emphasis is on modeling data and knowledge requirements rather than processing needs. A subset of first-order logic is proposed as the principal means for constructing formalizations of the GDP requirements in a manner that is independent of the data representation. Requirements executability is achieved by selecting a subset of logic, compatible with the inference mechanisms available in Prolog. Concepts with GDP significance such as time, space, and accuracy are added for the formalization without losing Prolog implementability or separation of concerns. Rules of reasoning about time, space, and accuracy can be compactly stated in a subset of second-order predicate calculus and can be easily modified to meet the particular needs of a specific application. The feasibility of the approach is established with the aid of a prototype implementation of the formalism in Prolog. The implementation also provides the means for the graphical rendering of logical information on a high-resolution color display. >

Dissertation abstract

Information retrieval can be defined as the extraction of specific information out of a great number of stored information items. Information retrieval systems, used for the retrieval of documents, try to answer more or less precise questions about interesting topics with a number of suitable documents or references to documents. Such systems should contain 'knowledge' about the meaning of questions, about the content of the stored information and the particular user's needs for information.Knowledge-bases systems claim to be able to store knowledge an draw conclusions from it. The goal of this thesis is to investigate the use of knowledge-based methods and technologies for information retrieval. A knowledge-based information retrieval system should represent its Information Structures, as well as knowledge in a common knowledge representation formalism. The retrieval process of the system should employ the inferential methods of the used knowledge representation formalism.A subset of first order logic is chosen for this thesis to represent knowledge. Specially designed retrieval rules represent knowledge for the purpose of retrieval. Retrieval rules capture knowledge about the user's vocabulary, his working domain and his way to perform the retrieval of documents. The problem of recall and precision of the answers of an information retrieval system is approached by an explicit representation of control knowledge.A theoretical model of a knowledge-based information retrieval system developed in this thesis specifies the requirements and properties, of such a system. In particular a novel term-similarity function could be defined. Properties like completeness and termination could be derived and boundaries for the amount of overhead of false control strategies could be investigated.The proposed model is implemented in a prototype of a knowledge-based information retrieval system, called KIR. KIR is a single-user system for personal document- and knowledge retrieval running on computer workstations. It is implemented using Prolog and Modula-2.

Horn clause computability

It is proved that a Turing computable functionf is computable in binary Horn clauses, which are a subset of first order logic. Moreover, it is proved that the binary Horn clauses do not need more than one function symbol. The proofs comprise computable relations that can be run efficiently as logic programs on a computer.