The category of "structured arrows"

For T : C ⥤ D, a T-structured arrow with source S : D is just a morphism S ⟶ T.obj Y, for some Y : C.

These form a category with morphisms g : Y ⟶ Y' making the obvious diagram commute.

We prove that 𝟙 (T.obj Y) is the initial object in T-structured objects with source T.obj Y.

def CategoryTheory.StructuredArrow {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] (S : D) (T : Functor C D) : Type (max u₁ v₂)

The category of T-structured arrows with domain S : D (here T : C ⥤ D), has as its objects D-morphisms of the form S ⟶ T Y, for some Y : C, and morphisms C-morphisms Y ⟶ Y' making the obvious triangle commute.

instance CategoryTheory.instCategoryStructuredArrow {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] (S : D) (T : Functor C D) : Category.{v₁, max u₁ v₂} (StructuredArrow S T)

See through the type synonym StructuredArrow S T = Comma _ _.

def CategoryTheory.StructuredArrow.proj {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] (S : D) (T : Functor C D) : Functor (StructuredArrow S T) C

The obvious projection functor from structured arrows.

@[simp]

theorem CategoryTheory.StructuredArrow.proj_obj {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] (S : D) (T : Functor C D) (X : Comma (Functor.fromPUnit S) T) : (proj S T).obj X = X.right

@[simp]

theorem CategoryTheory.StructuredArrow.proj_map {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] (S : D) (T : Functor C D) {X✝ Y✝ : Comma (Functor.fromPUnit S) T} (f : X✝ ⟶ Y✝) : (proj S T).map f = f.right

