Inductive type

Last updated

In type theory, a system has inductive types if it has facilities for creating a new type from constants and functions that create terms of that type. The feature serves a role similar to data structures in a programming language and allows a type theory to add concepts like numbers, relations, and trees. As the name suggests, inductive types can be self-referential, but usually only in a way that permits structural recursion.

Contents

The standard example is encoding the natural numbers using Peano's encoding. It can be defined in Coq as follows:

Inductivenat:Type:=|0:nat|S:nat->nat.

Here, a natural number is created either from the constant "0" or by applying the function "S" to another natural number. "S" is the successor function which represents adding 1 to a number. Thus, "0" is zero, "S 0" is one, "S (S 0)" is two, "S (S (S 0))" is three, and so on.

Since their introduction, inductive types have been extended to encode more and more structures, while still being predicative and supporting structural recursion.

Elimination

Inductive types usually come with a function to prove properties about them. Thus, "nat" may come with (in Coq syntax):

nat_elim:(forallP:nat->Prop,(P0)->(foralln,Pn->P(Sn))->(foralln,Pn)).

In words: for any predicate "P" over natural numbers, given a proof of "P 0" and a proof of "P n -> P (n+1)", we get back a proof of "forall n, P n". This is the familiar induction principle for natural numbers.

Implementations

W- and M-types

W-types are well-founded types in intuitionistic type theory (ITT). [1] They generalize natural numbers, lists, binary trees, and other "tree-shaped" data types. Let U be a universe of types. Given a type A : U and a dependent family B : AU, one can form a W-type . The type A may be thought of as "labels" for the (potentially infinitely many) constructors of the inductive type being defined, whereas B indicates the (potentially infinite) arity of each constructor. W-types (resp. M-types) may also be understood as well-founded (resp. non-well-founded) trees with nodes labeled by elements a : A and where the node labeled by a has B(a)-many subtrees. [2] Each W-type is isomorphic to the initial algebra of a so-called polynomial functor.

Let 0, 1, 2, etc. be finite types with inhabitants 11 : 1, 12, 22:2, etc. One may define the natural numbers as the W-type with f : 2U is defined by f(12) = 0 (representing the constructor for zero, which takes no arguments), and f(22) = 1 (representing the successor function, which takes one argument).

One may define lists over a type A : U as where and 11 is the sole inhabitant of 1. The value of corresponds to the constructor for the empty list, whereas the value of corresponds to the constructor that appends a to the beginning of another list.

The constructor for elements of a generic W-type has type We can also write this rule in the style of a natural deduction proof,

The elimination rule for W-types works similarly to structural induction on trees. If, whenever a property (under the propositions-as-types interpretation) holds for all subtrees of a given tree it also holds for that tree, then it holds for all trees.

In extensional type theories, W-types (resp. M-types) can be defined up to isomorphism as initial algebras (resp. final coalgebras) for polynomial functors. In this case, the property of initiality (res. finality) corresponds directly to the appropriate induction principle. [3] In intensional type theories with the univalence axiom, this correspondence holds up to homotopy (propositional equality). [4] [5] [6]

M-types are dual to W-types, they represent coinductive (potentially infinite) data such as streams. [7] M-types can be derived from W-types. [8]

Mutually inductive definitions

This technique allows some definitions of multiple types that depend on each other. For example, defining two parity predicates on natural numbers using two mutually inductive types in Coq:

Inductiveeven:nat->Prop:=|zero_is_even:evenO|S_of_odd_is_even:(foralln:nat,oddn->even(Sn))withodd:nat->Prop:=|S_of_even_is_odd:(foralln:nat,evenn->odd(Sn)).

Induction-recursion

Induction-recursion started as a study into the limits of ITT. Once found, the limits were turned into rules that allowed defining new inductive types. These types could depend upon a function and the function on the type, as long as both were defined simultaneously.

Universe types can be defined using induction-recursion.

Induction-induction

Induction-induction allows definition of a type and a family of types at the same time. So, a type A and a family of types .

Higher inductive types

This is a current research area in Homotopy Type Theory (HoTT). HoTT differs from ITT by its identity type (equality). Higher inductive types not only define a new type with constants and functions that create elements of the type, but also new instances of the identity type that relate them.

A simple example is the circle type, which is defined with two constructors, a basepoint;

base : circle

and a loop;

loop : base = base.

The existence of a new constructor for the identity type makes circle a higher inductive type.

See also

Related Research Articles

In mathematics and theoretical computer science, a type theory is the formal presentation of a specific type system. Type theory is the academic study of type systems.

In linear algebra, the trace of a square matrix A, denoted tr(A), is defined to be the sum of elements on the main diagonal of A. The trace is only defined for a square matrix.

In the mathematical discipline of set theory, forcing is a technique for proving consistency and independence results. Intuitively, forcing can be thought of as a technique to expand the set theoretical universe to a larger universe by introducing a new "generic" object .

Intuitionistic type theory is a type theory and an alternative foundation of mathematics. Intuitionistic type theory was created by Per Martin-Löf, a Swedish mathematician and philosopher, who first published it in 1972. There are multiple versions of the type theory: Martin-Löf proposed both intensional and extensional variants of the theory and early impredicative versions, shown to be inconsistent by Girard's paradox, gave way to predicative versions. However, all versions keep the core design of constructive logic using dependent types.

<span class="mw-page-title-main">Projection (linear algebra)</span> Idempotent linear transformation from a vector space to itself

