#jsDisabledContent { display:none; } My Account | Register | Help

# Dependent types

Article Id: WHEBN0001949791
Reproduction Date:

 Title: Dependent types Author: World Heritage Encyclopedia Language: English Subject: Collection: Publisher: World Heritage Encyclopedia Publication Date:

### Dependent types

In computer science and logic, a dependent type is a type that depends on a value. It is an overlapping of feature of math-encoding type theory and bug-stopping type systems. In intuitionistic type theory, dependent types are used to encode logic's quantifiers like "for all" and "there exists". In functional programming languages like ATS, Agda and Epigram, dependent types prevent bugs by allowing very expressive types.

Two common examples of dependent types are dependent functions and dependent pairs. A dependent function's return type may depend on the value (not just type) of an argument. A function that takes a positive integer "n" may return an array of length "n". (Note that this is different from polymorphism where the type is an argument.) A dependent pair may have a second value that depends on the first. It can be used to encode a pair of integers where the second one is greater than the first.

Dependent types add complexity to a type system. Deciding the equality of dependent types in a program may require computations. If arbitrary values are allowed in dependent types, then deciding type equality may involve deciding whether two arbitrary programs produce the same result; hence type checking may become undecidable.

## History

Dependent types were created to deepen the connection between programming and logic.

In 1934, Haskell Curry noticed that the types used in mathematic programming languages followed the same pattern as axioms in propositional logic. Going further, for every proof in the logic, there was a matching function (term) in the programming language. One of Curry's examples was the correspondence between simply typed lambda calculus and intuitionistic logic.[1]

Predicate logic is an extension of propositional logic, adding quantifiers. Howard and de Bruijn extended lambda calculus to match this more powerful logic by creating types for dependent functions, which correspond to "for all", and dependent pairs, which correspond to "there exists".[2]

(Because of this and other work by Howard, propositions-as-types is known as the Curry-Howard correspondence.)

## Formal definition

Dependent types can be, very loosely speaking, imagined to be similar to the type of an indexed family of sets. More formally, given a type $A:\mathcal\left\{U\right\}$ in a universe of types $\mathcal\left\{U\right\}$, one may have a family of types $B:A\to\mathcal\left\{U\right\}$ which assigns to each term $a:A$ a type $B\left(a\right):\mathcal\left\{U\right\}$. A function whose codomain varies depending on its argument is a dependent function, and the type of this function is called a dependent type, dependent product type or pi-type. For this example, the dependent type would be written as

$\Pi_\left\{\left(x:A\right)\right\}B\left(x\right)$

or as

$\Pi \left(x:A\right),B\left(x\right)$

If B is a constant, the dependent type becomes an ordinary function $A\to B$. That is, $\Pi_\left\{\left(x:A\right)\right\}B$ is judgementally equal to the function type $A\to B$.

The name 'pi-type' comes from the idea that these may be viewed as a Cartesian product of types. Pi-types can also be understood as models of universal quantifiers.

For example, writing $\mbox\left\{Vec\right\}\left(\left\{\mathbb R\right\},n\right)$ for $n$-tuples of real numbers, then $\Pi_\left\{\left(n:\left\{\mathbb N\right\}\right)\right\} \mbox\left\{Vec\right\}\left(\left\{\mathbb R\right\},n\right)$ would be the type of functions which, given a natural number n, return a tuple of real numbers of size n. The usual function space arises as a special case when the range type does not actually depend on the input, e.g. $\Pi_\left\{\left(n:\left\{\mathbb N\right\}\right)\right\}\; \left\{\mathbb R\right\}$ is the type of functions from natural numbers to the real numbers, which is written as $\left\{\mathbb N\right\}\to\left\{\mathbb R\right\}$ in the simply typed lambda calculus.

Polymorphic functions are an important example of dependent functions, that is, functions having dependent type. Given a type, these functions act on elements of that type (or on elements of a type constructed (derived, inherited) from that type). A polymorphic function returning elements of type C would have a polymorphic type written as

$\Pi_\left\{\left(A:\mathcal\left\{U\right\}\right)\right\} A\to C$

## Dependent pair type

The opposite of the dependent type is the dependent pair type, dependent sum type or sigma-type. It is analogous to the coproduct or disjoint union. Sigma-types can also be understood as models of existential quantifiers. Notationally, it is written as

$\Sigma_\left\{\left(x:A\right)\right\} B\left(x\right)$

The dependent pair type captures the idea of a pair, where the type of the second term is dependent on the first. Thus, if

$\left(a,b\right):\Sigma_\left\{\left(x:A\right)\right\} B\left(x\right)$

then $a:A$ and $b:B\left(a\right)$. If B is a constant, then the dependent pair type becomes (is judgementally equal to) the product type, that is, an ordinary Cartesian product $A\times B$.

## Systems of the lambda cube

