First-order unification by structural recursion

Authors:
Conor McBride
Affiliations:
Department of Computer Science, University of Durham, South Road Durham, DH1 3LE, UK (e-mail: c.t.mcbride@durham.ac.uk)
Venue:
Journal of Functional Programming
Year:
2003

Citing 8
Cited 8

Verifying the unification algorithm in LCF

Science of Computer Programming - Ellis Horwood series in artificial intelligence
Inductively defined functions in functional programming languages

Journal of Computer and System Sciences
Computation and reasoning: a type theory for computer science

Computation and reasoning: a type theory for computer science
Cayenne—a language with dependent types

ICFP '98 Proceedings of the third ACM SIGPLAN international conference on Functional programming
A Machine-Oriented Logic Based on the Resolution Principle

Journal of the ACM (JACM)
Elementary Strong Functional Programming

FPLE '95 Proceedings of the First International Symposium on Functional Programming Languages in Education
Inductively Defined Types in the Calculus of Constructions

Proceedings of the 5th International Conference on Mathematical Foundations of Programming Semantics
The Zipper

Journal of Functional Programming

Dependent types ensure partial correctness of theorem provers

Journal of Functional Programming
The view from the left

Journal of Functional Programming
Scrap your nameplate: (functional pearl)

Proceedings of the tenth ACM SIGPLAN international conference on Functional programming
Generating generic functions

Proceedings of the 2006 ACM SIGPLAN workshop on Generic programming
Type inference in context

Proceedings of the third ACM SIGPLAN workshop on Mathematically structured functional programming
Embedding polymorphic dynamic typing

Proceedings of the seventh ACM SIGPLAN workshop on Generic programming
Epigram: practical programming with dependent types

AFP'04 Proceedings of the 5th international conference on Advanced Functional Programming
(Nominal) unification by recursive descent with triangular substitutions

ITP'10 Proceedings of the First international conference on Interactive Theorem Proving

Quantified Score

Hi-index	0.00

Visualization

Abstract

First-order unification algorithms (Robinson, 1965) are traditionally implemented via general recursion, with separate proofs for partial correctness and termination. The latter tends to involve counting the number of unsolved variables and showing that this total decreases each time a substitution enlarges the terms. There are many such proofs in the literature (Manna & Waldinger, 1981; Paulson, 1985; Coen, 1992; Rouyer, 1992; Jaume, 1997; Bove, 1999). This paper shows how a dependent type can relate terms to the set of variables over which they are constructed. As a consequence, first-order unification becomes a structurally recursive program, and a termination proof is no longer required. Both the program and its correctness proof have been checked using the proof assistant LEGO (Luo & Pollack, 1992; McBride, 1999).