Disjoint union of categories

We define the category structure on a sigma-type (disjoint union) of categories.

inductive CategoryTheory.Sigma.SigmaHom {I : Type w₁} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] : (i : I) × C i → (i : I) × C i → Type (max w₁ v₁ u₁)

The type of morphisms of a disjoint union of categories: for X : C i and Y : C j, a morphism (i, X) ⟶ (j, Y) if i = j is just a morphism X ⟶ Y, and if i ≠ j there are no such morphisms.

• mk {I : Type w₁} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {i : I} {X Y : C i} : (X ⟶ Y) → CategoryTheory.Sigma.SigmaHom ⟨i, X⟩ ⟨i, Y⟩

def CategoryTheory.Sigma.SigmaHom.id {I : Type w₁} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] (X : (i : I) × C i) : CategoryTheory.Sigma.SigmaHom X X

The identity morphism on an object.

Equations

• CategoryTheory.Sigma.SigmaHom.id ⟨fst, snd⟩ = CategoryTheory.Sigma.SigmaHom.mk (CategoryTheory.CategoryStruct.id snd)

instance CategoryTheory.Sigma.SigmaHom.instInhabited {I : Type w₁} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] (X : (i : I) × C i) : Inhabited (CategoryTheory.Sigma.SigmaHom X X)

Equations

• CategoryTheory.Sigma.SigmaHom.instInhabited X = { default := CategoryTheory.Sigma.SigmaHom.id X }

def CategoryTheory.Sigma.SigmaHom.comp {I : Type w₁} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {X Y Z : (i : I) × C i} : CategoryTheory.Sigma.SigmaHom X Y → CategoryTheory.Sigma.SigmaHom Y Z → CategoryTheory.Sigma.SigmaHom X Z

Composition of sigma homomorphisms.

Equations

• (CategoryTheory.Sigma.SigmaHom.mk f).comp (CategoryTheory.Sigma.SigmaHom.mk g) = CategoryTheory.Sigma.SigmaHom.mk (CategoryTheory.CategoryStruct.comp f g)

instance CategoryTheory.Sigma.SigmaHom.instCategoryStructSigma {I : Type w₁} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] : CategoryTheory.CategoryStruct.{max (max u₁ w₁) v₁, max u₁ w₁} ((i : I) × C i)

Equations

• One or more equations did not get rendered due to their size.

@[simp]

theorem CategoryTheory.Sigma.SigmaHom.comp_def {I : Type w₁} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] (i : I) (X Y Z : C i) (f : X ⟶ Y) (g : Y ⟶ Z) : (CategoryTheory.Sigma.SigmaHom.mk f).comp (CategoryTheory.Sigma.SigmaHom.mk g) = CategoryTheory.Sigma.SigmaHom.mk (CategoryTheory.CategoryStruct.comp f g)

theorem CategoryTheory.Sigma.SigmaHom.assoc {I : Type w₁} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {X Y Z W : (i : I) × C i} (f : X ⟶ Y) (g : Y ⟶ Z) (h : Z ⟶ W) : CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f g) h = CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp g h)

theorem CategoryTheory.Sigma.SigmaHom.id_comp {I : Type w₁} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {X Y : (i : I) × C i} (f : X ⟶ Y) : CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id X) f = f

theorem CategoryTheory.Sigma.SigmaHom.comp_id {I : Type w₁} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {X Y : (i : I) × C i} (f : X ⟶ Y) : CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.id Y) = f

instance CategoryTheory.Sigma.sigma {I : Type w₁} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] : CategoryTheory.Category.{max (max u₁ v₁) w₁, max u₁ w₁} ((i : I) × C i)

Equations

• CategoryTheory.Sigma.sigma = CategoryTheory.Category.mk ⋯ ⋯ ⋯

def CategoryTheory.Sigma.incl {I : Type w₁} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] (i : I) : CategoryTheory.Functor (C i) ((i : I) × C i)

The inclusion functor into the disjoint union of categories.

Equations

• CategoryTheory.Sigma.incl i = { obj := fun (X : C i) => ⟨i, X⟩, map := fun {X Y : C i} => CategoryTheory.Sigma.SigmaHom.mk, map_id := ⋯, map_comp := ⋯ }

@[simp]

theorem CategoryTheory.Sigma.incl_map {I : Type w₁} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] (i : I) {X✝ Y✝ : C i} (a✝ : X✝ ⟶ Y✝) : (CategoryTheory.Sigma.incl i).map a✝ = CategoryTheory.Sigma.SigmaHom.mk a✝

@[simp]

