Definition of the Finite typeclass #

This file defines a typeclass Finite saying that α : Sort* is finite. A type is Finite if it is equivalent to Fin n for some n. We also define Infinite α as a typeclass equivalent to ¬Finite α.

The Finite predicate has no computational relevance and, being Prop-valued, gets to enjoy proof irrelevance -- it represents the mere fact that the type is finite. While the Finite class also represents finiteness of a type, a key difference is that a Fintype instance represents finiteness in a computable way: it gives a concrete algorithm to produce a Finset whose elements enumerate the terms of the given type. As such, one generally relies on congruence lemmas when rewriting expressions involving Fintype instances.

Every Fintype instance automatically gives a Finite instance, see Fintype.finite, but not vice versa. Every Fintype instance should be computable since they are meant for computation. If it's not possible to write a computable Fintype instance, one should prefer writing a Finite instance instead.

Main definitions #

Implementation notes #

The definition of Finite α is not just Nonempty (Fintype α) since Fintype requires that α : Type*, and the definition in this module allows for α : Sort*. This means we can write the instance Finite.prop.

Tags #

finite, fintype

class inductive Finite (α : Sort u_1) :

A type is Finite if it is in bijective correspondence to some Fin n.

While this could be defined as Nonempty (Fintype α), it is defined in this way to allow there to be Finite instances for propositions.

    theorem finite_iff_exists_equiv_fin {α : Sort u_3} :
    Finite α n, Nonempty (α Fin n)
    theorem Finite.exists_equiv_fin (α : Sort u_3) [h : Finite α] :
    n, Nonempty (α Fin n)
    theorem Finite.of_equiv {β : Sort u_2} (α : Sort u_3) [h : Finite α] (f : α β) :
    theorem Equiv.finite_iff {α : Sort u_1} {β : Sort u_2} (f : α β) :
    theorem Function.Bijective.finite_iff {α : Sort u_1} {β : Sort u_2} {f : αβ} (h : Function.Bijective f) :
    theorem Finite.ofBijective {α : Sort u_1} {β : Sort u_2} [Finite α] {f : αβ} (h : Function.Bijective f) :
    instance instFinitePLift {α : Sort u_1} [Finite α] :
    instance instFiniteULift {α : Type v} [Finite α] :
    class Infinite (α : Sort u_3) :
    • not_finite : ¬Finite α

      assertion that α is ¬Finite

    A type is said to be infinite if it is not finite. Note that Infinite α is equivalent to IsEmpty (Fintype α) or IsEmpty (Finite α).

      theorem Equiv.infinite_iff {α : Sort u_1} {β : Sort u_2} (e : α β) :
      instance instInfinitePLift {α : Sort u_1} [Infinite α] :
      theorem finite_or_infinite (α : Sort u_3) :
      theorem not_finite (α : Sort u_3) [Infinite α] [Finite α] :

      Infinite α is not Finite

      theorem Finite.false {α : Sort u_1} [Infinite α] :
      Finite αFalse
      theorem Infinite.false {α : Sort u_1} [Finite α] :
      theorem Finite.not_infinite {α : Sort u_1} :
      Finite α¬Infinite α

      Alias of the reverse direction of not_infinite_iff_finite.

      theorem Finite.of_not_infinite {α : Sort u_1} :
      ¬Infinite αFinite α

      Alias of the forward direction of not_infinite_iff_finite.