Английская Википедия:Dependent type
Шаблон:Short description Шаблон:Type systems 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, F*, Epigram, Idris, and Lean, 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 <math>n</math> may return an array of length <math>n</math>, 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.[1]
History
In 1934, Haskell Curry noticed that the types used in typed lambda calculus, and in its combinatory logic 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.[2]
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".[3]
(Because of this and other work by Howard, propositions-as-types is known as the Curry–Howard correspondence.)
Formal definition
Шаблон:AnchorLoosely speaking, dependent types are similar to the type of an indexed family of sets. More formally, given a type <math>A:\mathcal{U}</math> in a universe of types <math>\mathcal{U}</math>, one may have a family of types <math>B:A\to\mathcal{U}</math>, which assigns to each term <math>a:A</math> a type <math>B(a):\mathcal{U}</math>. We say that the type Шаблон:Math varies with Шаблон:Mvar.
Π type
A function whose type of return value varies with its argument (i.e. there is no fixed codomain) is a dependent function and the type of this function is called dependent product type, pi-type (Шаблон:Math type) or dependent function type.[4] From a family of types <math>B: A \to \mathcal{U}</math> we may construct the type of dependent functions <math display=inline>\prod_{x : A} B(x)</math>, whose terms are functions that take a term <math>a : A</math> and return a term in <math>B(a)</math>. For this example, the dependent function type is typically written as <math display=inline>\prod_{x:A} B(x),</math> <math display=inline>\prod_{x:A} B(x),</math> or <math display=inline>\prod {(x:A)} B(x)</math>.
If <math>B:A\to\mathcal{U}</math> is a constant function, the corresponding dependent product type is equivalent to an ordinary function type. That is, <math display=inline>\prod_{x:A}B</math> is judgmentally equal to <math>A\to B</math> when Шаблон:Mvar does not depend on Шаблон:Mvar.
The name 'Π-type' comes from the idea that these may be viewed as a Cartesian product of types. Π-types can also be understood as models of universal quantifiers.
For example, if we write <math>\operatorname{Vec}(\mathbb{R},n)</math> for n-tuples of real numbers, then <math display="inline">\prod_{n:\mathbb{N}} \operatorname{Vec}(\mathbb{R},n)</math> would be the type of a function which, given a natural number Шаблон:Mvar, returns a tuple of real numbers of size Шаблон:Mvar. The usual function space arises as a special case when the range type does not actually depend on the input. E.g. <math display="inline">\prod_{n:\mathbb{N}} {\mathbb{R}}</math> is the type of functions from natural numbers to the real numbers, which is written as <math>\mathbb{N}\to\mathbb{R}</math> in typed lambda calculus.
For a more concrete example, taking Шаблон:Mvar to be the type of unsigned integers from 0 to 255 (the ones that fit into 8 bits or 1 byte) and Шаблон:Math for Шаблон:Math, then <math display=inline>\prod_{x:A} B(x)</math> devolves into the product of Шаблон:Math.
Σ type
Шаблон:Anchor The dual of the dependent product type is the dependent pair type, dependent sum type, sigma-type, or (confusingly) dependent product type.[4] Sigma-types can also be understood as existential quantifiers. Continuing the above example, if, in the universe of types <math>\mathcal{U}</math>, there is a type <math>A:\mathcal{U}</math> and a family of types <math>B:A\to\mathcal{U}</math>, then there is a dependent pair type <math display=inline>\sum_{x:A} B(x)</math>. (The alternative notations are similar to that of Шаблон:Math 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 <math display="inline">(a,b):\sum_{x:A} B(x),</math> then <math>a:A</math> and <math>b:B(a)</math>. If Шаблон:Mvar is a constant function, then the dependent pair type becomes (is judgementally equal to) the product type, that is, an ordinary Cartesian product <math>A\times B</math>.Шаблон:Fcn
For a more concrete example, taking Шаблон:Mvar to again be type of unsigned integers from 0 to 255, and Шаблон:Math to again be equal to Шаблон:Math for 256 more arbitrary Шаблон:Math, then <math display=inline>\sum_{x:A} B(x)</math> devolves into the sum Шаблон:Math.
Example as existential quantification
Let <math>A:\mathcal{U}</math> be some type, and let <math>B:A\to\mathcal{U}</math>. By the Curry–Howard correspondence, Шаблон:Mvar can be interpreted as a logical predicate on terms of Шаблон:Mvar. For a given <math>a:A</math>, whether the type Шаблон:Math is inhabited indicates whether Шаблон:Mvar satisfies this predicate. The correspondence can be extended to existential quantification and dependent pairs: the proposition <math>\exists{a}{\in}A\,B(a)</math> is true if and only if the type <math display="inline">\sum_{a:A}B(a)</math> is inhabited.
For example, <math>m:\mathbb{N}</math> is less than or equal to <math>n:\mathbb{N}</math> if and only if there exists another natural number <math>k:\mathbb{N}</math> such that Шаблон:Math. In logic, this statement is codified by existential quantification:
<math display="block">m\le n \iff \exists{k}{\in}\mathbb{N}\,m+k=n.</math>
This proposition corresponds to the dependent pair type:
<math display="block">\sum_{k:\mathbb{N}} m+k=n.</math>
That is, a proof of the statement that Шаблон:Mvar is less than or equal to Шаблон:Mvar is a pair that contains both a non-negative number Шаблон:Mvar, which is the difference between Шаблон:Mvar and Шаблон:Mvar, and a proof of the equality Шаблон:Math.
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 <math>\lambda \Pi</math> 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 <math>\lambda \Pi 2</math> of second order dependent types is obtained from <math>\lambda \Pi</math> by allowing quantification over type constructors. In this theory the dependent product operator subsumes both the <math>\to</math> operator of simply typed lambda calculus and the <math>\forall</math> binder of System F.
Higher order dependently typed polymorphic lambda calculus
The higher order system <math>\lambda \Pi \omega</math> extends <math>\lambda \Pi 2</math> 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
See also
References
Further reading
- Шаблон:Cite book
- Шаблон:Cite book
- Шаблон:Cite bookШаблон:Dead link
- Brandl, Helmut (2022). Calculus of Constructions
- Шаблон:Cite journal
- Шаблон:Cite book
- Шаблон:Cite thesis
- Шаблон:Cite book
- Шаблон:Cite book
- Шаблон:Cite book
- Шаблон:Cite book
External links
- Dependently Typed Programming 2008
- Dependently Typed Programming 2010
- Dependently Typed Programming 2011
- "Dependent type" at the Haskell Wiki
- Шаблон:Nlab
- Шаблон:Nlab
- Шаблон:Nlab
- Шаблон:Nlab
- Шаблон:Nlab
- Шаблон:Nlab
- ↑ Шаблон:Citation
- ↑ Шаблон:Citation
- ↑ Шаблон:Citation
- ↑ 4,0 4,1 Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ 8,0 8,1 Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ 18,0 18,1 Шаблон:Cite web
- ↑ Шаблон:Cite thesis
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ 22,0 22,1 Шаблон:Cite web
- ↑ Шаблон:Cite web
