Incomputer science andlogic, adependent type is a type whose definition depends on a value. It is an overlapping feature oftype theory andtype systems. Inintuitionistic type theory, dependent types are used to encode logic'squantifiers like "for all" and "there exists". Infunctional programminglanguages likeAgda,ATS,Rocq (previously known asCoq),F*,Epigram,Idris, andLean, dependent types help reduce bugs by enabling the programmer to assign types that further restrain the set of possible implementations.

Two common examples of dependent types aredependent functions anddependent pairs. The return type of a dependent function may depend on thevalue (not just type) of one of its arguments. For instance, a function that takes a positive integer${\displaystyle n}$ may return an array of length${\displaystyle n}$, where the array length is part of the type of the array. (Note that this is different frompolymorphism andgeneric programming, both of which include the type as an argument.) A dependent pair may have a second value, the type of which depends on the first value. Sticking with the array example, a dependent pair may be used to pair an array with its length in a type-safe way.

Dependent types add complexity to a type system. Deciding theequality 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 thedecidability oftype checking may depend on the given type theory's semantics of equality, that is, whether the type theory isintensional orextensional.^[1]

In 1934,Haskell Curry noticed that the types used intyped lambda calculus, and in itscombinatory logic counterpart, followed the same pattern as axioms inpropositional 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 betweensimply typed lambda calculus andintuitionistic logic.^[2]

Predicate logic is an extension of propositional logic, adding quantifiers.Howard andde 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".^[3]

Because of this, and other work by Howard, propositions-as-types is known as theCurry–Howard correspondence.

Loosely speaking, dependent types are similar to the type of anindexed family of sets. More formally, given a type${\displaystyle A:\mathcal{U}}$ in a universe of types${\displaystyle \mathcal{U}}$, one may have afamily of types${\displaystyle B:A\to \mathcal{U}}$, which assigns to each term${\displaystyle a:A}$ a type${\displaystyle B(a):\mathcal{U}}$. We say that the type${\displaystyle B(a)}$ varies with${\displaystyle a}$.

A function whose type of return value varies with its argument (i.e. there is no fixedcodomain) is adependent function and the type of this function is calleddependent product type,pi-type (Π type) ordependent function type.^[4] From a family of types${\displaystyle B:A\to \mathcal{U}}$ we may construct the type of dependent functions$\prod _{x:A}B(x)$, whose terms are functions that take a term${\displaystyle a:A}$ and return a term in${\displaystyle B(a)}$. For this example, the dependent function type is typically written as$\prod _{x:A}B(x)$ or$\prod (x:A)B(x)$.

If${\displaystyle B:A\to \mathcal{U}}$ is a constant function, the corresponding dependent product type is equivalent to an ordinaryfunction type. That is,$\prod _{x:A}B$ is judgmentally equal to${\displaystyle A\to B}$ when${\displaystyle B}$ does not depend on${\displaystyle x}$.

The name 'Π-type' comes from the idea that these may be viewed as aCartesian product of types. Π-types can also be understood asmodels ofuniversal quantifiers.

For example, if we write${\displaystyle \mathrm{Vec}(\mathbb{R},n)}$ forn-tuples ofreal numbers, then$\prod _{n:\mathbb{N}}\mathrm{Vec}(\mathbb{R},n)$ would be the type of a function which, given anatural numbern, returns a tuple of real numbers of sizen. The usual function space arises as a special case when the range type does not actually depend on the input. E.g.$\prod _{n:\mathbb{N}}\mathbb{R}$ is the type of functions from natural numbers to the real numbers, which is written as${\displaystyle \mathbb{N}\to \mathbb{R}}$ in typed lambda calculus.

For a more concrete example, taking${\displaystyle A}$ to be the type of unsigned integers from 0 to 255 (the ones that fit into 8 bits or 1 byte) and${\displaystyle B(a)=X_a}$ for${\displaystyle a:A}$, then$\prod _{x:A}B(x)$ devolves into the product of${\displaystyle X_0\times X_1\times X_2\times \dots \times X_{253}\times X_{254}\times X_{255}}$.

