HOME

TheInfoList



OR:

In computer science and logic, a dependent type is a type whose definition depends on a value. It is an overlapping feature of type theory and 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 Agda, ATS,
Coq Coq is an interactive theorem prover first released in 1989. It allows for expressing mathematical assertions, mechanically checks proofs of these assertions, helps find formal proofs, and extracts a certified program from the constructive proof ...
, F*, Epigram, and Idris, 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 are ''dependent functions'' and ''dependent pairs''. The return type of a dependent function may depend on the ''value'' (not just type) of one of its arguments. For instance, a function that takes a positive integer n may return an array of length n, where the array length is part of the type of the array. (Note that this is different from polymorphism and generic 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 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 the decidability of type checking may depend on the given type theory's semantics of equality, that is, whether the type theory is intensional or
extensional In any of several fields of study that treat the use of signs — for example, in linguistics, logic, mathematics, semantics, semiotics, and philosophy of language — an extensional context (or transparent context) is a syntactic environment in wh ...
.


History

In 1934,
Haskell Curry Haskell Brooks Curry (; September 12, 1900 – September 1, 1982) was an American mathematician and logician. Curry is best known for his work in combinatory logic. While the initial concept of combinatory logic was based on a single paper by ...
noticed that the types used in typed lambda calculus, and in its
combinatory logic Combinatory logic is a notation to eliminate the need for quantified variables in mathematical logic. It was introduced by Moses Schönfinkel and Haskell Curry, and has more recently been used in computer science as a theoretical model of comput ...
counterpart, 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.
Predicate logic First-order logic—also known as predicate logic, quantificational logic, and first-order predicate calculus—is a collection of formal systems used in mathematics, philosophy, linguistics, and computer science. First-order logic uses quantifi ...
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". (Because of this and other work by Howard, propositions-as-types is known as the
Curry–Howard correspondence In programming language theory and proof theory, the Curry–Howard correspondence (also known as the Curry–Howard isomorphism or equivalence, or the proofs-as-programs and propositions- or formulae-as-types interpretation) is the direct relati ...
.)


Formal definition


Π type

Loosely speaking, dependent types are similar to the type of an indexed family of sets. More formally, given a type A:\mathcal in a universe of types \mathcal, one may have a family of types B:A\to\mathcal, which assigns to each term a:A a type B(a):\mathcal. We say that the type varies with . A function whose type of return value varies with its argument (i.e. there is no fixed
codomain In mathematics, the codomain or set of destination of a function is the set into which all of the output of the function is constrained to fall. It is the set in the notation . The term range is sometimes ambiguously used to refer to either ...
) is a dependent function and the type of this function is called dependent product type, pi-type ( type) or dependent function type. From a family of types B: A \to \mathcal we may construct the type of dependent functions \prod_ B(x), whose terms are functions which take a term a : A and return a term in B(a). For this example, the dependent function type is typically written as \prod_ B(x), \prod_ B(x), or \prod (x:A), B(x). If B:A\to\mathcal is a constant function, the corresponding dependent product type is equivalent to an ordinary function type. That is, \prod_B is judgmentally equal to A\to B when does not depend on . The name 'Π-type' comes from the idea that these may be viewed as a
Cartesian product In mathematics, specifically set theory, the Cartesian product of two sets ''A'' and ''B'', denoted ''A''×''B'', is the set of all ordered pairs where ''a'' is in ''A'' and ''b'' is in ''B''. In terms of set-builder notation, that is : A\tim ...
of types. Π-types can also be understood as
models A model is an informative representation of an object, person or system. The term originally denoted the plans of a building in late 16th-century English, and derived via French and Italian ultimately from Latin ''modulus'', a measure. Models c ...
of universal quantifiers. For example, if we write \operatorname(\mathbb,n) for ''n''-tuples of
real numbers In mathematics, a real number is a number that can be used to measure a ''continuous'' one-dimensional quantity such as a distance, duration or temperature. Here, ''continuous'' means that values can have arbitrarily small variations. Every ...
, then \prod_ \operatorname(\mathbb,n) would be the type of a function which, given a natural number , returns a tuple of real numbers of size . The usual function space arises as a special case when the range type does not actually depend on the input. E.g. \prod_ is the type of functions from natural numbers to the real numbers, which is written as \mathbb\to\mathbb in typed lambda calculus. For a more concrete example, taking to be equal to the family of unsigned integers from 0 to 255 (the ones that fit into 8 bits or 1 byte) and for , then \prod_ B(x) devolves into the product of ''precisely because'' the finite set of integers from 0 to 255 would ultimately stop at the bounds just mentioned, resulting in a finite codomain of the dependent function.