In linear algebra and functional analysis, a projection is a linear transformation from a vector space to itself such that . That is, whenever is applied twice to any vector, it gives the same result as if it were applied once. It leaves its image unchanged. This definition of "projection" formalizes and generalizes the idea of graphical projection. One can also consider the effect of a projection on a geometrical object by examining the effect of the projection on points in the object.

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, the CoC and its variants have been the basis for Coq and other proof assistants.

System F is a typed lambda calculus that introduces, to simply typed lambda calculus, a mechanism of universal quantification over types. System F formalizes parametric polymorphism in programming languages, thus forming a theoretical basis for languages such as Haskell and ML. It was discovered independently by logician Jean-Yves Girard (1972) and computer scientist John C. Reynolds.

In the mathematical fields of linear algebra and functional analysis, the orthogonal complement of a subspace of a vector space equipped with a bilinear form is the set of all vectors in that are orthogonal to every vector in . Informally, it is called the perp, short for perpendicular complement. It is a subspace of .

Epigram is a functional programming language with dependent types, and the integrated development environment (IDE) usually packaged with the language. Epigram's type system is strong enough to express program specifications. The goal is to support a smooth transition from ordinary programming to integrated programs and proofs whose correctness can be checked and certified by the compiler. Epigram exploits the Curry–Howard correspondence, also termed the propositions as types principle, and is based on intuitionistic type theory.

This is a glossary of properties and concepts in category theory in mathematics.

In set theory, -induction, also called epsilon-induction or set-induction, is a principle that can be used to prove that all sets satisfy a given property. Considered as an axiomatic principle, it is called the axiom schema of set induction.

In mathematics, the classifying space for the unitary group U(n) is a space BU(n) together with a universal bundle EU(n) such that any hermitian bundle on a paracompact space X is the pull-back of EU(n) by a map X → BU(n) unique up to homotopy.

In programming languages and type theory, parametric polymorphism allows a single piece of code to be given a "generic" type, using variables in place of actual types, and then instantiated with particular types as needed. Parametrically polymorphic functions and data types are sometimes called generic functions and generic datatypes, respectively, and they form the basis of generic programming.

Axiomatic constructive set theory is an approach to mathematical constructivism following the program of axiomatic set theory. The same first-order language with "" and "" of classical set theory is usually used, so this is not to be confused with a constructive types approach. On the other hand, some constructive theories are indeed motivated by their interpretability in type theories.

In proof theory, ordinal analysis assigns ordinals to mathematical theories as a measure of their strength. If theories have the same proof-theoretic ordinal they are often equiconsistent, and if one theory has a larger proof-theoretic ordinal than another it can often prove the consistency of the second theory.

In intuitionistic type theory (ITT), a discipline within mathematical logic, induction-recursion is a feature for simultaneously declaring a type and function on that type. It allows the creation of larger types than inductive types, such as universes. The types created still remain predicative inside ITT.

In mathematical logic, fixed-point logics are extensions of classical predicate logic that have been introduced to express recursion. Their development has been motivated by descriptive complexity theory and their relationship to database query languages, in particular to Datalog.

In type theory, a polynomial functor is a kind of endofunctor of a category of types that is intimately related to the concept of inductive and coinductive types. Specifically, all W-types are initial algebras of such functors.

In intuitionistic type theory (ITT), a discipline within mathematical logic, induction-induction is for simultaneously declaring some inductive type and some inductive predicate over this type.

In set theory and logic, Buchholz's ID hierarchy is a hierarchy of subsystems of first-order arithmetic. The systems/theories are referred to as "the formal theories of ν-times iterated inductive definitions". IDν extends PA by ν iterated least fixed points of monotone operators.

References

  1. Martin-Löf, Per (1984). Intuitionistic type theory (PDF). Sambin, Giovanni. Napoli: Bibliopolis. ISBN   8870881059. OCLC   12731401.
  2. Ahrens, Benedikt; Capriotti, Paolo; Spadotti, Régis (2015-04-12). Non-wellfounded trees in Homotopy Type Theory. Leibniz International Proceedings in Informatics (LIPIcs). Vol. 38. pp. 17–30. arXiv: 1504.02949 . doi:10.4230/LIPIcs.TLCA.2015.17. ISBN   9783939897873. S2CID   15020752.
  3. Dybjer, Peter (1997). "Representing inductively defined sets by wellorderings in Martin-Löf's type theory". Theoretical Computer Science. 176 (1–2): 329–335. doi:10.1016/s0304-3975(96)00145-4.
  4. Awodey, Steve; Gambino, Nicola; Sojakova, Kristina (2012-01-18). "Inductive types in homotopy type theory". arXiv: 1201.3898 [math.LO].
  5. Ahrens, Benedikt; Capriotti, Paolo; Spadotti, Régis (2015-04-12). Non-wellfounded trees in Homotopy Type Theory. Leibniz International Proceedings in Informatics (LIPIcs). Vol. 38. pp. 17–30. arXiv: 1504.02949 . doi:10.4230/LIPIcs.TLCA.2015.17. ISBN   9783939897873. S2CID   15020752.
  6. Awodey, Steve; Gambino, Nicola; Sojakova, Kristina (2015-04-21). "Homotopy-initial algebras in type theory". arXiv: 1504.05531 [math.LO].
  7. van den Berg, Benno; Marchi, Federico De (2007). "Non-well-founded trees in categories". Annals of Pure and Applied Logic. 146 (1): 40–59. arXiv: math/0409158 . doi:10.1016/j.apal.2006.12.001. S2CID   360990.
  8. Abbott, Michael; Altenkirch, Thorsten; Ghani, Neil (2005). "Containers: Constructing strictly positive types". Theoretical Computer Science. 342 (1): 3–27. CiteSeerX   10.1.1.166.34 . doi: 10.1016/j.tcs.2005.06.002 .