Henk Barendregt developed the lambda cube as a means of classifying type systems along three axes. The eight corners of the resulting cube-shaped diagram each correspond to a type system, with simply typed lambda calculus in the least expressive corner, and calculus of constructions in the most expressive. The three axes of the cube correspond to three different augmentations of the simply typed lambda calculus: the addition of dependent types, the addition of polymorphism, and the addition of higher kinded type constructors (functions from types to types, for example). The lambda cube is generalized further by pure type systems.

### First order dependent type theory

The system $\lambda \Pi$ of pure first order dependent types, corresponding to the logical framework LF, is obtained by generalising the function space type of the simply typed lambda calculus to the dependent product type.

### Second order dependent type theory

The system $\lambda \Pi 2$ of second order dependent types is obtained from $\lambda \Pi$ by allowing quantification over type constructors. In this theory the dependent product operator subsumes both the $\to$ operator of simply typed lambda calculus and the $\forall$ binder of System F.

### Higher order dependently typed polymorphic lambda calculus

The higher order system $\lambda \Pi \omega$ extends $\lambda \Pi 2$ to all four forms of abstraction from the lambda cube: functions from terms to terms, types to types, terms to types and types to terms. The system corresponds to the Calculus of constructions whose derivative, the calculus of inductive constructions is the underlying system of the Coq proof assistant.

## Simultaneous Programming language and Logic

The Curry–Howard correspondence implies that types can be constructed that express arbitrarily complex mathematical properties. If the user can supply a constructive proof that a type is inhabited (i.e., that a value of that type exists) then a compiler can check the proof and convert it into executable computer code that computes the value by carrying out the construction. The proof checking feature makes dependently typed languages closely related to proof assistants. The code-generation aspect provides a powerful approach to formal program verification and proof-carrying code, since the code is derived directly from a mechanically verified mathematical proof.

## Comparison of languages with dependent types

Language Actively developed Paradigm[fn 1] Tactics Proof terms Termination checking Types can depend on[fn 2] Universes Proof irrelevance Program extraction Extraction erases irrelevant terms
Agda Yes[3] Purely functional Few/limited[fn 3] Yes Yes (optional) Any term Yes (optional)[fn 4] Proof-irrelevant arguments (experimental)[5] Haskell, Javascript Yes[5]
ATS Yes[6] Functional / imperative No[7] Yes Yes ? ? ? Yes ?
Cayenne No Purely functional No Yes No Any term No No ? ?
Coq Yes[8] Purely functional Yes Yes Yes Any term Yes[fn 5] No Haskell, Scheme and OCaml Yes
Dependent ML No[fn 6] ? ? Yes ? Natural numbers ? ? ? ?
Guru No[9] Purely functional[10] hypjoin[11] Yes[10] Yes Any term No Yes Carraway Yes
Idris Yes[12] Purely functional[13] Yes[14] Yes Yes (optional) Any term No No Yes Yes, aggressively[14]
Matita Yes[15] Purely functional Yes Yes Yes Any term Yes ? OCaml ?
NuPRL Yes Purely functional Yes Yes Yes Any term Yes ? Yes ?
F* Yes Functional /imperative ? ? ? ? ? ? ? ?
PVS Yes ? Yes ? ? ? ? ? ? ?
Sage ? Hybrid typechecking ? ? ? ? ? ? ? ?
Twelf Yes Logic programming ? Yes Yes (optional) Any (LF) term No No ? ?
Xanadu No[16] Imperative ? ? ? ? ? ? ? ?

## References

• Norell, Ulf. Towards a practical programming language based on dependent type theory. PhD thesis, Department of Computer Science and Engineering, Chalmers University of Technology, SE-412 96 Göteborg, Sweden, September 2007.
• Oury, Nicolas and Swierstra, Wouter (2008). "The Power of Pi". Accepted for presentation at ICFP, 2008.
• Norell, Ulf (2008). Dependently Typed Programming in Agda.

## External

• Dependently Typed Programming 2008
• Dependently Typed Programming 2010
• Dependently Typed Programming 2011
• "Dependent type" at the Haskell Wiki
• Template:Nlab
• Template:Nlab
• Template:Nlab
• Template:Nlab
• Template:Nlab
• Template:Nlab
This article was sourced from Creative Commons Attribution-ShareAlike License; additional terms may apply. World Heritage Encyclopedia content is assembled from numerous content providers, Open Access Publishing, and in compliance with The Fair Access to Science and Technology Research Act (FASTR), Wikimedia Foundation, Inc., Public Library of Science, The Encyclopedia of Life, Open Book Publishers (OBP), PubMed, U.S. National Library of Medicine, National Center for Biotechnology Information, U.S. National Library of Medicine, National Institutes of Health (NIH), U.S. Department of Health & Human Services, and USA.gov, which sources content from all federal, state, local, tribal, and territorial government publication portals (.gov, .mil, .edu). Funding for USA.gov and content contributors is made possible from the U.S. Congress, E-Government Act of 2002.

Crowd sourced content that is contributed to World Heritage Encyclopedia is peer reviewed and edited by our editorial staff to ensure quality scholarly research articles.