theorem CategoryTheory.Sigma.incl_obj {I : Type w₁} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {i : I} (X : C i) : (CategoryTheory.Sigma.incl i).obj X = ⟨i, X⟩

instance CategoryTheory.Sigma.instFullSigmaIncl {I : Type w₁} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] (i : I) : (CategoryTheory.Sigma.incl i).Full

instance CategoryTheory.Sigma.instFaithfulSigmaIncl {I : Type w₁} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] (i : I) : (CategoryTheory.Sigma.incl i).Faithful

def CategoryTheory.Sigma.natTrans {I : Type w₁} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F G : CategoryTheory.Functor ((i : I) × C i) D} (h : (i : I) → (CategoryTheory.Sigma.incl i).comp F ⟶ (CategoryTheory.Sigma.incl i).comp G) : F ⟶ G

To build a natural transformation over the sigma category, it suffices to specify it restricted to each subcategory.

Equations

• CategoryTheory.Sigma.natTrans h = { app := fun (x : (i : I) × C i) => match x with | ⟨j, X⟩ => (h j).app X, naturality := ⋯ }

@[simp]

theorem CategoryTheory.Sigma.natTrans_app {I : Type w₁} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F G : CategoryTheory.Functor ((i : I) × C i) D} (h : (i : I) → (CategoryTheory.Sigma.incl i).comp F ⟶ (CategoryTheory.Sigma.incl i).comp G) (i : I) (X : C i) : (CategoryTheory.Sigma.natTrans h).app ⟨i, X⟩ = (h i).app X

def CategoryTheory.Sigma.descMap {I : Type w₁} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : (i : I) → CategoryTheory.Functor (C i) D) (X Y : (i : I) × C i) : (X ⟶ Y) → ((F X.fst).obj X.snd ⟶ (F Y.fst).obj Y.snd)

(Implementation). An auxiliary definition to build the functor desc.

Equations

• CategoryTheory.Sigma.descMap F ⟨i, X⟩ ⟨i, Y⟩ (CategoryTheory.Sigma.SigmaHom.mk g) = (F ⟨i, X⟩.fst).map g

def CategoryTheory.Sigma.desc {I : Type w₁} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : (i : I) → CategoryTheory.Functor (C i) D) : CategoryTheory.Functor ((i : I) × C i) D

Given a collection of functors F i : C i ⥤ D, we can produce a functor (Σ i, C i) ⥤ D.

The produced functor desc F satisfies: incl i ⋙ desc F ≅ F i, i.e. restricted to just the subcategory C i, desc F agrees with F i, and it is unique (up to natural isomorphism) with this property.

This witnesses that the sigma-type is the coproduct in Cat.

Equations

• One or more equations did not get rendered due to their size.

@[simp]

theorem CategoryTheory.Sigma.desc_obj {I : Type w₁} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : (i : I) → CategoryTheory.Functor (C i) D) (X : (i : I) × C i) : (CategoryTheory.Sigma.desc F).obj X = (F X.fst).obj X.snd

@[simp]

theorem CategoryTheory.Sigma.desc_map_mk {I : Type w₁} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : (i : I) → CategoryTheory.Functor (C i) D) {i : I} (X Y : C i) (f : X ⟶ Y) : (CategoryTheory.Sigma.desc F).map (CategoryTheory.Sigma.SigmaHom.mk f) = (F i).map f

def CategoryTheory.Sigma.inclDesc {I : Type w₁} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : (i : I) → CategoryTheory.Functor (C i) D) (i : I) : (CategoryTheory.Sigma.incl i).comp (CategoryTheory.Sigma.desc F) ≅ F i

This shows that when desc F is restricted to just the subcategory C i, desc F agrees with F i.

Equations

• One or more equations did not get rendered due to their size.

@[simp]

theorem CategoryTheory.Sigma.inclDesc_hom_app {I : Type w₁} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : (i : I) → CategoryTheory.Functor (C i) D) (i : I) (X : C i) : (CategoryTheory.Sigma.inclDesc F i).hom.app X = CategoryTheory.CategoryStruct.id ((F i).obj X)

@[simp]

theorem CategoryTheory.Sigma.inclDesc_inv_app {I : Type w₁} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : (i : I) → CategoryTheory.Functor (C i) D) (i : I) (X : C i) : (CategoryTheory.Sigma.inclDesc F i).inv.app X = CategoryTheory.CategoryStruct.id ((F i).obj X)

