A higher-order unification algorithm for inductive types and dependent types

1997 ◽  
Vol 12 (3) ◽  
pp. 231-243
Author(s):  
Qingping Tan
Keyword(s):  
Higher Order ◽  
Dependent Types ◽  
Unification Algorithm ◽  
Inductive Types

scholarly journals A framework for improving error messages in dependently-typed languages

2019 ◽  
Vol 9 (1) ◽  
pp. 1-32 ◽  
Author(s):  
Joseph Eremondi ◽  
Wouter Swierstra ◽  
Jurriaan Hage
Keyword(s):  
Programming Languages ◽  
Type System ◽  
Higher Order ◽  
Type Checking ◽  
Unification Algorithm ◽  
Implicit Arguments ◽  
Unification Problem ◽  
Heuristic Analysis ◽  
Type Check ◽  
Typed Languages

AbstractDependently-typed programming languages provide a powerful tool for establishing code correctness. However, it can be hard for newcomers to learn how to employ the advanced type system of such languages effectively. For simply-typed languages, several techniques have been devised to generate helpful error messages and suggestions for the programmer. We adapt these techniques to dependently-typed languages, to facilitate their more widespread adoption. In particular, we modify a higher-order unification algorithm that is used to resolve and type-check implicit arguments. We augment this algorithm with replay graphs, allowing for a global heuristic analysis of a unification problem-set, error-tolerant typing, which allows type-checking to continue after errors are found, and counter-factual unification, which makes error messages less affected by the order in which types are checked. A formalization of our algorithm is presented with an outline of its correctness. We implement replay graphs, and compare the generated error messages to those from existing languages, highlighting the improvements we achieved.

Algebra of programming in Agda: Dependent types for relational program derivation

2009 ◽  
Vol 19 (5) ◽  
pp. 545-579 ◽  
Author(s):  
SHIN-CHENG MU ◽  
HSIANG-SHANG KO ◽  
PATRIK JANSSON
Keyword(s):  
Programming Language ◽  
Type Theory ◽  
Type System ◽  
Dependent Types ◽  
Dependent Type Theory ◽  
Program Derivation ◽  
Inductive Types ◽  
Algebra Of Programming ◽  
Dependent Type

AbstractRelational program derivation is the technique of stepwise refining a relational specification to a program by algebraic rules. The program thus obtained is correct by construction. Meanwhile, dependent type theory is rich enough to express various correctness properties to be verified by the type checker. We have developed a library, AoPA (Algebra of Programming in Agda), to encode relational derivations in the dependently typed programming language Agda. A program is coupled with an algebraic derivation whose correctness is guaranteed by the type system. Two non-trivial examples are presented: an optimisation problem and a derivation of quicksort in which well-founded recursion is used to model terminating hylomorphisms in a language with inductive types.

scholarly journals Bounded Higher-order Unification using Regular Terms

10.29007/zhpc ◽  
2018 ◽  
Author(s):  
Tomer Libal
Keyword(s):  
Higher Order ◽  
Correctness Proof ◽  
Unification Algorithm ◽  
Higher Order Terms ◽  
Unification Algorithms

We present an algorithm for the bounded unification of higher-order terms.The algorithm extends G. P. Huet's pre-unification algorithm with rules for the generation and folding of regular terms.The concise form of the algorithm allows the reuse of the pre-unification correctness proof. Furthermore, the regular termscan be restricted in order to decide the unifiability problem.Finally, the algorithm avoids re-computation of terms in a non-deterministic search which leads to a better performance in practice when compared to other boundedunification algorithms.

scholarly journals A Resolution Calculus for Second-order Logic with Eager Unification

10.29007/zpg2 ◽  
2018 ◽  
Author(s):  
Alexander Leitsch ◽  
Tomer Libal
Keyword(s):  
Higher Order ◽  
Second Order ◽  
Order Logic ◽  
Higher Order Logic ◽  
Unification Algorithm ◽  
Efficient Search ◽  
First Order ◽  
Unification Algorithms ◽  
Second Order Logic ◽  
Resolution Calculus

