Dependent type

Short description: Type whose definition depends on a value

Type systems

General concepts

* Type safety

Major categories

* Static vs. dynamic
* Manifest vs. inferred
* Nominal vs. structural
* Duck typing

Minor categories

* Dependent
* Flow-sensitive
* Gradual
* Intersection
* Latent
* Refinement
* Substructural
* Unique

See also

* Strong and weak typing

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, Rocq (previously known as 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 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.[1]

## Contents

* 1 History
* 2 Formal definition
* 2.1 Π type
* 2.2 Σ type
* 2.2.1 Example as existential quantification
* 3 Systems of the lambda cube
* 3.1 First order dependent type theory
* 3.2 Second order dependent type theory
* 3.3 Higher order dependently typed polymorphic lambda calculus
* 4 Simultaneous programming language and logic
* 5 Comparison of languages with dependent types
* 6 See also
* 7 References
* 8 Further reading
* 9 External links

## 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

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 𝒰 denote a universe of types, and write A:𝒰 to indicate that A is a type in 𝒰. For a term a of type A, write a:A. A dependent family of types over A is written B:A->𝒰, meaning that to each term a:A the family assigns a type B(a):𝒰. Thus, given A:𝒰 and B:A->𝒰, 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.[4] From a family of types B:A->𝒰 we may construct the type of dependent functions ∏x:AB(x), whose terms are functions that take a term a:A and return a term in B(a). For this example, the dependent function type is typically written as ∏x:AB(x) or ∏(x:A)B(x).

If B:A->𝒰 is a constant function, the corresponding dependent product type is equivalent to an ordinary function type. That is, ∏x:AB is judgmentally equal to A->B when B does not depend on x.

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 Vec⁡(ℝ,n) for n-tuples of real numbers, then ∏n:ℕVec⁡(ℝ,n) would be the type of a function which, given a natural number n, returns 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. ∏n:ℕℝ is the type of functions from natural numbers to the real numbers, which is written as ℕ->ℝ in typed lambda calculus.

For a more concrete example, taking A to be the type of unsigned integers from 0 to 255 (the ones that fit into 8 bits or 1 byte) and B(a)=Xa for a:A, then ∏x:AB(x) devolves into the product of X0×X1×X2×…×X253×X254×X255.

### Σ type

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 𝒰, there is a type A:𝒰 and a family of types B:A->𝒰, then there is a dependent pair type ∑x:AB(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):∑x:AB(x), then a:A and b:B(a). If B is a constant function, then the dependent pair type becomes (is judgmentally equal to) the product type, that is, an ordinary Cartesian product A×B.[4]

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 Xa for 256 more arbitrary Xa, then ∑x:AB(x) devolves into the sum X0+X1+X2+…+X253+X254+X255.

#### Example as existential quantification

Let A:𝒰 be some type, and let B:A->𝒰. 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 ∃a∈AB(a) is true if and only if the type ∑a:AB(a) is inhabited.

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

m≤n⟺∃k∈ℕm+k=n.

This proposition corresponds to the dependent pair type:

∑k:ℕ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 λΠ 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 λΠ2 of second order dependent types is obtained from λΠ by allowing quantification over type constructors. In this theory the dependent product operator subsumes both the -> operator of simply typed lambda calculus and the ∀ binder of System F.

### Higher order dependently typed polymorphic lambda calculus

The higher order system λΠω extends λΠ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

Template:Sort-under

Language | Actively developed | Paradigm[lower-alpha 1] | Tactics | Proof terms | Termination checking | Types can depend on[lower-alpha 2] | Universes | Proof irrelevance | Program extraction | Extraction erases irrelevant terms

|
|
|
|
|
|
|
|
|
|

Agda | Yes[5] | Purely functional | Few/limited[lower-alpha 3] | Yes | Yes (optional) | Any term | Yes (optional)[lower-alpha 4] | Proof-irrelevant arguments[7] Proof-irrelevant propositions[8] | Haskell, JavaScript | Yes[7]
ATS | Yes[9] | Functional / imperative | No[10] | Yes | Yes | Static terms[11] | ? | Yes | Yes | Yes
Cayenne | No | Purely functional | No | Yes | No | Any term | No | No | ? | ?
Gallina
(Rocq (previously known as Coq)) | Yes[12] | Purely functional | Yes | Yes | Yes | Any term | Yes[lower-alpha 5] | Yes[13] | Haskell, Scheme, OCaml | Yes
Dependent ML | No[lower-alpha 6] | ? | ? | Yes | ? | Natural numbers | ? | ? | ? | ?
F* | Yes[14] | Functional and imperative | Yes[15] | Yes | Yes (optional) | Any pure term | Yes | Yes | OCaml, F#, and C | Yes
Guru | No[16] | Purely functional[17] | hypjoin[18] | Yes[17] | Yes | Any term | No | Yes | Carraway | Yes
Idris | Yes[19] | Purely functional[20] | Yes[21] | Yes | Yes (optional) | Any term | Yes | No | Yes | Yes[21]
Lean | Yes | Purely functional | Yes | Yes | Yes | Any term | Yes | Yes | Yes | Yes
Matita | Yes[22] | Purely functional | Yes | Yes | Yes | Any term | Yes | Yes | OCaml | Yes
NuPRL | Yes | Purely functional | Yes | Yes | Yes | Any term | Yes | ? | Yes | ?
PVS | Yes | ? | Yes | ? | ? | ? | ? | ? | ? | ?
Sage | No[lower-alpha 7] | Purely functional | No | No | No | ? | No | ? | ? | ?
SPARK | Yes[23] | Imperative | Yes[24] | Yes[25] | Yes[26] | Any term[lower-alpha 8] | ? | ? | Ada and C[27] | Yes[28]
Twelf | Yes | Logic programming | ? | Yes | Yes (optional) | Any (LF) term | No | No | ? | ?

1. ↑ This refers to the core language, not to any tactic (theorem proving procedure) or code generation sublanguage.
2. ↑ Subject to semantic constraints, such as universe constraints
3. ↑ Ring solver[6]
4. ↑ Optional universes, optional universe polymorphism, and optional explicitly specified universes
5. ↑ Universes, automatically inferred universe constraints (not the same as Agda's universe polymorphism) and optional explicit printing of universe constraints
6. ↑ Has been superseded by ATS
7. ↑ Last Sage paper and last code snapshot are both dated 2006
8. ↑ Static_Predicate for restricted terms, Dynamic_Predicate for Assert-like checking of any term in type cast

## See also

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

## References

1. ↑ Hofmann, Martin (1995), Extensional concepts in intensional type theory, https://ncatlab.org/nlab/files/HofmannExtensionalIntensionalTypeTheory.pdf
2. ↑ Sørensen, Morten Heine B.; Urzyczyn, Pawel (1998), Lectures on the Curry-Howard Isomorphism
3. ↑ Bove, Ana; Dybjer, Peter (2008). ﻿Dependent Types at Work﻿ (Report). Chalmers University of Technology. http://www.cse.chalmers.se/~peterd/papers/DependentTypesAtWork.pdf.
4. ↑ 4.0 4.1 4.2 Altenkirch, Thorsten; Danielsson, Nils Anders; Löh, Andres; Oury, Nicolas (2010). "Functional and Logic Programming, 10th International Symposium, FLOPS 2010, Sendai, Japan, April 19-21, 2010. Proceedings". in Blume, Matthias; Kobayashi, Naoki; Vidal, Germán. 6009. Springer. pp. 40–55. doi:10.1007/978-3-642-12251-4_5.
5. ↑ "Agda download page". http://wiki.portal.chalmers.se/agda/pmwiki.php?n=Main.Download.
6. ↑ "Agda Ring Solver". http://www.cs.nott.ac.uk/~nad/listings/lib/Algebra.RingSolver.html.
7. ↑ 7.0 7.1 "Announce: Agda 2.2.8". http://permalink.gmane.org/gmane.comp.lang.agda/2051.
8. ↑ "Agda 2.6.0 changelog". http://hackage.haskell.org/package/Agda-2.6.0/changelog.
9. ↑ "ATS2 downloads". https://sourceforge.net/projects/ats2-lang/files/.
10. ↑ "email from ATS inventor Hongwei Xi". https://sourceforge.net/mailarchive/message.php?msg_id=27050673.
11. ↑ Xi, Hongwei (March 2017). "Applied Type System: An Approach to Practical Programming with Theorem-Proving". http://www.ats-lang.org/MYDATA/ATSfoundation.pdf.
12. ↑ "Coq changes in Subversion repository". https://gforge.inria.fr/scm/viewvc.php/trunk/CHANGES?root=coq&view=log.
13. ↑ "Introduction of SProp in Coq 8.10". https://coq.github.io/doc/master/refman/changes.html#version-8-10.
14. ↑ "F* changes on GitHub". https://github.com/FStarLang/FStar/commits/master.
15. ↑ "F* v0.9.5.0 release notes on GitHub". https://github.com/FStarLang/FStar/releases/tag/v0.9.5.0.
16. ↑ "Guru SVN". https://code.google.com/p/guru-lang/source/list.
17. ↑ 17.0 17.1 Aaron Stump (6 April 2009). "Verified Programming in Guru". http://guru-lang.googlecode.com/svn/branches/1.0/doc/book.pdf.
18. ↑ Petcher, Adam (May 2008). Deciding Joinability Modulo Ground Equations in Operational Type Theory (PDF) (MSc). Washington University. Retrieved 14 October 2010.
19. ↑ "Idris git repository". 17 May 2022. https://github.com/idris-lang/Idris-dev/.
20. ↑ Brady, Edwin. "Idris, a language with dependent types — extended abstract". https://eb.host.cs.st-andrews.ac.uk/drafts/ifl08.pdf.
21. ↑ 21.0 21.1 Brady, Edwin. "How does Idris compare to other dependently-typed programming languages?". http://www.quora.com/How-does-Idris-compare-to-other-dependently-typed-programming-languages.
22. ↑ "Matita SVN". http://helm.cs.unibo.it/websvn/listing.php?repname=helm&path=/&sc=0.
23. ↑ "SPARK installation using ALIRE". https://alire.ada.dev/transition_from_gnat_community.html.
24. ↑ "§3.2.4 Subtype Predicates". Ada Reference Manual. http://www.ada-auth.org/standards/12rm/html/RM-3-2-4.html.
25. ↑ "5.11.6. SPARK Lemma Library". SPARK User's Guide. https://docs.adacore.com/spark2014-docs/html/ug/en/source/spark_libraries.html#spark-lemma-library.
26. ↑ "5.2.8. Contracts for Termination". SPARK User's Guide. https://docs.adacore.com/spark2014-docs/html/ug/en/source/subprogram_contracts.html#contracts-for-termination.
27. ↑ "1.2. Calling and Using CCG". GNAT Pro Common Code Generator Users's Guide Supplement. https://docs.adacore.com/live/wave/gnat-ccg/html/gnatccg_ug/gnat_ccg/gnat_ccg.html.
28. ↑ "Compiling with a non-SPARK Aware Compiler". SPARK User's Guide. https://docs.adacore.com/spark2014-docs/html/ug/en/appendix/portability_issues.html#compiling-with-a-non-spark-aware-compiler.

## Further reading

* Martin-Löf, Per (1984). Intuitionistic Type Theory. Bibliopolis. https://www.cs.cmu.edu/afs/cs/Web/People/crary/819-f09/Martin-Lof80.pdf.
* Nordström, Bengt; Petersson, Kent; Smith, Jan M. (1990). Programming in Martin-Löf's Type Theory: An Introduction. Oxford University Press. ISBN 9780198538141. http://www.cse.chalmers.se/research/group/logic/book/.
* Barendregt, H. (1992). "Lambda calculi with types". in Abramsky, S.; Gabbay, D.; Maibaum, T.. Handbook of Logic in Computer Science. Oxford Science Publications. doi:10.1017/CBO9781139032636. ftp://ftp.cs.ru.nl/pub/CompMath.Found/HBK.ps.
* Brandl, Helmut (2022). Calculus of Constructions
* McBride, Conor; McKinna, James (January 2004). "The view from the left". Journal of Functional Programming 14 (1): 69–111. doi:10.1017/s0956796803004829. http://strictlypositive.org/view.ps.gz.
* Altenkirch, Thorsten; McBride, Conor; McKinna, James (2006). "Why dependent types matter". Proceedings of the 33rd ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, POPL 2006, Charleston, South Carolina, USA, January 11-13. ISBN 1-59593-027-2. http://www.cs.nott.ac.uk/~txa/publ/ydtm.pdf.
* Norell, Ulf (September 2007). Towards a practical programming language based on dependent type theory (PDF) (PhD). Göteborg, Sweden: Department of Computer Science and Engineering, Chalmers University of Technology. ISBN 978-91-7291-996-9.
* Oury, Nicolas; Swierstra, Wouter (2008). "The Power of Pi". ICFP '08: Proceedings of the 13th ACM SIGPLAN international conference on Functional programming. pp. 39–50. doi:10.1145/1411204.1411213. ISBN 9781595939197. https://www.cs.ru.nl/~wouters/Publications/ThePowerOfPi.pdf.
* Norell, Ulf (2009). "Dependently Typed Programming in Agda". in Koopman, P.; Plasmeijer, R.; Swierstra, D.. Advanced Functional Programming. AFP 2008. Lecture Notes in Computer Science. 5832. Springer. pp. 230–266. doi:10.1007/978-3-642-04652-0_5. ISBN 978-3-642-04651-3. http://www.cse.chalmers.se/~ulfn/papers/afp08/tutorial.pdf.
* Sitnikovski, Boro (2018). Gentle Introduction to Dependent Types with Idris. Lean Publishing. ISBN 978-1723139413.
* McBride, Conor; Nordvall-Forsberg, Fredrik (2022). "Type systems for programs respecting dimensions". Advanced Mathematical and Computational Tools in Metrology and Testing XII. Advances in Mathematics for Applied Sciences. World Scientific. pp. 331–345. doi:10.1142/9789811242380_0020. ISBN 9789811242380. https://strathprints.strath.ac.uk/76626/1/McBride_etal_amctmtxii2021_type_systems_for_programs_respecting_dimensions.pdf.

## External links

* Dependently Typed Programming 2008
* Dependently Typed Programming 2010
* Dependently Typed Programming 2011
* "Dependent type" at the Haskell Wiki
* dependent type theory in nLab
* dependent type in nLab
* dependent product type in nLab
* dependent sum type in nLab
* dependent product in nLab
* dependent sum in nLab

Template:Foundations-footer Template:Programming paradigms navbox

0.00

(0 votes)

Original source: https://en.wikipedia.org/wiki/Dependent type. Read more

|

Retrieved from "https://handwiki.org/wiki/index.php?title=Dependent_type&oldid=4228855"