mathlib documentation

data.setoid.basic

Equivalence relations #

This file defines the complete lattice of equivalence relations on a type, results about the inductively defined equivalence closure of a binary relation, and the analogues of some isomorphism theorems for quotients of arbitrary types.

Implementation notes #

The function rel and lemmas ending in ' make it easier to talk about different equivalence relations on the same type.

The complete lattice instance for equivalence relations could have been defined by lifting the Galois insertion of equivalence relations on α into binary relations on α, and then using complete_lattice.copy to define a complete lattice instance with more appropriate definitional equalities (a similar example is filter.complete_lattice in order/filter/basic.lean). This does not save space, however, and is less clear.

Partitions are not defined as a separate structure here; users are encouraged to reason about them using the existing setoid and its infrastructure.

Tags #

setoid, equivalence, iseqv, relation, equivalence relation

def setoid.rel {α : Type u_1} (r : setoid α) :

α → α → Prop

A version of setoid.r that takes the equivalence relation as an explicit argument.

Equations

r.rel = setoid.r

theorem quotient.eq_rel {α : Type u_1} {r : setoid α} {x y : α} :

quotient.mk' x = quotient.mk' y ↔ r.rel x y

A version of quotient.eq' compatible with setoid.rel, to make rewriting possible.

@[ext]

theorem setoid.ext' {α : Type u_1} {r s : setoid α} (H : ∀ (a b : α), r.rel a b ↔ s.rel a b) :

r = s

theorem setoid.ext_iff {α : Type u_1} {r s : setoid α} :

r = s ↔ ∀ (a b : α), r.rel a b ↔ s.rel a b

theorem setoid.eq_iff_rel_eq {α : Type u_1} {r₁ r₂ : setoid α} :

r₁ = r₂ ↔ r₁.rel = r₂.rel

Two equivalence relations are equal iff their underlying binary operations are equal.

@[protected, instance]

def setoid.has_le {α : Type u_1} :

has_le (setoid α)

Defining ≤ for equivalence relations.

Equations

setoid.has_le = {le := λ (r s : setoid α), ∀ ⦃x y : α⦄, r.rel x y → s.rel x y}

theorem setoid.le_def {α : Type u_1} {r s : setoid α} :

r ≤ s ↔ ∀ {x y : α}, r.rel x y → s.rel x y

theorem setoid.refl' {α : Type u_1} (r : setoid α) (x : α) :

r.rel x x

theorem setoid.symm' {α : Type u_1} (r : setoid α) {x y : α} :

r.rel x y → r.rel y x

theorem setoid.trans' {α : Type u_1} (r : setoid α) {x y z : α} :

r.rel x y → r.rel y z → r.rel x z

theorem setoid.comm' {α : Type u_1} (s : setoid α) {x y : α} :

s.rel x y ↔ s.rel y x

def setoid.ker {α : Type u_1} {β : Type u_2} (f : α → β) :

The kernel of a function is an equivalence relation.

Equations

setoid.ker f = {r := eq on f, iseqv := _}

@[simp]

theorem setoid.ker_mk_eq {α : Type u_1} (r : setoid α) :

setoid.ker quotient.mk = r

The kernel of the quotient map induced by an equivalence relation r equals r.

theorem setoid.ker_apply_mk_out {α : Type u_1} {β : Type u_2} {f : α → β} (a : α) :

f ⟦a⟧.out = f a

theorem setoid.ker_apply_mk_out' {α : Type u_1} {β : Type u_2} {f : α → β} (a : α) :