def CategoryTheory.Sigma.descUniq {I : Type w₁} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : (i : I) → CategoryTheory.Functor (C i) D) (q : CategoryTheory.Functor ((i : I) × C i) D) (h : (i : I) → (CategoryTheory.Sigma.incl i).comp q ≅ F i) : q ≅ CategoryTheory.Sigma.desc F

If q when restricted to each subcategory C i agrees with F i, then q is isomorphic to desc F.

Equations

• CategoryTheory.Sigma.descUniq F q h = CategoryTheory.NatIso.ofComponents (fun (x : (i : I) × C i) => match x with | ⟨i, X⟩ => (h i).app X) ⋯

@[simp]

theorem CategoryTheory.Sigma.descUniq_hom_app {I : Type w₁} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : (i : I) → CategoryTheory.Functor (C i) D) (q : CategoryTheory.Functor ((i : I) × C i) D) (h : (i : I) → (CategoryTheory.Sigma.incl i).comp q ≅ F i) (i : I) (X : C i) : (CategoryTheory.Sigma.descUniq F q h).hom.app ⟨i, X⟩ = (h i).hom.app X

@[simp]

theorem CategoryTheory.Sigma.descUniq_inv_app {I : Type w₁} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : (i : I) → CategoryTheory.Functor (C i) D) (q : CategoryTheory.Functor ((i : I) × C i) D) (h : (i : I) → (CategoryTheory.Sigma.incl i).comp q ≅ F i) (i : I) (X : C i) : (CategoryTheory.Sigma.descUniq F q h).inv.app ⟨i, X⟩ = (h i).inv.app X

def CategoryTheory.Sigma.natIso {I : Type w₁} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {q₁ q₂ : CategoryTheory.Functor ((i : I) × C i) D} (h : (i : I) → (CategoryTheory.Sigma.incl i).comp q₁ ≅ (CategoryTheory.Sigma.incl i).comp q₂) : q₁ ≅ q₂

If q₁ and q₂ when restricted to each subcategory C i agree, then q₁ and q₂ are isomorphic.

Equations

• One or more equations did not get rendered due to their size.

@[simp]

theorem CategoryTheory.Sigma.natIso_hom {I : Type w₁} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {q₁ q₂ : CategoryTheory.Functor ((i : I) × C i) D} (h : (i : I) → (CategoryTheory.Sigma.incl i).comp q₁ ≅ (CategoryTheory.Sigma.incl i).comp q₂) : (CategoryTheory.Sigma.natIso h).hom = CategoryTheory.Sigma.natTrans fun (i : I) => (h i).hom

@[simp]

theorem CategoryTheory.Sigma.natIso_inv {I : Type w₁} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {q₁ q₂ : CategoryTheory.Functor ((i : I) × C i) D} (h : (i : I) → (CategoryTheory.Sigma.incl i).comp q₁ ≅ (CategoryTheory.Sigma.incl i).comp q₂) : (CategoryTheory.Sigma.natIso h).inv = CategoryTheory.Sigma.natTrans fun (i : I) => (h i).inv

