Unification Procedure Research Articles

Pattern Unification with Sequence Variables and Flexible Arity Symbols

A unification procedure for a theory with individual and sequence variables, free constants, free fixed and flexible arity function symbols and patterns is described. The procedure enumerates a set of substitution/constraint pairs which constitutes the minimal complete set of unifiers.

Preface: Volume 66, Issue 5

This part of the volume contains the papers accepted for presentation at the workshop on Unification in Non-Classical Logics (UNCL), co-located with ICALP 2002, which took place on July 12, 2002 in M\\'alaga, Spain.The workshop was concerned with one of the most promising areas of research on non-classical logics and its applications. Unification in non-classical logics, with various approaches to handling generalised terms, has drawn more and more attention in recent years. So far, most popular lines of research include fuzzy unification of (conventional) databases and the use of fuzzy concepts in information retrieval.This workshop was conceived as a forum for the exchange of ideas relevant for the concept of unification in non-classical logics, including, but not limited to, the topics of: •Unification in multiple-valued and fuzzy logic programming.•Unification based on similarities and fuzzy equivalence relations.•Categorical unification.•Practical use of non-classical unification, e.g. in expert systems and information retrieval.The program committee selected six papers after a reviewing process in which each submitted paper received at least two reviews. Considerable effort was devoted for the evaluation of the submissions and to providing the authors with helpful feedback. The criteria for selection were originality, quality, and relevance to the topic of the workshop.Alsinet et al reviewed and compared two models which extend first order possibilistic logic in order to enable fuzzy unification. The extension considers mainly fuzzy constants, and in form of restrictions on existential quantifiers.Banerjee and Bujosa presented a non-classical interpretion of classical unification in terms of geometrical constructions over a suitable R-module M. The main result is that unification of two terms can be seen as the intersection of their corresponding affine varieties on M. This paves the way of using methods from computer algebra in the field of unification.In Eklund et al, substitutions and unifiers appear as constructs in Kleisli categories related to particular composed powerset term monads. It is shown that an often used similarity-based approach to fuzzy unification is compatible with the categorical approach, and can be adequately extended.Kutsia presented a unification procedure for a theory with individual and sequence variables, free fixed and flexible arity function symbols and patterns. These theories have been used in different contexts such as databases, rewriting, programming languages, or theorem proving.Medina et al introduced a formal model for similarity-based fuzzy unification in multi-adjoint logic programs. On this computational model, a similarity-based unification approach which provides a semantic framework for logic programming with different notions of similarity was constructed.Virtanen introduced unification in similarity-based logic programming. One of the crucial points is the definition of similarity degrees between sets, giving rise to [lambda]-interpretations. The selection of so called most significant terms again is one of the cornerstones of the paper.We would like to thank all those who submitted papers for consideration, the authors of accepted papers for their interesting discussions during the workshop, the additional referees for their careful work, and Inma Fortes from the local organising committee for her assistance.

Type classes with more higher-order polymorphism

We propose an extension of Haskell's type class system with lambda abstractions in the type language. Type inference for our extension relies on a novel constrained unification procedure called guided higher-order unification. This unification procedure is more general than Haskell's kind-preserving unification but less powerful than full higher-order unification.The main technical result is the soundness and completeness of the unification rules for the fragment of lambda calculus that we admit on the type level.

Wavelength-compensated Fourier and Fresnel transformers: a unified approach

We recognize that one can adapt any dispersion-compensated broadband optical Fourier transformer to achieve wavelength compensation in the Fresnel diffraction region just by inserting a diffractive lens at the input plane and vice versa. This unification procedure is employed in a second stage in the design of a novel hybrid (diffractive-refractive) optical setup that provides, in a sequential way, nearly wavelength-independent Fresnel diffraction patterns in the irradiance of the object transmittance.

Set-sharing is redundant for pair-sharing

Although the usual goal of sharing analysis is to detect which pairs of variables share, the standard choice for sharing analysis is a domain that characterizes set-sharing. In this paper, we question, apparently for the first time, whether this domain is over-complex for pair-sharing analysis. We show that the answer is yes. By defining an equivalence relation over the set-sharing domain we obtain a simpler domain, reducing the complexity of the abstract unification procedure. We present experimental results showing that, in practice, our domain compares favorably with the set-sharing one over a wide range of benchmark and real programs.

Unification via the se-style of explicit substitutions

A unification method based on the λse-style of explicit substitution is proposed. This method together with appropriate translations, provide a Higher Order Unification (HOU) procedure for the pure λ-calculus. Our method is influenced by the treatment introduced by Dowek, Hardin and Kirchner using the λσ-style of explicit substitution. Correctness and completeness properties of the proposed λse-unification method are shown and its advantages, inherited from the qualities of the λse-calculus, are pointed out. Our method needs only one sort of objects: terms. And in contrast to the HOU approach based on the λσ-calculus, it avoids the use of substitution objects. This makes our method closer to the syntax of the λ-calculus. Furthermore, detection of redices depends on the search for solutions of simple arithmetic constraints which makes our method more operational than the one based on the λσ-style of explicit substitution.