f (quotient.mk' a).out' = f a

theorem setoid.ker_def {α : Type u_1} {β : Type u_2} {f : α → β} {x y : α} :

(setoid.ker f).rel x y ↔ f x = f y

@[protected]

def setoid.prod {α : Type u_1} {β : Type u_2} (r : setoid α) (s : setoid β) :

setoid (α × β)

Given types α, β, the product of two equivalence relations r on α and s on β: (x₁, x₂), (y₁, y₂) ∈ α × β are related by r.prod s iff x₁ is related to y₁ by r and x₂ is related to y₂ by s.

Equations

r.prod s = {r := λ (x y : α × β), r.rel x.fst y.fst ∧ s.rel x.snd y.snd, iseqv := _}

@[protected, instance]

def setoid.has_inf {α : Type u_1} :

has_inf (setoid α)

The infimum of two equivalence relations.

Equations

setoid.has_inf = {inf := λ (r s : setoid α), {r := λ (x y : α), r.rel x y ∧ s.rel x y, iseqv := _}}

theorem setoid.inf_def {α : Type u_1} {r s : setoid α} :

(r ⊓ s).rel = r.rel ⊓ s.rel

The infimum of 2 equivalence relations r and s is the same relation as the infimum of the underlying binary operations.

theorem setoid.inf_iff_and {α : Type u_1} {r s : setoid α} {x y : α} :

(r ⊓ s).rel x y ↔ r.rel x y ∧ s.rel x y

@[protected, instance]

def setoid.has_Inf {α : Type u_1} :

has_Inf (setoid α)

The infimum of a set of equivalence relations.

Equations

setoid.has_Inf = {Inf := λ (S : set (setoid α)), {r := λ (x y : α), ∀ (r : setoid α), r ∈ S → r.rel x y, iseqv := _}}

theorem setoid.Inf_def {α : Type u_1} {s : set (setoid α)} :

(Inf s).rel = Inf (setoid.rel '' s)

The underlying binary operation of the infimum of a set of equivalence relations is the infimum of the set's image under the map to the underlying binary operation.

@[protected, instance]

def setoid.partial_order {α : Type u_1} :

partial_order (setoid α)

Equations

setoid.partial_order = {le := has_le.le setoid.has_le, lt := λ (r s : setoid α), r ≤ s ∧ ¬s ≤ r, le_refl := _, le_trans := _, lt_iff_le_not_le := _, le_antisymm := _}

@[protected, instance]

def setoid.complete_lattice {α : Type u_1} :

complete_lattice (setoid α)

The complete lattice of equivalence relations on a type, with bottom element = and top element the trivial equivalence relation.

Equations

setoid.complete_lattice = {sup := complete_lattice.sup (complete_lattice_of_Inf (setoid α) setoid.complete_lattice._proof_1), le := complete_lattice.le (complete_lattice_of_Inf (setoid α) setoid.complete_lattice._proof_1), lt := complete_lattice.lt (complete_lattice_of_Inf (setoid α) setoid.complete_lattice._proof_1), le_refl := _, le_trans := _, lt_iff_le_not_le := _, le_antisymm := _, le_sup_left := _, le_sup_right := _, sup_le := _, inf := has_inf.inf setoid.has_inf, inf_le_left := _, inf_le_right := _, le_inf := _, Sup := complete_lattice.Sup (complete_lattice_of_Inf (setoid α) setoid.complete_lattice._proof_1), le_Sup := _, Sup_le := _, Inf := complete_lattice.Inf (complete_lattice_of_Inf (setoid α) setoid.complete_lattice._proof_1), Inf_le := _, le_Inf := _, top := {r := λ (_x _x : α), true, iseqv := _}, bot := {r := eq α, iseqv := _}, le_top := _, bot_le := _}

@[simp]

theorem setoid.top_def {α : Type u_1} :

@[simp]

theorem setoid.bot_def {α : Type u_1} :

theorem setoid.eq_top_iff {α : Type u_1} {s : setoid α} :

s = ⊤ ↔ ∀ (x y : α), s.rel x y

theorem setoid.eqv_gen_eq {α : Type u_1} (r : α → α → Prop) :

eqv_gen.setoid r = Inf {s : setoid α | ∀ ⦃x y : α⦄, r x y → s.rel x y}

The inductively defined equivalence closure of a binary relation r is the infimum of the set of all equivalence relations containing r.

theorem setoid.sup_eq_eqv_gen {α : Type u_1} (r s : setoid α) :

r ⊔ s = eqv_gen.setoid (λ (x y : α), r.rel x y ∨ s.rel x y)

The supremum of two equivalence relations r and s is the equivalence closure of the binary relation x is related to y by r or s.

theorem setoid.sup_def {α : Type u_1} {r s : setoid α} :

r ⊔ s = eqv_gen.setoid (r.rel ⊔ s.rel)

The supremum of 2 equivalence relations r and s is the equivalence closure of the supremum of the underlying binary operations.

theorem setoid.Sup_eq_eqv_gen {α : Type u_1} (S : set (setoid α)) :

Sup S = eqv_gen.setoid (λ (x y : α), ∃ (r : setoid α), r ∈ S ∧ r.rel x y)

The supremum of a set S of equivalence relations is the equivalence closure of the binary relation there exists r ∈ S relating x and y.

theorem setoid.Sup_def {α : Type u_1} {s : set (setoid α)} :

Sup s = eqv_gen.setoid (Sup (setoid.rel '' s))

The supremum of a set of equivalence relations is the equivalence closure of the supremum of the set's image under the map to the underlying binary operation.

@[simp]

theorem setoid.eqv_gen_of_setoid {α : Type u_1} (r : setoid α) :

eqv_gen.setoid setoid.r = r

The equivalence closure of an equivalence relation r is r.

@[simp]

theorem setoid.eqv_gen_idem {α : Type u_1} (r : α → α → Prop) :

eqv_gen.setoid (eqv_gen.setoid r).rel = eqv_gen.setoid r

Equivalence closure is idempotent.

theorem setoid.eqv_gen_le {α : Type u_1} {r : α → α → Prop} {s : setoid α} (h : ∀ (x y : α), r x y → s.rel x y) :

eqv_gen.setoid r ≤ s

The equivalence closure of a binary relation r is contained in any equivalence relation containing r.

theorem setoid.eqv_gen_mono {α : Type u_1} {r s : α → α → Prop} (h : ∀ (x y : α), r x y → s x y) :

eqv_gen.setoid r ≤ eqv_gen.setoid s

Equivalence closure of binary relations is monotone.

def setoid.gi {α : Type u_1} :

galois_insertion eqv_gen.setoid setoid.rel

There is a Galois insertion of equivalence relations on α into binary relations on α, with equivalence closure the lower adjoint.

Equations

setoid.gi = {choice := λ (r : α → α → Prop) (h : (eqv_gen.setoid r).rel ≤ r), eqv_gen.setoid r, gc := _, le_l_u := _, choice_eq := _}

theorem setoid.injective_iff_ker_bot {α : Type u_1} {β : Type u_2} (f : α → β) :

function.injective f ↔ setoid.ker f = ⊥

A function from α to β is injective iff its kernel is the bottom element of the complete lattice of equivalence relations on α.

theorem setoid.ker_iff_mem_preimage {α : Type u_1} {β : Type u_2} {f : α → β} {x y : α} :

(setoid.ker f).rel x y ↔ x ∈ f ⁻¹' {f y}

The elements related to x ∈ α by the kernel of f are those in the preimage of f(x) under f.

def setoid.lift_equiv {α : Type u_1} {β : Type u_2} (r : setoid α) :

{f // r ≤ setoid.ker f} ≃ (quotient r → β)

Equivalence between functions α → β such that r x y → f x = f y and functions quotient r → β.

Equations

r.lift_equiv = {to_fun := λ (f : {f // r ≤ setoid.ker f}), quotient.lift ↑f _, inv_fun := λ (f : quotient r → β), ⟨f ∘ quotient.mk, _⟩, left_inv := _, right_inv := _}

theorem setoid.lift_unique {α : Type u_1} {β : Type u_2} {r : setoid α} {f : α → β} (H : r ≤ setoid.ker f) (g : quotient r → β) (Hg : f = g ∘ quotient.mk) :

quotient.lift f H = g

The uniqueness part of the universal property for quotients of an arbitrary type.

theorem setoid.ker_lift_injective {α : Type u_1} {β : Type u_2} (f : α → β) :

function.injective (quotient.lift f _)

Given a map f from α to β, the natural map from the quotient of α by the kernel of f is injective.

theorem setoid.ker_eq_lift_of_injective {α : Type u_1} {β : Type u_2} {r : setoid α} (f : α → β) (H : ∀ (x y : α), r.rel x y → f x = f y) (h : function.injective (quotient.lift f H)) :

setoid.ker f = r

Given a map f from α to β, the kernel of f is the unique equivalence relation on α whose induced map from the quotient of α to β is injective.

noncomputable def setoid.quotient_ker_equiv_range {α : Type u_1} {β : Type u_2} (f : α → β) :

quotient (setoid.ker f) ≃ ↥(set.range f)

The first isomorphism theorem for sets: the quotient of α by the kernel of a function f bijects with f's image.

Equations

setoid.quotient_ker_equiv_range f = equiv.of_bijective (quotient.lift (λ (x : α), ⟨f x, _⟩) _) _

@[simp]

theorem setoid.quotient_ker_equiv_of_right_inverse_apply {α : Type u_1} {β : Type u_2} (f : α → β) (g : β → α) (hf : function.right_inverse g f) (a : quotient (setoid.ker f)) :

⇑(setoid.quotient_ker_equiv_of_right_inverse f g hf) a = a.lift_on' f _

@[simp]

theorem setoid.quotient_ker_equiv_of_right_inverse_symm_apply {α : Type u_1} {β : Type u_2} (f : α → β) (g : β → α) (hf : function.right_inverse g f) (b : β) :

⇑((setoid.quotient_ker_equiv_of_right_inverse f g hf).symm) b = quotient.mk' (g b)

def setoid.quotient_ker_equiv_of_right_inverse {α : Type u_1} {β : Type u_2} (f : α → β) (g : β → α) (hf : function.right_inverse g f) :

quotient (setoid.ker f) ≃ β

If f has a computable right-inverse, then the quotient by its kernel is equivalent to its domain.

Equations

setoid.quotient_ker_equiv_of_right_inverse f g hf = {to_fun := λ (a : quotient (setoid.ker f)), a.lift_on' f _, inv_fun := λ (b : β), quotient.mk' (g b), left_inv := _, right_inv := hf}

noncomputable def setoid.quotient_ker_equiv_of_surjective {α : Type u_1} {β : Type u_2} (f : α → β) (hf : function.surjective f) :

quotient (setoid.ker f) ≃ β

The quotient of α by the kernel of a surjective function f bijects with f's codomain.

If a specific right-inverse of f is known, setoid.quotient_ker_equiv_of_right_inverse can be definitionally more useful.

Equations

setoid.quotient_ker_equiv_of_surjective f hf = setoid.quotient_ker_equiv_of_right_inverse f (function.surj_inv hf) _

def setoid.map {α : Type u_1} {β : Type u_2} (r : setoid α) (f : α → β) :

Given a function f : α → β and equivalence relation r on α, the equivalence closure of the relation on f's image defined by 'x ≈ y iff the elements of f⁻¹(x) are related to the elements of f⁻¹(y) by r.'

Equations

r.map f = eqv_gen.setoid (λ (x y : β), ∃ (a b : α), f a = x ∧ f b = y ∧ r.rel a b)

def setoid.map_of_surjective {α : Type u_1} {β : Type u_2} (r : setoid α) (f : α → β) (h : setoid.ker f ≤ r) (hf : function.surjective f) :

Given a surjective function f whose kernel is contained in an equivalence relation r, the equivalence relation on f's codomain defined by x ≈ y ↔ the elements of f⁻¹(x) are related to the elements of f⁻¹(y) by r.

Equations

r.map_of_surjective f h hf = {r := λ (x y : β), ∃ (a b : α), f a = x ∧ f b = y ∧ r.rel a b, iseqv := _}

theorem setoid.map_of_surjective_eq_map {α : Type u_1} {β : Type u_2} {r : setoid α} {f : α → β} (h : setoid.ker f ≤ r) (hf : function.surjective f) :

r.map f = r.map_of_surjective f h hf

A special case of the equivalence closure of an equivalence relation r equalling r.

def setoid.comap {α : Type u_1} {β : Type u_2} (f : α → β) (r : setoid β) :

Given a function f : α → β, an equivalence relation r on β induces an equivalence relation on α defined by 'x ≈ y iff f(x) is related to f(y) by r'.

Equations

setoid.comap f r = {r := r.rel on f, iseqv := _}

theorem setoid.comap_rel {α : Type u_1} {β : Type u_2} (f : α → β) (r : setoid β) (x y : α) :

(setoid.comap f r).rel x y ↔ r.rel (f x) (f y)

theorem setoid.comap_eq {α : Type u_1} {β : Type u_2} {f : α → β} {r : setoid β} :

setoid.comap f r = setoid.ker (quotient.mk ∘ f)

Given a map f : N → M and an equivalence relation r on β, the equivalence relation induced on α by f equals the kernel of r's quotient map composed with f.

noncomputable def setoid.comap_quotient_equiv {α : Type u_1} {β : Type u_2} (f : α → β) (r : setoid β) :

quotient (setoid.comap f r) ≃ ↥(set.range (quotient.mk ∘ f))

The second isomorphism theorem for sets.

Equations

setoid.comap_quotient_equiv f r = (quotient.congr_right _).trans (setoid.quotient_ker_equiv_range (quotient.mk ∘ f))

def setoid.quotient_quotient_equiv_quotient {α : Type u_1} (r s : setoid α) (h : r ≤ s) :

quotient (setoid.ker (quot.map_right h)) ≃ quotient s

The third isomorphism theorem for sets.

Equations

r.quotient_quotient_equiv_quotient s h = {to_fun := λ (x : quotient (setoid.ker (quot.map_right h))), x.lift_on' (λ (w : quot (λ (x y : α), r.rel x y)), quotient.lift_on' w quotient.mk _) _, inv_fun := λ (x : quotient s), x.lift_on' (λ (w : α), ⟦⟦w⟧⟧) _, left_inv := _, right_inv := _}

def setoid.correspondence {α : Type u_1} (r : setoid α) :

{s // r ≤ s} ≃o setoid (quotient r)

Given an equivalence relation r on α, the order-preserving bijection between the set of equivalence relations containing r and the equivalence relations on the quotient of α by r.

Equations

r.correspondence = {to_equiv := {to_fun := λ (s : {s // r ≤ s}), s.val.map_of_surjective quotient.mk _ quotient.exists_rep, inv_fun := λ (s : setoid (quotient r)), ⟨setoid.comap quotient.mk' s, _⟩, left_inv := _, right_inv := _}, map_rel_iff' := _}

@[simp]

theorem quotient.subsingleton_iff {α : Type u_1} {s : setoid α} :

subsingleton (quotient s) ↔ s = ⊤

theorem quot.subsingleton_iff {α : Type u_1} (r : α → α → Prop) :

subsingleton (quot r) ↔ eqv_gen r = ⊤