def CategoryTheory.Sigma.map {I : Type w₁} (C : I → Type u₁) [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {J : Type w₂} (g : J → I) : CategoryTheory.Functor ((j : J) × C (g j)) ((i : I) × C i)

A function J → I induces a functor Σ j, C (g j) ⥤ Σ i, C i.

Equations

• CategoryTheory.Sigma.map C g = CategoryTheory.Sigma.desc fun (j : J) => CategoryTheory.Sigma.incl (g j)

@[simp]

theorem CategoryTheory.Sigma.map_obj {I : Type w₁} (C : I → Type u₁) [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {J : Type w₂} (g : J → I) (j : J) (X : C (g j)) : (CategoryTheory.Sigma.map C g).obj ⟨j, X⟩ = ⟨g j, X⟩

@[simp]

theorem CategoryTheory.Sigma.map_map {I : Type w₁} (C : I → Type u₁) [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {J : Type w₂} (g : J → I) {j : J} {X Y : C (g j)} (f : X ⟶ Y) : (CategoryTheory.Sigma.map C g).map (CategoryTheory.Sigma.SigmaHom.mk f) = CategoryTheory.Sigma.SigmaHom.mk f

def CategoryTheory.Sigma.inclCompMap {I : Type w₁} (C : I → Type u₁) [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {J : Type w₂} (g : J → I) (j : J) : (CategoryTheory.Sigma.incl j).comp (CategoryTheory.Sigma.map C g) ≅ CategoryTheory.Sigma.incl (g j)

The functor Sigma.map C g restricted to the subcategory C j acts as the inclusion of g j.

Equations

• CategoryTheory.Sigma.inclCompMap C g j = CategoryTheory.Iso.refl ((CategoryTheory.Sigma.incl j).comp (CategoryTheory.Sigma.map C g))

@[simp]

theorem CategoryTheory.Sigma.inclCompMap_inv_app {I : Type w₁} (C : I → Type u₁) [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {J : Type w₂} (g : J → I) (j : J) (X : C (g j)) : (CategoryTheory.Sigma.inclCompMap C g j).inv.app X = CategoryTheory.CategoryStruct.id ⟨g j, X⟩

@[simp]

theorem CategoryTheory.Sigma.inclCompMap_hom_app {I : Type w₁} (C : I → Type u₁) [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {J : Type w₂} (g : J → I) (j : J) (X : C (g j)) : (CategoryTheory.Sigma.inclCompMap C g j).hom.app X = CategoryTheory.CategoryStruct.id ⟨g j, X⟩

def CategoryTheory.Sigma.mapId (I : Type w₁) (C : I → Type u₁) [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] : CategoryTheory.Sigma.map C id ≅ CategoryTheory.Functor.id ((i : I) × C i)

The functor Sigma.map applied to the identity function is just the identity functor.

Equations

• One or more equations did not get rendered due to their size.

@[simp]

theorem CategoryTheory.Sigma.mapId_inv_app (I : Type w₁) (C : I → Type u₁) [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] (x✝ : (i : I) × (fun (i : I) => C (id i)) i) : (CategoryTheory.Sigma.mapId I C).inv.app x✝ = CategoryTheory.CategoryStruct.id ⟨x✝.fst, x✝.snd⟩

@[simp]

theorem CategoryTheory.Sigma.mapId_hom_app (I : Type w₁) (C : I → Type u₁) [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] (x✝ : (i : I) × (fun (i : I) => C (id i)) i) : (CategoryTheory.Sigma.mapId I C).hom.app x✝ = CategoryTheory.CategoryStruct.id ⟨x✝.fst, x✝.snd⟩

def CategoryTheory.Sigma.mapComp {I : Type w₁} (C : I → Type u₁) [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {J : Type w₂} {K : Type w₃} (f : K → J) (g : J → I) : (CategoryTheory.Sigma.map (fun (x : J) => C (g x)) f).comp (CategoryTheory.Sigma.map C g) ≅ CategoryTheory.Sigma.map C (g ∘ f)

The functor Sigma.map applied to a composition is a composition of functors.

Equations

• One or more equations did not get rendered due to their size.

@[simp]

theorem CategoryTheory.Sigma.mapComp_inv_app {I : Type w₁} (C : I → Type u₁) [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {J : Type w₂} {K : Type w₃} (f : K → J) (g : J → I) (X : (i : K) × (fun (i : K) => C (g (f i))) i) : (CategoryTheory.Sigma.mapComp C f g).inv.app X = CategoryTheory.CategoryStruct.id ⟨g (f X.fst), X.snd⟩

@[simp]

theorem CategoryTheory.Sigma.mapComp_hom_app {I : Type w₁} (C : I → Type u₁) [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {J : Type w₂} {K : Type w₃} (f : K → J) (g : J → I) (X : (i : K) × (fun (i : K) => C (g (f i))) i) : (CategoryTheory.Sigma.mapComp C f g).hom.app X = CategoryTheory.CategoryStruct.id ⟨g (f X.fst), X.snd⟩

def CategoryTheory.Sigma.Functor.sigma {I : Type w₁} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {D : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (D i)] (F : (i : I) → CategoryTheory.Functor (C i) (D i)) : CategoryTheory.Functor ((i : I) × C i) ((i : I) × D i)

Assemble an I-indexed family of functors into a functor between the sigma types.

Equations

• CategoryTheory.Sigma.Functor.sigma F = CategoryTheory.Sigma.desc fun (i : I) => (F i).comp (CategoryTheory.Sigma.incl i)

def CategoryTheory.Sigma.natTrans.sigma {I : Type w₁} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {D : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (D i)] {F G : (i : I) → CategoryTheory.Functor (C i) (D i)} (α : (i : I) → F i ⟶ G i) : CategoryTheory.Sigma.Functor.sigma F ⟶ CategoryTheory.Sigma.Functor.sigma G

Assemble an I-indexed family of natural transformations into a single natural transformation.

Equations

• CategoryTheory.Sigma.natTrans.sigma α = { app := fun (f : (i : I) × C i) => CategoryTheory.Sigma.SigmaHom.mk ((α f.fst).app f.snd), naturality := ⋯ }