theorem CategoryTheory.StructuredArrow.hom_ext {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {T : Functor C D} {X Y : StructuredArrow S T} (f g : X ⟶ Y) (h : f.right = g.right) : f = g

theorem CategoryTheory.StructuredArrow.hom_ext_iff {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {T : Functor C D} {X Y : StructuredArrow S T} {f g : X ⟶ Y} : f = g ↔ f.right = g.right

@[simp]

theorem CategoryTheory.StructuredArrow.hom_eq_iff {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {T : Functor C D} {X Y : StructuredArrow S T} (f g : X ⟶ Y) : f = g ↔ f.right = g.right

def CategoryTheory.StructuredArrow.mk {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {Y : C} {T : Functor C D} (f : S ⟶ T.obj Y) : StructuredArrow S T

Construct a structured arrow from a morphism.

@[simp]

theorem CategoryTheory.StructuredArrow.mk_left {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {Y : C} {T : Functor C D} (f : S ⟶ T.obj Y) : (mk f).left = { as := PUnit.unit }

@[simp]

theorem CategoryTheory.StructuredArrow.mk_right {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {Y : C} {T : Functor C D} (f : S ⟶ T.obj Y) : (mk f).right = Y

@[simp]

theorem CategoryTheory.StructuredArrow.mk_hom_eq_self {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {Y : C} {T : Functor C D} (f : S ⟶ T.obj Y) : (mk f).hom = f

@[simp]

theorem CategoryTheory.StructuredArrow.w {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {T : Functor C D} {A B : StructuredArrow S T} (f : A ⟶ B) : CategoryStruct.comp A.hom (T.map f.right) = B.hom

@[simp]

theorem CategoryTheory.StructuredArrow.w_assoc {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {T : Functor C D} {A B : StructuredArrow S T} (f : A ⟶ B) {Z : D} (h : T.obj B.right ⟶ Z) : CategoryStruct.comp A.hom (CategoryStruct.comp (T.map f.right) h) = CategoryStruct.comp B.hom h

@[simp]

theorem CategoryTheory.StructuredArrow.comp_right {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {T : Functor C D} {X Y Z : StructuredArrow S T} (f : X ⟶ Y) (g : Y ⟶ Z) : (CategoryStruct.comp f g).right = CategoryStruct.comp f.right g.right

@[simp]

theorem CategoryTheory.StructuredArrow.id_right {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {T : Functor C D} (X : StructuredArrow S T) : (CategoryStruct.id X).right = CategoryStruct.id X.right

@[simp]

theorem CategoryTheory.StructuredArrow.eqToHom_right {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {T : Functor C D} {X Y : StructuredArrow S T} (h : X = Y) : (eqToHom h).right = eqToHom ⋯

@[simp]

theorem CategoryTheory.StructuredArrow.left_eq_id {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {T : Functor C D} {X Y : StructuredArrow S T} (f : X ⟶ Y) : f.left = CategoryStruct.id X.left

def CategoryTheory.StructuredArrow.homMk {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {T : Functor C D} {f f' : StructuredArrow S T} (g : f.right ⟶ f'.right) (w : CategoryStruct.comp f.hom (T.map g) = f'.hom := by cat_disch) : f ⟶ f'

To construct a morphism of structured arrows, we need a morphism of the objects underlying the target, and to check that the triangle commutes.

@[simp]

theorem CategoryTheory.StructuredArrow.homMk_right {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {T : Functor C D} {f f' : StructuredArrow S T} (g : f.right ⟶ f'.right) (w : CategoryStruct.comp f.hom (T.map g) = f'.hom := by cat_disch) : (homMk g w).right = g

theorem CategoryTheory.StructuredArrow.homMk_surjective {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {T : Functor C D} {f f' : StructuredArrow S T} (φ : f ⟶ f') : ∃ (ψ : f.right ⟶ f'.right) (hψ : CategoryStruct.comp f.hom (T.map ψ) = f'.hom), φ = homMk ψ hψ

def CategoryTheory.StructuredArrow.homMk' {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {Y' : C} {T : Functor C D} (f : StructuredArrow S T) (g : f.right ⟶ Y') : f ⟶ mk (CategoryStruct.comp f.hom (T.map g))

Given a structured arrow X ⟶ T(Y), and an arrow Y ⟶ Y', we can construct a morphism of structured arrows given by (X ⟶ T(Y)) ⟶ (X ⟶ T(Y) ⟶ T(Y')).

@[simp]

theorem CategoryTheory.StructuredArrow.homMk'_left {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {Y' : C} {T : Functor C D} (f : StructuredArrow S T) (g : f.right ⟶ Y') : (f.homMk' g).left = CategoryStruct.id f.left

@[simp]

theorem CategoryTheory.StructuredArrow.homMk'_right {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {Y' : C} {T : Functor C D} (f : StructuredArrow S T) (g : f.right ⟶ Y') : (f.homMk' g).right = g

theorem CategoryTheory.StructuredArrow.homMk'_id {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {T : Functor C D} (f : StructuredArrow S T) : f.homMk' (CategoryStruct.id f.right) = eqToHom ⋯

theorem CategoryTheory.StructuredArrow.homMk'_mk_id {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {Y : C} {T : Functor C D} (f : S ⟶ T.obj Y) : (mk f).homMk' (CategoryStruct.id Y) = eqToHom ⋯

theorem CategoryTheory.StructuredArrow.homMk'_comp {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {Y' Y'' : C} {T : Functor C D} (f : StructuredArrow S T) (g : f.right ⟶ Y') (g' : Y' ⟶ Y'') : f.homMk' (CategoryStruct.comp g g') = CategoryStruct.comp (f.homMk' g) (CategoryStruct.comp ((mk (CategoryStruct.comp f.hom (T.map g))).homMk' g') (eqToHom ⋯))

theorem CategoryTheory.StructuredArrow.homMk'_mk_comp {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {Y Y' Y'' : C} {T : Functor C D} (f : S ⟶ T.obj Y) (g : Y ⟶ Y') (g' : Y' ⟶ Y'') : (mk f).homMk' (CategoryStruct.comp g g') = CategoryStruct.comp ((mk f).homMk' g) (CategoryStruct.comp ((mk (CategoryStruct.comp f (T.map g))).homMk' g') (eqToHom ⋯))

def CategoryTheory.StructuredArrow.mkPostcomp {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {Y Y' : C} {T : Functor C D} (f : S ⟶ T.obj Y) (g : Y ⟶ Y') : mk f ⟶ mk (CategoryStruct.comp f (T.map g))

Variant of homMk' where both objects are applications of mk.

@[simp]

theorem CategoryTheory.StructuredArrow.mkPostcomp_right {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {Y Y' : C} {T : Functor C D} (f : S ⟶ T.obj Y) (g : Y ⟶ Y') : (mkPostcomp f g).right = g

@[simp]

theorem CategoryTheory.StructuredArrow.mkPostcomp_left {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {Y Y' : C} {T : Functor C D} (f : S ⟶ T.obj Y) (g : Y ⟶ Y') : (mkPostcomp f g).left = CategoryStruct.id (mk f).left

theorem CategoryTheory.StructuredArrow.mkPostcomp_id {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {Y : C} {T : Functor C D} (f : S ⟶ T.obj Y) : mkPostcomp f (CategoryStruct.id Y) = eqToHom ⋯

theorem CategoryTheory.StructuredArrow.mkPostcomp_comp {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {Y Y' Y'' : C} {T : Functor C D} (f : S ⟶ T.obj Y) (g : Y ⟶ Y') (g' : Y' ⟶ Y'') : mkPostcomp f (CategoryStruct.comp g g') = CategoryStruct.comp (mkPostcomp f g) (CategoryStruct.comp (mkPostcomp (CategoryStruct.comp f (T.map g)) g') (eqToHom ⋯))

def CategoryTheory.StructuredArrow.isoMk {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {T : Functor C D} {f f' : StructuredArrow S T} (g : f.right ≅ f'.right) (w : CategoryStruct.comp f.hom (T.map g.hom) = f'.hom := by cat_disch) : f ≅ f'

To construct an isomorphism of structured arrows, we need an isomorphism of the objects underlying the target, and to check that the triangle commutes.

@[simp]

theorem CategoryTheory.StructuredArrow.isoMk_inv_right {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {T : Functor C D} {f f' : StructuredArrow S T} (g : f.right ≅ f'.right) (w : CategoryStruct.comp f.hom (T.map g.hom) = f'.hom := by cat_disch) : (isoMk g w).inv.right = g.inv

@[simp]

theorem CategoryTheory.StructuredArrow.isoMk_hom_right {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {T : Functor C D} {f f' : StructuredArrow S T} (g : f.right ≅ f'.right) (w : CategoryStruct.comp f.hom (T.map g.hom) = f'.hom := by cat_disch) : (isoMk g w).hom.right = g.hom

theorem CategoryTheory.StructuredArrow.obj_ext {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {T : Functor C D} (x y : StructuredArrow S T) (hr : x.right = y.right) (hh : CategoryStruct.comp x.hom (T.map (eqToHom hr)) = y.hom) : x = y

theorem CategoryTheory.StructuredArrow.ext {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {T : Functor C D} {A B : StructuredArrow S T} (f g : A ⟶ B) : f.right = g.right → f = g

theorem CategoryTheory.StructuredArrow.ext_iff {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {T : Functor C D} {A B : StructuredArrow S T} (f g : A ⟶ B) : f = g ↔ f.right = g.right

instance CategoryTheory.StructuredArrow.proj_faithful {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {T : Functor C D} : (proj S T).Faithful

theorem CategoryTheory.StructuredArrow.mono_of_mono_right {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {T : Functor C D} {A B : StructuredArrow S T} (f : A ⟶ B) [h : Mono f.right] : Mono f

The converse of this is true with additional assumptions, see mono_iff_mono_right.

theorem CategoryTheory.StructuredArrow.epi_of_epi_right {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {T : Functor C D} {A B : StructuredArrow S T} (f : A ⟶ B) [h : Epi f.right] : Epi f

instance CategoryTheory.StructuredArrow.mono_homMk {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {T : Functor C D} {A B : StructuredArrow S T} (f : A.right ⟶ B.right) (w : CategoryStruct.comp A.hom (T.map f) = B.hom) [h : Mono f] : Mono (homMk f w)

instance CategoryTheory.StructuredArrow.epi_homMk {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {T : Functor C D} {A B : StructuredArrow S T} (f : A.right ⟶ B.right) (w : CategoryStruct.comp A.hom (T.map f) = B.hom) [h : Epi f] : Epi (homMk f w)

theorem CategoryTheory.StructuredArrow.eq_mk {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {T : Functor C D} (f : StructuredArrow S T) : f = mk f.hom

Eta rule for structured arrows. Prefer StructuredArrow.eta for rewriting, since equality of objects tends to cause problems.

def CategoryTheory.StructuredArrow.eta {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {T : Functor C D} (f : StructuredArrow S T) : f ≅ mk f.hom

Eta rule for structured arrows.

@[simp]

theorem CategoryTheory.StructuredArrow.eta_hom_right {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {T : Functor C D} (f : StructuredArrow S T) : f.eta.hom.right = CategoryStruct.id f.right

@[simp]

theorem CategoryTheory.StructuredArrow.eta_inv_right {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {T : Functor C D} (f : StructuredArrow S T) : f.eta.inv.right = CategoryStruct.id f.right

theorem CategoryTheory.StructuredArrow.mk_surjective {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {T : Functor C D} (f : StructuredArrow S T) : ∃ (Y : C) (g : S ⟶ T.obj Y), f = mk g

def CategoryTheory.StructuredArrow.map {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S S' : D} {T : Functor C D} (f : S ⟶ S') : Functor (StructuredArrow S' T) (StructuredArrow S T)

A morphism between source objects S ⟶ S' contravariantly induces a functor between structured arrows, StructuredArrow S' T ⥤ StructuredArrow S T.

Ideally this would be described as a 2-functor from D (promoted to a 2-category with equations as 2-morphisms) to Cat.

@[simp]

theorem CategoryTheory.StructuredArrow.map_obj_right {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S S' : D} {T : Functor C D} (f : S ⟶ S') (X : Comma (Functor.fromPUnit S') T) : ((map f).obj X).right = X.right

@[simp]

theorem CategoryTheory.StructuredArrow.map_obj_hom {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S S' : D} {T : Functor C D} (f : S ⟶ S') (X : Comma (Functor.fromPUnit S') T) : ((map f).obj X).hom = CategoryStruct.comp f X.hom

@[simp]

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

@[simp]

theorem CategoryTheory.StructuredArrow.map_map_right {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S S' : D} {T : Functor C D} (f : S ⟶ S') {X✝ Y✝ : Comma (Functor.fromPUnit S') T} (f✝ : X✝ ⟶ Y✝) : ((map f).map f✝).right = f✝.right

@[simp]

theorem CategoryTheory.StructuredArrow.map_obj_left {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S S' : D} {T : Functor C D} (f : S ⟶ S') (X : Comma (Functor.fromPUnit S') T) : ((map f).obj X).left = X.left

@[simp]

theorem CategoryTheory.StructuredArrow.map_mk {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S S' : D} {Y : C} {T : Functor C D} {f : S' ⟶ T.obj Y} (g : S ⟶ S') : (map g).obj (mk f) = mk (CategoryStruct.comp g f)

@[simp]

theorem CategoryTheory.StructuredArrow.map_id {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {T : Functor C D} {f : StructuredArrow S T} : (map (CategoryStruct.id S)).obj f = f

@[simp]

theorem CategoryTheory.StructuredArrow.map_comp {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S S' S'' : D} {T : Functor C D} {f : S ⟶ S'} {f' : S' ⟶ S''} {h : StructuredArrow S'' T} : (map (CategoryStruct.comp f f')).obj h = (map f).obj ((map f').obj h)

def CategoryTheory.StructuredArrow.mapIso {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S S' : D} {T : Functor C D} (i : S ≅ S') : StructuredArrow S T ≌ StructuredArrow S' T

An isomorphism S ≅ S' induces an equivalence StructuredArrow S T ≌ StructuredArrow S' T.

@[simp]

theorem CategoryTheory.StructuredArrow.mapIso_inverse_obj_right {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S S' : D} {T : Functor C D} (i : S ≅ S') (X : Comma (Functor.fromPUnit S') T) : ((mapIso i).inverse.obj X).right = X.right

@[simp]

theorem CategoryTheory.StructuredArrow.mapIso_inverse_obj_left {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S S' : D} {T : Functor C D} (i : S ≅ S') (X : Comma (Functor.fromPUnit S') T) : ((mapIso i).inverse.obj X).left = X.left

@[simp]

theorem CategoryTheory.StructuredArrow.mapIso_unitIso_inv_app_right {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S S' : D} {T : Functor C D} (i : S ≅ S') (X : Comma (Functor.fromPUnit S) T) : ((mapIso i).unitIso.inv.app X).right = CategoryStruct.id X.right

@[simp]

theorem CategoryTheory.StructuredArrow.mapIso_counitIso_hom_app_right {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S S' : D} {T : Functor C D} (i : S ≅ S') (X : Comma (Functor.fromPUnit S') T) : ((mapIso i).counitIso.hom.app X).right = CategoryStruct.id X.right

@[simp]

theorem CategoryTheory.StructuredArrow.mapIso_functor_map_right {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S S' : D} {T : Functor C D} (i : S ≅ S') {X✝ Y✝ : Comma (Functor.fromPUnit S) T} (f : X✝ ⟶ Y✝) : ((mapIso i).functor.map f).right = f.right

@[simp]

theorem CategoryTheory.StructuredArrow.mapIso_functor_obj_hom {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S S' : D} {T : Functor C D} (i : S ≅ S') (X : Comma (Functor.fromPUnit S) T) : ((mapIso i).functor.obj X).hom = CategoryStruct.comp i.inv X.hom

@[simp]

theorem CategoryTheory.StructuredArrow.mapIso_functor_obj_left {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S S' : D} {T : Functor C D} (i : S ≅ S') (X : Comma (Functor.fromPUnit S) T) : ((mapIso i).functor.obj X).left = X.left

@[simp]

theorem CategoryTheory.StructuredArrow.mapIso_inverse_map_right {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S S' : D} {T : Functor C D} (i : S ≅ S') {X✝ Y✝ : Comma (Functor.fromPUnit S') T} (f : X✝ ⟶ Y✝) : ((mapIso i).inverse.map f).right = f.right

@[simp]

theorem CategoryTheory.StructuredArrow.mapIso_counitIso_inv_app_right {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S S' : D} {T : Functor C D} (i : S ≅ S') (X : Comma (Functor.fromPUnit S') T) : ((mapIso i).counitIso.inv.app X).right = CategoryStruct.id X.right

@[simp]

theorem CategoryTheory.StructuredArrow.mapIso_functor_map_left {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S S' : D} {T : Functor C D} (i : S ≅ S') {X✝ Y✝ : Comma (Functor.fromPUnit S) T} (f : X✝ ⟶ Y✝) : ((mapIso i).functor.map f).left = CategoryStruct.id X✝.left

@[simp]

theorem CategoryTheory.StructuredArrow.mapIso_unitIso_hom_app_right {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S S' : D} {T : Functor C D} (i : S ≅ S') (X : Comma (Functor.fromPUnit S) T) : ((mapIso i).unitIso.hom.app X).right = CategoryStruct.id X.right

@[simp]

theorem CategoryTheory.StructuredArrow.mapIso_functor_obj_right {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S S' : D} {T : Functor C D} (i : S ≅ S') (X : Comma (Functor.fromPUnit S) T) : ((mapIso i).functor.obj X).right = X.right

@[simp]

theorem CategoryTheory.StructuredArrow.mapIso_inverse_map_left {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S S' : D} {T : Functor C D} (i : S ≅ S') {X✝ Y✝ : Comma (Functor.fromPUnit S') T} (f : X✝ ⟶ Y✝) : ((mapIso i).inverse.map f).left = CategoryStruct.id X✝.left

@[simp]

theorem CategoryTheory.StructuredArrow.mapIso_inverse_obj_hom {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S S' : D} {T : Functor C D} (i : S ≅ S') (X : Comma (Functor.fromPUnit S') T) : ((mapIso i).inverse.obj X).hom = CategoryStruct.comp i.hom X.hom

def CategoryTheory.StructuredArrow.mapNatIso {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {T T' : Functor C D} (i : T ≅ T') : StructuredArrow S T ≌ StructuredArrow S T'

A natural isomorphism T ≅ T' induces an equivalence StructuredArrow S T ≌ StructuredArrow S T'.

@[simp]

theorem CategoryTheory.StructuredArrow.mapNatIso_functor_obj_hom {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {T T' : Functor C D} (i : T ≅ T') (X : Comma (Functor.fromPUnit S) T) : ((mapNatIso i).functor.obj X).hom = CategoryStruct.comp X.hom (i.hom.app X.right)

@[simp]

theorem CategoryTheory.StructuredArrow.mapNatIso_counitIso_hom_app_right {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {T T' : Functor C D} (i : T ≅ T') (X : Comma (Functor.fromPUnit S) T') : ((mapNatIso i).counitIso.hom.app X).right = CategoryStruct.id X.right

@[simp]

theorem CategoryTheory.StructuredArrow.mapNatIso_inverse_obj_hom {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {T T' : Functor C D} (i : T ≅ T') (X : Comma (Functor.fromPUnit S) T') : ((mapNatIso i).inverse.obj X).hom = CategoryStruct.comp X.hom (i.inv.app X.right)

@[simp]

theorem CategoryTheory.StructuredArrow.mapNatIso_functor_obj_right {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {T T' : Functor C D} (i : T ≅ T') (X : Comma (Functor.fromPUnit S) T) : ((mapNatIso i).functor.obj X).right = X.right

@[simp]

theorem CategoryTheory.StructuredArrow.mapNatIso_unitIso_hom_app_right {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {T T' : Functor C D} (i : T ≅ T') (X : Comma (Functor.fromPUnit S) T) : ((mapNatIso i).unitIso.hom.app X).right = CategoryStruct.id X.right

@[simp]

theorem CategoryTheory.StructuredArrow.mapNatIso_inverse_obj_right {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {T T' : Functor C D} (i : T ≅ T') (X : Comma (Functor.fromPUnit S) T') : ((mapNatIso i).inverse.obj X).right = X.right

@[simp]

theorem CategoryTheory.StructuredArrow.mapNatIso_inverse_map_right {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {T T' : Functor C D} (i : T ≅ T') {X✝ Y✝ : Comma (Functor.fromPUnit S) T'} (f : X✝ ⟶ Y✝) : ((mapNatIso i).inverse.map f).right = f.right

@[simp]

theorem CategoryTheory.StructuredArrow.mapNatIso_functor_map_left {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {T T' : Functor C D} (i : T ≅ T') {X✝ Y✝ : Comma (Functor.fromPUnit S) T} (f : X✝ ⟶ Y✝) : ((mapNatIso i).functor.map f).left = CategoryStruct.id X✝.left

@[simp]

theorem CategoryTheory.StructuredArrow.mapNatIso_counitIso_inv_app_right {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {T T' : Functor C D} (i : T ≅ T') (X : Comma (Functor.fromPUnit S) T') : ((mapNatIso i).counitIso.inv.app X).right = CategoryStruct.id X.right

@[simp]

theorem CategoryTheory.StructuredArrow.mapNatIso_unitIso_inv_app_right {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {T T' : Functor C D} (i : T ≅ T') (X : Comma (Functor.fromPUnit S) T) : ((mapNatIso i).unitIso.inv.app X).right = CategoryStruct.id X.right

@[simp]

theorem CategoryTheory.StructuredArrow.mapNatIso_inverse_obj_left {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {T T' : Functor C D} (i : T ≅ T') (X : Comma (Functor.fromPUnit S) T') : ((mapNatIso i).inverse.obj X).left = X.left

@[simp]

theorem CategoryTheory.StructuredArrow.mapNatIso_inverse_map_left {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {T T' : Functor C D} (i : T ≅ T') {X✝ Y✝ : Comma (Functor.fromPUnit S) T'} (f : X✝ ⟶ Y✝) : ((mapNatIso i).inverse.map f).left = CategoryStruct.id X✝.left

@[simp]

theorem CategoryTheory.StructuredArrow.mapNatIso_functor_obj_left {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {T T' : Functor C D} (i : T ≅ T') (X : Comma (Functor.fromPUnit S) T) : ((mapNatIso i).functor.obj X).left = X.left

@[simp]

theorem CategoryTheory.StructuredArrow.mapNatIso_functor_map_right {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {T T' : Functor C D} (i : T ≅ T') {X✝ Y✝ : Comma (Functor.fromPUnit S) T} (f : X✝ ⟶ Y✝) : ((mapNatIso i).functor.map f).right = f.right

instance CategoryTheory.StructuredArrow.proj_reflectsIsomorphisms {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {T : Functor C D} : (proj S T).ReflectsIsomorphisms

noncomputable def CategoryTheory.StructuredArrow.mkIdInitial {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {Y : C} {T : Functor C D} [T.Full] [T.Faithful] : Limits.IsInitial (mk (CategoryStruct.id (T.obj Y)))

The identity structured arrow is initial.

def CategoryTheory.StructuredArrow.pre {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {B : Type u₄} [Category.{v₄, u₄} B] (S : D) (F : Functor B C) (G : Functor C D) : Functor (StructuredArrow S (F.comp G)) (StructuredArrow S G)

The functor (S, F ⋙ G) ⥤ (S, G).

@[simp]

theorem CategoryTheory.StructuredArrow.pre_map_left {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {B : Type u₄} [Category.{v₄, u₄} B] (S : D) (F : Functor B C) (G : Functor C D) {X✝ Y✝ : Comma (Functor.fromPUnit S) (F.comp G)} (f : X✝ ⟶ Y✝) : ((pre S F G).map f).left = CategoryStruct.id X✝.left

@[simp]

theorem CategoryTheory.StructuredArrow.pre_obj_right {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {B : Type u₄} [Category.{v₄, u₄} B] (S : D) (F : Functor B C) (G : Functor C D) (X : Comma (Functor.fromPUnit S) (F.comp G)) : ((pre S F G).obj X).right = F.obj X.right

@[simp]

theorem CategoryTheory.StructuredArrow.pre_obj_hom {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {B : Type u₄} [Category.{v₄, u₄} B] (S : D) (F : Functor B C) (G : Functor C D) (X : Comma (Functor.fromPUnit S) (F.comp G)) : ((pre S F G).obj X).hom = X.hom

@[simp]

theorem CategoryTheory.StructuredArrow.pre_map_right {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {B : Type u₄} [Category.{v₄, u₄} B] (S : D) (F : Functor B C) (G : Functor C D) {X✝ Y✝ : Comma (Functor.fromPUnit S) (F.comp G)} (f : X✝ ⟶ Y✝) : ((pre S F G).map f).right = F.map f.right

@[simp]

theorem CategoryTheory.StructuredArrow.pre_obj_left {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {B : Type u₄} [Category.{v₄, u₄} B] (S : D) (F : Functor B C) (G : Functor C D) (X : Comma (Functor.fromPUnit S) (F.comp G)) : ((pre S F G).obj X).left = X.left

instance CategoryTheory.StructuredArrow.instFaithfulCompPre {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {B : Type u₄} [Category.{v₄, u₄} B] (S : D) (F : Functor B C) (G : Functor C D) [F.Faithful] : (pre S F G).Faithful

instance CategoryTheory.StructuredArrow.instFullCompPre {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {B : Type u₄} [Category.{v₄, u₄} B] (S : D) (F : Functor B C) (G : Functor C D) [F.Full] : (pre S F G).Full

instance CategoryTheory.StructuredArrow.instEssSurjCompPre {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {B : Type u₄} [Category.{v₄, u₄} B] (S : D) (F : Functor B C) (G : Functor C D) [F.EssSurj] : (pre S F G).EssSurj

instance CategoryTheory.StructuredArrow.isEquivalence_pre {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {B : Type u₄} [Category.{v₄, u₄} B] (S : D) (F : Functor B C) (G : Functor C D) [F.IsEquivalence] : (pre S F G).IsEquivalence

If F is an equivalence, then so is the functor (S, F ⋙ G) ⥤ (S, G).

def CategoryTheory.StructuredArrow.post {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {B : Type u₄} [Category.{v₄, u₄} B] (S : C) (F : Functor B C) (G : Functor C D) : Functor (StructuredArrow S F) (StructuredArrow (G.obj S) (F.comp G))

The functor (S, F) ⥤ (G(S), F ⋙ G).

@[simp]

theorem CategoryTheory.StructuredArrow.post_obj {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {B : Type u₄} [Category.{v₄, u₄} B] (S : C) (F : Functor B C) (G : Functor C D) (X : StructuredArrow S F) : (post S F G).obj X = mk (G.map X.hom)

@[simp]

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

instance CategoryTheory.StructuredArrow.instFaithfulObjCompPost {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {B : Type u₄} [Category.{v₄, u₄} B] (S : C) (F : Functor B C) (G : Functor C D) : (post S F G).Faithful

instance CategoryTheory.StructuredArrow.instFullObjCompPostOfFaithful {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {B : Type u₄} [Category.{v₄, u₄} B] (S : C) (F : Functor B C) (G : Functor C D) [G.Faithful] : (post S F G).Full

instance CategoryTheory.StructuredArrow.instEssSurjObjCompPostOfFull {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {B : Type u₄} [Category.{v₄, u₄} B] (S : C) (F : Functor B C) (G : Functor C D) [G.Full] : (post S F G).EssSurj

instance CategoryTheory.StructuredArrow.isEquivalence_post {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {B : Type u₄} [Category.{v₄, u₄} B] (S : C) (F : Functor B C) (G : Functor C D) [G.Full] [G.Faithful] : (post S F G).IsEquivalence

If G is fully faithful, then post S F G : (S, F) ⥤ (G(S), F ⋙ G) is an equivalence.

def CategoryTheory.StructuredArrow.map₂ {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {A : Type u₃} [Category.{v₃, u₃} A] {B : Type u₄} [Category.{v₄, u₄} B] {L : D} {R : Functor C D} {L' : B} {R' : Functor A B} {F : Functor C A} {G : Functor D B} (α : L' ⟶ G.obj L) (β : R.comp G ⟶ F.comp R') : Functor (StructuredArrow L R) (StructuredArrow L' R')

The functor StructuredArrow L R ⥤ StructuredArrow L' R' that is deduced from a natural transformation R ⋙ G ⟶ F ⋙ R' and a morphism L' ⟶ G.obj L.

@[simp]

theorem CategoryTheory.StructuredArrow.map₂_map_left {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {A : Type u₃} [Category.{v₃, u₃} A] {B : Type u₄} [Category.{v₄, u₄} B] {L : D} {R : Functor C D} {L' : B} {R' : Functor A B} {F : Functor C A} {G : Functor D B} (α : L' ⟶ G.obj L) (β : R.comp G ⟶ F.comp R') {X Y : Comma (Functor.fromPUnit L) R} (φ : X ⟶ Y) : ((map₂ α β).map φ).left = CategoryStruct.id X.left

@[simp]

theorem CategoryTheory.StructuredArrow.map₂_obj_right {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {A : Type u₃} [Category.{v₃, u₃} A] {B : Type u₄} [Category.{v₄, u₄} B] {L : D} {R : Functor C D} {L' : B} {R' : Functor A B} {F : Functor C A} {G : Functor D B} (α : L' ⟶ G.obj L) (β : R.comp G ⟶ F.comp R') (X : Comma (Functor.fromPUnit L) R) : ((map₂ α β).obj X).right = F.obj X.right

@[simp]

theorem CategoryTheory.StructuredArrow.map₂_obj_hom {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {A : Type u₃} [Category.{v₃, u₃} A] {B : Type u₄} [Category.{v₄, u₄} B] {L : D} {R : Functor C D} {L' : B} {R' : Functor A B} {F : Functor C A} {G : Functor D B} (α : L' ⟶ G.obj L) (β : R.comp G ⟶ F.comp R') (X : Comma (Functor.fromPUnit L) R) : ((map₂ α β).obj X).hom = CategoryStruct.comp α (CategoryStruct.comp (G.map X.hom) (β.app X.right))

@[simp]

theorem CategoryTheory.StructuredArrow.map₂_obj_left {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {A : Type u₃} [Category.{v₃, u₃} A] {B : Type u₄} [Category.{v₄, u₄} B] {L : D} {R : Functor C D} {L' : B} {R' : Functor A B} {F : Functor C A} {G : Functor D B} (α : L' ⟶ G.obj L) (β : R.comp G ⟶ F.comp R') (X : Comma (Functor.fromPUnit L) R) : ((map₂ α β).obj X).left = X.left

@[simp]

theorem CategoryTheory.StructuredArrow.map₂_map_right {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {A : Type u₃} [Category.{v₃, u₃} A] {B : Type u₄} [Category.{v₄, u₄} B] {L : D} {R : Functor C D} {L' : B} {R' : Functor A B} {F : Functor C A} {G : Functor D B} (α : L' ⟶ G.obj L) (β : R.comp G ⟶ F.comp R') {X Y : Comma (Functor.fromPUnit L) R} (φ : X ⟶ Y) : ((map₂ α β).map φ).right = F.map φ.right

instance CategoryTheory.StructuredArrow.faithful_map₂ {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {A : Type u₃} [Category.{v₃, u₃} A] {B : Type u₄} [Category.{v₄, u₄} B] {L : D} {R : Functor C D} {L' : B} {R' : Functor A B} {F : Functor C A} {G : Functor D B} (α : L' ⟶ G.obj L) (β : R.comp G ⟶ F.comp R') [F.Faithful] : (map₂ α β).Faithful

instance CategoryTheory.StructuredArrow.full_map₂ {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {A : Type u₃} [Category.{v₃, u₃} A] {B : Type u₄} [Category.{v₄, u₄} B] {L : D} {R : Functor C D} {L' : B} {R' : Functor A B} {F : Functor C A} {G : Functor D B} (α : L' ⟶ G.obj L) (β : R.comp G ⟶ F.comp R') [G.Faithful] [F.Full] [IsIso α] [IsIso β] : (map₂ α β).Full

instance CategoryTheory.StructuredArrow.essSurj_map₂ {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {A : Type u₃} [Category.{v₃, u₃} A] {B : Type u₄} [Category.{v₄, u₄} B] {L : D} {R : Functor C D} {L' : B} {R' : Functor A B} {F : Functor C A} {G : Functor D B} (α : L' ⟶ G.obj L) (β : R.comp G ⟶ F.comp R') [F.EssSurj] [G.Full] [IsIso α] [IsIso β] : (map₂ α β).EssSurj

instance CategoryTheory.StructuredArrow.isEquivalenceMap₂ {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {A : Type u₃} [Category.{v₃, u₃} A] {B : Type u₄} [Category.{v₄, u₄} B] {L : D} {R : Functor C D} {L' : B} {R' : Functor A B} {F : Functor C A} {G : Functor D B} (α : L' ⟶ G.obj L) (β : R.comp G ⟶ F.comp R') [F.IsEquivalence] [G.Faithful] [G.Full] [IsIso α] [IsIso β] : (map₂ α β).IsEquivalence

def CategoryTheory.StructuredArrow.map₂CompMap₂Iso {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {A : Type u₃} [Category.{v₃, u₃} A] {B : Type u₄} [Category.{v₄, u₄} B] {L : D} {R : Functor C D} {L' : B} {R' : Functor A B} {F : Functor C A} {G : Functor D B} (α : L' ⟶ G.obj L) (β : R.comp G ⟶ F.comp R') {C' : Type u₆} [Category.{v₆, u₆} C'] {D' : Type u₅} [Category.{v₅, u₅} D'] {L'' : D'} {R'' : Functor C' D'} {F' : Functor C' C} {G' : Functor D' D} (α' : L ⟶ G'.obj L'') (β' : R''.comp G' ⟶ F'.comp R) : (map₂ α' β').comp (map₂ α β) ≅ map₂ (CategoryStruct.comp α (G.map α')) (CategoryStruct.comp (R''.associator G' G).inv (CategoryStruct.comp (Functor.whiskerRight β' G) (CategoryStruct.comp (F'.associator R G).hom (CategoryStruct.comp (F'.whiskerLeft β) (F'.associator F R').inv))))

The composition of two applications of map₂ is naturally isomorphic to a single such one.

def CategoryTheory.StructuredArrow.postIsoMap₂ {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {B : Type u₄} [Category.{v₄, u₄} B] (S : C) (F : Functor B C) (G : Functor C D) : post S F G ≅ map₂ (CategoryStruct.id (G.obj S)) (CategoryStruct.id (F.comp G))

StructuredArrow.post is a special case of StructuredArrow.map₂ up to natural isomorphism.

def CategoryTheory.StructuredArrow.mapIsoMap₂ {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : Functor C D} {S S' : D} (f : S ⟶ S') : map f ≅ map₂ f (CategoryStruct.id T)

StructuredArrow.map is a special case of StructuredArrow.map₂ up to natural isomorphism.

def CategoryTheory.StructuredArrow.preIsoMap₂ {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {B : Type u₄} [Category.{v₄, u₄} B] (S : D) (F : Functor B C) (G : Functor C D) : pre S F G ≅ map₂ (CategoryStruct.id S) (CategoryStruct.id (F.comp G))

StructuredArrow.pre is a special case of StructuredArrow.map₂ up to natural isomorphism.

@[reducible, inline]

abbrev CategoryTheory.StructuredArrow.IsUniversal {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {T : Functor C D} (f : StructuredArrow S T) : Type (max (max u₁ v₂) v₁)

A structured arrow is called universal if it is initial.

theorem CategoryTheory.StructuredArrow.IsUniversal.uniq {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {T : Functor C D} {f g : StructuredArrow S T} (h : f.IsUniversal) (η : f ⟶ g) : η = Limits.IsInitial.to h g

def CategoryTheory.StructuredArrow.IsUniversal.desc {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {T : Functor C D} {f : StructuredArrow S T} (h : f.IsUniversal) (g : StructuredArrow S T) : f.right ⟶ g.right

The family of morphisms out of a universal arrow.

@[simp]

theorem CategoryTheory.StructuredArrow.IsUniversal.fac {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {T : Functor C D} {f : StructuredArrow S T} (h : f.IsUniversal) (g : StructuredArrow S T) : CategoryStruct.comp f.hom (T.map (h.desc g)) = g.hom

Any structured arrow factors through a universal arrow.

@[simp]

theorem CategoryTheory.StructuredArrow.IsUniversal.fac_assoc {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {T : Functor C D} {f : StructuredArrow S T} (h : f.IsUniversal) (g : StructuredArrow S T) {Z : D} (h✝ : T.obj g.right ⟶ Z) : CategoryStruct.comp f.hom (CategoryStruct.comp (T.map (h.desc g)) h✝) = CategoryStruct.comp g.hom h✝

Any structured arrow factors through a universal arrow.

theorem CategoryTheory.StructuredArrow.IsUniversal.hom_desc {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {T : Functor C D} {f : StructuredArrow S T} (h : f.IsUniversal) {c : C} (η : f.right ⟶ c) : η = h.desc (mk (CategoryStruct.comp f.hom (T.map η)))

theorem CategoryTheory.StructuredArrow.IsUniversal.hom_ext {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {T : Functor C D} {f : StructuredArrow S T} (h : f.IsUniversal) {c : C} {η η' : f.right ⟶ c} (w : CategoryStruct.comp f.hom (T.map η) = CategoryStruct.comp f.hom (T.map η')) : η = η'

Two morphisms out of a universal T-structured arrow are equal if their image under T are equal after precomposing the universal arrow.

theorem CategoryTheory.StructuredArrow.IsUniversal.existsUnique {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {S : D} {T : Functor C D} {f : StructuredArrow S T} (h : f.IsUniversal) (g : StructuredArrow S T) : ∃! η : f.right ⟶ g.right, CategoryStruct.comp f.hom (T.map η) = g.hom

def CategoryTheory.CostructuredArrow {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] (S : Functor C D) (T : D) : Type (max u₁ v₂)

The category of S-costructured arrows with target T : D (here S : C ⥤ D), has as its objects D-morphisms of the form S Y ⟶ T, for some Y : C, and morphisms C-morphisms Y ⟶ Y' making the obvious triangle commute.

instance CategoryTheory.instCategoryCostructuredArrow {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] (S : Functor C D) (T : D) : Category.{v₁, max u₁ v₂} (CostructuredArrow S T)

def CategoryTheory.CostructuredArrow.proj {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] (S : Functor C D) (T : D) : Functor (CostructuredArrow S T) C

The obvious projection functor from costructured arrows.

@[simp]

theorem CategoryTheory.CostructuredArrow.proj_map {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] (S : Functor C D) (T : D) {X✝ Y✝ : Comma S (Functor.fromPUnit T)} (f : X✝ ⟶ Y✝) : (proj S T).map f = f.left

@[simp]

theorem CategoryTheory.CostructuredArrow.proj_obj {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] (S : Functor C D) (T : D) (X : Comma S (Functor.fromPUnit T)) : (proj S T).obj X = X.left

theorem CategoryTheory.CostructuredArrow.hom_ext {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S : Functor C D} {X Y : CostructuredArrow S T} (f g : X ⟶ Y) (h : f.left = g.left) : f = g

theorem CategoryTheory.CostructuredArrow.hom_ext_iff {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S : Functor C D} {X Y : CostructuredArrow S T} {f g : X ⟶ Y} : f = g ↔ f.left = g.left

@[simp]

theorem CategoryTheory.CostructuredArrow.hom_eq_iff {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S : Functor C D} {X Y : CostructuredArrow S T} (f g : X ⟶ Y) : f = g ↔ f.left = g.left

def CategoryTheory.CostructuredArrow.mk {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {Y : C} {S : Functor C D} (f : S.obj Y ⟶ T) : CostructuredArrow S T

Construct a costructured arrow from a morphism.

@[simp]

theorem CategoryTheory.CostructuredArrow.mk_left {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {Y : C} {S : Functor C D} (f : S.obj Y ⟶ T) : (mk f).left = Y

@[simp]

theorem CategoryTheory.CostructuredArrow.mk_right {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {Y : C} {S : Functor C D} (f : S.obj Y ⟶ T) : (mk f).right = { as := PUnit.unit }

@[simp]

theorem CategoryTheory.CostructuredArrow.mk_hom_eq_self {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {Y : C} {S : Functor C D} (f : S.obj Y ⟶ T) : (mk f).hom = f

theorem CategoryTheory.CostructuredArrow.w {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S : Functor C D} {A B : CostructuredArrow S T} (f : A ⟶ B) : CategoryStruct.comp (S.map f.left) B.hom = A.hom

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

@[simp]

theorem CategoryTheory.CostructuredArrow.comp_left {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S : Functor C D} {X Y Z : CostructuredArrow S T} (f : X ⟶ Y) (g : Y ⟶ Z) : (CategoryStruct.comp f g).left = CategoryStruct.comp f.left g.left

@[simp]

theorem CategoryTheory.CostructuredArrow.id_left {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S : Functor C D} (X : CostructuredArrow S T) : (CategoryStruct.id X).left = CategoryStruct.id X.left

@[simp]

theorem CategoryTheory.CostructuredArrow.eqToHom_left {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S : Functor C D} {X Y : CostructuredArrow S T} (h : X = Y) : (eqToHom h).left = eqToHom ⋯

@[simp]

theorem CategoryTheory.CostructuredArrow.right_eq_id {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S : Functor C D} {X Y : CostructuredArrow S T} (f : X ⟶ Y) : f.right = CategoryStruct.id X.right

def CategoryTheory.CostructuredArrow.homMk {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S : Functor C D} {f f' : CostructuredArrow S T} (g : f.left ⟶ f'.left) (w : CategoryStruct.comp (S.map g) f'.hom = f.hom := by cat_disch) : f ⟶ f'

To construct a morphism of costructured arrows, we need a morphism of the objects underlying the source, and to check that the triangle commutes.

@[simp]

theorem CategoryTheory.CostructuredArrow.homMk_left {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S : Functor C D} {f f' : CostructuredArrow S T} (g : f.left ⟶ f'.left) (w : CategoryStruct.comp (S.map g) f'.hom = f.hom := by cat_disch) : (homMk g w).left = g

theorem CategoryTheory.CostructuredArrow.homMk_surjective {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S : Functor C D} {f f' : CostructuredArrow S T} (φ : f ⟶ f') : ∃ (ψ : f.left ⟶ f'.left) (hψ : CategoryStruct.comp (S.map ψ) f'.hom = f.hom), φ = homMk ψ hψ

def CategoryTheory.CostructuredArrow.homMk' {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {Y' : C} {S : Functor C D} (f : CostructuredArrow S T) (g : Y' ⟶ f.left) : mk (CategoryStruct.comp (S.map g) f.hom) ⟶ f

Given a costructured arrow S(Y) ⟶ X, and an arrow Y' ⟶ Y', we can construct a morphism of costructured arrows given by (S(Y) ⟶ X) ⟶ (S(Y') ⟶ S(Y) ⟶ X).

@[simp]

theorem CategoryTheory.CostructuredArrow.homMk'_right {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {Y' : C} {S : Functor C D} (f : CostructuredArrow S T) (g : Y' ⟶ f.left) : (f.homMk' g).right = CategoryStruct.id (mk (CategoryStruct.comp (S.map g) f.hom)).right

@[simp]

theorem CategoryTheory.CostructuredArrow.homMk'_left {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {Y' : C} {S : Functor C D} (f : CostructuredArrow S T) (g : Y' ⟶ f.left) : (f.homMk' g).left = g

theorem CategoryTheory.CostructuredArrow.homMk'_id {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S : Functor C D} (f : CostructuredArrow S T) : f.homMk' (CategoryStruct.id f.left) = eqToHom ⋯

theorem CategoryTheory.CostructuredArrow.homMk'_mk_id {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {Y : C} {S : Functor C D} (f : S.obj Y ⟶ T) : (mk f).homMk' (CategoryStruct.id Y) = eqToHom ⋯

theorem CategoryTheory.CostructuredArrow.homMk'_comp {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {Y' Y'' : C} {S : Functor C D} (f : CostructuredArrow S T) (g : Y' ⟶ f.left) (g' : Y'' ⟶ Y') : f.homMk' (CategoryStruct.comp g' g) = CategoryStruct.comp (eqToHom ⋯) (CategoryStruct.comp ((mk (CategoryStruct.comp (S.map g) f.hom)).homMk' g') (f.homMk' g))

theorem CategoryTheory.CostructuredArrow.homMk'_mk_comp {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {Y Y' Y'' : C} {S : Functor C D} (f : S.obj Y ⟶ T) (g : Y' ⟶ Y) (g' : Y'' ⟶ Y') : (mk f).homMk' (CategoryStruct.comp g' g) = CategoryStruct.comp (eqToHom ⋯) (CategoryStruct.comp ((mk (CategoryStruct.comp (S.map g) f)).homMk' g') ((mk f).homMk' g))

def CategoryTheory.CostructuredArrow.mkPrecomp {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {Y Y' : C} {S : Functor C D} (f : S.obj Y ⟶ T) (g : Y' ⟶ Y) : mk (CategoryStruct.comp (S.map g) f) ⟶ mk f

Variant of homMk' where both objects are applications of mk.

@[simp]

theorem CategoryTheory.CostructuredArrow.mkPrecomp_right {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {Y Y' : C} {S : Functor C D} (f : S.obj Y ⟶ T) (g : Y' ⟶ Y) : (mkPrecomp f g).right = CategoryStruct.id (mk (CategoryStruct.comp (S.map g) f)).right

@[simp]

theorem CategoryTheory.CostructuredArrow.mkPrecomp_left {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {Y Y' : C} {S : Functor C D} (f : S.obj Y ⟶ T) (g : Y' ⟶ Y) : (mkPrecomp f g).left = g

theorem CategoryTheory.CostructuredArrow.mkPrecomp_id {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {Y : C} {S : Functor C D} (f : S.obj Y ⟶ T) : mkPrecomp f (CategoryStruct.id Y) = eqToHom ⋯

theorem CategoryTheory.CostructuredArrow.mkPrecomp_comp {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {Y Y' Y'' : C} {S : Functor C D} (f : S.obj Y ⟶ T) (g : Y' ⟶ Y) (g' : Y'' ⟶ Y') : mkPrecomp f (CategoryStruct.comp g' g) = CategoryStruct.comp (eqToHom ⋯) (CategoryStruct.comp (mkPrecomp (CategoryStruct.comp (S.map g) f) g') (mkPrecomp f g))

def CategoryTheory.CostructuredArrow.isoMk {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S : Functor C D} {f f' : CostructuredArrow S T} (g : f.left ≅ f'.left) (w : CategoryStruct.comp (S.map g.hom) f'.hom = f.hom := by cat_disch) : f ≅ f'

To construct an isomorphism of costructured arrows, we need an isomorphism of the objects underlying the source, and to check that the triangle commutes.

@[simp]

theorem CategoryTheory.CostructuredArrow.isoMk_inv_left {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S : Functor C D} {f f' : CostructuredArrow S T} (g : f.left ≅ f'.left) (w : CategoryStruct.comp (S.map g.hom) f'.hom = f.hom := by cat_disch) : (isoMk g w).inv.left = g.inv

@[simp]

theorem CategoryTheory.CostructuredArrow.isoMk_hom_left {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S : Functor C D} {f f' : CostructuredArrow S T} (g : f.left ≅ f'.left) (w : CategoryStruct.comp (S.map g.hom) f'.hom = f.hom := by cat_disch) : (isoMk g w).hom.left = g.hom

theorem CategoryTheory.CostructuredArrow.obj_ext {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S : Functor C D} (x y : CostructuredArrow S T) (hl : x.left = y.left) (hh : CategoryStruct.comp (S.map (eqToHom hl)) y.hom = x.hom) : x = y

theorem CategoryTheory.CostructuredArrow.ext {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S : Functor C D} {A B : CostructuredArrow S T} (f g : A ⟶ B) (h : f.left = g.left) : f = g

theorem CategoryTheory.CostructuredArrow.ext_iff {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S : Functor C D} {A B : CostructuredArrow S T} (f g : A ⟶ B) : f = g ↔ f.left = g.left

instance CategoryTheory.CostructuredArrow.proj_faithful {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S : Functor C D} : (proj S T).Faithful

theorem CategoryTheory.CostructuredArrow.mono_of_mono_left {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S : Functor C D} {A B : CostructuredArrow S T} (f : A ⟶ B) [h : Mono f.left] : Mono f

theorem CategoryTheory.CostructuredArrow.epi_of_epi_left {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S : Functor C D} {A B : CostructuredArrow S T} (f : A ⟶ B) [h : Epi f.left] : Epi f

The converse of this is true with additional assumptions, see epi_iff_epi_left.

instance CategoryTheory.CostructuredArrow.mono_homMk {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S : Functor C D} {A B : CostructuredArrow S T} (f : A.left ⟶ B.left) (w : CategoryStruct.comp (S.map f) B.hom = A.hom) [h : Mono f] : Mono (homMk f w)

instance CategoryTheory.CostructuredArrow.epi_homMk {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S : Functor C D} {A B : CostructuredArrow S T} (f : A.left ⟶ B.left) (w : CategoryStruct.comp (S.map f) B.hom = A.hom) [h : Epi f] : Epi (homMk f w)

theorem CategoryTheory.CostructuredArrow.eq_mk {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S : Functor C D} (f : CostructuredArrow S T) : f = mk f.hom

Eta rule for costructured arrows. Prefer CostructuredArrow.eta for rewriting, as equality of objects tends to cause problems.

def CategoryTheory.CostructuredArrow.eta {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S : Functor C D} (f : CostructuredArrow S T) : f ≅ mk f.hom

Eta rule for costructured arrows.

@[simp]

theorem CategoryTheory.CostructuredArrow.eta_hom_left {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S : Functor C D} (f : CostructuredArrow S T) : f.eta.hom.left = CategoryStruct.id f.left

@[simp]

theorem CategoryTheory.CostructuredArrow.eta_inv_left {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S : Functor C D} (f : CostructuredArrow S T) : f.eta.inv.left = CategoryStruct.id f.left

theorem CategoryTheory.CostructuredArrow.mk_surjective {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S : Functor C D} (f : CostructuredArrow S T) : ∃ (Y : C) (g : S.obj Y ⟶ T), f = mk g

def CategoryTheory.CostructuredArrow.map {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T T' : D} {S : Functor C D} (f : T ⟶ T') : Functor (CostructuredArrow S T) (CostructuredArrow S T')

A morphism between target objects T ⟶ T' covariantly induces a functor between costructured arrows, CostructuredArrow S T ⥤ CostructuredArrow S T'.

Ideally this would be described as a 2-functor from D (promoted to a 2-category with equations as 2-morphisms) to Cat.

@[simp]

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

@[simp]

theorem CategoryTheory.CostructuredArrow.map_obj_right {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T T' : D} {S : Functor C D} (f : T ⟶ T') (X : Comma S (Functor.fromPUnit T)) : ((map f).obj X).right = X.right

@[simp]

theorem CategoryTheory.CostructuredArrow.map_map_left {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T T' : D} {S : Functor C D} (f : T ⟶ T') {X✝ Y✝ : Comma S (Functor.fromPUnit T)} (f✝ : X✝ ⟶ Y✝) : ((map f).map f✝).left = f✝.left

@[simp]

theorem CategoryTheory.CostructuredArrow.map_obj_left {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T T' : D} {S : Functor C D} (f : T ⟶ T') (X : Comma S (Functor.fromPUnit T)) : ((map f).obj X).left = X.left

@[simp]

theorem CategoryTheory.CostructuredArrow.map_obj_hom {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T T' : D} {S : Functor C D} (f : T ⟶ T') (X : Comma S (Functor.fromPUnit T)) : ((map f).obj X).hom = CategoryStruct.comp X.hom f

@[simp]

theorem CategoryTheory.CostructuredArrow.map_mk {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T T' : D} {Y : C} {S : Functor C D} {f : S.obj Y ⟶ T} (g : T ⟶ T') : (map g).obj (mk f) = mk (CategoryStruct.comp f g)

@[simp]

theorem CategoryTheory.CostructuredArrow.map_id {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S : Functor C D} {f : CostructuredArrow S T} : (map (CategoryStruct.id T)).obj f = f

@[simp]

theorem CategoryTheory.CostructuredArrow.map_comp {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T T' T'' : D} {S : Functor C D} {f : T ⟶ T'} {f' : T' ⟶ T''} {h : CostructuredArrow S T} : (map (CategoryStruct.comp f f')).obj h = (map f').obj ((map f).obj h)

def CategoryTheory.CostructuredArrow.mapIso {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T T' : D} {S : Functor C D} (i : T ≅ T') : CostructuredArrow S T ≌ CostructuredArrow S T'

An isomorphism T ≅ T' induces an equivalence CostructuredArrow S T ≌ CostructuredArrow S T'.

@[simp]

theorem CategoryTheory.CostructuredArrow.mapIso_counitIso_inv_app_left {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T T' : D} {S : Functor C D} (i : T ≅ T') (X : Comma S (Functor.fromPUnit T')) : ((mapIso i).counitIso.inv.app X).left = CategoryStruct.id X.left

@[simp]

theorem CategoryTheory.CostructuredArrow.mapIso_functor_map_right {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T T' : D} {S : Functor C D} (i : T ≅ T') {X✝ Y✝ : Comma S (Functor.fromPUnit T)} (f : X✝ ⟶ Y✝) : ((mapIso i).functor.map f).right = CategoryStruct.id X✝.right

@[simp]

theorem CategoryTheory.CostructuredArrow.mapIso_inverse_obj_left {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T T' : D} {S : Functor C D} (i : T ≅ T') (X : Comma S (Functor.fromPUnit T')) : ((mapIso i).inverse.obj X).left = X.left

@[simp]

theorem CategoryTheory.CostructuredArrow.mapIso_inverse_map_right {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T T' : D} {S : Functor C D} (i : T ≅ T') {X✝ Y✝ : Comma S (Functor.fromPUnit T')} (f : X✝ ⟶ Y✝) : ((mapIso i).inverse.map f).right = CategoryStruct.id X✝.right

@[simp]

theorem CategoryTheory.CostructuredArrow.mapIso_inverse_obj_hom {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T T' : D} {S : Functor C D} (i : T ≅ T') (X : Comma S (Functor.fromPUnit T')) : ((mapIso i).inverse.obj X).hom = CategoryStruct.comp X.hom i.inv

@[simp]

theorem CategoryTheory.CostructuredArrow.mapIso_functor_obj_right {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T T' : D} {S : Functor C D} (i : T ≅ T') (X : Comma S (Functor.fromPUnit T)) : ((mapIso i).functor.obj X).right = X.right

@[simp]

theorem CategoryTheory.CostructuredArrow.mapIso_inverse_map_left {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T T' : D} {S : Functor C D} (i : T ≅ T') {X✝ Y✝ : Comma S (Functor.fromPUnit T')} (f : X✝ ⟶ Y✝) : ((mapIso i).inverse.map f).left = f.left

@[simp]

theorem CategoryTheory.CostructuredArrow.mapIso_functor_map_left {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T T' : D} {S : Functor C D} (i : T ≅ T') {X✝ Y✝ : Comma S (Functor.fromPUnit T)} (f : X✝ ⟶ Y✝) : ((mapIso i).functor.map f).left = f.left

@[simp]

theorem CategoryTheory.CostructuredArrow.mapIso_functor_obj_hom {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T T' : D} {S : Functor C D} (i : T ≅ T') (X : Comma S (Functor.fromPUnit T)) : ((mapIso i).functor.obj X).hom = CategoryStruct.comp X.hom i.hom

@[simp]

theorem CategoryTheory.CostructuredArrow.mapIso_counitIso_hom_app_left {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T T' : D} {S : Functor C D} (i : T ≅ T') (X : Comma S (Functor.fromPUnit T')) : ((mapIso i).counitIso.hom.app X).left = CategoryStruct.id X.left

@[simp]

theorem CategoryTheory.CostructuredArrow.mapIso_inverse_obj_right {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T T' : D} {S : Functor C D} (i : T ≅ T') (X : Comma S (Functor.fromPUnit T')) : ((mapIso i).inverse.obj X).right = X.right

@[simp]

theorem CategoryTheory.CostructuredArrow.mapIso_unitIso_inv_app_left {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T T' : D} {S : Functor C D} (i : T ≅ T') (X : Comma S (Functor.fromPUnit T)) : ((mapIso i).unitIso.inv.app X).left = CategoryStruct.id X.left

@[simp]

theorem CategoryTheory.CostructuredArrow.mapIso_functor_obj_left {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T T' : D} {S : Functor C D} (i : T ≅ T') (X : Comma S (Functor.fromPUnit T)) : ((mapIso i).functor.obj X).left = X.left

@[simp]

theorem CategoryTheory.CostructuredArrow.mapIso_unitIso_hom_app_left {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T T' : D} {S : Functor C D} (i : T ≅ T') (X : Comma S (Functor.fromPUnit T)) : ((mapIso i).unitIso.hom.app X).left = CategoryStruct.id X.left

def CategoryTheory.CostructuredArrow.mapNatIso {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S S' : Functor C D} (i : S ≅ S') : CostructuredArrow S T ≌ CostructuredArrow S' T

A natural isomorphism S ≅ S' induces an equivalence CostrucutredArrow S T ≌ CostructuredArrow S' T.

@[simp]

theorem CategoryTheory.CostructuredArrow.mapNatIso_counitIso_inv_app_left {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S S' : Functor C D} (i : S ≅ S') (X : Comma S' (Functor.fromPUnit T)) : ((mapNatIso i).counitIso.inv.app X).left = CategoryStruct.id X.left

@[simp]

theorem CategoryTheory.CostructuredArrow.mapNatIso_functor_obj_hom {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S S' : Functor C D} (i : S ≅ S') (X : Comma S (Functor.fromPUnit T)) : ((mapNatIso i).functor.obj X).hom = CategoryStruct.comp (i.inv.app X.left) X.hom

@[simp]

theorem CategoryTheory.CostructuredArrow.mapNatIso_inverse_obj_hom {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S S' : Functor C D} (i : S ≅ S') (X : Comma S' (Functor.fromPUnit T)) : ((mapNatIso i).inverse.obj X).hom = CategoryStruct.comp (i.hom.app X.left) X.hom

@[simp]

theorem CategoryTheory.CostructuredArrow.mapNatIso_functor_obj_right {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S S' : Functor C D} (i : S ≅ S') (X : Comma S (Functor.fromPUnit T)) : ((mapNatIso i).functor.obj X).right = X.right

@[simp]

theorem CategoryTheory.CostructuredArrow.mapNatIso_inverse_obj_right {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S S' : Functor C D} (i : S ≅ S') (X : Comma S' (Functor.fromPUnit T)) : ((mapNatIso i).inverse.obj X).right = X.right

@[simp]

theorem CategoryTheory.CostructuredArrow.mapNatIso_functor_map_left {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S S' : Functor C D} (i : S ≅ S') {X✝ Y✝ : Comma S (Functor.fromPUnit T)} (f : X✝ ⟶ Y✝) : ((mapNatIso i).functor.map f).left = f.left

@[simp]

theorem CategoryTheory.CostructuredArrow.mapNatIso_functor_map_right {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S S' : Functor C D} (i : S ≅ S') {X✝ Y✝ : Comma S (Functor.fromPUnit T)} (f : X✝ ⟶ Y✝) : ((mapNatIso i).functor.map f).right = CategoryStruct.id X✝.right

@[simp]

theorem CategoryTheory.CostructuredArrow.mapNatIso_inverse_obj_left {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S S' : Functor C D} (i : S ≅ S') (X : Comma S' (Functor.fromPUnit T)) : ((mapNatIso i).inverse.obj X).left = X.left

@[simp]

theorem CategoryTheory.CostructuredArrow.mapNatIso_unitIso_hom_app_left {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S S' : Functor C D} (i : S ≅ S') (X : Comma S (Functor.fromPUnit T)) : ((mapNatIso i).unitIso.hom.app X).left = CategoryStruct.id X.left

@[simp]

theorem CategoryTheory.CostructuredArrow.mapNatIso_functor_obj_left {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S S' : Functor C D} (i : S ≅ S') (X : Comma S (Functor.fromPUnit T)) : ((mapNatIso i).functor.obj X).left = X.left

@[simp]

theorem CategoryTheory.CostructuredArrow.mapNatIso_counitIso_hom_app_left {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S S' : Functor C D} (i : S ≅ S') (X : Comma S' (Functor.fromPUnit T)) : ((mapNatIso i).counitIso.hom.app X).left = CategoryStruct.id X.left

@[simp]

theorem CategoryTheory.CostructuredArrow.mapNatIso_unitIso_inv_app_left {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S S' : Functor C D} (i : S ≅ S') (X : Comma S (Functor.fromPUnit T)) : ((mapNatIso i).unitIso.inv.app X).left = CategoryStruct.id X.left

@[simp]

theorem CategoryTheory.CostructuredArrow.mapNatIso_inverse_map_right {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S S' : Functor C D} (i : S ≅ S') {X✝ Y✝ : Comma S' (Functor.fromPUnit T)} (f : X✝ ⟶ Y✝) : ((mapNatIso i).inverse.map f).right = CategoryStruct.id X✝.right

@[simp]

theorem CategoryTheory.CostructuredArrow.mapNatIso_inverse_map_left {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S S' : Functor C D} (i : S ≅ S') {X✝ Y✝ : Comma S' (Functor.fromPUnit T)} (f : X✝ ⟶ Y✝) : ((mapNatIso i).inverse.map f).left = f.left

instance CategoryTheory.CostructuredArrow.proj_reflectsIsomorphisms {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S : Functor C D} : (proj S T).ReflectsIsomorphisms

noncomputable def CategoryTheory.CostructuredArrow.mkIdTerminal {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {Y : C} {S : Functor C D} [S.Full] [S.Faithful] : Limits.IsTerminal (mk (CategoryStruct.id (S.obj Y)))

The identity costructured arrow is terminal.

def CategoryTheory.CostructuredArrow.pre {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {B : Type u₄} [Category.{v₄, u₄} B] (F : Functor B C) (G : Functor C D) (S : D) : Functor (CostructuredArrow (F.comp G) S) (CostructuredArrow G S)

The functor (F ⋙ G, S) ⥤ (G, S).

@[simp]

theorem CategoryTheory.CostructuredArrow.pre_map_right {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {B : Type u₄} [Category.{v₄, u₄} B] (F : Functor B C) (G : Functor C D) (S : D) {X✝ Y✝ : Comma (F.comp G) (Functor.fromPUnit S)} (f : X✝ ⟶ Y✝) : ((pre F G S).map f).right = CategoryStruct.id X✝.right

@[simp]

theorem CategoryTheory.CostructuredArrow.pre_map_left {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {B : Type u₄} [Category.{v₄, u₄} B] (F : Functor B C) (G : Functor C D) (S : D) {X✝ Y✝ : Comma (F.comp G) (Functor.fromPUnit S)} (f : X✝ ⟶ Y✝) : ((pre F G S).map f).left = F.map f.left

@[simp]

theorem CategoryTheory.CostructuredArrow.pre_obj_right {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {B : Type u₄} [Category.{v₄, u₄} B] (F : Functor B C) (G : Functor C D) (S : D) (X : Comma (F.comp G) (Functor.fromPUnit S)) : ((pre F G S).obj X).right = X.right

@[simp]

theorem CategoryTheory.CostructuredArrow.pre_obj_left {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {B : Type u₄} [Category.{v₄, u₄} B] (F : Functor B C) (G : Functor C D) (S : D) (X : Comma (F.comp G) (Functor.fromPUnit S)) : ((pre F G S).obj X).left = F.obj X.left

@[simp]

theorem CategoryTheory.CostructuredArrow.pre_obj_hom {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {B : Type u₄} [Category.{v₄, u₄} B] (F : Functor B C) (G : Functor C D) (S : D) (X : Comma (F.comp G) (Functor.fromPUnit S)) : ((pre F G S).obj X).hom = X.hom

instance CategoryTheory.CostructuredArrow.instFaithfulCompPre {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {B : Type u₄} [Category.{v₄, u₄} B] (F : Functor B C) (G : Functor C D) (S : D) [F.Faithful] : (pre F G S).Faithful

instance CategoryTheory.CostructuredArrow.instFullCompPre {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {B : Type u₄} [Category.{v₄, u₄} B] (F : Functor B C) (G : Functor C D) (S : D) [F.Full] : (pre F G S).Full

instance CategoryTheory.CostructuredArrow.instEssSurjCompPre {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {B : Type u₄} [Category.{v₄, u₄} B] (F : Functor B C) (G : Functor C D) (S : D) [F.EssSurj] : (pre F G S).EssSurj

instance CategoryTheory.CostructuredArrow.isEquivalence_pre {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {B : Type u₄} [Category.{v₄, u₄} B] (F : Functor B C) (G : Functor C D) (S : D) [F.IsEquivalence] : (pre F G S).IsEquivalence

If F is an equivalence, then so is the functor (F ⋙ G, S) ⥤ (G, S).

def CategoryTheory.CostructuredArrow.post {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {B : Type u₄} [Category.{v₄, u₄} B] (F : Functor B C) (G : Functor C D) (S : C) : Functor (CostructuredArrow F S) (CostructuredArrow (F.comp G) (G.obj S))

The functor (F, S) ⥤ (F ⋙ G, G(S)).

@[simp]

theorem CategoryTheory.CostructuredArrow.post_obj {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {B : Type u₄} [Category.{v₄, u₄} B] (F : Functor B C) (G : Functor C D) (S : C) (X : CostructuredArrow F S) : (post F G S).obj X = mk (G.map X.hom)

@[simp]

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

instance CategoryTheory.CostructuredArrow.instFaithfulCompObjPost {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {B : Type u₄} [Category.{v₄, u₄} B] (F : Functor B C) (G : Functor C D) (S : C) : (post F G S).Faithful

instance CategoryTheory.CostructuredArrow.instFullCompObjPostOfFaithful {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {B : Type u₄} [Category.{v₄, u₄} B] (F : Functor B C) (G : Functor C D) (S : C) [G.Faithful] : (post F G S).Full

instance CategoryTheory.CostructuredArrow.instEssSurjCompObjPostOfFull {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {B : Type u₄} [Category.{v₄, u₄} B] (F : Functor B C) (G : Functor C D) (S : C) [G.Full] : (post F G S).EssSurj

instance CategoryTheory.CostructuredArrow.isEquivalence_post {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {B : Type u₄} [Category.{v₄, u₄} B] (S : C) (F : Functor B C) (G : Functor C D) [G.Full] [G.Faithful] : (post F G S).IsEquivalence

If G is fully faithful, then post F G S : (F, S) ⥤ (F ⋙ G, G(S)) is an equivalence.

def CategoryTheory.CostructuredArrow.map₂ {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S : Functor C D} {A : Type u₃} [Category.{v₃, u₃} A] {B : Type u₄} [Category.{v₄, u₄} B] {U : Functor A B} {V : B} {F : Functor C A} {G : Functor D B} (α : F.comp U ⟶ S.comp G) (β : G.obj T ⟶ V) : Functor (CostructuredArrow S T) (CostructuredArrow U V)

The functor CostructuredArrow S T ⥤ CostructuredArrow U V that is deduced from a natural transformation F ⋙ U ⟶ S ⋙ G and a morphism G.obj T ⟶ V

@[simp]

theorem CategoryTheory.CostructuredArrow.map₂_obj_right {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S : Functor C D} {A : Type u₃} [Category.{v₃, u₃} A] {B : Type u₄} [Category.{v₄, u₄} B] {U : Functor A B} {V : B} {F : Functor C A} {G : Functor D B} (α : F.comp U ⟶ S.comp G) (β : G.obj T ⟶ V) (X : Comma S (Functor.fromPUnit T)) : ((map₂ α β).obj X).right = X.right

@[simp]

theorem CategoryTheory.CostructuredArrow.map₂_map_right {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S : Functor C D} {A : Type u₃} [Category.{v₃, u₃} A] {B : Type u₄} [Category.{v₄, u₄} B] {U : Functor A B} {V : B} {F : Functor C A} {G : Functor D B} (α : F.comp U ⟶ S.comp G) (β : G.obj T ⟶ V) {X Y : Comma S (Functor.fromPUnit T)} (φ : X ⟶ Y) : ((map₂ α β).map φ).right = CategoryStruct.id X.right

@[simp]

theorem CategoryTheory.CostructuredArrow.map₂_map_left {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S : Functor C D} {A : Type u₃} [Category.{v₃, u₃} A] {B : Type u₄} [Category.{v₄, u₄} B] {U : Functor A B} {V : B} {F : Functor C A} {G : Functor D B} (α : F.comp U ⟶ S.comp G) (β : G.obj T ⟶ V) {X Y : Comma S (Functor.fromPUnit T)} (φ : X ⟶ Y) : ((map₂ α β).map φ).left = F.map φ.left

@[simp]

theorem CategoryTheory.CostructuredArrow.map₂_obj_left {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S : Functor C D} {A : Type u₃} [Category.{v₃, u₃} A] {B : Type u₄} [Category.{v₄, u₄} B] {U : Functor A B} {V : B} {F : Functor C A} {G : Functor D B} (α : F.comp U ⟶ S.comp G) (β : G.obj T ⟶ V) (X : Comma S (Functor.fromPUnit T)) : ((map₂ α β).obj X).left = F.obj X.left

@[simp]

theorem CategoryTheory.CostructuredArrow.map₂_obj_hom {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S : Functor C D} {A : Type u₃} [Category.{v₃, u₃} A] {B : Type u₄} [Category.{v₄, u₄} B] {U : Functor A B} {V : B} {F : Functor C A} {G : Functor D B} (α : F.comp U ⟶ S.comp G) (β : G.obj T ⟶ V) (X : Comma S (Functor.fromPUnit T)) : ((map₂ α β).obj X).hom = CategoryStruct.comp (α.app X.left) (CategoryStruct.comp (G.map X.hom) β)

instance CategoryTheory.CostructuredArrow.faithful_map₂ {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S : Functor C D} {A : Type u₃} [Category.{v₃, u₃} A] {B : Type u₄} [Category.{v₄, u₄} B] {U : Functor A B} {V : B} {F : Functor C A} {G : Functor D B} (α : F.comp U ⟶ S.comp G) (β : G.obj T ⟶ V) [F.Faithful] : (map₂ α β).Faithful

instance CategoryTheory.CostructuredArrow.full_map₂ {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S : Functor C D} {A : Type u₃} [Category.{v₃, u₃} A] {B : Type u₄} [Category.{v₄, u₄} B] {U : Functor A B} {V : B} {F : Functor C A} {G : Functor D B} (α : F.comp U ⟶ S.comp G) (β : G.obj T ⟶ V) [G.Faithful] [F.Full] [IsIso α] [IsIso β] : (map₂ α β).Full

instance CategoryTheory.CostructuredArrow.essSurj_map₂ {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S : Functor C D} {A : Type u₃} [Category.{v₃, u₃} A] {B : Type u₄} [Category.{v₄, u₄} B] {U : Functor A B} {V : B} {F : Functor C A} {G : Functor D B} (α : F.comp U ⟶ S.comp G) (β : G.obj T ⟶ V) [F.EssSurj] [G.Full] [IsIso α] [IsIso β] : (map₂ α β).EssSurj

instance CategoryTheory.CostructuredArrow.isEquivalenceMap₂ {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S : Functor C D} {A : Type u₃} [Category.{v₃, u₃} A] {B : Type u₄} [Category.{v₄, u₄} B] {U : Functor A B} {V : B} {F : Functor C A} {G : Functor D B} (α : F.comp U ⟶ S.comp G) (β : G.obj T ⟶ V) [F.IsEquivalence] [G.Faithful] [G.Full] [IsIso α] [IsIso β] : (map₂ α β).IsEquivalence

def CategoryTheory.CostructuredArrow.postIsoMap₂ {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {B : Type u₄} [Category.{v₄, u₄} B] (S : C) (F : Functor B C) (G : Functor C D) : post F G S ≅ map₂ (CategoryStruct.id (F.comp G)) (CategoryStruct.id (G.obj S))

CostructuredArrow.post is a special case of CostructuredArrow.map₂ up to natural isomorphism.

@[reducible, inline]

abbrev CategoryTheory.CostructuredArrow.IsUniversal {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S : Functor C D} (f : CostructuredArrow S T) : Type (max (max u₁ v₂) v₁)

A costructured arrow is called universal if it is terminal.

theorem CategoryTheory.CostructuredArrow.IsUniversal.uniq {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S : Functor C D} {f g : CostructuredArrow S T} (h : f.IsUniversal) (η : g ⟶ f) : η = Limits.IsTerminal.from h g

def CategoryTheory.CostructuredArrow.IsUniversal.lift {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S : Functor C D} {f : CostructuredArrow S T} (h : f.IsUniversal) (g : CostructuredArrow S T) : g.left ⟶ f.left

The family of morphisms into a universal arrow.

@[simp]

theorem CategoryTheory.CostructuredArrow.IsUniversal.fac {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S : Functor C D} {f : CostructuredArrow S T} (h : f.IsUniversal) (g : CostructuredArrow S T) : CategoryStruct.comp (S.map (h.lift g)) f.hom = g.hom

Any costructured arrow factors through a universal arrow.

@[simp]

theorem CategoryTheory.CostructuredArrow.IsUniversal.fac_assoc {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S : Functor C D} {f : CostructuredArrow S T} (h : f.IsUniversal) (g : CostructuredArrow S T) {Z : D} (h✝ : (Functor.fromPUnit T).obj f.right ⟶ Z) : CategoryStruct.comp (S.map (h.lift g)) (CategoryStruct.comp f.hom h✝) = CategoryStruct.comp g.hom h✝

Any costructured arrow factors through a universal arrow.

theorem CategoryTheory.CostructuredArrow.IsUniversal.hom_desc {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S : Functor C D} {f : CostructuredArrow S T} (h : f.IsUniversal) {c : C} (η : c ⟶ f.left) : η = h.lift (mk (CategoryStruct.comp (S.map η) f.hom))

theorem CategoryTheory.CostructuredArrow.IsUniversal.hom_ext {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S : Functor C D} {f : CostructuredArrow S T} (h : f.IsUniversal) {c : C} {η η' : c ⟶ f.left} (w : CategoryStruct.comp (S.map η) f.hom = CategoryStruct.comp (S.map η') f.hom) : η = η'

Two morphisms into a universal S-costructured arrow are equal if their image under S are equal after postcomposing the universal arrow.

theorem CategoryTheory.CostructuredArrow.IsUniversal.existsUnique {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {T : D} {S : Functor C D} {f : CostructuredArrow S T} (h : f.IsUniversal) (g : CostructuredArrow S T) : ∃! η : g.left ⟶ f.left, CategoryStruct.comp (S.map η) f.hom = g.hom

def CategoryTheory.Functor.toStructuredArrow {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {E : Type u₃} [Category.{v₃, u₃} E] (G : Functor E C) (X : D) (F : Functor C D) (f : (Y : E) → X ⟶ F.obj (G.obj Y)) (h : ∀ {Y Z : E} (g : Y ⟶ Z), CategoryStruct.comp (f Y) (F.map (G.map g)) = f Z) : Functor E (StructuredArrow X F)

Given X : D and F : C ⥤ D, to upgrade a functor G : E ⥤ C to a functor E ⥤ StructuredArrow X F, it suffices to provide maps X ⟶ F.obj (G.obj Y) for all Y making the obvious triangles involving all F.map (G.map g) commute.

This is of course the same as providing a cone over F ⋙ G with cone point X, see Functor.toStructuredArrowIsoToStructuredArrow.

@[simp]

theorem CategoryTheory.Functor.toStructuredArrow_obj {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {E : Type u₃} [Category.{v₃, u₃} E] (G : Functor E C) (X : D) (F : Functor C D) (f : (Y : E) → X ⟶ F.obj (G.obj Y)) (h : ∀ {Y Z : E} (g : Y ⟶ Z), CategoryStruct.comp (f Y) (F.map (G.map g)) = f Z) (Y : E) : (G.toStructuredArrow X F f h).obj Y = StructuredArrow.mk (f Y)

@[simp]

theorem CategoryTheory.Functor.toStructuredArrow_map {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {E : Type u₃} [Category.{v₃, u₃} E] (G : Functor E C) (X : D) (F : Functor C D) (f : (Y : E) → X ⟶ F.obj (G.obj Y)) (h : ∀ {Y Z : E} (g : Y ⟶ Z), CategoryStruct.comp (f Y) (F.map (G.map g)) = f Z) {X✝ Y✝ : E} (g : X✝ ⟶ Y✝) : (G.toStructuredArrow X F f h).map g = StructuredArrow.homMk (G.map g) ⋯

def CategoryTheory.Functor.toStructuredArrowCompProj {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {E : Type u₃} [Category.{v₃, u₃} E] (G : Functor E C) (X : D) (F : Functor C D) (f : (Y : E) → X ⟶ F.obj (G.obj Y)) (h : ∀ {Y Z : E} (g : Y ⟶ Z), CategoryStruct.comp (f Y) (F.map (G.map g)) = f Z) : (G.toStructuredArrow X F f ⋯).comp (StructuredArrow.proj X F) ≅ G

Upgrading a functor E ⥤ C to a functor E ⥤ StructuredArrow X F and composing with the forgetful functor StructuredArrow X F ⥤ C recovers the original functor.

@[simp]

theorem CategoryTheory.Functor.toStructuredArrow_comp_proj {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {E : Type u₃} [Category.{v₃, u₃} E] (G : Functor E C) (X : D) (F : Functor C D) (f : (Y : E) → X ⟶ F.obj (G.obj Y)) (h : ∀ {Y Z : E} (g : Y ⟶ Z), CategoryStruct.comp (f Y) (F.map (G.map g)) = f Z) : (G.toStructuredArrow X F f ⋯).comp (StructuredArrow.proj X F) = G

def CategoryTheory.Functor.toCostructuredArrow {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {E : Type u₃} [Category.{v₃, u₃} E] (G : Functor E C) (F : Functor C D) (X : D) (f : (Y : E) → F.obj (G.obj Y) ⟶ X) (h : ∀ {Y Z : E} (g : Y ⟶ Z), CategoryStruct.comp (F.map (G.map g)) (f Z) = f Y) : Functor E (CostructuredArrow F X)

Given F : C ⥤ D and X : D, to upgrade a functor G : E ⥤ C to a functor E ⥤ CostructuredArrow F X, it suffices to provide maps F.obj (G.obj Y) ⟶ X for all Y making the obvious triangles involving all F.map (G.map g) commute.

This is of course the same as providing a cocone over F ⋙ G with cocone point X, see Functor.toCostructuredArrowIsoToCostructuredArrow.

@[simp]

theorem CategoryTheory.Functor.toCostructuredArrow_obj {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {E : Type u₃} [Category.{v₃, u₃} E] (G : Functor E C) (F : Functor C D) (X : D) (f : (Y : E) → F.obj (G.obj Y) ⟶ X) (h : ∀ {Y Z : E} (g : Y ⟶ Z), CategoryStruct.comp (F.map (G.map g)) (f Z) = f Y) (Y : E) : (G.toCostructuredArrow F X f h).obj Y = CostructuredArrow.mk (f Y)

@[simp]

theorem CategoryTheory.Functor.toCostructuredArrow_map {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {E : Type u₃} [Category.{v₃, u₃} E] (G : Functor E C) (F : Functor C D) (X : D) (f : (Y : E) → F.obj (G.obj Y) ⟶ X) (h : ∀ {Y Z : E} (g : Y ⟶ Z), CategoryStruct.comp (F.map (G.map g)) (f Z) = f Y) {X✝ Y✝ : E} (g : X✝ ⟶ Y✝) : (G.toCostructuredArrow F X f h).map g = CostructuredArrow.homMk (G.map g) ⋯

def CategoryTheory.Functor.toCostructuredArrowCompProj {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {E : Type u₃} [Category.{v₃, u₃} E] (G : Functor E C) (F : Functor C D) (X : D) (f : (Y : E) → F.obj (G.obj Y) ⟶ X) (h : ∀ {Y Z : E} (g : Y ⟶ Z), CategoryStruct.comp (F.map (G.map g)) (f Z) = f Y) : (G.toCostructuredArrow F X f ⋯).comp (CostructuredArrow.proj F X) ≅ G

Upgrading a functor E ⥤ C to a functor E ⥤ CostructuredArrow F X and composing with the forgetful functor CostructuredArrow F X ⥤ C recovers the original functor.

@[simp]

theorem CategoryTheory.Functor.toCostructuredArrow_comp_proj {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {E : Type u₃} [Category.{v₃, u₃} E] (G : Functor E C) (F : Functor C D) (X : D) (f : (Y : E) → F.obj (G.obj Y) ⟶ X) (h : ∀ {Y Z : E} (g : Y ⟶ Z), CategoryStruct.comp (F.map (G.map g)) (f Z) = f Y) : (G.toCostructuredArrow F X f ⋯).comp (CostructuredArrow.proj F X) = G

def CategoryTheory.StructuredArrow.toCostructuredArrow {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] (F : Functor C D) (d : D) : Functor (StructuredArrow d F)ᵒᵖ (CostructuredArrow F.op (Opposite.op d))

For a functor F : C ⥤ D and an object d : D, we obtain a contravariant functor from the category of structured arrows d ⟶ F.obj c to the category of costructured arrows F.op.obj c ⟶ (op d).

@[simp]

theorem CategoryTheory.StructuredArrow.toCostructuredArrow_map {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] (F : Functor C D) (d : D) {X✝ Y✝ : (StructuredArrow d F)ᵒᵖ} (f : X✝ ⟶ Y✝) : (toCostructuredArrow F d).map f = CostructuredArrow.homMk f.unop.right.op ⋯

@[simp]

theorem CategoryTheory.StructuredArrow.toCostructuredArrow_obj {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] (F : Functor C D) (d : D) (X : (StructuredArrow d F)ᵒᵖ) : (toCostructuredArrow F d).obj X = CostructuredArrow.mk (Opposite.unop X).hom.op

def CategoryTheory.StructuredArrow.toCostructuredArrow' {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] (F : Functor C D) (d : D) : Functor (StructuredArrow (Opposite.op d) F.op)ᵒᵖ (CostructuredArrow F d)

For a functor F : C ⥤ D and an object d : D, we obtain a contravariant functor from the category of structured arrows op d ⟶ F.op.obj c to the category of costructured arrows F.obj c ⟶ d.

@[simp]

theorem CategoryTheory.StructuredArrow.toCostructuredArrow'_map {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] (F : Functor C D) (d : D) {X✝ Y✝ : (StructuredArrow (Opposite.op d) F.op)ᵒᵖ} (f : X✝ ⟶ Y✝) : (toCostructuredArrow' F d).map f = CostructuredArrow.homMk f.unop.right.unop ⋯

@[simp]

theorem CategoryTheory.StructuredArrow.toCostructuredArrow'_obj {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] (F : Functor C D) (d : D) (X : (StructuredArrow (Opposite.op d) F.op)ᵒᵖ) : (toCostructuredArrow' F d).obj X = CostructuredArrow.mk (Opposite.unop X).hom.unop

def CategoryTheory.CostructuredArrow.toStructuredArrow {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] (F : Functor C D) (d : D) : Functor (CostructuredArrow F d)ᵒᵖ (StructuredArrow (Opposite.op d) F.op)

For a functor F : C ⥤ D and an object d : D, we obtain a contravariant functor from the category of costructured arrows F.obj c ⟶ d to the category of structured arrows op d ⟶ F.op.obj c.

@[simp]

theorem CategoryTheory.CostructuredArrow.toStructuredArrow_obj {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] (F : Functor C D) (d : D) (X : (CostructuredArrow F d)ᵒᵖ) : (toStructuredArrow F d).obj X = StructuredArrow.mk (Opposite.unop X).hom.op

@[simp]

theorem CategoryTheory.CostructuredArrow.toStructuredArrow_map {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] (F : Functor C D) (d : D) {X✝ Y✝ : (CostructuredArrow F d)ᵒᵖ} (f : X✝ ⟶ Y✝) : (toStructuredArrow F d).map f = StructuredArrow.homMk f.unop.left.op ⋯

def CategoryTheory.CostructuredArrow.toStructuredArrow' {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] (F : Functor C D) (d : D) : Functor (CostructuredArrow F.op (Opposite.op d))ᵒᵖ (StructuredArrow d F)

For a functor F : C ⥤ D and an object d : D, we obtain a contravariant functor from the category of costructured arrows F.op.obj c ⟶ op d to the category of structured arrows d ⟶ F.obj c.

@[simp]

theorem CategoryTheory.CostructuredArrow.toStructuredArrow'_map {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] (F : Functor C D) (d : D) {X✝ Y✝ : (CostructuredArrow F.op (Opposite.op d))ᵒᵖ} (f : X✝ ⟶ Y✝) : (toStructuredArrow' F d).map f = StructuredArrow.homMk f.unop.left.unop ⋯

@[simp]

theorem CategoryTheory.CostructuredArrow.toStructuredArrow'_obj {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] (F : Functor C D) (d : D) (X : (CostructuredArrow F.op (Opposite.op d))ᵒᵖ) : (toStructuredArrow' F d).obj X = StructuredArrow.mk (Opposite.unop X).hom.unop

def CategoryTheory.structuredArrowOpEquivalence {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] (F : Functor C D) (d : D) : (StructuredArrow d F)ᵒᵖ ≌ CostructuredArrow F.op (Opposite.op d)

For a functor F : C ⥤ D and an object d : D, the category of structured arrows d ⟶ F.obj c is contravariantly equivalent to the category of costructured arrows F.op.obj c ⟶ op d.

def CategoryTheory.costructuredArrowOpEquivalence {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] (F : Functor C D) (d : D) : (CostructuredArrow F d)ᵒᵖ ≌ StructuredArrow (Opposite.op d) F.op

For a functor F : C ⥤ D and an object d : D, the category of costructured arrows F.obj c ⟶ d is contravariantly equivalent to the category of structured arrows op d ⟶ F.op.obj c.

def CategoryTheory.StructuredArrow.preEquivalenceFunctor {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {E : Type u₃} [Category.{v₃, u₃} E] (F : Functor C D) {G : Functor D E} {e : E} (f : StructuredArrow e G) : Functor (StructuredArrow f (pre e F G)) (StructuredArrow f.right F)

The functor establishing the equivalence StructuredArrow.preEquivalence.

@[simp]

theorem CategoryTheory.StructuredArrow.preEquivalenceFunctor_obj_left_as {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {E : Type u₃} [Category.{v₃, u₃} E] (F : Functor C D) {G : Functor D E} {e : E} (f : StructuredArrow e G) (g : StructuredArrow f (pre e F G)) : ((preEquivalenceFunctor F f).obj g).left.as = PUnit.unit

@[simp]

theorem CategoryTheory.StructuredArrow.preEquivalenceFunctor_obj_right {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {E : Type u₃} [Category.{v₃, u₃} E] (F : Functor C D) {G : Functor D E} {e : E} (f : StructuredArrow e G) (g : StructuredArrow f (pre e F G)) : ((preEquivalenceFunctor F f).obj g).right = g.right.right

@[simp]

theorem CategoryTheory.StructuredArrow.preEquivalenceFunctor_map_right {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {E : Type u₃} [Category.{v₃, u₃} E] (F : Functor C D) {G : Functor D E} {e : E} (f : StructuredArrow e G) {X✝ Y✝ : StructuredArrow f (pre e F G)} (φ : X✝ ⟶ Y✝) : ((preEquivalenceFunctor F f).map φ).right = φ.right.right

@[simp]

theorem CategoryTheory.StructuredArrow.preEquivalenceFunctor_obj_hom {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {E : Type u₃} [Category.{v₃, u₃} E] (F : Functor C D) {G : Functor D E} {e : E} (f : StructuredArrow e G) (g : StructuredArrow f (pre e F G)) : ((preEquivalenceFunctor F f).obj g).hom = g.hom.right

def CategoryTheory.StructuredArrow.preEquivalenceInverse {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {E : Type u₃} [Category.{v₃, u₃} E] (F : Functor C D) {G : Functor D E} {e : E} (f : StructuredArrow e G) : Functor (StructuredArrow f.right F) (StructuredArrow f (pre e F G))

The inverse functor establishing the equivalence StructuredArrow.preEquivalence.

@[simp]

theorem CategoryTheory.StructuredArrow.preEquivalenceInverse_map_right_right {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {E : Type u₃} [Category.{v₃, u₃} E] (F : Functor C D) {G : Functor D E} {e : E} (f : StructuredArrow e G) {X✝ Y✝ : StructuredArrow f.right F} (φ : X✝ ⟶ Y✝) : ((preEquivalenceInverse F f).map φ).right.right = φ.right

@[simp]

theorem CategoryTheory.StructuredArrow.preEquivalenceInverse_obj_left_as {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {E : Type u₃} [Category.{v₃, u₃} E] (F : Functor C D) {G : Functor D E} {e : E} (f : StructuredArrow e G) (g : StructuredArrow f.right F) : ((preEquivalenceInverse F f).obj g).left.as = PUnit.unit

@[simp]

theorem CategoryTheory.StructuredArrow.preEquivalenceInverse_obj_right_hom {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {E : Type u₃} [Category.{v₃, u₃} E] (F : Functor C D) {G : Functor D E} {e : E} (f : StructuredArrow e G) (g : StructuredArrow f.right F) : ((preEquivalenceInverse F f).obj g).right.hom = CategoryStruct.comp f.hom (G.map g.hom)

@[simp]

theorem CategoryTheory.StructuredArrow.preEquivalenceInverse_obj_right_right {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {E : Type u₃} [Category.{v₃, u₃} E] (F : Functor C D) {G : Functor D E} {e : E} (f : StructuredArrow e G) (g : StructuredArrow f.right F) : ((preEquivalenceInverse F f).obj g).right.right = g.right

@[simp]

theorem CategoryTheory.StructuredArrow.preEquivalenceInverse_obj_right_left_as {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {E : Type u₃} [Category.{v₃, u₃} E] (F : Functor C D) {G : Functor D E} {e : E} (f : StructuredArrow e G) (g : StructuredArrow f.right F) : ((preEquivalenceInverse F f).obj g).right.left.as = PUnit.unit

@[simp]

theorem CategoryTheory.StructuredArrow.preEquivalenceInverse_obj_hom_right {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {E : Type u₃} [Category.{v₃, u₃} E] (F : Functor C D) {G : Functor D E} {e : E} (f : StructuredArrow e G) (g : StructuredArrow f.right F) : ((preEquivalenceInverse F f).obj g).hom.right = g.hom

def CategoryTheory.StructuredArrow.preEquivalence {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {E : Type u₃} [Category.{v₃, u₃} E] (F : Functor C D) {G : Functor D E} {e : E} (f : StructuredArrow e G) : StructuredArrow f (pre e F G) ≌ StructuredArrow f.right F

A structured arrow category on a StructuredArrow.pre e F G functor is equivalent to the structured arrow category on F

@[simp]

theorem CategoryTheory.StructuredArrow.preEquivalence_inverse {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {E : Type u₃} [Category.{v₃, u₃} E] (F : Functor C D) {G : Functor D E} {e : E} (f : StructuredArrow e G) : (preEquivalence F f).inverse = preEquivalenceInverse F f

@[simp]

theorem CategoryTheory.StructuredArrow.preEquivalence_unitIso {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {E : Type u₃} [Category.{v₃, u₃} E] (F : Functor C D) {G : Functor D E} {e : E} (f : StructuredArrow e G) : (preEquivalence F f).unitIso = NatIso.ofComponents (fun (x : StructuredArrow f (pre e F G)) => isoMk (isoMk (Iso.refl ((Functor.id (StructuredArrow f (pre e F G))).obj x).right.right) ⋯) ⋯) ⋯

@[simp]

theorem CategoryTheory.StructuredArrow.preEquivalence_functor {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {E : Type u₃} [Category.{v₃, u₃} E] (F : Functor C D) {G : Functor D E} {e : E} (f : StructuredArrow e G) : (preEquivalence F f).functor = preEquivalenceFunctor F f

@[simp]

theorem CategoryTheory.StructuredArrow.preEquivalence_counitIso {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {E : Type u₃} [Category.{v₃, u₃} E] (F : Functor C D) {G : Functor D E} {e : E} (f : StructuredArrow e G) : (preEquivalence F f).counitIso = NatIso.ofComponents (fun (x : StructuredArrow f.right F) => isoMk (Iso.refl (((preEquivalenceInverse F f).comp (preEquivalenceFunctor F f)).obj x).right) ⋯) ⋯

def CategoryTheory.StructuredArrow.map₂IsoPreEquivalenceInverseCompProj {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {E : Type u₃} [Category.{v₃, u₃} E] {T : Functor C D} {S : Functor D E} {T' : Functor C E} (d : D) (e : E) (u : e ⟶ S.obj d) (α : T.comp S ⟶ T') : map₂ u α ≅ (preEquivalence T (mk u)).inverse.comp ((proj (mk u) (pre e T S)).comp (map₂ (CategoryStruct.id e) α))

The functor StructuredArrow d T ⥤ StructuredArrow e (T ⋙ S) that u : e ⟶ S.obj d induces via StructuredArrow.map₂ can be expressed up to isomorphism by StructuredArrow.preEquivalence and StructuredArrow.proj.

def CategoryTheory.CostructuredArrow.preEquivalence.functor {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {E : Type u₃} [Category.{v₃, u₃} E] (F : Functor C D) {G : Functor D E} {e : E} (f : CostructuredArrow G e) : Functor (CostructuredArrow (pre F G e) f) (CostructuredArrow F f.left)

The functor establishing the equivalence CostructuredArrow.preEquivalence.

@[simp]

theorem CategoryTheory.CostructuredArrow.preEquivalence.functor_map_left {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {E : Type u₃} [Category.{v₃, u₃} E] (F : Functor C D) {G : Functor D E} {e : E} (f : CostructuredArrow G e) {X✝ Y✝ : CostructuredArrow (pre F G e) f} (φ : X✝ ⟶ Y✝) : ((functor F f).map φ).left = φ.left.left

@[simp]

theorem CategoryTheory.CostructuredArrow.preEquivalence.functor_obj_left {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {E : Type u₃} [Category.{v₃, u₃} E] (F : Functor C D) {G : Functor D E} {e : E} (f : CostructuredArrow G e) (g : CostructuredArrow (pre F G e) f) : ((functor F f).obj g).left = g.left.left

@[simp]

theorem CategoryTheory.CostructuredArrow.preEquivalence.functor_obj_right_as {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {E : Type u₃} [Category.{v₃, u₃} E] (F : Functor C D) {G : Functor D E} {e : E} (f : CostructuredArrow G e) (g : CostructuredArrow (pre F G e) f) : ((functor F f).obj g).right.as = PUnit.unit

@[simp]

theorem CategoryTheory.CostructuredArrow.preEquivalence.functor_obj_hom {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {E : Type u₃} [Category.{v₃, u₃} E] (F : Functor C D) {G : Functor D E} {e : E} (f : CostructuredArrow G e) (g : CostructuredArrow (pre F G e) f) : ((functor F f).obj g).hom = g.hom.left

def CategoryTheory.CostructuredArrow.preEquivalence.inverse {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {E : Type u₃} [Category.{v₃, u₃} E] (F : Functor C D) {G : Functor D E} {e : E} (f : CostructuredArrow G e) : Functor (CostructuredArrow F f.left) (CostructuredArrow (pre F G e) f)

The inverse functor establishing the equivalence CostructuredArrow.preEquivalence.

@[simp]

theorem CategoryTheory.CostructuredArrow.preEquivalence.inverse_obj_right_as {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {E : Type u₃} [Category.{v₃, u₃} E] (F : Functor C D) {G : Functor D E} {e : E} (f : CostructuredArrow G e) (g : CostructuredArrow F f.left) : ((inverse F f).obj g).right.as = PUnit.unit

@[simp]

theorem CategoryTheory.CostructuredArrow.preEquivalence.inverse_obj_hom_left {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {E : Type u₃} [Category.{v₃, u₃} E] (F : Functor C D) {G : Functor D E} {e : E} (f : CostructuredArrow G e) (g : CostructuredArrow F f.left) : ((inverse F f).obj g).hom.left = g.hom

@[simp]

theorem CategoryTheory.CostructuredArrow.preEquivalence.inverse_obj_left_right_as {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {E : Type u₃} [Category.{v₃, u₃} E] (F : Functor C D) {G : Functor D E} {e : E} (f : CostructuredArrow G e) (g : CostructuredArrow F f.left) : ((inverse F f).obj g).left.right.as = PUnit.unit

@[simp]

theorem CategoryTheory.CostructuredArrow.preEquivalence.inverse_map_left_left {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {E : Type u₃} [Category.{v₃, u₃} E] (F : Functor C D) {G : Functor D E} {e : E} (f : CostructuredArrow G e) {X✝ Y✝ : CostructuredArrow F f.left} (φ : X✝ ⟶ Y✝) : ((inverse F f).map φ).left.left = φ.left

@[simp]

theorem CategoryTheory.CostructuredArrow.preEquivalence.inverse_obj_left_hom {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {E : Type u₃} [Category.{v₃, u₃} E] (F : Functor C D) {G : Functor D E} {e : E} (f : CostructuredArrow G e) (g : CostructuredArrow F f.left) : ((inverse F f).obj g).left.hom = CategoryStruct.comp (G.map g.hom) f.hom

@[simp]

theorem CategoryTheory.CostructuredArrow.preEquivalence.inverse_obj_left_left {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {E : Type u₃} [Category.{v₃, u₃} E] (F : Functor C D) {G : Functor D E} {e : E} (f : CostructuredArrow G e) (g : CostructuredArrow F f.left) : ((inverse F f).obj g).left.left = g.left

def CategoryTheory.CostructuredArrow.preEquivalence {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {E : Type u₃} [Category.{v₃, u₃} E] (F : Functor C D) {G : Functor D E} {e : E} (f : CostructuredArrow G e) : CostructuredArrow (pre F G e) f ≌ CostructuredArrow F f.left

A costructured arrow category on a CostructuredArrow.pre F G e functor is equivalent to the costructured arrow category on F

def CategoryTheory.CostructuredArrow.map₂IsoPreEquivalenceInverseCompProj {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {E : Type u₃} [Category.{v₃, u₃} E] (T : Functor C D) (S : Functor D E) (d : D) (e : E) (u : S.obj d ⟶ e) : map₂ (CategoryStruct.id (T.comp S)) u ≅ (preEquivalence T (mk u)).inverse.comp (proj (pre T S e) (mk u))

The functor CostructuredArrow T d ⥤ CostructuredArrow (T ⋙ S) e that u : S.obj d ⟶ e induces via CostructuredArrow.map₂ can be expressed up to isomorphism by CostructuredArrow.preEquivalence and CostructuredArrow.proj.

@[simp]

theorem CategoryTheory.StructuredArrow.w_prod_fst {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {C' : Type u₃} [Category.{v₃, u₃} C'] {D' : Type u₄} [Category.{v₄, u₄} D'] (S : D) (S' : D') (T : Functor C D) (T' : Functor C' D') {X Y : StructuredArrow (S, S') (T.prod T')} (f : X ⟶ Y) : CategoryStruct.comp X.hom.1 (T.map f.right.1) = Y.hom.1

@[simp]

theorem CategoryTheory.StructuredArrow.w_prod_fst_assoc {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {C' : Type u₃} [Category.{v₃, u₃} C'] {D' : Type u₄} [Category.{v₄, u₄} D'] (S : D) (S' : D') (T : Functor C D) (T' : Functor C' D') {X Y : StructuredArrow (S, S') (T.prod T')} (f : X ⟶ Y) {Z : D} (h : T.obj Y.right.1 ⟶ Z) : CategoryStruct.comp X.hom.1 (CategoryStruct.comp (T.map f.right.1) h) = CategoryStruct.comp Y.hom.1 h

@[simp]

theorem CategoryTheory.StructuredArrow.w_prod_snd {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {C' : Type u₃} [Category.{v₃, u₃} C'] {D' : Type u₄} [Category.{v₄, u₄} D'] (S : D) (S' : D') (T : Functor C D) (T' : Functor C' D') {X Y : StructuredArrow (S, S') (T.prod T')} (f : X ⟶ Y) : CategoryStruct.comp X.hom.2 (T'.map f.right.2) = Y.hom.2

@[simp]

theorem CategoryTheory.StructuredArrow.w_prod_snd_assoc {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {C' : Type u₃} [Category.{v₃, u₃} C'] {D' : Type u₄} [Category.{v₄, u₄} D'] (S : D) (S' : D') (T : Functor C D) (T' : Functor C' D') {X Y : StructuredArrow (S, S') (T.prod T')} (f : X ⟶ Y) {Z : D'} (h : T'.obj Y.right.2 ⟶ Z) : CategoryStruct.comp X.hom.2 (CategoryStruct.comp (T'.map f.right.2) h) = CategoryStruct.comp Y.hom.2 h

def CategoryTheory.StructuredArrow.prodFunctor {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {C' : Type u₃} [Category.{v₃, u₃} C'] {D' : Type u₄} [Category.{v₄, u₄} D'] (S : D) (S' : D') (T : Functor C D) (T' : Functor C' D') : Functor (StructuredArrow (S, S') (T.prod T')) (StructuredArrow S T × StructuredArrow S' T')

Implementation; see StructuredArrow.prodEquivalence.

@[simp]

theorem CategoryTheory.StructuredArrow.prodFunctor_obj {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {C' : Type u₃} [Category.{v₃, u₃} C'] {D' : Type u₄} [Category.{v₄, u₄} D'] (S : D) (S' : D') (T : Functor C D) (T' : Functor C' D') (f : StructuredArrow (S, S') (T.prod T')) : (prodFunctor S S' T T').obj f = (mk f.hom.1, mk f.hom.2)

@[simp]

theorem CategoryTheory.StructuredArrow.prodFunctor_map {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {C' : Type u₃} [Category.{v₃, u₃} C'] {D' : Type u₄} [Category.{v₄, u₄} D'] (S : D) (S' : D') (T : Functor C D) (T' : Functor C' D') {X✝ Y✝ : StructuredArrow (S, S') (T.prod T')} (η : X✝ ⟶ Y✝) : (prodFunctor S S' T T').map η = (homMk η.right.1 ⋯, homMk η.right.2 ⋯)

def CategoryTheory.StructuredArrow.prodInverse {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {C' : Type u₃} [Category.{v₃, u₃} C'] {D' : Type u₄} [Category.{v₄, u₄} D'] (S : D) (S' : D') (T : Functor C D) (T' : Functor C' D') : Functor (StructuredArrow S T × StructuredArrow S' T') (StructuredArrow (S, S') (T.prod T'))

Implementation; see StructuredArrow.prodEquivalence.

@[simp]

theorem CategoryTheory.StructuredArrow.prodInverse_obj {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {C' : Type u₃} [Category.{v₃, u₃} C'] {D' : Type u₄} [Category.{v₄, u₄} D'] (S : D) (S' : D') (T : Functor C D) (T' : Functor C' D') (f : StructuredArrow S T × StructuredArrow S' T') : (prodInverse S S' T T').obj f = mk (f.1.hom, f.2.hom)

@[simp]

theorem CategoryTheory.StructuredArrow.prodInverse_map {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {C' : Type u₃} [Category.{v₃, u₃} C'] {D' : Type u₄} [Category.{v₄, u₄} D'] (S : D) (S' : D') (T : Functor C D) (T' : Functor C' D') {X✝ Y✝ : StructuredArrow S T × StructuredArrow S' T'} (η : X✝ ⟶ Y✝) : (prodInverse S S' T T').map η = homMk (η.1.right, η.2.right) ⋯

def CategoryTheory.StructuredArrow.prodEquivalence {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {C' : Type u₃} [Category.{v₃, u₃} C'] {D' : Type u₄} [Category.{v₄, u₄} D'] (S : D) (S' : D') (T : Functor C D) (T' : Functor C' D') : StructuredArrow (S, S') (T.prod T') ≌ StructuredArrow S T × StructuredArrow S' T'

The natural equivalence StructuredArrow (S, S') (T.prod T') ≌ StructuredArrow S T × StructuredArrow S' T'.

@[simp]

theorem CategoryTheory.StructuredArrow.prodEquivalence_inverse {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {C' : Type u₃} [Category.{v₃, u₃} C'] {D' : Type u₄} [Category.{v₄, u₄} D'] (S : D) (S' : D') (T : Functor C D) (T' : Functor C' D') : (prodEquivalence S S' T T').inverse = prodInverse S S' T T'

@[simp]

theorem CategoryTheory.StructuredArrow.prodEquivalence_functor {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {C' : Type u₃} [Category.{v₃, u₃} C'] {D' : Type u₄} [Category.{v₄, u₄} D'] (S : D) (S' : D') (T : Functor C D) (T' : Functor C' D') : (prodEquivalence S S' T T').functor = prodFunctor S S' T T'

@[simp]

theorem CategoryTheory.StructuredArrow.prodEquivalence_counitIso {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {C' : Type u₃} [Category.{v₃, u₃} C'] {D' : Type u₄} [Category.{v₄, u₄} D'] (S : D) (S' : D') (T : Functor C D) (T' : Functor C' D') : (prodEquivalence S S' T T').counitIso = NatIso.ofComponents (fun (f : StructuredArrow S T × StructuredArrow S' T') => Iso.refl (((prodInverse S S' T T').comp (prodFunctor S S' T T')).obj f)) ⋯

@[simp]

theorem CategoryTheory.StructuredArrow.prodEquivalence_unitIso {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {C' : Type u₃} [Category.{v₃, u₃} C'] {D' : Type u₄} [Category.{v₄, u₄} D'] (S : D) (S' : D') (T : Functor C D) (T' : Functor C' D') : (prodEquivalence S S' T T').unitIso = NatIso.ofComponents (fun (f : StructuredArrow (S, S') (T.prod T')) => Iso.refl ((Functor.id (StructuredArrow (S, S') (T.prod T'))).obj f)) ⋯

@[simp]

theorem CategoryTheory.CostructuredArrow.w_prod_fst {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {C' : Type u₃} [Category.{v₃, u₃} C'] {D' : Type u₄} [Category.{v₄, u₄} D'] (S : Functor C D) (S' : Functor C' D') (T : D) (T' : D') {A B : CostructuredArrow (S.prod S') (T, T')} (f : A ⟶ B) : CategoryStruct.comp (S.map f.left.1) B.hom.1 = A.hom.1

@[simp]

theorem CategoryTheory.CostructuredArrow.w_prod_fst_assoc {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {C' : Type u₃} [Category.{v₃, u₃} C'] {D' : Type u₄} [Category.{v₄, u₄} D'] (S : Functor C D) (S' : Functor C' D') (T : D) (T' : D') {A B : CostructuredArrow (S.prod S') (T, T')} (f : A ⟶ B) {Z : D} (h : ((Functor.fromPUnit (T, T')).obj B.right).1 ⟶ Z) : CategoryStruct.comp (S.map f.left.1) (CategoryStruct.comp B.hom.1 h) = CategoryStruct.comp A.hom.1 h

@[simp]

theorem CategoryTheory.CostructuredArrow.w_prod_snd {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {C' : Type u₃} [Category.{v₃, u₃} C'] {D' : Type u₄} [Category.{v₄, u₄} D'] (S : Functor C D) (S' : Functor C' D') (T : D) (T' : D') {A B : CostructuredArrow (S.prod S') (T, T')} (f : A ⟶ B) : CategoryStruct.comp (S'.map f.left.2) B.hom.2 = A.hom.2

@[simp]

theorem CategoryTheory.CostructuredArrow.w_prod_snd_assoc {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {C' : Type u₃} [Category.{v₃, u₃} C'] {D' : Type u₄} [Category.{v₄, u₄} D'] (S : Functor C D) (S' : Functor C' D') (T : D) (T' : D') {A B : CostructuredArrow (S.prod S') (T, T')} (f : A ⟶ B) {Z : D'} (h : ((Functor.fromPUnit (T, T')).obj B.right).2 ⟶ Z) : CategoryStruct.comp (S'.map f.left.2) (CategoryStruct.comp B.hom.2 h) = CategoryStruct.comp A.hom.2 h

def CategoryTheory.CostructuredArrow.prodFunctor {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {C' : Type u₃} [Category.{v₃, u₃} C'] {D' : Type u₄} [Category.{v₄, u₄} D'] (S : Functor C D) (S' : Functor C' D') (T : D) (T' : D') : Functor (CostructuredArrow (S.prod S') (T, T')) (CostructuredArrow S T × CostructuredArrow S' T')

Implementation; see CostructuredArrow.prodEquivalence.

@[simp]

theorem CategoryTheory.CostructuredArrow.prodFunctor_map {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {C' : Type u₃} [Category.{v₃, u₃} C'] {D' : Type u₄} [Category.{v₄, u₄} D'] (S : Functor C D) (S' : Functor C' D') (T : D) (T' : D') {X✝ Y✝ : CostructuredArrow (S.prod S') (T, T')} (η : X✝ ⟶ Y✝) : (prodFunctor S S' T T').map η = (homMk η.left.1 ⋯, homMk η.left.2 ⋯)

@[simp]

theorem CategoryTheory.CostructuredArrow.prodFunctor_obj {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {C' : Type u₃} [Category.{v₃, u₃} C'] {D' : Type u₄} [Category.{v₄, u₄} D'] (S : Functor C D) (S' : Functor C' D') (T : D) (T' : D') (f : CostructuredArrow (S.prod S') (T, T')) : (prodFunctor S S' T T').obj f = (mk f.hom.1, mk f.hom.2)

def CategoryTheory.CostructuredArrow.prodInverse {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {C' : Type u₃} [Category.{v₃, u₃} C'] {D' : Type u₄} [Category.{v₄, u₄} D'] (S : Functor C D) (S' : Functor C' D') (T : D) (T' : D') : Functor (CostructuredArrow S T × CostructuredArrow S' T') (CostructuredArrow (S.prod S') (T, T'))

Implementation; see CostructuredArrow.prodEquivalence.

@[simp]

theorem CategoryTheory.CostructuredArrow.prodInverse_map {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {C' : Type u₃} [Category.{v₃, u₃} C'] {D' : Type u₄} [Category.{v₄, u₄} D'] (S : Functor C D) (S' : Functor C' D') (T : D) (T' : D') {X✝ Y✝ : CostructuredArrow S T × CostructuredArrow S' T'} (η : X✝ ⟶ Y✝) : (prodInverse S S' T T').map η = homMk (η.1.left, η.2.left) ⋯

@[simp]

theorem CategoryTheory.CostructuredArrow.prodInverse_obj {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {C' : Type u₃} [Category.{v₃, u₃} C'] {D' : Type u₄} [Category.{v₄, u₄} D'] (S : Functor C D) (S' : Functor C' D') (T : D) (T' : D') (f : CostructuredArrow S T × CostructuredArrow S' T') : (prodInverse S S' T T').obj f = mk (f.1.hom, f.2.hom)

def CategoryTheory.CostructuredArrow.prodEquivalence {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {C' : Type u₃} [Category.{v₃, u₃} C'] {D' : Type u₄} [Category.{v₄, u₄} D'] (S : Functor C D) (S' : Functor C' D') (T : D) (T' : D') : CostructuredArrow (S.prod S') (T, T') ≌ CostructuredArrow S T × CostructuredArrow S' T'

The natural equivalence CostructuredArrow (S.prod S') (T, T') ≌ CostructuredArrow S T × CostructuredArrow S' T'.

@[simp]

theorem CategoryTheory.CostructuredArrow.prodEquivalence_functor {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {C' : Type u₃} [Category.{v₃, u₃} C'] {D' : Type u₄} [Category.{v₄, u₄} D'] (S : Functor C D) (S' : Functor C' D') (T : D) (T' : D') : (prodEquivalence S S' T T').functor = prodFunctor S S' T T'

@[simp]

theorem CategoryTheory.CostructuredArrow.prodEquivalence_counitIso {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {C' : Type u₃} [Category.{v₃, u₃} C'] {D' : Type u₄} [Category.{v₄, u₄} D'] (S : Functor C D) (S' : Functor C' D') (T : D) (T' : D') : (prodEquivalence S S' T T').counitIso = NatIso.ofComponents (fun (f : CostructuredArrow S T × CostructuredArrow S' T') => Iso.refl (((prodInverse S S' T T').comp (prodFunctor S S' T T')).obj f)) ⋯

@[simp]

theorem CategoryTheory.CostructuredArrow.prodEquivalence_inverse {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {C' : Type u₃} [Category.{v₃, u₃} C'] {D' : Type u₄} [Category.{v₄, u₄} D'] (S : Functor C D) (S' : Functor C' D') (T : D) (T' : D') : (prodEquivalence S S' T T').inverse = prodInverse S S' T T'

@[simp]

theorem CategoryTheory.CostructuredArrow.prodEquivalence_unitIso {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {C' : Type u₃} [Category.{v₃, u₃} C'] {D' : Type u₄} [Category.{v₄, u₄} D'] (S : Functor C D) (S' : Functor C' D') (T : D) (T' : D') : (prodEquivalence S S' T T').unitIso = NatIso.ofComponents (fun (f : CostructuredArrow (S.prod S') (T, T')) => Iso.refl ((Functor.id (CostructuredArrow (S.prod S') (T, T'))).obj f)) ⋯