Thedual of the dependent product type is thedependent pair type,dependent sum type,sigma-type, or (confusingly)dependent product type.^[4] Sigma-types can also be understood asexistential quantifiers. Continuing the above example, if, in the universe of types${\displaystyle \mathcal{U}}$, there is a type${\displaystyle A:\mathcal{U}}$ and a family of types${\displaystyle B:A\to \mathcal{U}}$, then there is a dependent pair type$\sum _{x:A}B(x)$. (The alternative notations are similar to that ofΠ types.)

The dependent pair type captures the idea of an ordered pair where the type of the second term is dependent on the value of the first. If$(a,b):\sum _{x:A}B(x),$ then${\displaystyle a:A}$ and${\displaystyle b:B(a)}$. If${\displaystyle B}$ is a constant function, then the dependent pair type becomes (is judgementally equal to) theproduct type, that is, an ordinary Cartesian product${\displaystyle A\times B}$.^[4]

For a more concrete example, taking${\displaystyle A}$ to again be type of unsigned integers from 0 to 255, and${\displaystyle B(a)}$ to again be equal to${\displaystyle X_a}$ for 256 more arbitrary${\displaystyle X_a}$, then$\sum _{x:A}B(x)$ devolves into the sum${\displaystyle X_0+X_1+X_2+\dots +X_{253}+X_{254}+X_{255}}$.

Let${\displaystyle A:\mathcal{U}}$ be some type, and let${\displaystyle B:A\to \mathcal{U}}$. By the Curry–Howard correspondence,${\displaystyle B}$ can be interpreted as a logicalpredicate on terms of${\displaystyle A}$. For a given${\displaystyle a:A}$, whether the type${\displaystyle B(a)}$ is inhabited indicates whether${\displaystyle a}$ satisfies this predicate. The correspondence can be extended to existential quantification and dependent pairs: the proposition${\displaystyle \mathrm{\exists }a\in AB(a)}$ is trueif and only if the type$\sum _{a:A}B(a)$ is inhabited.

For example,${\displaystyle m:\mathbb{N}}$ is less than or equal to${\displaystyle n:\mathbb{N}}$ if and only if there exists another natural number${\displaystyle k:\mathbb{N}}$ such that${\displaystyle m+k=n}$. In logic, this statement is codified by existential quantification:

$${\displaystyle m\le n⟺\mathrm{\exists }k\in \mathbb{N}m+k=n.}$$

This proposition corresponds to the dependent pair type:

$${\displaystyle \sum _{k:\mathbb{N}}m+k=n.}$$

That is, a proof of the statement that${\displaystyle m}$ is less than or equal to${\displaystyle n}$ is a pair that contains both a non-negative number${\displaystyle k}$, which is the difference between${\displaystyle m}$ and${\displaystyle n}$, and a proof of the equality${\displaystyle m+k=n}$.

Henk Barendregt developed thelambda 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, withsimply typed lambda calculus in the least expressive corner, andcalculus 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 higherkinded type constructors (functions from types to types, for example). The lambda cube is generalized further bypure type systems.

The system${\displaystyle \lambda \mathrm{\Pi }}$ of pure first order dependent types, corresponding to the logical frameworkLF, is obtained by generalising the function space type of thesimply typed lambda calculus to the dependent product type.

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

The higher order system${\displaystyle \lambda \mathrm{\Pi }\omega }$ extends${\displaystyle \lambda \mathrm{\Pi }2}$ to all four forms of abstraction from thelambda cube: functions from terms to terms, types to types, terms to types and types to terms. The system corresponds to thecalculus of constructions whose derivative, thecalculus of inductive constructions is the underlying system of Rocq.

The Curry–Howard correspondence implies that types can be constructed that express arbitrarily complex mathematical properties. If the user can supply aconstructive proof that a type isinhabited (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 toproof assistants. The code-generation aspect provides a powerful approach to formalprogram verification andproof-carrying code, since the code is derived directly from a mechanically verified mathematical proof.

• Typed lambda calculus
• Intuitionistic type theory
• Design by contract

• Dependently Typed Programming 2008
• Dependently Typed Programming 2010
• Dependently Typed Programming 2011
• "Dependent type" at the Haskell Wiki
• dependent type theory at thenLab
• dependent type at thenLab
• dependent product type at thenLab
• dependent sum type at thenLab
• dependent product at thenLab
• dependent sum at thenLab

• Foundations of mathematics
• Dependently typed programming
• Type theory
• Type systems

• Articles with short description
• Short description is different from Wikidata
• Webarchive template wayback links