Clause Logic Research Articles

Generating logical expressions from positive and negative examples via a branch-and-bound approach

Consider a logical system with N entities which assume binary values of either TRUE (1) or FALSE (0). There are 2 N vectors, each with N components, of this type. Even when a modest value of N, e.g. N = 50, the number of such vectors exceeds one quadrillion. We assume that an ‘expert’ exists which can ascertain whether a particular vector (observation) such as (1, 1, 0, 0, 1, 0, …, 1) is allowable or not. This expert can be a human expert or an unknown system whose rules have to be inferred. Further, we assume that a sampling of m observations has resulted in M 1 instances which the expert has classified as allowable and M 2 = m − M 1 instances which are not allowable. We call these instances positive and negative examples, respectively. The objective of this research is to infer a set of logical rules for the entire system based upon the m, and possibly, additional sample observations. The proposed algorithm in this paper is based on an highly efficient branch-and-bound formulation. This algorithm configures a sequence of logical clauses in conjunctive normal form (CNF), that when are taken together, accept all the positive examples and reject all the negative examples. Some computational results indicate that the proposed approach can process problems that involve hundreds of positive and negative examples in a few CPU seconds and with small memory requirements.

The logic of plaza space: representing design knowledge on shape and function

This paper concludes a series of three, in which the formalization of “soft” architectural design knowledge is studied in the context of making it accessible to knowledge-based design systems for support of early sketch design. A wide range of design ideas with the common theme of schematic “plaza design” is studied, including design from scratch and the reconstruction of existing plazas. Formal conceptual models in Horn clause logic are suggested. The additional evidence thus provided, that “soft” design knowledge may be accessible to design support systems, is the main contribution of the paper, which is rounded off by a brief discussion of the feasibility and future development of such systems.

Tractability through symmetries in propositional calculus

Many propositional calculus problems — for example the Ramsey or the pigeon-hole problems — can quite naturally be represented by a small set of first-order logical clauses which becomes a very large set of propositional clauses when we substitute the variables by the constants of the domainD. In many cases the set of clauses contains several symmetries, i.e. the set of clauses remains invariant under certain permutations of variable names. We show how we can shorten the proof of such problems. We first present an algorithm which detects the symmetries and then we explain how the symmetries are introduced and used in the following methods: SLRI, Davis and Putnam and semantic evaluation. Symmetries have been used to obtain results on many known problems, such as the pigeonhole, Schur's lemma, Ramsey's, the eight queen, etc. The most interesting one is that we have been able to prove for the first time the unsatisfiability of Ramsey's problem (17 vertices and three colors) which has been the subject of much research.

Circumscribing embedded implications (without stratifications)

This paper is a study of circumscription, not in classical logic, as usual, but in intuitionistic logic. We first review the intuitionistic circumscription of Horn clause logic programs, which was discussed in previous work, and we then consider the larger class of embedded implications. The ordinary circumscription axiom turns out to be inappropriate for this class of rules, and we analyze two alternatives: (1) prioritized circumscription, which works for stratified embedded implications; (2) partial circumscription, which is independent of the stratification. We then show that these two approaches coincide by identifying a single structure that serves as the final Kripke model for both circumscription axioms. This means that prioritized circumscription and partial circumscription entail exactly the same set of implicational queries. Several applications of these ideas are described, including (1) an interpretation of negation-as-failure, (2) a formalization of indefinite reasoning with definite rules, and (3) a methodology for analyzing inductive properties of PROLOG programs.

An implementation of pure Horn clause logic programming in a reduction system

Many reduction systems have been presented for implementing functional programming languages. We propose here an extension of a reduction architecture to realize a kind of logic programming — pure Horn clause logic programming. This is an attempt to approach amalgamation of the two important programming paradigms.

Beyond associative memories: Logics and variables in connectionist models

This paper demonstrates the role of connectionist (neural network) models in reasoning beyond that of an associative memory. First it is shown that there is a connection between propositional logics and the weighted-sum computation customarily used in connectionist models. Specifically, the weighted-sum computation can handle Horn clause logic and Shoham's logic as special cases. Second, it is shown how variables can be incorporated into connectionist models to enhance their representational power. Solutions to the connectionist variable binding problem are devised to enable connectionist networks to handle variables and dynamic bindings in reasoning. A new model, the discrete neuron formalism, which is an extension of the weighted-sum models, is employed for dealing with the variable binding problem. Formal definitions are presented, and examples are analyzed in detail.