The efficiency of the first-order resolution calculus is impaired when lifting it to higher-order logic. The main reason for that is the semi-decidability and infinitary natureof higher-order unification algorithms, which requires the integration of unification within the calculus and results in a non-efficient search for refutations.We present a modification of the constrained resolution calculus (Huet'72) which uses an eager unification algorithm while retaining completeness. Thealgorithm is complete with regard to bounded unification only, which for many cases, does not pose a problem in practice.

scholarly journals Unification of Higher-order Patterns modulo Simple Syntactic Equational Theories

2000 ◽  
Vol Vol. 4 no. 1 ◽  
Author(s):  
Alexandre Boudet
Keyword(s):  
Higher Order ◽  
Unification Algorithm ◽  
First Order ◽  
Equational Theories ◽  
Order Case ◽  
International Audience ◽  
Syntactic Theories

International audience We present an algorithm for unification of higher-order patterns modulo simple syntactic equational theories as defined by Kirchner [14]. The algorithm by Miller [17] for pattern unification, refined by Nipkow [18] is first modified in order to behave as a first-order unification algorithm. Then the mutation rule for syntactic theories of Kirchner [13,14] is adapted to pattern E-unification. If the syntactic algorithm for a theory E terminates in the first-order case, then our algorithm will also terminate for pattern E-unification. The result is a DAG-solved form plus some equations of the form λ øverlinex.F(øverlinex) = λ øverlinex. F(øverlinex^π ) where øverlinex^π is a permutation of øverlinex When all function symbols are decomposable these latter equations can be discarded, otherwise the compatibility of such equations with the solved form remains open.

A realizability interpretation of Martin-Löf’s type Theory

1998 ◽  
Author(s):  
Catarina Coquand
Keyword(s):  
Type Theory ◽  
The Other ◽  
Dependent Types ◽  
Powerful Method ◽  
Natural Numbers ◽  
Simple Argument ◽  
Calculus Of Constructions ◽  
Polymorphic Type ◽  
Inductive Types ◽  
System F

The notion of computability predicate developed by Tail gives a powerful method for proving normalization for various λ-calculi. There are actually two versions of this method: a typed and an untyped approach. In the former approach we define a computability predicate over well-typed terms. This technique was developed by Tail (1967) in order to prove normalization for Gödel’s system T. His method was extended by Girard (1971) for his System F and by Martin-Löf (1971) for his type theory. The second approach is similar to Kleene’s realizability interpretation (Kleene 1945), but in this approach formulas are realized by (not necessarily well-typed) λ-terms rather than Gödel numbers. This technique was developed by Tail (1975) where he uses this method to obtain a simplified proof of normalization for Girard’s system F. The method was later rediscovered independently by several others, for instance Mitchell (1986). There are two ways of defining typed λ-calculus: we have either equality as conversion (on raw terms) or equality as judgments. It is more difficult to show in the theory with equality as judgments that every well-typed term has a normal form of the same type. We can find different approaches to how to solve this problem in Altenkirch (1993), Coquand (1991), Goguen (1994) and Martin-Löf (1975). There are several papers addressing normalization for calculi with equality as untyped conversion; two relevant papers showing normalization are Altenkirch’s (1994) proof for system F using the untyped method and Werner’s (1994) proof for the calculus of constructions with inductive types using the other method. Another difference is the predicative and impredicative formulations of λ-calculi where it is more intricate to prove normalization for the impredicative ones. The aim of this paper is to give a simple argument of normalization for a theory with “real” dependent types, i.e. a theory in which we can define types by recursion on the natural numbers (like Nn). For this we choose to study the simplest theory that has such types, namely the N, Π, U-fragment of Martin-Löf’s polymorphic type theory (Martin-Löf 1972) which contains the natural numbers, dependent functions and one universe. This theory has equality as conversion and is predicative.

Sign in / Sign up

Export Citation Format

Share Document