Tractable and intractable instances of combination problems for unification and disunification

The algorithms for combining decision procedures for (dis)unification in the union of arbitrary disjoint equational theories known from the literature generate an exponential number of 'pure' output problems over the component theories. Despite several optimization techniques, no general results are known that describe in which cases a polynomial-time combination procedure is (im)possible. In the first part of this paper we characterize a large class of equational theories E where E-unification with free function symbols is NP-hard and where a polynomial-time optimization of the combination algorithm is impossible (unless P = NP). This supports the conjecture that for the theories in this class there is no polynomial-time algorithm for combining E-unification with constants with free unification. In the second part of the paper we introduce another class of equational theories where (dis)unification algorithms can be combined deterministically and in polynomial time. Under reasonable assumptions on the form of the given unification procedure, each unitary, regular and collapse-free equational theory with a polynomial-time unification algorithm belongs to this class.

How to realize LSE narrowing

Narrowing is a complete unification procedure for equational theories defined by canonical term rewriting systems. It is also the operational semantics of various logic and functional programming languages. In [BKW93], we introduced the LSE narrowing strategy which is complete for arbitrary canonical rewriting systems and optimal in the sense that two different LSE narrowing derivations cannot generate the same narrowing substitution. LSE narrowing improves all previously known strategies for arbitrary systems. According to their definition, LSE narrowing steps seem to be very expensive, because a large number of subterms has to be checked for reducibility. In this paper, we first show that many of these subterms are identical. Then we describe how using left-to-right basic occurrences the number of subterms that have to be tested can be reduced drastically. Finally, based on these theoretical results, we develop an efficient implementation of LSE narrowing.

An Experiment in Abstract Machine Design

In this article we present Typed Feature Structures as an extension of Prolog, and show how to come up with a compilation scheme and an abstract machine using a design methodology based on partial evaluation. First we define the transformations used by our partial evaluator. Then we present the design methodology which we will use later. Next, we clarify the notion of Typed Feature Structures that underlies our work, and formally define the unification of such structures. Based on this definition, we develop a unification procedure with explicit heap representation. By partially evaluating this procedure with respect to some example programs, we show how to come up with the machine instructions and translation schemes. Finally, we briefly address coreferences, cyclic structures and the unification of types. © 1997 by John Wiley & Sons, Ltd.

RANK 2 INTERSECTION TYPE ASSIGNMENT IN TERM REWRITING SYSTEMS

A notion of type assignment on Curryfied Term Rewriting Systems is introduced that uses Intersection Types of Rank 2, and in which all function symbols are assumed to have a type. Type assignment will consist of specifying derivation rules that describe how types can be assigned to terms, using the types of function symbols. Using a modified unification procedure, for each term the principal pair (of basis and type) will be defined in the following sense: from these all admissible pairs can be generated by chains of operations on pairs, consisting of the operations substitution, copying, and weakening. In general, given an arbitrary typeable GTRS, the subject reduction property does not hold. Using the principal type for the left-hand side of a rewrite rule, a sufficient and decidable condition will be formulated that typeable rewrite rules should satisfy in order to obtain this property.

Reproductive outcome following abdominal metroplasty

Objective: To evaluate pregnancy outcome following uterine unification procedures in patients with uterine anomalies. Methods: A retrospective survey included all abdominal metroplasty procedures performed on 43 patients at the American University of Beirut Medical Center between January 1, 1974 and December 31, 1991. Age at metroplasty, type of anomaly and surgical procedures, as well as preoperative and postoperative reproductive performance were all recorded. Results: Forty (93%) out of 43 patients who underwent metroplasty had postoperative live births compared with five (12%) prior to surgery. The fetal wastage rate dropped from 93% pre- to 16% postoperatively. All seven patients with a history of primary infertility conceived and had live births. Conclusion: Our data suggest a remarkable improvement following abdominal metroplasty in patients with both typical and uncharacteristic preoperative reproductive performance.

Incremental constraint satisfaction for equational logic programming

In this paper we are concerned with an instance of the Constraint Logic Programming (CLP) scheme specialized in solving equations with respect to a Horn equational theory E . The intended structure H E is given by the finest partition induced by E on the Herbrand universe H over a finite one sorted alphabet. This work deals with the description of an incremental constraint solver as the kernel of an operational semantics for the language CLP( H E ). The primary issues are: how to verify the solvability of constraints in the structure ( H E ) by using some sound and complete semantic unification procedure such as narrowing, how to simplify constraints in a computation sequence, how to achieve incrementality in the computation process and how to profit from finitely failed derivations as a heuristic for optimizing the algorithms.