The logic of neural networks

A higher-order Hopfield neural network is used to minimise logical inconsistency in interpretations of logic clauses or programs. We show that Hebbian learning in an environment with some underlying logical rules governing events is equivalent to hardwiring the network with these rules.

The logic of walking: representing design knowledge on pedestrian traffic nets

Specific examples of how ‘soft’ architectural design knowledge can be formalized and made available to knowledge-based design support systems are scarce in the literature. In this paper such an example is presented in some detail. In a context of design of networks of footpaths, streets, or the like for pedestrian traffic, two particular design concepts are studied: ‘concentration of pedestrians’ and ‘smoothness of walking lines’. The concepts are put to work in a hypothetical design, and on that background their possible representation in Horn clause logic is outlined, and computational aspects of the representation are discussed.

Modelling Prolog Control

The goal of this paper is to construct a semantic basis for the abstract interpretaion of Prolog programs. Prolog is a well-known logic programming language which applies a depth-first search strategy in order to provide a practical approximation of Horn clause logic. While pure logic programming has clean fix-point, model-theoretic and operational semantics the situation for Prolog is different. Difficulties in capturing the declarative meaning of Prolog programs have led to various semantic definitions which attempt to encode the search strategy in different mathematical frameworks. However semantic based analyses of Prolog are typically achieved by abstracting the more simple but less precise declarative semantics of pure logic Programs.We propose instead to model Prolog control in a simple constraint logic language which is presented together with its declarative and operational semantics. This enables us to maintain the usual approach to declarative semantics of logic programs while capturing control aspects such as search strategy and selection rule.

A bottom-up polymorphic type inference in logic programming

We present a type inference system for Horn clause logic programs, based on a bottom-up abstract interpretation technique. Through the definition of suitable abstract operators, we obtain an abstract immediate consequence operator map associated with the program to analyze. The least fixpoint of such an operator gives an approximated description, by means of types, of the success set of the program. By changing the abstract domain of types, we easily obtain different type inference systems. This is useful to make the inference appropriate for different purposes. Due to the semantic basis, the system declaratively handles type union and parametric polymorphism.

An explication of reasoning in multiple inheritance systems through non-monotonic horn clause logic

In this paper we present a new approach to explicate the IS-A link and the inheritance of properties down through IS-A links. We introduce the syntactic category of common nouns intended to represent kinds (or prototypes) of objects. We describe two sentence-forming operations: the attribution of membership of kinds to objects or objects of a certain kind, and the attribution of properties to objects or objects of a certain kind. We then argue that the inferential behavior of sentences is different depending on how the sentence was formed. Although the attribution of membership in a kind will always hold true for any instance, the attribution of a property may be overridden. We explicate the inferential behavior of these sentences in non-monotonic logic and present the proof theory and semantics for this non-monotonic logic.

From failure to success: comparing a denotational and a declarative semantics for Horn clause logic

The main purpose of the paper is to relate different models for Horn clause logic: operational, denotational, declarative. We study their relationship by contrasting models based on interleaving, on the one hand, to models based on maximal parallelism, on the other. We make use of complete metric spaces as an important mathematical tool, both in defining and in comparing the various models.

A comparative study of five parallel programming languages

Many different paradigms for parallel programming exist, nearly each of which is employed in dozens of languages. Several researchers have tried to compare these languages and paradigms by examining the expressivity and flexibility of their constructs. Few attempts have been made, however, at practical studies based on actual programming experience with multiple languages. Such a study is the topic of this paper. We will look at five parallel languages, all based on different paradigms. The languages are: SR (based on message passing), Emerald (concurrent objects), Parlog (parallel Horn clause logic), Linda (Tuple Space), and Orca (logically shared data). We have implemented the same parallel programs in each language, using real parallel machines. The paper reports on our experiences in implementing three frequently occurring communication patterns: message passing through a mailbox, one-to-many communication, and access to replicated shared data.

Complexity of resolution proofs and function introduction

