This article needs additional citations for verification .(January 2018) |

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.

- Elimination
- Implementations
- W- and M-types
- Mutually inductive definitions
- Induction-recursion
- Induction-induction
- Higher inductive types
- See also
- References
- External links

The standard example is encoding the natural numbers using Peano's encoding.

`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.

Inductive types usually come with a function to prove properties about them. Thus, "nat" may come with:

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

This is the expected function for structural recursion for the type "nat".

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` : `A` → `U`, 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 1_{1} : **1**, 1_{2}, 2_{2}:**2**, etc. One may define the natural numbers as the W-type

with `f` : **2** → `U` is defined by `f`(1_{2}) = **0** (representing the constructor for zero, which takes no arguments), and `f`(2_{2}) = **1** (representing the successor function, which takes one argument).

One may define lists over a type `A` : `U` as where

and 1_{1} 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] }

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 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 allows definition of a type and a family of types at the same time. So, a type A and a family of 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.

- Coinduction permits (effectively) infinite structures in type theory.

In mathematics, logic, and computer science, a **type system** is a formal system in which every term has a "type" which defines its meaning and the operations that may be performed on it. **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**.

In mathematics, a **tuple** is a finite ordered list (sequence) of elements. An **n-tuple** is a sequence of n elements, where n is a non-negative integer. There is only one 0-tuple, referred to as *the empty tuple*. An n-tuple is defined inductively using the construction of an ordered pair.

In mathematics and computer science in general, a *fixed point* of a function is a value that is mapped to itself by the function. In combinatory logic for computer science, a **fixed-point combinator** is a higher-order function that returns some fixed point of its argument function, if one exists.

In the mathematical discipline of set theory, **forcing** is a technique for proving consistency and independence results. It was first used by Paul Cohen in 1963, to prove the independence of the axiom of choice and the continuum hypothesis from Zermelo–Fraenkel set theory.

In axiomatic set theory and the branches of mathematics and philosophy that use it, the **axiom of infinity** is one of the axioms of Zermelo–Fraenkel set theory. It guarantees the existence of at least one infinite set, namely a set containing the natural numbers. It was first published by Ernst Zermelo as part of his set theory in 1908.

**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.

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**, also known as the (**Girard–Reynolds**) **polymorphic lambda calculus** or the **second-order lambda calculus**, is a typed lambda calculus that differs from the simply typed lambda calculus by the introduction of a mechanism of universal quantification over types. System F thus formalizes the notion of parametric polymorphism in programming languages, and forms a theoretical basis for languages such as Haskell and ML. System F was discovered independently by logician Jean-Yves Girard (1972) and computer scientist John C. Reynolds (1974).

In mathematical logic and type theory, the **λ-cube** is a framework introduced by Henk Barendregt to investigate the different dimensions in which the calculus of constructions is a generalization of the simply typed λ-calculus. Each dimension of the cube corresponds to a new kind of dependency between terms and types. Here, "dependency" refers to the capacity of a term or type to bind a term or type. The respective dimensions of the λ-cube correspond to:

**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.

In computer programming languages, a **recursive data type** is a data type for values that may contain other values of the same type. Data of recursive types are usually viewed as directed graphs.

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

In mathematics, an **initial algebra** is an initial object in the category of F-algebras for a given endofunctor F. This initiality provides a general framework for induction and recursion.

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 descriptive complexity, a branch of computational complexity, **FO** is a complexity class of structures that can be recognized by formulas of first-order logic, and also equals the complexity class AC^{0}. Descriptive complexity uses the formalism of logic, but does not use several key notions associated with logic such as proof theory or axiomatization.

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, such as universes, than inductive types. The types created still remain predicative inside ITT.

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), some discipline within mathematical logic, **induction-induction** is for simultaneously declaring some inductive type and some inductive predicate over this type.

- ↑ Martin-Löf, Per (1984).
*Intuitionistic type theory*(PDF). Sambin, Giovanni. Napoli: Bibliopolis. ISBN 8870881059. OCLC 12731401. - ↑ Ahrens, Benedikt; Capriotti, Paolo; Spadotti, Régis (2015-04-12). "Non-wellfounded trees in Homotopy Type Theory". arXiv: 1504.02949 . doi:10.4230/LIPIcs.TLCA.2015.17.Cite journal requires
`|journal=`

(help) - ↑ 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 . - ↑ Awodey, Steve; Gambino, Nicola; Sojakova, Kristina (2012-01-18). "Inductive types in homotopy type theory". arXiv: 1201.3898 [math.LO].
- ↑ Ahrens, Benedikt; Capriotti, Paolo; Spadotti, Régis (2015-04-12). "Non-wellfounded trees in Homotopy Type Theory". arXiv: 1504.02949 . doi:10.4230/LIPIcs.TLCA.2015.17.Cite journal requires
`|journal=`

(help) - ↑ Awodey, Steve; Gambino, Nicola; Sojakova, Kristina (2015-04-21). "Homotopy-initial algebras in type theory". arXiv: 1504.05531 [math.LO].
- ↑ 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. - ↑ Abbott, Michael; Altenkirch, Thorsten; Ghani, Neil (2005). "Containers: Constructing strictly positive types".
*Theoretical Computer Science*.**342**(1): 3–27. doi:10.1016/j.tcs.2005.06.002.

- Univalent Foundations Program (2013).
*Homotopy Type Theory: Univalent Foundations of Mathematics*. Institute for Advanced Study.

This page is based on this Wikipedia article

Text is available under the CC BY-SA 4.0 license; additional terms may apply.

Images, videos and audio are available under their respective licenses.

Text is available under the CC BY-SA 4.0 license; additional terms may apply.

Images, videos and audio are available under their respective licenses.