Dependent type

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. 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". Because of this, and other work by Howard, propositions-as-types is known as the Curry–Howard correspondence. ==Formal definition==

In dependent type theory, a dependent type is a type whose specification may vary with a value, and can be viewed as analogous to an indexed family of sets. Let \mathcal{U} denote a universe of types, and write A:\mathcal{U} to indicate that A is a type in \mathcal{U}. For a term a of type A, write a:A. A dependent family of types over A is written B:A\to\mathcal{U}, meaning that to each term a:A the family assigns a type B(a):\mathcal{U}. Thus, given A:\mathcal{U} and B:A\to\mathcal{U}, the expression B(a) denotes a type that depends on the particular value a. In standard terminology, this is described by saying that the type B(a) varies with a. Π 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 ( type) or dependent function type. For a more concrete example, taking A to again be type of unsigned integers from 0 to 255, and B(a) to again be equal to X_a for 256 more arbitrary X_a, then \sum_{x:A} B(x) devolves into the sum X_0+X_1+X_2+\ldots+X_{253}+X_{254}+X_{255}. Example as existential quantification Let A:\mathcal{U} be some type, and let B:A\to\mathcal{U}. By the Curry–Howard correspondence, B can be interpreted as a logical predicate on terms of A. For a given a : A, whether the type B(a) is inhabited indicates whether a satisfies this predicate. The correspondence can be extended to existential quantification and dependent pairs: the proposition \exists{a}{\in}A\,B(a) is true if and only if the type \sum_{a:A}B(a) is inhabited. For example, m:\mathbb{N} is less than or equal to n:\mathbb{N} if and only if there exists another natural number k:\mathbb{N} such that m + k = n. In logic, this statement is codified by existential quantification: m\le n \iff \exists{k}{\in}\mathbb{N}\,m+k=n. This proposition corresponds to the dependent pair type: \sum_{k:\mathbb{N}} m+k=n. That is, a proof of the statement that m is less than or equal to n is a pair that contains both a non-negative number k, which is the difference between m and n, and a proof of the equality m + k = n. ==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 Rocq. == 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 ==