Σ type

The
dual Dual or Duals may refer to: Paired/two things * Dual (mathematics), a notion of paired concepts that mirror one another ** Dual (category theory), a formalization of mathematical duality *** see more cases in :Duality theories * Dual (grammatical ...
of the dependent product type is the dependent pair type, dependent sum type, sigma-type, or (confusingly) dependent product type. Sigma-types can also be understood as existential quantifiers. Continuing the above example, if, in the universe of types \mathcal, there is a type A:\mathcal and a family of types B:A\to\mathcal, then there is a dependent pair type \sum_ 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_ B(x), then a:A and b:B(a). If is a constant function, then the dependent pair type becomes (is judgementally equal to) the product type, that is, an ordinary Cartesian product A\times B. For a more concrete example, taking to again be equal to the family of unsigned integers from 0 to 255, and to again be equal to for 256 more arbitrary , then \sum_ B(x) devolves into the sum for the same reasons as to what happened to the codomain of the dependent function.


Example as existential quantification

Let A:\mathcal be some type, and let B:A\to\mathcal. By the Curry–Howard correspondence, can be interpreted as a logical
predicate Predicate or predication may refer to: * Predicate (grammar), in linguistics * Predication (philosophy) * several closely related uses in mathematics and formal logic: **Predicate (mathematical logic) **Propositional function **Finitary relation, o ...
on terms of . For a given a:A, whether the type is inhabited indicates whether satisfies this predicate. The correspondence can be extended to existential quantification and dependent pairs: the proposition \existsA\,B(a) is true if and only if the type \sum_B(a) is inhabited. For example, m:\mathbb is less than or equal to n:\mathbb if and only if there exists another natural number k:\mathbb such that . In logic, this statement is codified by existential quantification: m\le n \iff \exists\mathbb\,m+k=n. This proposition corresponds to the dependent pair type: \sum_ m+k=n. That is, a proof of the statement that is less than or equal to is a pair that contains both a non-negative number , which is the difference between and , and a proof of the equality .


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 mathematical logic and computer science, the calculus of constructions (CoC) is a type theory created by Thierry Coquand. It can serve as both a typed programming language and as constructive foundation for mathematics. For this second reason ...
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 In mathematical logic and computer science, the calculus of constructions (CoC) is a type theory created by Thierry Coquand. It can serve as both a typed programming language and as constructive foundation for mathematics. For this second reason ...
whose derivative, the
calculus of inductive constructions In mathematical logic and computer science, the calculus of constructions (CoC) is a type theory created by Thierry Coquand. It can serve as both a typed programming language and as constructive foundation for mathematics. For this second reason ...
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 In mathematics, a constructive proof is a method of proof that demonstrates the existence of a mathematical object by creating or providing a method for creating the object. This is in contrast to a non-constructive proof (also known as an existen ...
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 Proof-carrying code (PCC) is a software mechanism that allows a host system to verify properties about an application via a formal proof that accompanies the application's executable code. The host system can quickly verify the validity of the proo ...
, since the code is derived directly from a mechanically verified mathematical proof.


Comparison of languages with dependent types


See also

* Typed lambda calculus * Intuitionistic type theory


References


Further reading

* * * * Brandl, Helmut (2022)
Calculus of Constructions
* * * * * * *


External links


Dependently Typed Programming 2008

Dependently Typed Programming 2010

Dependently Typed Programming 2011

"Dependent type"
at the Haskell Wiki * * * * * * {{DEFAULTSORT:Dependent Type Foundations of mathematics Type theory Type systems