NARROWING STRATEGIES FOR ARBITRARY CANONICAL REWRITE SYSTEMS

Narrowing is a universal unification procedure for equational theories defined by a,canonical term rewriting system. In its original form it is extremely inefficient. Therefore, many optimizations have been proposed during the last years. In this paper, we present the narrowing strategies for arbitrary canonical systems in a uniform framework and introduce the new narrowing strategy LSE narrowing. LSE narrowing is complete and improves all other strategies which are complete for arbitrary-canonical systems. It is optimal in the sense that two different LSE narrowing derivations cannot generate the same narrowing substitution. Moreover, LSE narrowing computes only normalized narrowing substitutions.

Conditional narrowing modulo a set of equations

Narrowing is a universal unification procedure for equational theories given by a canonical term rewrite system. In this paper we introduce conditional narrowing modulo a set of conditional equations and give a full proof of its correctness and completeness for equational conditional rewrite systemsR, E without extravariables whereE is regular andR, E is Church-Rosser moduloE and decreasing moduloE. This result can be seen as the theoretical foundation of a special form of constraint logic and functional programming.

A full theorem-prover under uncertainty

Prolog embodies an ordered input resolution inference mechanism, with a powerful unification procedure. However, Prolog is not a full theorem-prover, and does not contain an inexact reasoning mechanism. In this paper, it is shown how these capabilities can be combined in a Prolog environment. A Prolog meta-interpreter is used in an elegant and simple way for this purpose. The inexact reasoning mechanism is presented through the certainty factor model, but it is also discussed how other inexact reasoning models may be also implemented.

Finite Acyclic Theories are Unitary

The main result in this paper is that the class of finite acyclic theories contains only unitary theories. As far as we are aware, this is the first class of unitary theories to be discovered. Interestingly, two of the known unitary theories (those of left and right distributivity) belong to this class. Moreover, it is possible to construct a universal unification procedure for this class of theories—the procedure is similar to the one developed by Kirchner for decomposable theories (generalizing the efficient free-unification algorithm of Martelli and Montanari). The decidability of unification in an arbitrary finite acyclic theory is open. The termination technique developed by Tiden and Arnborg for one-sided distributivity appears to be adaptable for many but not for all theories in the class.

Logic programming with typed unification and its realization on an abstract machine

Logic programming can benefit from a typing concept which supports many software engineering principles such as data abstraction, modularization, etc. From a computational point of view, the use of types can drastically reduce the search space. Starting from these observations, this paper gives a survey of many-sorted, order-sorted, and polymorphic approaches to type concepts in logic programming. The underlying unification procedures for ordinary term unification, order-sorted unification, and in particular for polymorphic order-sorted unification are given in the style of solving a set of equations, giving a common basis for comparing them. In addition, the realization of these unification procedures on a Warren Abstract Machine-like architecture is described. Special emphasis is placed on the abstract machine developed for PROTOS-L, a logic programming language based on polymorphic order-sorted unification.

Uterine unification procedures: Post-operative obstetrical outcome

Seventeen patients with different uterine anomalies underwent unification procedures for various indications. Preoperative obstetrical performance segregated them into three main groups: seven patients had only first trimester abortion (group A), seven patients had second trimester abortion with or without first trimester abortion (group B) and three patients were infertile (group C). Postoperatively, all seven patients in group A became pregnant with 100% viable pregnancy rate. Six patients in group B became pregnant (85.7%) and five (57%) had living children. All three patients with primary infertility (group C) became pregnant and two had living babies. The overall pregnancy rate was 94.1% and the viable pregnancy rate was 76.5%. Uterine unification procedures are recommended for patients with repeated first trimester abortions as well as for selected patients with infertility.

The foundation of a generic theorem prover

Isabelle [28, 30] is an interactive theorem prover that supports a variety of logics. It represents rules as propositions (not as functions) and builds proofs by combining rules. These operations constitute a meta-logic (or ‘logical framework’) in which the object-logics are formalized. Isabelle is now based on higher-order logic-a precise and well-understood foundation. Examples illustrate the use of this meta-logic to formalize logics and proofs. Axioms for first-order logic are shown to be sound and complete. Backwards proof is formalized by meta-reasoning about object-level entailment. Higher-order logic has several practical advantages over other meta-logics. Many proof techniques are known, such as Huet's higher-order unification procedure.

Adventures in associative-commutative unification

We have discovered an efficient algorithm for matching and unification in associative-commutative (AC) equational theories. In most cases of AC unification our method obviates the need for solving diophantine equations, and thus avoids one of the bottlenecks of other associative-commutative unification techniques. The algorithm efficiently utilizes powerful constraints to eliminate much of the search involved in generating valid substitutions. Moreover, it is able to generate solutions lazily, enabling its use in an SLD-resolution-based environment like Prolog. We have found the method to run much faster and use less space than other associative-commutative unification procedures on many commonly encountered AC problems.