The length of resolution proofs is investigated, relative to the model-theoretic measure of Herband complexity. A concept of resolution deduction (R-deduction) is introduced which is somewhat more general than the classical concepts. It is shown that proof complexity is exponential in terms of Herband complexity and that this bound is tight. The concept of R-deduction is extended to FR-deduction, where, besides resolution, a function introduction rule (based on a re-Skolemization technique) is allowed. As an example, consider the clause P(x, y) ∨ Q(x, y): conclude P(x,f(x)) ∨ Q(a, y), where a, f(x) are new function symbols extending Herbrand's universe. (We use the derivability of (∀x)(∃y) P(x, y) ∨ (∃x)(∀) Q(x, y) from (∀x)(∀y)( P(x, y) ∨ Q(x, y)) and Skolemization). By modification of a construction of Statman it is shown that FR-deductions may be nonelementarily shorter than R-deductions (thus giving a nonelementary speedup with respect to Herbrand complexity and search space). Finally it is proved that FR-deduction has weaker effects only (maximally double exponential speedup) if clausal logic is restricted to Horn logic.

STORK and PENGUIN: Logic programming systems using general clauses and defaults

This paper describes two logic programming systems with the expressive power of full clausal first-order logic and with a nonmonotonic component. They provide a direct generalization of pure Prolog and can be implemented using the same technology as Prolog processors. The inference engine of both systems is based on the weak-model elimination method which, in the case of the second system, is extended to incorporate defaults.

MULTILEVEL DESIGN ARCHITECTURE FOR KNOWLEDGE-BASE MANAGEMENT SYSTEMS

A three-level architecture is developed for knowledge-base management systems. As in database management systems, each level is an abstraction targeted for a different type of user. At the external level for end users, all data and rules are viewed as graphs, and all end-user interaction is facilitated with visual aids. At the conceptual level for analysis, all data and rules are viewed as logical clauses since they provide a concise and conceptual framework for analysis. At the internal level for the implementors, all rules are viewed as data and rule management is supported by the database management system

On the complexities of non-Horn Clause logic programming

There have been active work to extend the Prolog style Horn Clause logic programming to non-Horn clauses. In this paper, we will analyze the complexities of several such extensions. The purpose is to understand the computational complexity of these inference systems. The analyses do not prove that any one system is better than the others all the time. But they do suggest that one system may be better than the others for some particular problems. We also discuss the effect of caching.

A typed functional extension of logic programming

A logic language is suitable for specification if it is equipped with features for data abstraction and modularization. In this paper, an effective mechanism to incorporate function and type into logic programming is presented as the means to embed data abstraction mechanism into logic programming. This incorporation is essentially based on Horn clause logic with equality and a polymorphic type system that is an extension of Mycroft and O’Keefe’s system. This paper also presents an implementation based on Warren Abstract Machine (WAM) and shows the performance, along with a comparison with WAM.

Extending Horn clause logic with implication goals

The paper deals with the problem of extending positive Horn clause logic by introducing implication in goals as a tool for programs structuring. We allow a goal G i in a clause G 1 ∧⋯∧ G n → A to be not only an atom but also an implication D ⊃ G (we shall it an implication goal), where D is a set of clauses and G a goal. This extension of the language allows local definitions of clauses in logic programs. In fact, an implication goal D ⊃ G can be thought of as a block ( D, G), where D is the set of local clause declarations. In this paper we define a language with blocks in which, as in conventional block structured programming languages, static scope rules have been chosen for locally defined clauses. We analyse static scope rules, where a goal can refer only to clauses defined in statically surrounding blocks, and we compare this extension with other proposals in the literature. We argue, on account of both implementative and semantic considerations, that this kind of block structured language is a very natural extension of Horn clauses when used as a programming language. We show it by defining an operational, fixpoint and model–theoretic semantics which are extensions of the standard ones, and by proving their equivalence. We show that static scope rules can be obtained by interpreting → as classical and ⇒ as intuitionistic implication with respect to Herbrand interpretations.

Generalized resolution for 0?1 linear inequalities

We show how the resolution method of theorem proving can be extended to obtain a procedure for solving a fundamental problem of integer programming, that of finding all valid cuts of a set of linear inequalities in 0-1 variables. Resolution generalizes to two cutting plane operations that, when applied repeatedly, generate all strongest possible or “prime” cuts (analogous to prime implications in logic). Every valid cut is then dominated by at least one of the prime cuts. The algorithm is practical when restricted to classes of inequalities within which one can easily tell when one inequality dominates another. We specialize the algorithm to several such classes, including inequalities representing logical clauses, for which it reduces to classical resolution.