Over and under categories

Over (and under) categories are special cases of comma categories.

• If L is the identity functor and R is a constant functor, then Comma L R is the "slice" or "over" category over the object R maps to.
• Conversely, if L is a constant functor and R is the identity functor, then Comma L R is the "coslice" or "under" category under the object L maps to.

Tags

Comma, Slice, Coslice, Over, Under

def CategoryTheory.Over {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T) : Type (max u₁ v₁)

The over category has as objects arrows in T with codomain X and as morphisms commutative triangles.

See https://stacks.math.columbia.edu/tag/001G.

Equations

• CategoryTheory.Over X = CategoryTheory.CostructuredArrow (CategoryTheory.Functor.id T) X

instance CategoryTheory.instCategoryOver {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T) : CategoryTheory.Category.{v₁, max u₁ v₁} (CategoryTheory.Over X)

Equations

• CategoryTheory.instCategoryOver X = CategoryTheory.commaCategory

instance CategoryTheory.Over.inhabited {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] [Inhabited T] : Inhabited (CategoryTheory.Over default)

Equations

• CategoryTheory.Over.inhabited = { default := { left := default, right := default, hom := CategoryTheory.CategoryStruct.id ((CategoryTheory.Functor.id T).obj default) } }

theorem CategoryTheory.Over.OverMorphism.ext {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {U V : CategoryTheory.Over X} {f g : U ⟶ V} (h : f.left = g.left) : f = g

@[simp]

theorem CategoryTheory.Over.over_right {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} (U : CategoryTheory.Over X) : U.right = { as := PUnit.unit }

@[simp]

theorem CategoryTheory.Over.id_left {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} (U : CategoryTheory.Over X) : (CategoryTheory.CategoryStruct.id U).left = CategoryTheory.CategoryStruct.id U.left

@[simp]

theorem CategoryTheory.Over.comp_left {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} (a b c : CategoryTheory.Over X) (f : a ⟶ b) (g : b ⟶ c) : (CategoryTheory.CategoryStruct.comp f g).left = CategoryTheory.CategoryStruct.comp f.left g.left

theorem CategoryTheory.Over.comp_left_assoc {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} (a b c : CategoryTheory.Over X) (f : a ⟶ b) (g : b ⟶ c) {Z : T} (h : c.left ⟶ Z) : CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f g).left h = CategoryTheory.CategoryStruct.comp f.left (CategoryTheory.CategoryStruct.comp g.left h)

@[simp]

theorem CategoryTheory.Over.w {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {A B : CategoryTheory.Over X} (f : A ⟶ B) : CategoryTheory.CategoryStruct.comp f.left B.hom = A.hom

@[simp]

theorem CategoryTheory.Over.w_assoc {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {A B : CategoryTheory.Over X} (f : A ⟶ B) {Z : T} (h : (CategoryTheory.Functor.fromPUnit X).obj B.right ⟶ Z) : CategoryTheory.CategoryStruct.comp f.left (CategoryTheory.CategoryStruct.comp B.hom h) = CategoryTheory.CategoryStruct.comp A.hom h

def CategoryTheory.Over.mk {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X Y : T} (f : Y ⟶ X) : CategoryTheory.Over X

To give an object in the over category, it suffices to give a morphism with codomain X.

Equations

• CategoryTheory.Over.mk f = CategoryTheory.CostructuredArrow.mk f

@[simp]

theorem CategoryTheory.Over.mk_left {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X Y : T} (f : Y ⟶ X) : (CategoryTheory.Over.mk f).left = Y

@[simp]

theorem CategoryTheory.Over.mk_hom {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X Y : T} (f : Y ⟶ X) : (CategoryTheory.Over.mk f).hom = f

def CategoryTheory.Over.coeFromHom {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X Y : T} : CoeOut (Y ⟶ X) (CategoryTheory.Over X)

We can set up a coercion from arrows with codomain X to over X. This most likely should not be a global instance, but it is sometimes useful.

Equations

• CategoryTheory.Over.coeFromHom = { coe := CategoryTheory.Over.mk }

@[simp]

theorem CategoryTheory.Over.coe_hom {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X Y : T} (f : Y ⟶ X) : (CategoryTheory.Over.mk f).hom = f

def CategoryTheory.Over.homMk {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {U V : CategoryTheory.Over X} (f : U.left ⟶ V.left) (w : CategoryTheory.CategoryStruct.comp f V.hom = U.hom := by aesop_cat) : U ⟶ V

To give a morphism in the over category, it suffices to give an arrow fitting in a commutative triangle.

Equations

• CategoryTheory.Over.homMk f w = CategoryTheory.CostructuredArrow.homMk f w

@[simp]

theorem CategoryTheory.Over.homMk_left {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {U V : CategoryTheory.Over X} (f : U.left ⟶ V.left) (w : CategoryTheory.CategoryStruct.comp f V.hom = U.hom := by aesop_cat) : (CategoryTheory.Over.homMk f w).left = f

@[simp]

theorem CategoryTheory.Over.homMk_right_down_down {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {U V : CategoryTheory.Over X} (f : U.left ⟶ V.left) (w : CategoryTheory.CategoryStruct.comp f V.hom = U.hom := by aesop_cat) : ⋯ = ⋯

def CategoryTheory.Over.isoMk {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {f g : CategoryTheory.Over X} (hl : f.left ≅ g.left) (hw : CategoryTheory.CategoryStruct.comp hl.hom g.hom = f.hom := by aesop_cat) : f ≅ g

Construct an isomorphism in the over category given isomorphisms of the objects whose forward direction gives a commutative triangle.

Equations

• CategoryTheory.Over.isoMk hl hw = CategoryTheory.CostructuredArrow.isoMk hl hw

@[simp]

theorem CategoryTheory.Over.isoMk_hom_right_down_down {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {f g : CategoryTheory.Over X} (hl : f.left ≅ g.left) (hw : CategoryTheory.CategoryStruct.comp hl.hom g.hom = f.hom := by aesop_cat) : ⋯ = ⋯

@[simp]

theorem CategoryTheory.Over.isoMk_hom_left {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {f g : CategoryTheory.Over X} (hl : f.left ≅ g.left) (hw : CategoryTheory.CategoryStruct.comp hl.hom g.hom = f.hom := by aesop_cat) : (CategoryTheory.Over.isoMk hl hw).hom.left = hl.hom

@[simp]

theorem CategoryTheory.Over.isoMk_inv_right_down_down {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {f g : CategoryTheory.Over X} (hl : f.left ≅ g.left) (hw : CategoryTheory.CategoryStruct.comp hl.hom g.hom = f.hom := by aesop_cat) : ⋯ = ⋯

@[simp]

theorem CategoryTheory.Over.isoMk_inv_left {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {f g : CategoryTheory.Over X} (hl : f.left ≅ g.left) (hw : CategoryTheory.CategoryStruct.comp hl.hom g.hom = f.hom := by aesop_cat) : (CategoryTheory.Over.isoMk hl hw).inv.left = hl.inv

@[simp]

theorem CategoryTheory.Over.hom_left_inv_left {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {f g : CategoryTheory.Over X} (e : f ≅ g) : CategoryTheory.CategoryStruct.comp e.hom.left e.inv.left = CategoryTheory.CategoryStruct.id f.left

@[simp]

theorem CategoryTheory.Over.hom_left_inv_left_assoc {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {f g : CategoryTheory.Over X} (e : f ≅ g) {Z : T} (h : f.left ⟶ Z) : CategoryTheory.CategoryStruct.comp e.hom.left (CategoryTheory.CategoryStruct.comp e.inv.left h) = h

@[simp]

theorem CategoryTheory.Over.inv_left_hom_left {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {f g : CategoryTheory.Over X} (e : f ≅ g) : CategoryTheory.CategoryStruct.comp e.inv.left e.hom.left = CategoryTheory.CategoryStruct.id g.left

@[simp]

theorem CategoryTheory.Over.inv_left_hom_left_assoc {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {f g : CategoryTheory.Over X} (e : f ≅ g) {Z : T} (h : g.left ⟶ Z) : CategoryTheory.CategoryStruct.comp e.inv.left (CategoryTheory.CategoryStruct.comp e.hom.left h) = h

def CategoryTheory.Over.forget {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T) : CategoryTheory.Functor (CategoryTheory.Over X) T

The forgetful functor mapping an arrow to its domain.

See https://stacks.math.columbia.edu/tag/001G.

Equations

• CategoryTheory.Over.forget X = CategoryTheory.Comma.fst (CategoryTheory.Functor.id T) (CategoryTheory.Functor.fromPUnit X)

@[simp]

theorem CategoryTheory.Over.forget_obj {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {U : CategoryTheory.Over X} : (CategoryTheory.Over.forget X).obj U = U.left

@[simp]

theorem CategoryTheory.Over.forget_map {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {U V : CategoryTheory.Over X} {f : U ⟶ V} : (CategoryTheory.Over.forget X).map f = f.left

def CategoryTheory.Over.forgetCocone {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T) : CategoryTheory.Limits.Cocone (CategoryTheory.Over.forget X)

The natural cocone over the forgetful functor Over X ⥤ T with cocone point X.

Equations

• CategoryTheory.Over.forgetCocone X = { pt := X, ι := { app := CategoryTheory.Comma.hom, naturality := ⋯ } }

@[simp]

theorem CategoryTheory.Over.forgetCocone_pt {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T) : (CategoryTheory.Over.forgetCocone X).pt = X

@[simp]

theorem CategoryTheory.Over.forgetCocone_ι_app {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T) (self : CategoryTheory.Comma (CategoryTheory.Functor.id T) (CategoryTheory.Functor.fromPUnit X)) : (CategoryTheory.Over.forgetCocone X).ι.app self = self.hom

def CategoryTheory.Over.map {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X Y : T} (f : X ⟶ Y) : CategoryTheory.Functor (CategoryTheory.Over X) (CategoryTheory.Over Y)

A morphism f : X ⟶ Y induces a functor Over X ⥤ Over Y in the obvious way.

See https://stacks.math.columbia.edu/tag/001G.

Equations

• CategoryTheory.Over.map f = CategoryTheory.Comma.mapRight (CategoryTheory.Functor.id T) (CategoryTheory.Discrete.natTrans fun (x : CategoryTheory.Discrete PUnit.{1}) => f)

@[simp]

theorem CategoryTheory.Over.map_obj_left {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X Y : T} {f : X ⟶ Y} {U : CategoryTheory.Over X} : ((CategoryTheory.Over.map f).obj U).left = U.left

@[simp]

theorem CategoryTheory.Over.map_obj_hom {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X Y : T} {f : X ⟶ Y} {U : CategoryTheory.Over X} : ((CategoryTheory.Over.map f).obj U).hom = CategoryTheory.CategoryStruct.comp U.hom f

@[simp]

theorem CategoryTheory.Over.map_map_left {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X Y : T} {f : X ⟶ Y} {U V : CategoryTheory.Over X} {g : U ⟶ V} : ((CategoryTheory.Over.map f).map g).left = g.left

def CategoryTheory.Over.mapIso {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X Y : T} (f : X ≅ Y) : CategoryTheory.Over X ≌ CategoryTheory.Over Y

If f is an isomorphism, map f is an equivalence of categories.

Equations

• CategoryTheory.Over.mapIso f = CategoryTheory.Comma.mapRightIso (CategoryTheory.Functor.id T) (CategoryTheory.Discrete.natIso fun (x : CategoryTheory.Discrete PUnit.{1}) => f)

@[simp]

theorem CategoryTheory.Over.mapIso_functor {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X Y : T} (f : X ≅ Y) : (CategoryTheory.Over.mapIso f).functor = CategoryTheory.Over.map f.hom

@[simp]

theorem CategoryTheory.Over.mapIso_inverse {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X Y : T} (f : X ≅ Y) : (CategoryTheory.Over.mapIso f).inverse = CategoryTheory.Over.map f.inv

This section proves various equalities between functors that demonstrate, for instance, that over categories assemble into a functor mapFunctor : T ⥤ Cat.

These equalities between functors are then converted to natural isomorphisms using eqToIso. Such natural isomorphisms could be obtained directly using Iso.refl but this method will have better computational properties, when used, for instance, in developing the theory of Beck-Chevalley transformations.

theorem CategoryTheory.Over.mapId_eq {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (Y : T) : CategoryTheory.Over.map (CategoryTheory.CategoryStruct.id Y) = CategoryTheory.Functor.id (CategoryTheory.Over Y)

Mapping by the identity morphism is just the identity functor.

def CategoryTheory.Over.mapId {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (Y : T) : CategoryTheory.Over.map (CategoryTheory.CategoryStruct.id Y) ≅ CategoryTheory.Functor.id (CategoryTheory.Over Y)

The natural isomorphism arising from mapForget_eq.

Equations

• CategoryTheory.Over.mapId Y = CategoryTheory.eqToIso ⋯

@[simp]

theorem CategoryTheory.Over.mapId_inv {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (Y : T) : (CategoryTheory.Over.mapId Y).inv = CategoryTheory.eqToHom ⋯

@[simp]

theorem CategoryTheory.Over.mapId_hom {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (Y : T) : (CategoryTheory.Over.mapId Y).hom = CategoryTheory.eqToHom ⋯

theorem CategoryTheory.Over.mapForget_eq {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X Y : T} (f : X ⟶ Y) : (CategoryTheory.Over.map f).comp (CategoryTheory.Over.forget Y) = CategoryTheory.Over.forget X

Mapping by f and then forgetting is the same as forgetting.

def CategoryTheory.Over.mapForget {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X Y : T} (f : X ⟶ Y) : (CategoryTheory.Over.map f).comp (CategoryTheory.Over.forget Y) ≅ CategoryTheory.Over.forget X

The natural isomorphism arising from mapForget_eq.

Equations

• CategoryTheory.Over.mapForget f = CategoryTheory.eqToIso ⋯

@[simp]

theorem CategoryTheory.Over.eqToHom_left {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {U V : CategoryTheory.Over X} (e : U = V) : (CategoryTheory.eqToHom e).left = CategoryTheory.eqToHom ⋯

theorem CategoryTheory.Over.mapComp_eq {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X Y Z : T} (f : X ⟶ Y) (g : Y ⟶ Z) : CategoryTheory.Over.map (CategoryTheory.CategoryStruct.comp f g) = (CategoryTheory.Over.map f).comp (CategoryTheory.Over.map g)

Mapping by the composite morphism f ≫ g is the same as mapping by f then by g.

def CategoryTheory.Over.mapComp {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X Y Z : T} (f : X ⟶ Y) (g : Y ⟶ Z) : CategoryTheory.Over.map (CategoryTheory.CategoryStruct.comp f g) ≅ (CategoryTheory.Over.map f).comp (CategoryTheory.Over.map g)

The natural isomorphism arising from mapComp_eq.

Equations

• CategoryTheory.Over.mapComp f g = CategoryTheory.eqToIso ⋯

@[simp]

theorem CategoryTheory.Over.mapComp_inv {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X Y Z : T} (f : X ⟶ Y) (g : Y ⟶ Z) : (CategoryTheory.Over.mapComp f g).inv = CategoryTheory.eqToHom ⋯

@[simp]

theorem CategoryTheory.Over.mapComp_hom {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X Y Z : T} (f : X ⟶ Y) (g : Y ⟶ Z) : (CategoryTheory.Over.mapComp f g).hom = CategoryTheory.eqToHom ⋯

def CategoryTheory.Over.mapCongr {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X Y : T} (f g : X ⟶ Y) (h : f = g) : CategoryTheory.Over.map f ≅ CategoryTheory.Over.map g

If f = g, then map f is naturally isomorphic to map g.

Equations

• CategoryTheory.Over.mapCongr f g h = CategoryTheory.NatIso.ofComponents (fun (A : CategoryTheory.Over X) => CategoryTheory.eqToIso ⋯) ⋯

@[simp]

theorem CategoryTheory.Over.mapCongr_inv_app {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X Y : T} (f g : X ⟶ Y) (h : f = g) (X✝ : CategoryTheory.Over X) : (CategoryTheory.Over.mapCongr f g h).inv.app X✝ = CategoryTheory.eqToHom ⋯

@[simp]

theorem CategoryTheory.Over.mapCongr_hom_app {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X Y : T} (f g : X ⟶ Y) (h : f = g) (X✝ : CategoryTheory.Over X) : (CategoryTheory.Over.mapCongr f g h).hom.app X✝ = CategoryTheory.eqToHom ⋯

def CategoryTheory.Over.mapFunctor (T : Type u₁) [CategoryTheory.Category.{v₁, u₁} T] : CategoryTheory.Functor T CategoryTheory.Cat

The functor defined by the over categories.

Equations

• CategoryTheory.Over.mapFunctor T = { obj := fun (X : T) => CategoryTheory.Cat.of (CategoryTheory.Over X), map := fun {X Y : T} => CategoryTheory.Over.map, map_id := ⋯, map_comp := ⋯ }

@[simp]

theorem CategoryTheory.Over.mapFunctor_obj (T : Type u₁) [CategoryTheory.Category.{v₁, u₁} T] (X : T) : (CategoryTheory.Over.mapFunctor T).obj X = CategoryTheory.Cat.of (CategoryTheory.Over X)

@[simp]

theorem CategoryTheory.Over.mapFunctor_map (T : Type u₁) [CategoryTheory.Category.{v₁, u₁} T] {X✝ Y✝ : T} (f : X✝ ⟶ Y✝) : (CategoryTheory.Over.mapFunctor T).map f = CategoryTheory.Over.map f

instance CategoryTheory.Over.forget_reflects_iso {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} : (CategoryTheory.Over.forget X).ReflectsIsomorphisms

Equations

• ⋯ = ⋯

noncomputable def CategoryTheory.Over.mkIdTerminal {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} : CategoryTheory.Limits.IsTerminal (CategoryTheory.Over.mk (CategoryTheory.CategoryStruct.id X))

The identity over X is terminal.

Equations

• CategoryTheory.Over.mkIdTerminal = CategoryTheory.CostructuredArrow.mkIdTerminal

instance CategoryTheory.Over.forget_faithful {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} : (CategoryTheory.Over.forget X).Faithful

Equations

• ⋯ = ⋯

theorem CategoryTheory.Over.epi_of_epi_left {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {f g : CategoryTheory.Over X} (k : f ⟶ g) [hk : CategoryTheory.Epi k.left] : CategoryTheory.Epi k

If k.left is an epimorphism, then k is an epimorphism. In other words, Over.forget X reflects epimorphisms. The converse does not hold without additional assumptions on the underlying category, see CategoryTheory.Over.epi_left_of_epi.

theorem CategoryTheory.Over.mono_of_mono_left {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {f g : CategoryTheory.Over X} (k : f ⟶ g) [hk : CategoryTheory.Mono k.left] : CategoryTheory.Mono k

If k.left is a monomorphism, then k is a monomorphism. In other words, Over.forget X reflects monomorphisms. The converse of CategoryTheory.Over.mono_left_of_mono.

This lemma is not an instance, to avoid loops in type class inference.

instance CategoryTheory.Over.mono_left_of_mono {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {f g : CategoryTheory.Over X} (k : f ⟶ g) [CategoryTheory.Mono k] : CategoryTheory.Mono k.left

If k is a monomorphism, then k.left is a monomorphism. In other words, Over.forget X preserves monomorphisms. The converse of CategoryTheory.Over.mono_of_mono_left.

Equations

• ⋯ = ⋯

def CategoryTheory.Over.iteratedSliceForward {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} (f : CategoryTheory.Over X) : CategoryTheory.Functor (CategoryTheory.Over f) (CategoryTheory.Over f.left)

Given f : Y ⟶ X, this is the obvious functor from (T/X)/f to T/Y

Equations

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

@[simp]

theorem CategoryTheory.Over.iteratedSliceForward_map {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} (f : CategoryTheory.Over X) {X✝ Y✝ : CategoryTheory.Over f} (κ : X✝ ⟶ Y✝) : f.iteratedSliceForward.map κ = CategoryTheory.Over.homMk κ.left.left ⋯

@[simp]

theorem CategoryTheory.Over.iteratedSliceForward_obj {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} (f : CategoryTheory.Over X) (α : CategoryTheory.Over f) : f.iteratedSliceForward.obj α = CategoryTheory.Over.mk α.hom.left

def CategoryTheory.Over.iteratedSliceBackward {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} (f : CategoryTheory.Over X) : CategoryTheory.Functor (CategoryTheory.Over f.left) (CategoryTheory.Over f)

Given f : Y ⟶ X, this is the obvious functor from T/Y to (T/X)/f

Equations

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

@[simp]

theorem CategoryTheory.Over.iteratedSliceBackward_obj {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} (f : CategoryTheory.Over X) (g : CategoryTheory.Over f.left) : f.iteratedSliceBackward.obj g = CategoryTheory.Over.mk (CategoryTheory.Over.homMk g.hom ⋯)

@[simp]

theorem CategoryTheory.Over.iteratedSliceBackward_map {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} (f : CategoryTheory.Over X) {X✝ Y✝ : CategoryTheory.Over f.left} (α : X✝ ⟶ Y✝) : f.iteratedSliceBackward.map α = CategoryTheory.Over.homMk (CategoryTheory.Over.homMk α.left ⋯) ⋯

def CategoryTheory.Over.iteratedSliceEquiv {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} (f : CategoryTheory.Over X) : CategoryTheory.Over f ≌ CategoryTheory.Over f.left

Given f : Y ⟶ X, we have an equivalence between (T/X)/f and T/Y

Equations

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

@[simp]

theorem CategoryTheory.Over.iteratedSliceEquiv_counitIso {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} (f : CategoryTheory.Over X) : f.iteratedSliceEquiv.counitIso = CategoryTheory.NatIso.ofComponents (fun (g : CategoryTheory.Over f.left) => CategoryTheory.Over.isoMk (CategoryTheory.Iso.refl ((f.iteratedSliceBackward.comp f.iteratedSliceForward).obj g).left) ⋯) ⋯

@[simp]

theorem CategoryTheory.Over.iteratedSliceEquiv_unitIso {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} (f : CategoryTheory.Over X) : f.iteratedSliceEquiv.unitIso = CategoryTheory.NatIso.ofComponents (fun (g : CategoryTheory.Over f) => CategoryTheory.Over.isoMk (CategoryTheory.Over.isoMk (CategoryTheory.Iso.refl ((CategoryTheory.Functor.id (CategoryTheory.Over f)).obj g).left.left) ⋯) ⋯) ⋯

@[simp]

theorem CategoryTheory.Over.iteratedSliceEquiv_functor {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} (f : CategoryTheory.Over X) : f.iteratedSliceEquiv.functor = f.iteratedSliceForward

@[simp]

theorem CategoryTheory.Over.iteratedSliceEquiv_inverse {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} (f : CategoryTheory.Over X) : f.iteratedSliceEquiv.inverse = f.iteratedSliceBackward

theorem CategoryTheory.Over.iteratedSliceForward_forget {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} (f : CategoryTheory.Over X) : f.iteratedSliceForward.comp (CategoryTheory.Over.forget f.left) = (CategoryTheory.Over.forget f).comp (CategoryTheory.Over.forget X)

theorem CategoryTheory.Over.iteratedSliceBackward_forget_forget {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} (f : CategoryTheory.Over X) : f.iteratedSliceBackward.comp ((CategoryTheory.Over.forget f).comp (CategoryTheory.Over.forget X)) = CategoryTheory.Over.forget f.left

def CategoryTheory.Over.post {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X : T} (F : CategoryTheory.Functor T D) : CategoryTheory.Functor (CategoryTheory.Over X) (CategoryTheory.Over (F.obj X))

A functor F : T ⥤ D induces a functor Over X ⥤ Over (F.obj X) in the obvious way.

Equations

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

@[simp]

theorem CategoryTheory.Over.post_map {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X : T} (F : CategoryTheory.Functor T D) {X✝ Y✝ : CategoryTheory.Over X} (f : X✝ ⟶ Y✝) : (CategoryTheory.Over.post F).map f = CategoryTheory.Over.homMk (F.map f.left) ⋯

@[simp]

theorem CategoryTheory.Over.post_obj {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X : T} (F : CategoryTheory.Functor T D) (Y : CategoryTheory.Over X) : (CategoryTheory.Over.post F).obj Y = CategoryTheory.Over.mk (F.map Y.hom)

theorem CategoryTheory.Over.post_comp {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X : T} {E : Type u_1} [CategoryTheory.Category.{u_2, u_1} E] (F : CategoryTheory.Functor T D) (G : CategoryTheory.Functor D E) : CategoryTheory.Over.post (F.comp G) = (CategoryTheory.Over.post F).comp (CategoryTheory.Over.post G)

def CategoryTheory.Over.postComp {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X : T} {E : Type u_1} [CategoryTheory.Category.{u_2, u_1} E] (F : CategoryTheory.Functor T D) (G : CategoryTheory.Functor D E) : CategoryTheory.Over.post (F.comp G) ≅ (CategoryTheory.Over.post F).comp (CategoryTheory.Over.post G)

post (F ⋙ G) is isomorphic (actually equal) to post F ⋙ post G.

Equations

• CategoryTheory.Over.postComp F G = CategoryTheory.NatIso.ofComponents (fun (X_1 : CategoryTheory.Over X) => CategoryTheory.Iso.refl ((CategoryTheory.Over.post (F.comp G)).obj X_1)) ⋯

@[simp]

theorem CategoryTheory.Over.postComp_hom_app_left {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X : T} {E : Type u_1} [CategoryTheory.Category.{u_2, u_1} E] (F : CategoryTheory.Functor T D) (G : CategoryTheory.Functor D E) (X✝ : CategoryTheory.Over X) : ((CategoryTheory.Over.postComp F G).hom.app X✝).left = CategoryTheory.CategoryStruct.id (G.obj (F.obj X✝.left))

@[simp]

theorem CategoryTheory.Over.postComp_inv_app_right_down_down {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X : T} {E : Type u_1} [CategoryTheory.Category.{u_2, u_1} E] (F : CategoryTheory.Functor T D) (G : CategoryTheory.Functor D E) (X✝ : CategoryTheory.Over X) : ⋯ = ⋯

@[simp]

theorem CategoryTheory.Over.postComp_inv_app_left {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X : T} {E : Type u_1} [CategoryTheory.Category.{u_2, u_1} E] (F : CategoryTheory.Functor T D) (G : CategoryTheory.Functor D E) (X✝ : CategoryTheory.Over X) : ((CategoryTheory.Over.postComp F G).inv.app X✝).left = CategoryTheory.CategoryStruct.id (G.obj (F.obj X✝.left))

@[simp]

theorem CategoryTheory.Over.postComp_hom_app_right_down_down {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X : T} {E : Type u_1} [CategoryTheory.Category.{u_2, u_1} E] (F : CategoryTheory.Functor T D) (G : CategoryTheory.Functor D E) (X✝ : CategoryTheory.Over X) : ⋯ = ⋯

def CategoryTheory.Over.postMap {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X : T} {F G : CategoryTheory.Functor T D} (e : F ⟶ G) : (CategoryTheory.Over.post F).comp (CategoryTheory.Over.map (e.app X)) ⟶ CategoryTheory.Over.post G

A natural transformation F ⟶ G induces a natural transformation on Over X up to Under.map.

Equations

• CategoryTheory.Over.postMap e = { app := fun (Y : CategoryTheory.Over X) => CategoryTheory.Over.homMk (e.app Y.left) ⋯, naturality := ⋯ }

@[simp]

theorem CategoryTheory.Over.postMap_app {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X : T} {F G : CategoryTheory.Functor T D} (e : F ⟶ G) (Y : CategoryTheory.Over X) : (CategoryTheory.Over.postMap e).app Y = CategoryTheory.Over.homMk (e.app Y.left) ⋯

def CategoryTheory.Over.postCongr {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X : T} {F G : CategoryTheory.Functor T D} (e : F ≅ G) : (CategoryTheory.Over.post F).comp (CategoryTheory.Over.map (e.hom.app X)) ≅ CategoryTheory.Over.post G

If F and G are naturally isomorphic, then Over.post F and Over.post G are also naturally isomorphic up to Over.map

Equations

• CategoryTheory.Over.postCongr e = CategoryTheory.NatIso.ofComponents (fun (A : CategoryTheory.Over X) => CategoryTheory.Over.isoMk (e.app A.left) ⋯) ⋯

@[simp]

theorem CategoryTheory.Over.postCongr_inv_app_left {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X : T} {F G : CategoryTheory.Functor T D} (e : F ≅ G) (X✝ : CategoryTheory.Over X) : ((CategoryTheory.Over.postCongr e).inv.app X✝).left = e.inv.app X✝.left

@[simp]

theorem CategoryTheory.Over.postCongr_hom_app_left {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X : T} {F G : CategoryTheory.Functor T D} (e : F ≅ G) (X✝ : CategoryTheory.Over X) : ((CategoryTheory.Over.postCongr e).hom.app X✝).left = e.hom.app X✝.left

@[simp]

theorem CategoryTheory.Over.postCongr_hom_app_right_down_down {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X : T} {F G : CategoryTheory.Functor T D} (e : F ≅ G) (X✝ : CategoryTheory.Over X) : ⋯ = ⋯

@[simp]

theorem CategoryTheory.Over.postCongr_inv_app_right_down_down {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X : T} {F G : CategoryTheory.Functor T D} (e : F ≅ G) (X✝ : CategoryTheory.Over X) : ⋯ = ⋯

instance CategoryTheory.Over.instFaithfulObjPost {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (X : T) (F : CategoryTheory.Functor T D) [F.Faithful] : (CategoryTheory.Over.post F).Faithful

Equations

• ⋯ = ⋯

instance CategoryTheory.Over.instFullObjPostOfFaithful {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (X : T) (F : CategoryTheory.Functor T D) [F.Faithful] [F.Full] : (CategoryTheory.Over.post F).Full

Equations

• ⋯ = ⋯

instance CategoryTheory.Over.instEssSurjObjPostOfFull {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (X : T) (F : CategoryTheory.Functor T D) [F.Full] [F.EssSurj] : (CategoryTheory.Over.post F).EssSurj

Equations

• ⋯ = ⋯

instance CategoryTheory.Over.instIsEquivalenceObjPost {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (X : T) (F : CategoryTheory.Functor T D) [F.IsEquivalence] : (CategoryTheory.Over.post F).IsEquivalence

Equations

• ⋯ = ⋯

def CategoryTheory.Over.postEquiv {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (X : T) (F : T ≌ D) : CategoryTheory.Over X ≌ CategoryTheory.Over (F.functor.obj X)

An equivalence of categories induces an equivalence on over categories.

Equations

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

@[simp]

theorem CategoryTheory.Over.postEquiv_counitIso {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (X : T) (F : T ≌ D) : (CategoryTheory.Over.postEquiv X F).counitIso = CategoryTheory.NatIso.ofComponents (fun (A : CategoryTheory.Over (F.functor.obj X)) => CategoryTheory.Over.isoMk (F.counitIso.app A.left) ⋯) ⋯

@[simp]

theorem CategoryTheory.Over.postEquiv_inverse {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (X : T) (F : T ≌ D) : (CategoryTheory.Over.postEquiv X F).inverse = (CategoryTheory.Over.post F.inverse).comp (CategoryTheory.Over.map (F.unitIso.inv.app X))

@[simp]

theorem CategoryTheory.Over.postEquiv_unitIso {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (X : T) (F : T ≌ D) : (CategoryTheory.Over.postEquiv X F).unitIso = CategoryTheory.NatIso.ofComponents (fun (A : CategoryTheory.Over X) => CategoryTheory.Over.isoMk (F.unitIso.app A.left) ⋯) ⋯

@[simp]

theorem CategoryTheory.Over.postEquiv_functor {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (X : T) (F : T ≌ D) : (CategoryTheory.Over.postEquiv X F).functor = CategoryTheory.Over.post F.functor

def CategoryTheory.CostructuredArrow.toOver {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor D T) (X : T) : CategoryTheory.Functor (CategoryTheory.CostructuredArrow F X) (CategoryTheory.Over X)

Reinterpreting an F-costructured arrow F.obj d ⟶ X as an arrow over X induces a functor CostructuredArrow F X ⥤ Over X.

Equations

• CategoryTheory.CostructuredArrow.toOver F X = CategoryTheory.CostructuredArrow.pre F (CategoryTheory.Functor.id T) X

@[simp]

theorem CategoryTheory.CostructuredArrow.toOver_map_left {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor D T) (X : T) {X✝ Y✝ : CategoryTheory.Comma (F.comp (CategoryTheory.Functor.id T)) (CategoryTheory.Functor.fromPUnit X)} (f : X✝ ⟶ Y✝) : ((CategoryTheory.CostructuredArrow.toOver F X).map f).left = F.map f.left

@[simp]

theorem CategoryTheory.CostructuredArrow.toOver_map_right {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor D T) (X : T) {X✝ Y✝ : CategoryTheory.Comma (F.comp (CategoryTheory.Functor.id T)) (CategoryTheory.Functor.fromPUnit X)} (f : X✝ ⟶ Y✝) : ((CategoryTheory.CostructuredArrow.toOver F X).map f).right = CategoryTheory.CategoryStruct.id X✝.right

@[simp]

theorem CategoryTheory.CostructuredArrow.toOver_obj_right {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor D T) (X : T) (X✝ : CategoryTheory.Comma (F.comp (CategoryTheory.Functor.id T)) (CategoryTheory.Functor.fromPUnit X)) : ((CategoryTheory.CostructuredArrow.toOver F X).obj X✝).right = X✝.right

@[simp]

theorem CategoryTheory.CostructuredArrow.toOver_obj_left {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor D T) (X : T) (X✝ : CategoryTheory.Comma (F.comp (CategoryTheory.Functor.id T)) (CategoryTheory.Functor.fromPUnit X)) : ((CategoryTheory.CostructuredArrow.toOver F X).obj X✝).left = F.obj X✝.left

@[simp]

theorem CategoryTheory.CostructuredArrow.toOver_obj_hom {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor D T) (X : T) (X✝ : CategoryTheory.Comma (F.comp (CategoryTheory.Functor.id T)) (CategoryTheory.Functor.fromPUnit X)) : ((CategoryTheory.CostructuredArrow.toOver F X).obj X✝).hom = X✝.hom

instance CategoryTheory.CostructuredArrow.instFaithfulOverToOver {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor D T) (X : T) [F.Faithful] : (CategoryTheory.CostructuredArrow.toOver F X).Faithful

Equations

• ⋯ = ⋯

instance CategoryTheory.CostructuredArrow.instFullOverToOver {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor D T) (X : T) [F.Full] : (CategoryTheory.CostructuredArrow.toOver F X).Full

Equations

• ⋯ = ⋯

instance CategoryTheory.CostructuredArrow.instEssSurjOverToOver {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor D T) (X : T) [F.EssSurj] : (CategoryTheory.CostructuredArrow.toOver F X).EssSurj

Equations

• ⋯ = ⋯

instance CategoryTheory.CostructuredArrow.isEquivalence_toOver {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor D T) (X : T) [F.IsEquivalence] : (CategoryTheory.CostructuredArrow.toOver F X).IsEquivalence

An equivalence F induces an equivalence CostructuredArrow F X ≌ Over X.

Equations

• ⋯ = ⋯

def CategoryTheory.Under {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T) : Type (max u₁ v₁)

The under category has as objects arrows with domain X and as morphisms commutative triangles.

Equations

• CategoryTheory.Under X = CategoryTheory.StructuredArrow X (CategoryTheory.Functor.id T)

instance CategoryTheory.instCategoryUnder {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T) : CategoryTheory.Category.{v₁, max u₁ v₁} (CategoryTheory.Under X)

Equations

• CategoryTheory.instCategoryUnder X = CategoryTheory.commaCategory

instance CategoryTheory.Under.inhabited {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] [Inhabited T] : Inhabited (CategoryTheory.Under default)

Equations

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

theorem CategoryTheory.Under.UnderMorphism.ext {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {U V : CategoryTheory.Under X} {f g : U ⟶ V} (h : f.right = g.right) : f = g

@[simp]

theorem CategoryTheory.Under.under_left {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} (U : CategoryTheory.Under X) : U.left = { as := PUnit.unit }

@[simp]

theorem CategoryTheory.Under.id_right {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} (U : CategoryTheory.Under X) : (CategoryTheory.CategoryStruct.id U).right = CategoryTheory.CategoryStruct.id U.right

@[simp]

theorem CategoryTheory.Under.comp_right {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} (a b c : CategoryTheory.Under X) (f : a ⟶ b) (g : b ⟶ c) : (CategoryTheory.CategoryStruct.comp f g).right = CategoryTheory.CategoryStruct.comp f.right g.right

@[simp]

theorem CategoryTheory.Under.w {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {A B : CategoryTheory.Under X} (f : A ⟶ B) : CategoryTheory.CategoryStruct.comp A.hom f.right = B.hom

@[simp]

theorem CategoryTheory.Under.w_assoc {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {A B : CategoryTheory.Under X} (f : A ⟶ B) {Z : T} (h : B.right ⟶ Z) : CategoryTheory.CategoryStruct.comp A.hom (CategoryTheory.CategoryStruct.comp f.right h) = CategoryTheory.CategoryStruct.comp B.hom h

def CategoryTheory.Under.mk {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X Y : T} (f : X ⟶ Y) : CategoryTheory.Under X

To give an object in the under category, it suffices to give an arrow with domain X.

Equations

• CategoryTheory.Under.mk f = CategoryTheory.StructuredArrow.mk f

@[simp]

theorem CategoryTheory.Under.mk_hom {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X Y : T} (f : X ⟶ Y) : (CategoryTheory.Under.mk f).hom = f

@[simp]

theorem CategoryTheory.Under.mk_right {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X Y : T} (f : X ⟶ Y) : (CategoryTheory.Under.mk f).right = Y

def CategoryTheory.Under.homMk {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {U V : CategoryTheory.Under X} (f : U.right ⟶ V.right) (w : CategoryTheory.CategoryStruct.comp U.hom f = V.hom := by aesop_cat) : U ⟶ V

To give a morphism in the under category, it suffices to give a morphism fitting in a commutative triangle.

Equations

• CategoryTheory.Under.homMk f w = CategoryTheory.StructuredArrow.homMk f w

@[simp]

theorem CategoryTheory.Under.homMk_right {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {U V : CategoryTheory.Under X} (f : U.right ⟶ V.right) (w : CategoryTheory.CategoryStruct.comp U.hom f = V.hom := by aesop_cat) : (CategoryTheory.Under.homMk f w).right = f

@[simp]

theorem CategoryTheory.Under.homMk_left_down_down {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {U V : CategoryTheory.Under X} (f : U.right ⟶ V.right) (w : CategoryTheory.CategoryStruct.comp U.hom f = V.hom := by aesop_cat) : ⋯ = ⋯

def CategoryTheory.Under.isoMk {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {f g : CategoryTheory.Under X} (hr : f.right ≅ g.right) (hw : CategoryTheory.CategoryStruct.comp f.hom hr.hom = g.hom := by aesop_cat) : f ≅ g

Construct an isomorphism in the over category given isomorphisms of the objects whose forward direction gives a commutative triangle.

Equations

• CategoryTheory.Under.isoMk hr hw = CategoryTheory.StructuredArrow.isoMk hr hw

@[simp]

theorem CategoryTheory.Under.isoMk_hom_right {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {f g : CategoryTheory.Under X} (hr : f.right ≅ g.right) (hw : CategoryTheory.CategoryStruct.comp f.hom hr.hom = g.hom) : (CategoryTheory.Under.isoMk hr hw).hom.right = hr.hom

@[simp]

theorem CategoryTheory.Under.isoMk_inv_right {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {f g : CategoryTheory.Under X} (hr : f.right ≅ g.right) (hw : CategoryTheory.CategoryStruct.comp f.hom hr.hom = g.hom) : (CategoryTheory.Under.isoMk hr hw).inv.right = hr.inv

@[simp]

theorem CategoryTheory.Under.hom_right_inv_right {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {f g : CategoryTheory.Under X} (e : f ≅ g) : CategoryTheory.CategoryStruct.comp e.hom.right e.inv.right = CategoryTheory.CategoryStruct.id f.right

@[simp]

theorem CategoryTheory.Under.hom_right_inv_right_assoc {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {f g : CategoryTheory.Under X} (e : f ≅ g) {Z : T} (h : f.right ⟶ Z) : CategoryTheory.CategoryStruct.comp e.hom.right (CategoryTheory.CategoryStruct.comp e.inv.right h) = h

@[simp]

theorem CategoryTheory.Under.inv_right_hom_right {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {f g : CategoryTheory.Under X} (e : f ≅ g) : CategoryTheory.CategoryStruct.comp e.inv.right e.hom.right = CategoryTheory.CategoryStruct.id g.right

@[simp]

theorem CategoryTheory.Under.inv_right_hom_right_assoc {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {f g : CategoryTheory.Under X} (e : f ≅ g) {Z : T} (h : g.right ⟶ Z) : CategoryTheory.CategoryStruct.comp e.inv.right (CategoryTheory.CategoryStruct.comp e.hom.right h) = h

def CategoryTheory.Under.forget {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T) : CategoryTheory.Functor (CategoryTheory.Under X) T

The forgetful functor mapping an arrow to its domain.

Equations

• CategoryTheory.Under.forget X = CategoryTheory.Comma.snd (CategoryTheory.Functor.fromPUnit X) (CategoryTheory.Functor.id T)

@[simp]

theorem CategoryTheory.Under.forget_obj {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {U : CategoryTheory.Under X} : (CategoryTheory.Under.forget X).obj U = U.right

@[simp]

theorem CategoryTheory.Under.forget_map {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {U V : CategoryTheory.Under X} {f : U ⟶ V} : (CategoryTheory.Under.forget X).map f = f.right

def CategoryTheory.Under.forgetCone {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T) : CategoryTheory.Limits.Cone (CategoryTheory.Under.forget X)

The natural cone over the forgetful functor Under X ⥤ T with cone point X.

Equations

• CategoryTheory.Under.forgetCone X = { pt := X, π := { app := CategoryTheory.Comma.hom, naturality := ⋯ } }

@[simp]

theorem CategoryTheory.Under.forgetCone_pt {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T) : (CategoryTheory.Under.forgetCone X).pt = X

@[simp]

theorem CategoryTheory.Under.forgetCone_π_app {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T) (self : CategoryTheory.Comma (CategoryTheory.Functor.fromPUnit X) (CategoryTheory.Functor.id T)) : (CategoryTheory.Under.forgetCone X).π.app self = self.hom

def CategoryTheory.Under.map {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X Y : T} (f : X ⟶ Y) : CategoryTheory.Functor (CategoryTheory.Under Y) (CategoryTheory.Under X)

A morphism X ⟶ Y induces a functor Under Y ⥤ Under X in the obvious way.

Equations

• CategoryTheory.Under.map f = CategoryTheory.Comma.mapLeft (CategoryTheory.Functor.id T) (CategoryTheory.Discrete.natTrans fun (x : CategoryTheory.Discrete PUnit.{1}) => f)

@[simp]

theorem CategoryTheory.Under.map_obj_right {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X Y : T} {f : X ⟶ Y} {U : CategoryTheory.Under Y} : ((CategoryTheory.Under.map f).obj U).right = U.right

@[simp]

theorem CategoryTheory.Under.map_obj_hom {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X Y : T} {f : X ⟶ Y} {U : CategoryTheory.Under Y} : ((CategoryTheory.Under.map f).obj U).hom = CategoryTheory.CategoryStruct.comp f U.hom

@[simp]

theorem CategoryTheory.Under.map_map_right {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X Y : T} {f : X ⟶ Y} {U V : CategoryTheory.Under Y} {g : U ⟶ V} : ((CategoryTheory.Under.map f).map g).right = g.right

def CategoryTheory.Under.mapIso {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X Y : T} (f : X ≅ Y) : CategoryTheory.Under Y ≌ CategoryTheory.Under X

If f is an isomorphism, map f is an equivalence of categories.

Equations

• CategoryTheory.Under.mapIso f = CategoryTheory.Comma.mapLeftIso (CategoryTheory.Functor.id T) (CategoryTheory.Discrete.natIso fun (x : CategoryTheory.Discrete PUnit.{1}) => f.symm)

@[simp]

theorem CategoryTheory.Under.mapIso_functor {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X Y : T} (f : X ≅ Y) : (CategoryTheory.Under.mapIso f).functor = CategoryTheory.Under.map f.hom

@[simp]

theorem CategoryTheory.Under.mapIso_inverse {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X Y : T} (f : X ≅ Y) : (CategoryTheory.Under.mapIso f).inverse = CategoryTheory.Under.map f.inv

This section proves various equalities between functors that demonstrate, for instance, that under categories assemble into a functor mapFunctor : Tᵒᵖ ⥤ Cat.

theorem CategoryTheory.Under.mapId_eq {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (Y : T) : CategoryTheory.Under.map (CategoryTheory.CategoryStruct.id Y) = CategoryTheory.Functor.id (CategoryTheory.Under Y)

Mapping by the identity morphism is just the identity functor.

def CategoryTheory.Under.mapId {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (Y : T) : CategoryTheory.Under.map (CategoryTheory.CategoryStruct.id Y) ≅ CategoryTheory.Functor.id (CategoryTheory.Under Y)

Mapping by the identity morphism is just the identity functor.

Equations

• CategoryTheory.Under.mapId Y = CategoryTheory.eqToIso ⋯

@[simp]

theorem CategoryTheory.Under.mapId_hom {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (Y : T) : (CategoryTheory.Under.mapId Y).hom = CategoryTheory.eqToHom ⋯

@[simp]

theorem CategoryTheory.Under.mapId_inv {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (Y : T) : (CategoryTheory.Under.mapId Y).inv = CategoryTheory.eqToHom ⋯

theorem CategoryTheory.Under.mapForget_eq {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X Y : T} (f : X ⟶ Y) : (CategoryTheory.Under.map f).comp (CategoryTheory.Under.forget X) = CategoryTheory.Under.forget Y

Mapping by f and then forgetting is the same as forgetting.

def CategoryTheory.Under.mapForget {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X Y : T} (f : X ⟶ Y) : (CategoryTheory.Under.map f).comp (CategoryTheory.Under.forget X) ≅ CategoryTheory.Under.forget Y

The natural isomorphism arising from mapForget_eq.

Equations

• CategoryTheory.Under.mapForget f = CategoryTheory.eqToIso ⋯

@[simp]

theorem CategoryTheory.Under.eqToHom_right {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {U V : CategoryTheory.Under X} (e : U = V) : (CategoryTheory.eqToHom e).right = CategoryTheory.eqToHom ⋯

theorem CategoryTheory.Under.mapComp_eq {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X Y Z : T} (f : X ⟶ Y) (g : Y ⟶ Z) : CategoryTheory.Under.map (CategoryTheory.CategoryStruct.comp f g) = (CategoryTheory.Under.map g).comp (CategoryTheory.Under.map f)

Mapping by the composite morphism f ≫ g is the same as mapping by f then by g.

def CategoryTheory.Under.mapComp {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X Y Z : T} (f : X ⟶ Y) (g : Y ⟶ Z) : CategoryTheory.Under.map (CategoryTheory.CategoryStruct.comp f g) ≅ (CategoryTheory.Under.map g).comp (CategoryTheory.Under.map f)

The natural isomorphism arising from mapComp_eq.

Equations

• CategoryTheory.Under.mapComp f g = CategoryTheory.eqToIso ⋯

@[simp]

theorem CategoryTheory.Under.mapComp_inv {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X Y Z : T} (f : X ⟶ Y) (g : Y ⟶ Z) : (CategoryTheory.Under.mapComp f g).inv = CategoryTheory.eqToHom ⋯

@[simp]

theorem CategoryTheory.Under.mapComp_hom {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X Y Z : T} (f : X ⟶ Y) (g : Y ⟶ Z) : (CategoryTheory.Under.mapComp f g).hom = CategoryTheory.eqToHom ⋯

def CategoryTheory.Under.mapCongr {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X Y : T} (f g : X ⟶ Y) (h : f = g) : CategoryTheory.Under.map f ≅ CategoryTheory.Under.map g

If f = g, then map f is naturally isomorphic to map g.

Equations

• CategoryTheory.Under.mapCongr f g h = CategoryTheory.NatIso.ofComponents (fun (A : CategoryTheory.Under Y) => CategoryTheory.eqToIso ⋯) ⋯

@[simp]

theorem CategoryTheory.Under.mapCongr_hom_app {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X Y : T} (f g : X ⟶ Y) (h : f = g) (X✝ : CategoryTheory.Under Y) : (CategoryTheory.Under.mapCongr f g h).hom.app X✝ = CategoryTheory.eqToHom ⋯

@[simp]

theorem CategoryTheory.Under.mapCongr_inv_app {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X Y : T} (f g : X ⟶ Y) (h : f = g) (X✝ : CategoryTheory.Under Y) : (CategoryTheory.Under.mapCongr f g h).inv.app X✝ = CategoryTheory.eqToHom ⋯

def CategoryTheory.Under.mapFunctor (T : Type u₁) [CategoryTheory.Category.{v₁, u₁} T] : CategoryTheory.Functor Tᵒᵖ CategoryTheory.Cat

The functor defined by the under categories.

Equations

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

@[simp]

theorem CategoryTheory.Under.mapFunctor_obj (T : Type u₁) [CategoryTheory.Category.{v₁, u₁} T] (X : Tᵒᵖ) : (CategoryTheory.Under.mapFunctor T).obj X = CategoryTheory.Cat.of (CategoryTheory.Under (Opposite.unop X))

@[simp]

theorem CategoryTheory.Under.mapFunctor_map (T : Type u₁) [CategoryTheory.Category.{v₁, u₁} T] {X✝ Y✝ : Tᵒᵖ} (f : X✝ ⟶ Y✝) : (CategoryTheory.Under.mapFunctor T).map f = CategoryTheory.Under.map f.unop

instance CategoryTheory.Under.forget_reflects_iso {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} : (CategoryTheory.Under.forget X).ReflectsIsomorphisms

Equations

• ⋯ = ⋯

noncomputable def CategoryTheory.Under.mkIdInitial {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} : CategoryTheory.Limits.IsInitial (CategoryTheory.Under.mk (CategoryTheory.CategoryStruct.id X))

The identity under X is initial.

Equations

• CategoryTheory.Under.mkIdInitial = CategoryTheory.StructuredArrow.mkIdInitial

instance CategoryTheory.Under.forget_faithful {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} : (CategoryTheory.Under.forget X).Faithful

Equations

• ⋯ = ⋯

theorem CategoryTheory.Under.mono_of_mono_right {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {f g : CategoryTheory.Under X} (k : f ⟶ g) [hk : CategoryTheory.Mono k.right] : CategoryTheory.Mono k

If k.right is a monomorphism, then k is a monomorphism. In other words, Under.forget X reflects epimorphisms. The converse does not hold without additional assumptions on the underlying category, see CategoryTheory.Under.mono_right_of_mono.

theorem CategoryTheory.Under.epi_of_epi_right {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {f g : CategoryTheory.Under X} (k : f ⟶ g) [hk : CategoryTheory.Epi k.right] : CategoryTheory.Epi k

If k.right is an epimorphism, then k is an epimorphism. In other words, Under.forget X reflects epimorphisms. The converse of CategoryTheory.Under.epi_right_of_epi.

This lemma is not an instance, to avoid loops in type class inference.

instance CategoryTheory.Under.epi_right_of_epi {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {f g : CategoryTheory.Under X} (k : f ⟶ g) [CategoryTheory.Epi k] : CategoryTheory.Epi k.right

If k is an epimorphism, then k.right is an epimorphism. In other words, Under.forget X preserves epimorphisms. The converse of CategoryTheory.under.epi_of_epi_right.

Equations

• ⋯ = ⋯

def CategoryTheory.Under.post {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X : T} (F : CategoryTheory.Functor T D) : CategoryTheory.Functor (CategoryTheory.Under X) (CategoryTheory.Under (F.obj X))

A functor F : T ⥤ D induces a functor Under X ⥤ Under (F.obj X) in the obvious way.

Equations

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

@[simp]

theorem CategoryTheory.Under.post_map {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X : T} (F : CategoryTheory.Functor T D) {X✝ Y✝ : CategoryTheory.Under X} (f : X✝ ⟶ Y✝) : (CategoryTheory.Under.post F).map f = CategoryTheory.Under.homMk (F.map f.right) ⋯

@[simp]

theorem CategoryTheory.Under.post_obj {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X : T} (F : CategoryTheory.Functor T D) (Y : CategoryTheory.Under X) : (CategoryTheory.Under.post F).obj Y = CategoryTheory.Under.mk (F.map Y.hom)

theorem CategoryTheory.Under.post_comp {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X : T} {E : Type u_1} [CategoryTheory.Category.{u_2, u_1} E] (F : CategoryTheory.Functor T D) (G : CategoryTheory.Functor D E) : CategoryTheory.Under.post (F.comp G) = (CategoryTheory.Under.post F).comp (CategoryTheory.Under.post G)

def CategoryTheory.Under.postComp {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X : T} {E : Type u_1} [CategoryTheory.Category.{u_2, u_1} E] (F : CategoryTheory.Functor T D) (G : CategoryTheory.Functor D E) : CategoryTheory.Under.post (F.comp G) ≅ (CategoryTheory.Under.post F).comp (CategoryTheory.Under.post G)

post (F ⋙ G) is isomorphic (actually equal) to post F ⋙ post G.

Equations

• CategoryTheory.Under.postComp F G = CategoryTheory.NatIso.ofComponents (fun (X_1 : CategoryTheory.Under X) => CategoryTheory.Iso.refl ((CategoryTheory.Under.post (F.comp G)).obj X_1)) ⋯

@[simp]

theorem CategoryTheory.Under.postComp_inv_app_right {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X : T} {E : Type u_1} [CategoryTheory.Category.{u_2, u_1} E] (F : CategoryTheory.Functor T D) (G : CategoryTheory.Functor D E) (X✝ : CategoryTheory.Under X) : ((CategoryTheory.Under.postComp F G).inv.app X✝).right = CategoryTheory.CategoryStruct.id (G.obj (F.obj X✝.right))

@[simp]

theorem CategoryTheory.Under.postComp_hom_app_right {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X : T} {E : Type u_1} [CategoryTheory.Category.{u_2, u_1} E] (F : CategoryTheory.Functor T D) (G : CategoryTheory.Functor D E) (X✝ : CategoryTheory.Under X) : ((CategoryTheory.Under.postComp F G).hom.app X✝).right = CategoryTheory.CategoryStruct.id (G.obj (F.obj X✝.right))

@[simp]

theorem CategoryTheory.Under.postComp_hom_app_left_down_down {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X : T} {E : Type u_1} [CategoryTheory.Category.{u_2, u_1} E] (F : CategoryTheory.Functor T D) (G : CategoryTheory.Functor D E) (X✝ : CategoryTheory.Under X) : ⋯ = ⋯

@[simp]

theorem CategoryTheory.Under.postComp_inv_app_left_down_down {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X : T} {E : Type u_1} [CategoryTheory.Category.{u_2, u_1} E] (F : CategoryTheory.Functor T D) (G : CategoryTheory.Functor D E) (X✝ : CategoryTheory.Under X) : ⋯ = ⋯

def CategoryTheory.Under.postMap {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X : T} {F G : CategoryTheory.Functor T D} (e : F ⟶ G) : CategoryTheory.Under.post F ⟶ (CategoryTheory.Under.post G).comp (CategoryTheory.Under.map (e.app X))

A natural transformation F ⟶ G induces a natural transformation on Under X up to Under.map.

Equations

• CategoryTheory.Under.postMap e = { app := fun (Y : CategoryTheory.Under X) => CategoryTheory.Under.homMk (e.app Y.right) ⋯, naturality := ⋯ }

@[simp]

theorem CategoryTheory.Under.postMap_app {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X : T} {F G : CategoryTheory.Functor T D} (e : F ⟶ G) (Y : CategoryTheory.Under X) : (CategoryTheory.Under.postMap e).app Y = CategoryTheory.Under.homMk (e.app Y.right) ⋯

def CategoryTheory.Under.postCongr {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X : T} {F G : CategoryTheory.Functor T D} (e : F ≅ G) : CategoryTheory.Under.post F ≅ (CategoryTheory.Under.post G).comp (CategoryTheory.Under.map (e.hom.app X))

If F and G are naturally isomorphic, then Under.post F and Under.post G are also naturally isomorphic up to Under.map

Equations

• CategoryTheory.Under.postCongr e = CategoryTheory.NatIso.ofComponents (fun (A : CategoryTheory.Under X) => CategoryTheory.Under.isoMk (e.app A.right) ⋯) ⋯

@[simp]

theorem CategoryTheory.Under.postCongr_hom_app_left_down_down {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X : T} {F G : CategoryTheory.Functor T D} (e : F ≅ G) (X✝ : CategoryTheory.Under X) : ⋯ = ⋯

@[simp]

theorem CategoryTheory.Under.postCongr_hom_app_right {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X : T} {F G : CategoryTheory.Functor T D} (e : F ≅ G) (X✝ : CategoryTheory.Under X) : ((CategoryTheory.Under.postCongr e).hom.app X✝).right = e.hom.app X✝.right

@[simp]

theorem CategoryTheory.Under.postCongr_inv_app_right {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X : T} {F G : CategoryTheory.Functor T D} (e : F ≅ G) (X✝ : CategoryTheory.Under X) : ((CategoryTheory.Under.postCongr e).inv.app X✝).right = e.inv.app X✝.right

@[simp]

theorem CategoryTheory.Under.postCongr_inv_app_left_down_down {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X : T} {F G : CategoryTheory.Functor T D} (e : F ≅ G) (X✝ : CategoryTheory.Under X) : ⋯ = ⋯

instance CategoryTheory.Under.instFaithfulObjPost {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (X : T) (F : CategoryTheory.Functor T D) [F.Faithful] : (CategoryTheory.Under.post F).Faithful

Equations

• ⋯ = ⋯

instance CategoryTheory.Under.instFullObjPostOfFaithful {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (X : T) (F : CategoryTheory.Functor T D) [F.Faithful] [F.Full] : (CategoryTheory.Under.post F).Full

Equations

• ⋯ = ⋯

instance CategoryTheory.Under.instEssSurjObjPostOfFull {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (X : T) (F : CategoryTheory.Functor T D) [F.Full] [F.EssSurj] : (CategoryTheory.Under.post F).EssSurj

Equations

• ⋯ = ⋯

instance CategoryTheory.Under.instIsEquivalenceObjPost {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (X : T) (F : CategoryTheory.Functor T D) [F.IsEquivalence] : (CategoryTheory.Under.post F).IsEquivalence

Equations

• ⋯ = ⋯

def CategoryTheory.Under.postEquiv {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (X : T) (F : T ≌ D) : CategoryTheory.Under X ≌ CategoryTheory.Under (F.functor.obj X)

An equivalence of categories induces an equivalence on under categories.

Equations

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

@[simp]

theorem CategoryTheory.Under.postEquiv_counitIso {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (X : T) (F : T ≌ D) : (CategoryTheory.Under.postEquiv X F).counitIso = CategoryTheory.NatIso.ofComponents (fun (A : CategoryTheory.Under (F.functor.obj X)) => CategoryTheory.Under.isoMk (F.counitIso.app A.right) ⋯) ⋯

@[simp]

theorem CategoryTheory.Under.postEquiv_unitIso {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (X : T) (F : T ≌ D) : (CategoryTheory.Under.postEquiv X F).unitIso = CategoryTheory.NatIso.ofComponents (fun (A : CategoryTheory.Under X) => CategoryTheory.Under.isoMk (F.unitIso.app A.right) ⋯) ⋯

@[simp]

theorem CategoryTheory.Under.postEquiv_inverse {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (X : T) (F : T ≌ D) : (CategoryTheory.Under.postEquiv X F).inverse = (CategoryTheory.Under.post F.inverse).comp (CategoryTheory.Under.map (F.unitIso.hom.app X))

@[simp]

theorem CategoryTheory.Under.postEquiv_functor {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (X : T) (F : T ≌ D) : (CategoryTheory.Under.postEquiv X F).functor = CategoryTheory.Under.post F.functor

def CategoryTheory.StructuredArrow.toUnder {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (X : T) (F : CategoryTheory.Functor D T) : CategoryTheory.Functor (CategoryTheory.StructuredArrow X F) (CategoryTheory.Under X)

Reinterpreting an F-structured arrow X ⟶ F.obj d as an arrow under X induces a functor StructuredArrow X F ⥤ Under X.

Equations

• CategoryTheory.StructuredArrow.toUnder X F = CategoryTheory.StructuredArrow.pre X F (CategoryTheory.Functor.id T)

@[simp]

theorem CategoryTheory.StructuredArrow.toUnder_map_right {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (X : T) (F : CategoryTheory.Functor D T) {X✝ Y✝ : CategoryTheory.Comma (CategoryTheory.Functor.fromPUnit X) (F.comp (CategoryTheory.Functor.id T))} (f : X✝ ⟶ Y✝) : ((CategoryTheory.StructuredArrow.toUnder X F).map f).right = F.map f.right

@[simp]

theorem CategoryTheory.StructuredArrow.toUnder_obj_left {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (X : T) (F : CategoryTheory.Functor D T) (X✝ : CategoryTheory.Comma (CategoryTheory.Functor.fromPUnit X) (F.comp (CategoryTheory.Functor.id T))) : ((CategoryTheory.StructuredArrow.toUnder X F).obj X✝).left = X✝.left

@[simp]

theorem CategoryTheory.StructuredArrow.toUnder_obj_right {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (X : T) (F : CategoryTheory.Functor D T) (X✝ : CategoryTheory.Comma (CategoryTheory.Functor.fromPUnit X) (F.comp (CategoryTheory.Functor.id T))) : ((CategoryTheory.StructuredArrow.toUnder X F).obj X✝).right = F.obj X✝.right

@[simp]

theorem CategoryTheory.StructuredArrow.toUnder_map_left {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (X : T) (F : CategoryTheory.Functor D T) {X✝ Y✝ : CategoryTheory.Comma (CategoryTheory.Functor.fromPUnit X) (F.comp (CategoryTheory.Functor.id T))} (f : X✝ ⟶ Y✝) : ((CategoryTheory.StructuredArrow.toUnder X F).map f).left = CategoryTheory.CategoryStruct.id X✝.left

@[simp]

theorem CategoryTheory.StructuredArrow.toUnder_obj_hom {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (X : T) (F : CategoryTheory.Functor D T) (X✝ : CategoryTheory.Comma (CategoryTheory.Functor.fromPUnit X) (F.comp (CategoryTheory.Functor.id T))) : ((CategoryTheory.StructuredArrow.toUnder X F).obj X✝).hom = X✝.hom

instance CategoryTheory.StructuredArrow.instFaithfulUnderToUnder {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (X : T) (F : CategoryTheory.Functor D T) [F.Faithful] : (CategoryTheory.StructuredArrow.toUnder X F).Faithful

Equations

• ⋯ = ⋯

instance CategoryTheory.StructuredArrow.instFullUnderToUnder {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (X : T) (F : CategoryTheory.Functor D T) [F.Full] : (CategoryTheory.StructuredArrow.toUnder X F).Full

Equations

• ⋯ = ⋯

instance CategoryTheory.StructuredArrow.instEssSurjUnderToUnder {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (X : T) (F : CategoryTheory.Functor D T) [F.EssSurj] : (CategoryTheory.StructuredArrow.toUnder X F).EssSurj

Equations

• ⋯ = ⋯

instance CategoryTheory.StructuredArrow.isEquivalence_toUnder {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (X : T) (F : CategoryTheory.Functor D T) [F.IsEquivalence] : (CategoryTheory.StructuredArrow.toUnder X F).IsEquivalence

An equivalence F induces an equivalence StructuredArrow X F ≌ Under X.

Equations

• ⋯ = ⋯

def CategoryTheory.Functor.toOver {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {S : Type u₂} [CategoryTheory.Category.{v₂, u₂} S] (F : CategoryTheory.Functor S T) (X : T) (f : (Y : S) → F.obj Y ⟶ X) (h : ∀ {Y Z : S} (g : Y ⟶ Z), CategoryTheory.CategoryStruct.comp (F.map g) (f Z) = f Y) : CategoryTheory.Functor S (CategoryTheory.Over X)

Given X : T, to upgrade a functor F : S ⥤ T to a functor S ⥤ Over X, it suffices to provide maps F.obj Y ⟶ X for all Y making the obvious triangles involving all F.map g commute.

Equations

• F.toOver X f h = F.toCostructuredArrow (CategoryTheory.Functor.id T) X f ⋯

@[simp]

theorem CategoryTheory.Functor.toOver_obj_left {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {S : Type u₂} [CategoryTheory.Category.{v₂, u₂} S] (F : CategoryTheory.Functor S T) (X : T) (f : (Y : S) → F.obj Y ⟶ X) (h : ∀ {Y Z : S} (g : Y ⟶ Z), CategoryTheory.CategoryStruct.comp (F.map g) (f Z) = f Y) (Y : S) : ((F.toOver X f h).obj Y).left = F.obj Y

@[simp]

theorem CategoryTheory.Functor.toOver_map_left {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {S : Type u₂} [CategoryTheory.Category.{v₂, u₂} S] (F : CategoryTheory.Functor S T) (X : T) (f : (Y : S) → F.obj Y ⟶ X) (h : ∀ {Y Z : S} (g : Y ⟶ Z), CategoryTheory.CategoryStruct.comp (F.map g) (f Z) = f Y) {X✝ Y✝ : S} (g : X✝ ⟶ Y✝) : ((F.toOver X f h).map g).left = F.map g

def CategoryTheory.Functor.toOverCompForget {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {S : Type u₂} [CategoryTheory.Category.{v₂, u₂} S] (F : CategoryTheory.Functor S T) (X : T) (f : (Y : S) → F.obj Y ⟶ X) (h : ∀ {Y Z : S} (g : Y ⟶ Z), CategoryTheory.CategoryStruct.comp (F.map g) (f Z) = f Y) : (F.toOver X f ⋯).comp (CategoryTheory.Over.forget X) ≅ F

Upgrading a functor S ⥤ T to a functor S ⥤ Over X and composing with the forgetful functor Over X ⥤ T recovers the original functor.

Equations

• F.toOverCompForget X f h = CategoryTheory.Iso.refl ((F.toOver X f ⋯).comp (CategoryTheory.Over.forget X))

@[simp]

theorem CategoryTheory.Functor.toOver_comp_forget {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {S : Type u₂} [CategoryTheory.Category.{v₂, u₂} S] (F : CategoryTheory.Functor S T) (X : T) (f : (Y : S) → F.obj Y ⟶ X) (h : ∀ {Y Z : S} (g : Y ⟶ Z), CategoryTheory.CategoryStruct.comp (F.map g) (f Z) = f Y) : (F.toOver X f ⋯).comp (CategoryTheory.Over.forget X) = F

def CategoryTheory.Functor.toUnder {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {S : Type u₂} [CategoryTheory.Category.{v₂, u₂} S] (F : CategoryTheory.Functor S T) (X : T) (f : (Y : S) → X ⟶ F.obj Y) (h : ∀ {Y Z : S} (g : Y ⟶ Z), CategoryTheory.CategoryStruct.comp (f Y) (F.map g) = f Z) : CategoryTheory.Functor S (CategoryTheory.Under X)

Given X : T, to upgrade a functor F : S ⥤ T to a functor S ⥤ Under X, it suffices to provide maps X ⟶ F.obj Y for all Y making the obvious triangles involving all F.map g commute.

Equations

• F.toUnder X f h = F.toStructuredArrow X (CategoryTheory.Functor.id T) f ⋯

@[simp]

theorem CategoryTheory.Functor.toUnder_map_right {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {S : Type u₂} [CategoryTheory.Category.{v₂, u₂} S] (F : CategoryTheory.Functor S T) (X : T) (f : (Y : S) → X ⟶ F.obj Y) (h : ∀ {Y Z : S} (g : Y ⟶ Z), CategoryTheory.CategoryStruct.comp (f Y) (F.map g) = f Z) {X✝ Y✝ : S} (g : X✝ ⟶ Y✝) : ((F.toUnder X f h).map g).right = F.map g

@[simp]

theorem CategoryTheory.Functor.toUnder_obj_right {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {S : Type u₂} [CategoryTheory.Category.{v₂, u₂} S] (F : CategoryTheory.Functor S T) (X : T) (f : (Y : S) → X ⟶ F.obj Y) (h : ∀ {Y Z : S} (g : Y ⟶ Z), CategoryTheory.CategoryStruct.comp (f Y) (F.map g) = f Z) (Y : S) : ((F.toUnder X f h).obj Y).right = F.obj Y

def CategoryTheory.Functor.toUnderCompForget {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {S : Type u₂} [CategoryTheory.Category.{v₂, u₂} S] (F : CategoryTheory.Functor S T) (X : T) (f : (Y : S) → X ⟶ F.obj Y) (h : ∀ {Y Z : S} (g : Y ⟶ Z), CategoryTheory.CategoryStruct.comp (f Y) (F.map g) = f Z) : (F.toUnder X f ⋯).comp (CategoryTheory.Under.forget X) ≅ F

Upgrading a functor S ⥤ T to a functor S ⥤ Under X and composing with the forgetful functor Under X ⥤ T recovers the original functor.

Equations

• F.toUnderCompForget X f h = CategoryTheory.Iso.refl ((F.toUnder X f ⋯).comp (CategoryTheory.Under.forget X))

@[simp]

theorem CategoryTheory.Functor.toUnder_comp_forget {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {S : Type u₂} [CategoryTheory.Category.{v₂, u₂} S] (F : CategoryTheory.Functor S T) (X : T) (f : (Y : S) → X ⟶ F.obj Y) (h : ∀ {Y Z : S} (g : Y ⟶ Z), CategoryTheory.CategoryStruct.comp (f Y) (F.map g) = f Z) : (F.toUnder X f ⋯).comp (CategoryTheory.Under.forget X) = F

def CategoryTheory.StructuredArrow.ofStructuredArrowProjEquivalence.functor {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor D T) (Y : T) (X : D) : CategoryTheory.Functor (CategoryTheory.StructuredArrow X (CategoryTheory.StructuredArrow.proj Y F)) (CategoryTheory.StructuredArrow Y ((CategoryTheory.Under.forget X).comp F))

A functor from the structured arrow category on the projection functor for any structured arrow category.

Equations

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

@[simp]

theorem CategoryTheory.StructuredArrow.ofStructuredArrowProjEquivalence.functor_obj_right_right {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor D T) (Y : T) (X : D) (Y✝ : CategoryTheory.StructuredArrow X (CategoryTheory.StructuredArrow.proj Y F)) : ((CategoryTheory.StructuredArrow.ofStructuredArrowProjEquivalence.functor F Y X).obj Y✝).right.right = Y✝.right.right

@[simp]

theorem CategoryTheory.StructuredArrow.ofStructuredArrowProjEquivalence.functor_obj_hom {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor D T) (Y : T) (X : D) (Y✝ : CategoryTheory.StructuredArrow X (CategoryTheory.StructuredArrow.proj Y F)) : ((CategoryTheory.StructuredArrow.ofStructuredArrowProjEquivalence.functor F Y X).obj Y✝).hom = Y✝.right.hom

@[simp]

theorem CategoryTheory.StructuredArrow.ofStructuredArrowProjEquivalence.functor_map_right_right {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor D T) (Y : T) (X : D) {X✝ Y✝ : CategoryTheory.StructuredArrow X (CategoryTheory.StructuredArrow.proj Y F)} (g : X✝ ⟶ Y✝) : ((CategoryTheory.StructuredArrow.ofStructuredArrowProjEquivalence.functor F Y X).map g).right.right = g.right.right

@[simp]

theorem CategoryTheory.StructuredArrow.ofStructuredArrowProjEquivalence.functor_obj_right_hom {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor D T) (Y : T) (X : D) (Y✝ : CategoryTheory.StructuredArrow X (CategoryTheory.StructuredArrow.proj Y F)) : ((CategoryTheory.StructuredArrow.ofStructuredArrowProjEquivalence.functor F Y X).obj Y✝).right.hom = Y✝.hom

@[simp]

theorem CategoryTheory.StructuredArrow.ofStructuredArrowProjEquivalence.functor_map_left_down_down {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor D T) (Y : T) (X : D) {X✝ Y✝ : CategoryTheory.StructuredArrow X (CategoryTheory.StructuredArrow.proj Y F)} (g : X✝ ⟶ Y✝) : ⋯ = ⋯

@[simp]

theorem CategoryTheory.StructuredArrow.ofStructuredArrowProjEquivalence.functor_obj_right_left_as {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor D T) (Y : T) (X : D) (Y✝ : CategoryTheory.StructuredArrow X (CategoryTheory.StructuredArrow.proj Y F)) : ((CategoryTheory.StructuredArrow.ofStructuredArrowProjEquivalence.functor F Y X).obj Y✝).right.left.as = PUnit.unit

@[simp]

theorem CategoryTheory.StructuredArrow.ofStructuredArrowProjEquivalence.functor_map_right_left_down_down {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor D T) (Y : T) (X : D) {X✝ Y✝ : CategoryTheory.StructuredArrow X (CategoryTheory.StructuredArrow.proj Y F)} (g : X✝ ⟶ Y✝) : ⋯ = ⋯

@[simp]

theorem CategoryTheory.StructuredArrow.ofStructuredArrowProjEquivalence.functor_obj_left_as {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor D T) (Y : T) (X : D) (Y✝ : CategoryTheory.StructuredArrow X (CategoryTheory.StructuredArrow.proj Y F)) : ((CategoryTheory.StructuredArrow.ofStructuredArrowProjEquivalence.functor F Y X).obj Y✝).left.as = PUnit.unit

def CategoryTheory.StructuredArrow.ofStructuredArrowProjEquivalence.inverse {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor D T) (Y : T) (X : D) : CategoryTheory.Functor (CategoryTheory.StructuredArrow Y ((CategoryTheory.Under.forget X).comp F)) (CategoryTheory.StructuredArrow X (CategoryTheory.StructuredArrow.proj Y F))

The inverse functor of ofStructuredArrowProjEquivalence.functor.

Equations

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

@[simp]

theorem CategoryTheory.StructuredArrow.ofStructuredArrowProjEquivalence.inverse_map_right_left_down_down {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor D T) (Y : T) (X : D) {X✝ Y✝ : CategoryTheory.StructuredArrow Y ((CategoryTheory.Under.forget X).comp F)} (g : X✝ ⟶ Y✝) : ⋯ = ⋯

@[simp]

theorem CategoryTheory.StructuredArrow.ofStructuredArrowProjEquivalence.inverse_obj_hom {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor D T) (Y : T) (X : D) (Y✝ : CategoryTheory.StructuredArrow Y ((CategoryTheory.Under.forget X).comp F)) : ((CategoryTheory.StructuredArrow.ofStructuredArrowProjEquivalence.inverse F Y X).obj Y✝).hom = Y✝.right.hom

@[simp]

theorem CategoryTheory.StructuredArrow.ofStructuredArrowProjEquivalence.inverse_obj_right_left_as {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor D T) (Y : T) (X : D) (Y✝ : CategoryTheory.StructuredArrow Y ((CategoryTheory.Under.forget X).comp F)) : ((CategoryTheory.StructuredArrow.ofStructuredArrowProjEquivalence.inverse F Y X).obj Y✝).right.left.as = PUnit.unit

@[simp]

theorem CategoryTheory.StructuredArrow.ofStructuredArrowProjEquivalence.inverse_obj_right_hom {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor D T) (Y : T) (X : D) (Y✝ : CategoryTheory.StructuredArrow Y ((CategoryTheory.Under.forget X).comp F)) : ((CategoryTheory.StructuredArrow.ofStructuredArrowProjEquivalence.inverse F Y X).obj Y✝).right.hom = Y✝.hom

@[simp]

theorem CategoryTheory.StructuredArrow.ofStructuredArrowProjEquivalence.inverse_map_right_right {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor D T) (Y : T) (X : D) {X✝ Y✝ : CategoryTheory.StructuredArrow Y ((CategoryTheory.Under.forget X).comp F)} (g : X✝ ⟶ Y✝) : ((CategoryTheory.StructuredArrow.ofStructuredArrowProjEquivalence.inverse F Y X).map g).right.right = g.right.right

@[simp]

theorem CategoryTheory.StructuredArrow.ofStructuredArrowProjEquivalence.inverse_map_left_down_down {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor D T) (Y : T) (X : D) {X✝ Y✝ : CategoryTheory.StructuredArrow Y ((CategoryTheory.Under.forget X).comp F)} (g : X✝ ⟶ Y✝) : ⋯ = ⋯

@[simp]

theorem CategoryTheory.StructuredArrow.ofStructuredArrowProjEquivalence.inverse_obj_right_right {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor D T) (Y : T) (X : D) (Y✝ : CategoryTheory.StructuredArrow Y ((CategoryTheory.Under.forget X).comp F)) : ((CategoryTheory.StructuredArrow.ofStructuredArrowProjEquivalence.inverse F Y X).obj Y✝).right.right = Y✝.right.right

@[simp]

theorem CategoryTheory.StructuredArrow.ofStructuredArrowProjEquivalence.inverse_obj_left_as {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor D T) (Y : T) (X : D) (Y✝ : CategoryTheory.StructuredArrow Y ((CategoryTheory.Under.forget X).comp F)) : ((CategoryTheory.StructuredArrow.ofStructuredArrowProjEquivalence.inverse F Y X).obj Y✝).left.as = PUnit.unit

def CategoryTheory.StructuredArrow.ofStructuredArrowProjEquivalence {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor D T) (Y : T) (X : D) : CategoryTheory.StructuredArrow X (CategoryTheory.StructuredArrow.proj Y F) ≌ CategoryTheory.StructuredArrow Y ((CategoryTheory.Under.forget X).comp F)

Characterization of the structured arrow category on the projection functor of any structured arrow category.

Equations

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

def CategoryTheory.StructuredArrow.ofDiagEquivalence.functor {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T × T) : CategoryTheory.Functor (CategoryTheory.StructuredArrow X (CategoryTheory.Functor.diag T)) (CategoryTheory.StructuredArrow X.2 (CategoryTheory.Under.forget X.1))

The canonical functor from the structured arrow category on the diagonal functor T ⥤ T × T to the structured arrow category on Under.forget.

Equations

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

@[simp]

theorem CategoryTheory.StructuredArrow.ofDiagEquivalence.functor_obj_hom {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T × T) (Y : CategoryTheory.StructuredArrow X (CategoryTheory.Functor.diag T)) : ((CategoryTheory.StructuredArrow.ofDiagEquivalence.functor X).obj Y).hom = Y.hom.2

@[simp]

theorem CategoryTheory.StructuredArrow.ofDiagEquivalence.functor_obj_right_hom {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T × T) (Y : CategoryTheory.StructuredArrow X (CategoryTheory.Functor.diag T)) : ((CategoryTheory.StructuredArrow.ofDiagEquivalence.functor X).obj Y).right.hom = Y.hom.1

@[simp]

theorem CategoryTheory.StructuredArrow.ofDiagEquivalence.functor_map_right_right {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T × T) {X✝ Y✝ : CategoryTheory.StructuredArrow X (CategoryTheory.Functor.diag T)} (g : X✝ ⟶ Y✝) : ((CategoryTheory.StructuredArrow.ofDiagEquivalence.functor X).map g).right.right = g.right

@[simp]

theorem CategoryTheory.StructuredArrow.ofDiagEquivalence.functor_obj_right_left_as {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T × T) (Y : CategoryTheory.StructuredArrow X (CategoryTheory.Functor.diag T)) : ((CategoryTheory.StructuredArrow.ofDiagEquivalence.functor X).obj Y).right.left.as = PUnit.unit

@[simp]

theorem CategoryTheory.StructuredArrow.ofDiagEquivalence.functor_obj_right_right {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T × T) (Y : CategoryTheory.StructuredArrow X (CategoryTheory.Functor.diag T)) : ((CategoryTheory.StructuredArrow.ofDiagEquivalence.functor X).obj Y).right.right = Y.right

@[simp]

theorem CategoryTheory.StructuredArrow.ofDiagEquivalence.functor_map_right_left_down_down {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T × T) {X✝ Y✝ : CategoryTheory.StructuredArrow X (CategoryTheory.Functor.diag T)} (g : X✝ ⟶ Y✝) : ⋯ = ⋯

@[simp]

theorem CategoryTheory.StructuredArrow.ofDiagEquivalence.functor_obj_left_as {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T × T) (Y : CategoryTheory.StructuredArrow X (CategoryTheory.Functor.diag T)) : ((CategoryTheory.StructuredArrow.ofDiagEquivalence.functor X).obj Y).left.as = PUnit.unit

@[simp]

theorem CategoryTheory.StructuredArrow.ofDiagEquivalence.functor_map_left_down_down {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T × T) {X✝ Y✝ : CategoryTheory.StructuredArrow X (CategoryTheory.Functor.diag T)} (g : X✝ ⟶ Y✝) : ⋯ = ⋯

def CategoryTheory.StructuredArrow.ofDiagEquivalence.inverse {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T × T) : CategoryTheory.Functor (CategoryTheory.StructuredArrow X.2 (CategoryTheory.Under.forget X.1)) (CategoryTheory.StructuredArrow X (CategoryTheory.Functor.diag T))

The inverse functor of ofDiagEquivalence.functor.

Equations

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

@[simp]

theorem CategoryTheory.StructuredArrow.ofDiagEquivalence.inverse_obj_hom {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T × T) (Y : CategoryTheory.StructuredArrow X.2 (CategoryTheory.Under.forget X.1)) : ((CategoryTheory.StructuredArrow.ofDiagEquivalence.inverse X).obj Y).hom = (Y.right.hom, Y.hom)

@[simp]

theorem CategoryTheory.StructuredArrow.ofDiagEquivalence.inverse_obj_right {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T × T) (Y : CategoryTheory.StructuredArrow X.2 (CategoryTheory.Under.forget X.1)) : ((CategoryTheory.StructuredArrow.ofDiagEquivalence.inverse X).obj Y).right = Y.right.right

@[simp]

theorem CategoryTheory.StructuredArrow.ofDiagEquivalence.inverse_map_right {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T × T) {X✝ Y✝ : CategoryTheory.StructuredArrow X.2 (CategoryTheory.Under.forget X.1)} (g : X✝ ⟶ Y✝) : ((CategoryTheory.StructuredArrow.ofDiagEquivalence.inverse X).map g).right = g.right.right

@[simp]

theorem CategoryTheory.StructuredArrow.ofDiagEquivalence.inverse_map_left_down_down {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T × T) {X✝ Y✝ : CategoryTheory.StructuredArrow X.2 (CategoryTheory.Under.forget X.1)} (g : X✝ ⟶ Y✝) : ⋯ = ⋯

@[simp]

theorem CategoryTheory.StructuredArrow.ofDiagEquivalence.inverse_obj_left_as {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T × T) (Y : CategoryTheory.StructuredArrow X.2 (CategoryTheory.Under.forget X.1)) : ((CategoryTheory.StructuredArrow.ofDiagEquivalence.inverse X).obj Y).left.as = PUnit.unit

def CategoryTheory.StructuredArrow.ofDiagEquivalence {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T × T) : CategoryTheory.StructuredArrow X (CategoryTheory.Functor.diag T) ≌ CategoryTheory.StructuredArrow X.2 (CategoryTheory.Under.forget X.1)

Characterization of the structured arrow category on the diagonal functor T ⥤ T × T.

Equations

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

def CategoryTheory.StructuredArrow.ofDiagEquivalence' {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T × T) : CategoryTheory.StructuredArrow X (CategoryTheory.Functor.diag T) ≌ CategoryTheory.StructuredArrow X.1 (CategoryTheory.Under.forget X.2)

A version of StructuredArrow.ofDiagEquivalence with the roles of the first and second projection swapped.

Equations

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

def CategoryTheory.CostructuredArrow.ofCostructuredArrowProjEquivalence.functor {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor T D) (Y : D) (X : T) : CategoryTheory.Functor (CategoryTheory.CostructuredArrow (CategoryTheory.CostructuredArrow.proj F Y) X) (CategoryTheory.CostructuredArrow ((CategoryTheory.Over.forget X).comp F) Y)

A functor from the costructured arrow category on the projection functor for any costructured arrow category.

Equations

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

@[simp]

theorem CategoryTheory.CostructuredArrow.ofCostructuredArrowProjEquivalence.functor_obj_left_hom {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor T D) (Y : D) (X : T) (Y✝ : CategoryTheory.CostructuredArrow (CategoryTheory.CostructuredArrow.proj F Y) X) : ((CategoryTheory.CostructuredArrow.ofCostructuredArrowProjEquivalence.functor F Y X).obj Y✝).left.hom = Y✝.hom

@[simp]

theorem CategoryTheory.CostructuredArrow.ofCostructuredArrowProjEquivalence.functor_map_left_right_down_down {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor T D) (Y : D) (X : T) {X✝ Y✝ : CategoryTheory.CostructuredArrow (CategoryTheory.CostructuredArrow.proj F Y) X} (g : X✝ ⟶ Y✝) : ⋯ = ⋯

@[simp]

theorem CategoryTheory.CostructuredArrow.ofCostructuredArrowProjEquivalence.functor_obj_left_left {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor T D) (Y : D) (X : T) (Y✝ : CategoryTheory.CostructuredArrow (CategoryTheory.CostructuredArrow.proj F Y) X) : ((CategoryTheory.CostructuredArrow.ofCostructuredArrowProjEquivalence.functor F Y X).obj Y✝).left.left = Y✝.left.left

@[simp]

theorem CategoryTheory.CostructuredArrow.ofCostructuredArrowProjEquivalence.functor_obj_hom {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor T D) (Y : D) (X : T) (Y✝ : CategoryTheory.CostructuredArrow (CategoryTheory.CostructuredArrow.proj F Y) X) : ((CategoryTheory.CostructuredArrow.ofCostructuredArrowProjEquivalence.functor F Y X).obj Y✝).hom = Y✝.left.hom

@[simp]

theorem CategoryTheory.CostructuredArrow.ofCostructuredArrowProjEquivalence.functor_map_left_left {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor T D) (Y : D) (X : T) {X✝ Y✝ : CategoryTheory.CostructuredArrow (CategoryTheory.CostructuredArrow.proj F Y) X} (g : X✝ ⟶ Y✝) : ((CategoryTheory.CostructuredArrow.ofCostructuredArrowProjEquivalence.functor F Y X).map g).left.left = g.left.left

@[simp]

theorem CategoryTheory.CostructuredArrow.ofCostructuredArrowProjEquivalence.functor_obj_left_right_as {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor T D) (Y : D) (X : T) (Y✝ : CategoryTheory.CostructuredArrow (CategoryTheory.CostructuredArrow.proj F Y) X) : ((CategoryTheory.CostructuredArrow.ofCostructuredArrowProjEquivalence.functor F Y X).obj Y✝).left.right.as = PUnit.unit

@[simp]

theorem CategoryTheory.CostructuredArrow.ofCostructuredArrowProjEquivalence.functor_obj_right_as {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor T D) (Y : D) (X : T) (Y✝ : CategoryTheory.CostructuredArrow (CategoryTheory.CostructuredArrow.proj F Y) X) : ((CategoryTheory.CostructuredArrow.ofCostructuredArrowProjEquivalence.functor F Y X).obj Y✝).right.as = PUnit.unit

@[simp]

theorem CategoryTheory.CostructuredArrow.ofCostructuredArrowProjEquivalence.functor_map_right_down_down {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor T D) (Y : D) (X : T) {X✝ Y✝ : CategoryTheory.CostructuredArrow (CategoryTheory.CostructuredArrow.proj F Y) X} (g : X✝ ⟶ Y✝) : ⋯ = ⋯

def CategoryTheory.CostructuredArrow.ofCostructuredArrowProjEquivalence.inverse {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor T D) (Y : D) (X : T) : CategoryTheory.Functor (CategoryTheory.CostructuredArrow ((CategoryTheory.Over.forget X).comp F) Y) (CategoryTheory.CostructuredArrow (CategoryTheory.CostructuredArrow.proj F Y) X)

The inverse functor of ofCostructuredArrowProjEquivalence.functor.

Equations

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

@[simp]

theorem CategoryTheory.CostructuredArrow.ofCostructuredArrowProjEquivalence.inverse_map_right_down_down {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor T D) (Y : D) (X : T) {X✝ Y✝ : CategoryTheory.CostructuredArrow ((CategoryTheory.Over.forget X).comp F) Y} (g : X✝ ⟶ Y✝) : ⋯ = ⋯

@[simp]

theorem CategoryTheory.CostructuredArrow.ofCostructuredArrowProjEquivalence.inverse_obj_hom {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor T D) (Y : D) (X : T) (Y✝ : CategoryTheory.CostructuredArrow ((CategoryTheory.Over.forget X).comp F) Y) : ((CategoryTheory.CostructuredArrow.ofCostructuredArrowProjEquivalence.inverse F Y X).obj Y✝).hom = Y✝.left.hom

@[simp]

theorem CategoryTheory.CostructuredArrow.ofCostructuredArrowProjEquivalence.inverse_map_left_left {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor T D) (Y : D) (X : T) {X✝ Y✝ : CategoryTheory.CostructuredArrow ((CategoryTheory.Over.forget X).comp F) Y} (g : X✝ ⟶ Y✝) : ((CategoryTheory.CostructuredArrow.ofCostructuredArrowProjEquivalence.inverse F Y X).map g).left.left = g.left.left

@[simp]

theorem CategoryTheory.CostructuredArrow.ofCostructuredArrowProjEquivalence.inverse_obj_right_as {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor T D) (Y : D) (X : T) (Y✝ : CategoryTheory.CostructuredArrow ((CategoryTheory.Over.forget X).comp F) Y) : ((CategoryTheory.CostructuredArrow.ofCostructuredArrowProjEquivalence.inverse F Y X).obj Y✝).right.as = PUnit.unit

@[simp]

theorem CategoryTheory.CostructuredArrow.ofCostructuredArrowProjEquivalence.inverse_obj_left_right_as {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor T D) (Y : D) (X : T) (Y✝ : CategoryTheory.CostructuredArrow ((CategoryTheory.Over.forget X).comp F) Y) : ((CategoryTheory.CostructuredArrow.ofCostructuredArrowProjEquivalence.inverse F Y X).obj Y✝).left.right.as = PUnit.unit

@[simp]

theorem CategoryTheory.CostructuredArrow.ofCostructuredArrowProjEquivalence.inverse_obj_left_hom {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor T D) (Y : D) (X : T) (Y✝ : CategoryTheory.CostructuredArrow ((CategoryTheory.Over.forget X).comp F) Y) : ((CategoryTheory.CostructuredArrow.ofCostructuredArrowProjEquivalence.inverse F Y X).obj Y✝).left.hom = Y✝.hom

@[simp]

theorem CategoryTheory.CostructuredArrow.ofCostructuredArrowProjEquivalence.inverse_map_left_right_down_down {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor T D) (Y : D) (X : T) {X✝ Y✝ : CategoryTheory.CostructuredArrow ((CategoryTheory.Over.forget X).comp F) Y} (g : X✝ ⟶ Y✝) : ⋯ = ⋯

@[simp]

theorem CategoryTheory.CostructuredArrow.ofCostructuredArrowProjEquivalence.inverse_obj_left_left {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor T D) (Y : D) (X : T) (Y✝ : CategoryTheory.CostructuredArrow ((CategoryTheory.Over.forget X).comp F) Y) : ((CategoryTheory.CostructuredArrow.ofCostructuredArrowProjEquivalence.inverse F Y X).obj Y✝).left.left = Y✝.left.left

def CategoryTheory.CostructuredArrow.ofCostructuredArrowProjEquivalence {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor T D) (Y : D) (X : T) : CategoryTheory.CostructuredArrow (CategoryTheory.CostructuredArrow.proj F Y) X ≌ CategoryTheory.CostructuredArrow ((CategoryTheory.Over.forget X).comp F) Y

Characterization of the costructured arrow category on the projection functor of any costructured arrow category.

Equations

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

def CategoryTheory.CostructuredArrow.ofDiagEquivalence.functor {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T × T) : CategoryTheory.Functor (CategoryTheory.CostructuredArrow (CategoryTheory.Functor.diag T) X) (CategoryTheory.CostructuredArrow (CategoryTheory.Over.forget X.1) X.2)

The canonical functor from the costructured arrow category on the diagonal functor T ⥤ T × T to the costructured arrow category on Under.forget.

Equations

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

@[simp]

theorem CategoryTheory.CostructuredArrow.ofDiagEquivalence.functor_map_right_down_down {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T × T) {X✝ Y✝ : CategoryTheory.CostructuredArrow (CategoryTheory.Functor.diag T) X} (g : X✝ ⟶ Y✝) : ⋯ = ⋯

@[simp]

theorem CategoryTheory.CostructuredArrow.ofDiagEquivalence.functor_obj_hom {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T × T) (Y : CategoryTheory.CostructuredArrow (CategoryTheory.Functor.diag T) X) : ((CategoryTheory.CostructuredArrow.ofDiagEquivalence.functor X).obj Y).hom = Y.hom.2

@[simp]

theorem CategoryTheory.CostructuredArrow.ofDiagEquivalence.functor_map_left_left {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T × T) {X✝ Y✝ : CategoryTheory.CostructuredArrow (CategoryTheory.Functor.diag T) X} (g : X✝ ⟶ Y✝) : ((CategoryTheory.CostructuredArrow.ofDiagEquivalence.functor X).map g).left.left = g.left

@[simp]

theorem CategoryTheory.CostructuredArrow.ofDiagEquivalence.functor_obj_left_right_as {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T × T) (Y : CategoryTheory.CostructuredArrow (CategoryTheory.Functor.diag T) X) : ((CategoryTheory.CostructuredArrow.ofDiagEquivalence.functor X).obj Y).left.right.as = PUnit.unit

@[simp]

theorem CategoryTheory.CostructuredArrow.ofDiagEquivalence.functor_map_left_right_down_down {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T × T) {X✝ Y✝ : CategoryTheory.CostructuredArrow (CategoryTheory.Functor.diag T) X} (g : X✝ ⟶ Y✝) : ⋯ = ⋯

@[simp]

theorem CategoryTheory.CostructuredArrow.ofDiagEquivalence.functor_obj_left_hom {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T × T) (Y : CategoryTheory.CostructuredArrow (CategoryTheory.Functor.diag T) X) : ((CategoryTheory.CostructuredArrow.ofDiagEquivalence.functor X).obj Y).left.hom = Y.hom.1

@[simp]

theorem CategoryTheory.CostructuredArrow.ofDiagEquivalence.functor_obj_left_left {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T × T) (Y : CategoryTheory.CostructuredArrow (CategoryTheory.Functor.diag T) X) : ((CategoryTheory.CostructuredArrow.ofDiagEquivalence.functor X).obj Y).left.left = Y.left

@[simp]

theorem CategoryTheory.CostructuredArrow.ofDiagEquivalence.functor_obj_right_as {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T × T) (Y : CategoryTheory.CostructuredArrow (CategoryTheory.Functor.diag T) X) : ((CategoryTheory.CostructuredArrow.ofDiagEquivalence.functor X).obj Y).right.as = PUnit.unit

def CategoryTheory.CostructuredArrow.ofDiagEquivalence.inverse {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T × T) : CategoryTheory.Functor (CategoryTheory.CostructuredArrow (CategoryTheory.Over.forget X.1) X.2) (CategoryTheory.CostructuredArrow (CategoryTheory.Functor.diag T) X)

The inverse functor of ofDiagEquivalence.functor.

Equations

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

@[simp]

theorem CategoryTheory.CostructuredArrow.ofDiagEquivalence.inverse_map_left {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T × T) {X✝ Y✝ : CategoryTheory.CostructuredArrow (CategoryTheory.Over.forget X.1) X.2} (g : X✝ ⟶ Y✝) : ((CategoryTheory.CostructuredArrow.ofDiagEquivalence.inverse X).map g).left = g.left.left

@[simp]

theorem CategoryTheory.CostructuredArrow.ofDiagEquivalence.inverse_obj_left {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T × T) (Y : CategoryTheory.CostructuredArrow (CategoryTheory.Over.forget X.1) X.2) : ((CategoryTheory.CostructuredArrow.ofDiagEquivalence.inverse X).obj Y).left = Y.left.left

@[simp]

theorem CategoryTheory.CostructuredArrow.ofDiagEquivalence.inverse_map_right_down_down {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T × T) {X✝ Y✝ : CategoryTheory.CostructuredArrow (CategoryTheory.Over.forget X.1) X.2} (g : X✝ ⟶ Y✝) : ⋯ = ⋯

@[simp]

theorem CategoryTheory.CostructuredArrow.ofDiagEquivalence.inverse_obj_hom {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T × T) (Y : CategoryTheory.CostructuredArrow (CategoryTheory.Over.forget X.1) X.2) : ((CategoryTheory.CostructuredArrow.ofDiagEquivalence.inverse X).obj Y).hom = (Y.left.hom, Y.hom)

@[simp]

theorem CategoryTheory.CostructuredArrow.ofDiagEquivalence.inverse_obj_right_as {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T × T) (Y : CategoryTheory.CostructuredArrow (CategoryTheory.Over.forget X.1) X.2) : ((CategoryTheory.CostructuredArrow.ofDiagEquivalence.inverse X).obj Y).right.as = PUnit.unit

def CategoryTheory.CostructuredArrow.ofDiagEquivalence {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T × T) : CategoryTheory.CostructuredArrow (CategoryTheory.Functor.diag T) X ≌ CategoryTheory.CostructuredArrow (CategoryTheory.Over.forget X.1) X.2

Characterization of the costructured arrow category on the diagonal functor T ⥤ T × T.

Equations

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

def CategoryTheory.CostructuredArrow.ofDiagEquivalence' {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T × T) : CategoryTheory.CostructuredArrow (CategoryTheory.Functor.diag T) X ≌ CategoryTheory.CostructuredArrow (CategoryTheory.Over.forget X.2) X.1

A version of CostructuredArrow.ofDiagEquivalence with the roles of the first and second projection swapped.

Equations

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

def CategoryTheory.Over.opToOpUnder {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T) : CategoryTheory.Functor (CategoryTheory.Over (Opposite.op X)) (CategoryTheory.Under X)ᵒᵖ

The canonical functor by reversing structure arrows.

Equations

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

@[simp]

theorem CategoryTheory.Over.opToOpUnder_map {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T) {Z Y : CategoryTheory.Over (Opposite.op X)} (f : Z ⟶ Y) : (CategoryTheory.Over.opToOpUnder X).map f = Opposite.op (CategoryTheory.Under.homMk f.left.unop ⋯)

@[simp]

theorem CategoryTheory.Over.opToOpUnder_obj {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T) (Y : CategoryTheory.Over (Opposite.op X)) : (CategoryTheory.Over.opToOpUnder X).obj Y = Opposite.op (CategoryTheory.Under.mk Y.hom.unop)

def CategoryTheory.Under.opToOverOp {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T) : CategoryTheory.Functor (CategoryTheory.Under X)ᵒᵖ (CategoryTheory.Over (Opposite.op X))

The canonical functor by reversing structure arrows.

Equations

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

@[simp]

theorem CategoryTheory.Under.opToOverOp_map {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T) {Z Y : (CategoryTheory.Under X)ᵒᵖ} (f : Z ⟶ Y) : (CategoryTheory.Under.opToOverOp X).map f = CategoryTheory.Over.homMk f.unop.right.op ⋯

@[simp]

theorem CategoryTheory.Under.opToOverOp_obj {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T) (Y : (CategoryTheory.Under X)ᵒᵖ) : (CategoryTheory.Under.opToOverOp X).obj Y = CategoryTheory.Over.mk (Opposite.unop Y).hom.op

def CategoryTheory.Over.opEquivOpUnder {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T) : CategoryTheory.Over (Opposite.op X) ≌ (CategoryTheory.Under X)ᵒᵖ

Over.opToOpUnder is an equivalence of categories.

Equations

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

@[simp]

theorem CategoryTheory.Over.opEquivOpUnder_functor {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T) : (CategoryTheory.Over.opEquivOpUnder X).functor = CategoryTheory.Over.opToOpUnder X

@[simp]

theorem CategoryTheory.Over.opEquivOpUnder_unitIso {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T) : (CategoryTheory.Over.opEquivOpUnder X).unitIso = CategoryTheory.Iso.refl (CategoryTheory.Functor.id (CategoryTheory.Over (Opposite.op X)))

@[simp]

theorem CategoryTheory.Over.opEquivOpUnder_counitIso {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T) : (CategoryTheory.Over.opEquivOpUnder X).counitIso = CategoryTheory.Iso.refl ((CategoryTheory.Under.opToOverOp X).comp (CategoryTheory.Over.opToOpUnder X))

@[simp]

theorem CategoryTheory.Over.opEquivOpUnder_inverse {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T) : (CategoryTheory.Over.opEquivOpUnder X).inverse = CategoryTheory.Under.opToOverOp X

def CategoryTheory.Under.opToOpOver {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T) : CategoryTheory.Functor (CategoryTheory.Under (Opposite.op X)) (CategoryTheory.Over X)ᵒᵖ

The canonical functor by reversing structure arrows.

Equations

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

@[simp]

theorem CategoryTheory.Under.opToOpOver_obj {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T) (Y : CategoryTheory.Under (Opposite.op X)) : (CategoryTheory.Under.opToOpOver X).obj Y = Opposite.op (CategoryTheory.Over.mk Y.hom.unop)

@[simp]

theorem CategoryTheory.Under.opToOpOver_map {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T) {Z Y : CategoryTheory.Under (Opposite.op X)} (f : Z ⟶ Y) : (CategoryTheory.Under.opToOpOver X).map f = Opposite.op (CategoryTheory.Over.homMk f.right.unop ⋯)

def CategoryTheory.Over.opToUnderOp {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T) : CategoryTheory.Functor (CategoryTheory.Over X)ᵒᵖ (CategoryTheory.Under (Opposite.op X))

The canonical functor by reversing structure arrows.

Equations

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

@[simp]

theorem CategoryTheory.Over.opToUnderOp_map {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T) {Z Y : (CategoryTheory.Over X)ᵒᵖ} (f : Z ⟶ Y) : (CategoryTheory.Over.opToUnderOp X).map f = CategoryTheory.Under.homMk f.unop.left.op ⋯

@[simp]

theorem CategoryTheory.Over.opToUnderOp_obj {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T) (Y : (CategoryTheory.Over X)ᵒᵖ) : (CategoryTheory.Over.opToUnderOp X).obj Y = CategoryTheory.Under.mk (Opposite.unop Y).hom.op

def CategoryTheory.Under.opEquivOpOver {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T) : CategoryTheory.Under (Opposite.op X) ≌ (CategoryTheory.Over X)ᵒᵖ

Under.opToOpOver is an equivalence of categories.

Equations

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

@[simp]

theorem CategoryTheory.Under.opEquivOpOver_counitIso {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T) : (CategoryTheory.Under.opEquivOpOver X).counitIso = CategoryTheory.Iso.refl ((CategoryTheory.Over.opToUnderOp X).comp (CategoryTheory.Under.opToOpOver X))

@[simp]

theorem CategoryTheory.Under.opEquivOpOver_unitIso {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T) : (CategoryTheory.Under.opEquivOpOver X).unitIso = CategoryTheory.Iso.refl (CategoryTheory.Functor.id (CategoryTheory.Under (Opposite.op X)))

@[simp]

theorem CategoryTheory.Under.opEquivOpOver_functor {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T) : (CategoryTheory.Under.opEquivOpOver X).functor = CategoryTheory.Under.opToOpOver X

@[simp]

theorem CategoryTheory.Under.opEquivOpOver_inverse {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T) : (CategoryTheory.Under.opEquivOpOver X).inverse = CategoryTheory.Over.opToUnderOp X