File: Mathlib/CategoryTheory/Comma/StructuredArrow.lean

full_name: CategoryTheory.StructuredArrow
code: /-- 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.
-/
-- We explicitly come from `PUnit.{1}` here to obtain the correct universe for morphisms of
-- structured arrows.
-- Porting note(#5171): linter not ported yet
-- @[nolint has_nonempty_instance]
def StructuredArrow (S : D) (T : C ⥤ D) 
goal: Type (max u₁ v₂)

full_name: CategoryTheory.instCategoryStructuredArrow
code: instance (S : D) (T : C ⥤ D) : Category (StructuredArrow S T) 
goal: CategoryTheory.Category.{v₁, max u₁ v₂} (CategoryTheory.StructuredArrow S T)

full_name: CategoryTheory.StructuredArrow.proj
code: /-- The obvious projection functor from structured arrows. -/
@[simps!]
def proj (S : D) (T : C ⥤ D) : StructuredArrow S T ⥤ C 
goal: CategoryTheory.Functor (CategoryTheory.StructuredArrow S T) C

full_name: CategoryTheory.StructuredArrow.proj_map
code: /-- The obvious projection functor from structured arrows. -/
@[simps!]
def proj (S : D) (T : C ⥤ D) : StructuredArrow S T ⥤ C 
goal: ∀ {X Y : CategoryTheory.Comma (CategoryTheory.Functor.fromPUnit S) T} (f : X ⟶ Y),
  (CategoryTheory.StructuredArrow.proj S T).map f = f.right

full_name: CategoryTheory.StructuredArrow.proj_obj
code: /-- The obvious projection functor from structured arrows. -/
@[simps!]
def proj (S : D) (T : C ⥤ D) : StructuredArrow S T ⥤ C 
goal: (CategoryTheory.StructuredArrow.proj S T).obj X = X.right

full_name: CategoryTheory.StructuredArrow.hom_ext
code: @[ext]
lemma hom_ext {X Y : StructuredArrow S T} (f g : X ⟶ Y) (h : f.right = g.right) : f = g 
goal: f = g

full_name: CategoryTheory.StructuredArrow.hom_eq_iff
code: @[simp]
theorem hom_eq_iff {X Y : StructuredArrow S T} (f g : X ⟶ Y) : f = g ↔ f.right = g.right 
goal: f = g ↔ f.right = g.right

full_name: CategoryTheory.StructuredArrow.mk
code: /-- Construct a structured arrow from a morphism. -/
def mk (f : S ⟶ T.obj Y) : StructuredArrow S T 
goal: CategoryTheory.StructuredArrow S T

full_name: CategoryTheory.StructuredArrow.mk_left
code: @[simp]
theorem mk_left (f : S ⟶ T.obj Y) : (mk f).left = ⟨⟨⟩⟩ 
goal: (CategoryTheory.StructuredArrow.mk f).left = { as := PUnit.unit }

full_name: CategoryTheory.StructuredArrow.mk_right
code: @[simp]
theorem mk_right (f : S ⟶ T.obj Y) : (mk f).right = Y 
goal: (CategoryTheory.StructuredArrow.mk f).right = Y

full_name: CategoryTheory.StructuredArrow.mk_hom_eq_self
code: @[simp]
theorem mk_hom_eq_self (f : S ⟶ T.obj Y) : (mk f).hom = f 
goal: (CategoryTheory.StructuredArrow.mk f).hom = f

full_name: CategoryTheory.StructuredArrow.w
code: @[reassoc (attr := simp)]
theorem w {A B : StructuredArrow S T} (f : A ⟶ B) : A.hom ≫ T.map f.right = B.hom 
goal: CategoryTheory.CategoryStruct.comp A.hom (T.map f.right) = B.hom

full_name: CategoryTheory.StructuredArrow.comp_right
code: @[simp]
theorem comp_right {X Y Z : StructuredArrow S T} (f : X ⟶ Y) (g : Y ⟶ Z) :
    (f ≫ g).right = f.right ≫ g.right 
goal: (CategoryTheory.CategoryStruct.comp f g).right = CategoryTheory.CategoryStruct.comp f.right g.right

full_name: CategoryTheory.StructuredArrow.id_right
code: @[simp]
theorem id_right (X : StructuredArrow S T) : (𝟙 X : X ⟶ X).right = 𝟙 X.right 
goal: (CategoryTheory.CategoryStruct.id X).right = CategoryTheory.CategoryStruct.id X.right

full_name: CategoryTheory.StructuredArrow.eqToHom_right
code: @[simp]
theorem eqToHom_right {X Y : StructuredArrow S T} (h : X = Y) :
    (eqToHom h).right = eqToHom (by rw [h]) 
goal: (CategoryTheory.eqToHom h).right = CategoryTheory.eqToHom ⋯

full_name: CategoryTheory.StructuredArrow.left_eq_id
code: @[simp]
theorem left_eq_id {X Y : StructuredArrow S T} (f : X ⟶ Y) : f.left = 𝟙 _ 
goal: f.left = CategoryTheory.CategoryStruct.id X.left

full_name: CategoryTheory.StructuredArrow.homMk
code: /-- To construct a morphism of structured arrows,
we need a morphism of the objects underlying the target,
and to check that the triangle commutes.
-/
@[simps]
def homMk {f f' : StructuredArrow S T} (g : f.right ⟶ f'.right)
    (w : f.hom ≫ T.map g = f'.hom := by aesop_cat) : f ⟶ f' 
goal: f ⟶ f'

full_name: CategoryTheory.StructuredArrow.homMk_left
code: /-- To construct a morphism of structured arrows,
we need a morphism of the objects underlying the target,
and to check that the triangle commutes.
-/
@[simps]
def homMk {f f' : StructuredArrow S T} (g : f.right ⟶ f'.right)
    (w : f.hom ≫ T.map g = f'.hom := by aesop_cat) : f ⟶ f' 
goal: (CategoryTheory.StructuredArrow.homMk g w).left = CategoryTheory.CategoryStruct.id f.left

full_name: CategoryTheory.StructuredArrow.homMk_right
code: /-- To construct a morphism of structured arrows,
we need a morphism of the objects underlying the target,
and to check that the triangle commutes.
-/
@[simps]
def homMk {f f' : StructuredArrow S T} (g : f.right ⟶ f'.right)
    (w : f.hom ≫ T.map g = f'.hom := by aesop_cat) : f ⟶ f' 
goal: (CategoryTheory.StructuredArrow.homMk g w).right = g

full_name: CategoryTheory.StructuredArrow.homMk_surjective
code: theorem homMk_surjective {f f' : StructuredArrow S T} (φ : f ⟶ f') :
    ∃ (ψ : f.right ⟶ f'.right) (hψ : f.hom ≫ T.map ψ = f'.hom),
      φ = StructuredArrow.homMk ψ hψ 
goal: ∃ ψ, ∃ (hψ : CategoryTheory.CategoryStruct.comp f.hom (T.map ψ) = f'.hom), φ = CategoryTheory.StructuredArrow.homMk ψ hψ

full_name: CategoryTheory.StructuredArrow.homMk'
code: /-- 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'))`.  -/
@[simps]
def homMk' (f : StructuredArrow S T) (g : f.right ⟶ Y') : f ⟶ mk (f.hom ≫ T.map g) 
goal: f ⟶ CategoryTheory.StructuredArrow.mk (CategoryTheory.CategoryStruct.comp f.hom (T.map g))

full_name: CategoryTheory.StructuredArrow.homMk'_right
code: /-- 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'))`.  -/
@[simps]
def homMk' (f : StructuredArrow S T) (g : f.right ⟶ Y') : f ⟶ mk (f.hom ≫ T.map g) 
goal: (f.homMk' g).right = g

full_name: CategoryTheory.StructuredArrow.homMk'_left
code: /-- 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'))`.  -/
@[simps]
def homMk' (f : StructuredArrow S T) (g : f.right ⟶ Y') : f ⟶ mk (f.hom ≫ T.map g) 
goal: (f.homMk' g).left = CategoryTheory.CategoryStruct.id f.left

full_name: CategoryTheory.StructuredArrow.homMk'_id
code: lemma homMk'_id (f : StructuredArrow S T) : homMk' f (𝟙 f.right) = eqToHom (by aesop_cat) 
goal: f.homMk' (CategoryTheory.CategoryStruct.id f.right) = CategoryTheory.eqToHom ⋯

full_name: CategoryTheory.StructuredArrow.homMk'_mk_id
code: lemma homMk'_mk_id (f : S ⟶ T.obj Y) : homMk' (mk f) (𝟙 Y) = eqToHom (by aesop_cat) 
goal: (CategoryTheory.StructuredArrow.mk f).homMk' (CategoryTheory.CategoryStruct.id Y) = CategoryTheory.eqToHom ⋯

full_name: CategoryTheory.StructuredArrow.homMk'_comp
code: lemma homMk'_comp (f : StructuredArrow S T) (g : f.right ⟶ Y') (g' : Y' ⟶ Y'') :
    homMk' f (g ≫ g') = homMk' f g ≫ homMk' (mk (f.hom ≫ T.map g)) g' ≫ eqToHom (by simp) 
goal: f.homMk' (CategoryTheory.CategoryStruct.comp g g') =
  CategoryTheory.CategoryStruct.comp (f.homMk' g)
    (CategoryTheory.CategoryStruct.comp
      ((CategoryTheory.StructuredArrow.mk (CategoryTheory.CategoryStruct.comp f.hom (T.map g))).homMk' g')
      (CategoryTheory.eqToHom ⋯))

full_name: CategoryTheory.StructuredArrow.homMk'_mk_comp
code: lemma homMk'_mk_comp (f : S ⟶ T.obj Y) (g : Y ⟶ Y') (g' : Y' ⟶ Y'') :
    homMk' (mk f) (g ≫ g') = homMk' (mk f) g ≫ homMk' (mk (f ≫ T.map g)) g' ≫ eqToHom (by simp) 
goal: (CategoryTheory.StructuredArrow.mk f).homMk' (CategoryTheory.CategoryStruct.comp g g') =
  CategoryTheory.CategoryStruct.comp ((CategoryTheory.StructuredArrow.mk f).homMk' g)
    (CategoryTheory.CategoryStruct.comp
      ((CategoryTheory.StructuredArrow.mk (CategoryTheory.CategoryStruct.comp f (T.map g))).homMk' g')
      (CategoryTheory.eqToHom ⋯))

full_name: CategoryTheory.StructuredArrow.mkPostcomp_left
code: /-- Variant of `homMk'` where both objects are applications of `mk`. -/
@[simps]
def mkPostcomp (f : S ⟶ T.obj Y) (g : Y ⟶ Y') : mk f ⟶ mk (f ≫ T.map g) 
goal: (CategoryTheory.StructuredArrow.mkPostcomp f g).left =
  CategoryTheory.CategoryStruct.id (CategoryTheory.StructuredArrow.mk f).left

full_name: CategoryTheory.StructuredArrow.mkPostcomp_right
code: /-- Variant of `homMk'` where both objects are applications of `mk`. -/
@[simps]
def mkPostcomp (f : S ⟶ T.obj Y) (g : Y ⟶ Y') : mk f ⟶ mk (f ≫ T.map g) 
goal: (CategoryTheory.StructuredArrow.mkPostcomp f g).right = g

full_name: CategoryTheory.StructuredArrow.mkPostcomp
code: /-- Variant of `homMk'` where both objects are applications of `mk`. -/
@[simps]
def mkPostcomp (f : S ⟶ T.obj Y) (g : Y ⟶ Y') : mk f ⟶ mk (f ≫ T.map g) 
goal: CategoryTheory.StructuredArrow.mk f ⟶ CategoryTheory.StructuredArrow.mk (CategoryTheory.CategoryStruct.comp f (T.map g))

full_name: CategoryTheory.StructuredArrow.mkPostcomp_id
code: lemma mkPostcomp_id (f : S ⟶ T.obj Y) : mkPostcomp f (𝟙 Y) = eqToHom (by aesop_cat) 
goal: CategoryTheory.StructuredArrow.mkPostcomp f (CategoryTheory.CategoryStruct.id Y) = CategoryTheory.eqToHom ⋯

full_name: CategoryTheory.StructuredArrow.mkPostcomp_comp
code: lemma mkPostcomp_comp (f : S ⟶ T.obj Y) (g : Y ⟶ Y') (g' : Y' ⟶ Y'') :
    mkPostcomp f (g ≫ g') = mkPostcomp f g ≫ mkPostcomp (f ≫ T.map g) g' ≫ eqToHom (by simp) 
goal: CategoryTheory.StructuredArrow.mkPostcomp f (CategoryTheory.CategoryStruct.comp g g') =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.StructuredArrow.mkPostcomp f g)
    (CategoryTheory.CategoryStruct.comp
      (CategoryTheory.StructuredArrow.mkPostcomp (CategoryTheory.CategoryStruct.comp f (T.map g)) g')
      (CategoryTheory.eqToHom ⋯))

full_name: CategoryTheory.StructuredArrow.isoMk_hom_left_down_down
code: /-- To construct an isomorphism of structured arrows,
we need an isomorphism of the objects underlying the target,
and to check that the triangle commutes.
-/
@[simps!]
def isoMk {f f' : StructuredArrow S T} (g : f.right ≅ f'.right)
    (w : f.hom ≫ T.map g.hom = f'.hom := by aesop_cat) :
    f ≅ f' 
goal: ⋯ = ⋯

full_name: CategoryTheory.StructuredArrow.isoMk_inv_right
code: /-- To construct an isomorphism of structured arrows,
we need an isomorphism of the objects underlying the target,
and to check that the triangle commutes.
-/
@[simps!]
def isoMk {f f' : StructuredArrow S T} (g : f.right ≅ f'.right)
    (w : f.hom ≫ T.map g.hom = f'.hom := by aesop_cat) :
    f ≅ f' 
goal: (CategoryTheory.StructuredArrow.isoMk g w).inv.right = g.inv

full_name: CategoryTheory.StructuredArrow.isoMk
code: /-- To construct an isomorphism of structured arrows,
we need an isomorphism of the objects underlying the target,
and to check that the triangle commutes.
-/
@[simps!]
def isoMk {f f' : StructuredArrow S T} (g : f.right ≅ f'.right)
    (w : f.hom ≫ T.map g.hom = f'.hom := by aesop_cat) :
    f ≅ f' 
goal: f ≅ f'

full_name: CategoryTheory.StructuredArrow.isoMk_hom_right
code: /-- To construct an isomorphism of structured arrows,
we need an isomorphism of the objects underlying the target,
and to check that the triangle commutes.
-/
@[simps!]
def isoMk {f f' : StructuredArrow S T} (g : f.right ≅ f'.right)
    (w : f.hom ≫ T.map g.hom = f'.hom := by aesop_cat) :
    f ≅ f' 
goal: (CategoryTheory.StructuredArrow.isoMk g w).hom.right = g.hom

full_name: CategoryTheory.StructuredArrow.isoMk_inv_left_down_down
code: /-- To construct an isomorphism of structured arrows,
we need an isomorphism of the objects underlying the target,
and to check that the triangle commutes.
-/
@[simps!]
def isoMk {f f' : StructuredArrow S T} (g : f.right ≅ f'.right)
    (w : f.hom ≫ T.map g.hom = f'.hom := by aesop_cat) :
    f ≅ f' 
goal: ⋯ = ⋯

full_name: CategoryTheory.StructuredArrow.ext
code: theorem ext {A B : StructuredArrow S T} (f g : A ⟶ B) : f.right = g.right → f = g 
goal: f.right = g.right → f = g

full_name: CategoryTheory.StructuredArrow.ext_iff
code: theorem ext_iff {A B : StructuredArrow S T} (f g : A ⟶ B) : f = g ↔ f.right = g.right 
goal: f = g ↔ f.right = g.right

full_name: CategoryTheory.StructuredArrow.proj_faithful
code: instance proj_faithful : (proj S T).Faithful 
goal: (CategoryTheory.StructuredArrow.proj S T).Faithful

full_name: CategoryTheory.StructuredArrow.mono_of_mono_right
code: /-- The converse of this is true with additional assumptions, see `mono_iff_mono_right`. -/
theorem mono_of_mono_right {A B : StructuredArrow S T} (f : A ⟶ B) [h : Mono f.right] : Mono f 
goal: CategoryTheory.Mono f

full_name: CategoryTheory.StructuredArrow.epi_of_epi_right
code: theorem epi_of_epi_right {A B : StructuredArrow S T} (f : A ⟶ B) [h : Epi f.right] : Epi f 
goal: CategoryTheory.Epi f

full_name: CategoryTheory.StructuredArrow.mono_homMk
code: instance mono_homMk {A B : StructuredArrow S T} (f : A.right ⟶ B.right) (w) [h : Mono f] :
    Mono (homMk f w) 
goal: CategoryTheory.Mono (CategoryTheory.StructuredArrow.homMk f w)

full_name: CategoryTheory.StructuredArrow.epi_homMk
code: instance epi_homMk {A B : StructuredArrow S T} (f : A.right ⟶ B.right) (w) [h : Epi f] :
    Epi (homMk f w) 
goal: CategoryTheory.Epi (CategoryTheory.StructuredArrow.homMk f w)

full_name: CategoryTheory.StructuredArrow.eq_mk
code: /-- Eta rule for structured arrows. Prefer `StructuredArrow.eta` for rewriting, since equality of
    objects tends to cause problems. -/
theorem eq_mk (f : StructuredArrow S T) : f = mk f.hom 
goal: f = CategoryTheory.StructuredArrow.mk f.hom

full_name: CategoryTheory.StructuredArrow.eta_hom_right
code: /-- Eta rule for structured arrows. -/
@[simps!]
def eta (f : StructuredArrow S T) : f ≅ mk f.hom 
goal: f.eta.hom.right = CategoryTheory.CategoryStruct.id f.right

full_name: CategoryTheory.StructuredArrow.eta_hom_left_down_down
code: /-- Eta rule for structured arrows. -/
@[simps!]
def eta (f : StructuredArrow S T) : f ≅ mk f.hom 
goal: ⋯ = ⋯

full_name: CategoryTheory.StructuredArrow.eta_inv_left_down_down
code: /-- Eta rule for structured arrows. -/
@[simps!]
def eta (f : StructuredArrow S T) : f ≅ mk f.hom 
goal: ⋯ = ⋯

full_name: CategoryTheory.StructuredArrow.eta_inv_right
code: /-- Eta rule for structured arrows. -/
@[simps!]
def eta (f : StructuredArrow S T) : f ≅ mk f.hom 
goal: f.eta.inv.right = CategoryTheory.CategoryStruct.id f.right

full_name: CategoryTheory.StructuredArrow.eta
code: /-- Eta rule for structured arrows. -/
@[simps!]
def eta (f : StructuredArrow S T) : f ≅ mk f.hom 
goal: f ≅ CategoryTheory.StructuredArrow.mk f.hom

full_name: CategoryTheory.StructuredArrow.mk_surjective
code: lemma mk_surjective (f : StructuredArrow S T) :
    ∃ (Y : C) (g : S ⟶ T.obj Y), f = mk g 
goal: ∃ Y g, f = CategoryTheory.StructuredArrow.mk g

full_name: CategoryTheory.StructuredArrow.map_map_right
code: /-- 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`.
-/
@[simps!]
def map (f : S ⟶ S') : StructuredArrow S' T ⥤ StructuredArrow S T 
goal: ∀ {X Y : CategoryTheory.Comma (CategoryTheory.Functor.fromPUnit S') T} (f_1 : X ⟶ Y),
  ((CategoryTheory.StructuredArrow.map f).map f_1).right = f_1.right

full_name: CategoryTheory.StructuredArrow.map_map_left
code: /-- 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`.
-/
@[simps!]
def map (f : S ⟶ S') : StructuredArrow S' T ⥤ StructuredArrow S T 
goal: ∀ {X Y : CategoryTheory.Comma (CategoryTheory.Functor.fromPUnit S') T} (f_1 : X ⟶ Y),
  ((CategoryTheory.StructuredArrow.map f).map f_1).left = CategoryTheory.CategoryStruct.id X.left

full_name: CategoryTheory.StructuredArrow.map_obj_hom
code: /-- 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`.
-/
@[simps!]
def map (f : S ⟶ S') : StructuredArrow S' T ⥤ StructuredArrow S T 
goal: ((CategoryTheory.StructuredArrow.map f).obj X).hom = CategoryTheory.CategoryStruct.comp f X.hom

full_name: CategoryTheory.StructuredArrow.map
code: /-- 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`.
-/
@[simps!]
def map (f : S ⟶ S') : StructuredArrow S' T ⥤ StructuredArrow S T 
goal: CategoryTheory.Functor (CategoryTheory.StructuredArrow S' T) (CategoryTheory.StructuredArrow S T)

full_name: CategoryTheory.StructuredArrow.map_obj_left
code: /-- 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`.
-/
@[simps!]
def map (f : S ⟶ S') : StructuredArrow S' T ⥤ StructuredArrow S T 
goal: ((CategoryTheory.StructuredArrow.map f).obj X).left = X.left

full_name: CategoryTheory.StructuredArrow.map_obj_right
code: /-- 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`.
-/
@[simps!]
def map (f : S ⟶ S') : StructuredArrow S' T ⥤ StructuredArrow S T 
goal: ((CategoryTheory.StructuredArrow.map f).obj X).right = X.right

full_name: CategoryTheory.StructuredArrow.map_mk
code: @[simp]
theorem map_mk {f : S' ⟶ T.obj Y} (g : S ⟶ S') : (map g).obj (mk f) = mk (g ≫ f) 
goal: (CategoryTheory.StructuredArrow.map g).obj (CategoryTheory.StructuredArrow.mk f) =
  CategoryTheory.StructuredArrow.mk (CategoryTheory.CategoryStruct.comp g f)

full_name: CategoryTheory.StructuredArrow.map_id
code: @[simp]
theorem map_id {f : StructuredArrow S T} : (map (𝟙 S)).obj f = f 
goal: (CategoryTheory.StructuredArrow.map (CategoryTheory.CategoryStruct.id S)).obj f = f

full_name: CategoryTheory.StructuredArrow.map_comp
code: @[simp]
theorem map_comp {f : S ⟶ S'} {f' : S' ⟶ S''} {h : StructuredArrow S'' T} :
    (map (f ≫ f')).obj h = (map f).obj ((map f').obj h) 
goal: (CategoryTheory.StructuredArrow.map (CategoryTheory.CategoryStruct.comp f f')).obj h =
  (CategoryTheory.StructuredArrow.map f).obj ((CategoryTheory.StructuredArrow.map f').obj h)

full_name: CategoryTheory.StructuredArrow.mapIso
code: /-- An isomorphism `S ≅ S'` induces an equivalence `StructuredArrow S T ≌ StructuredArrow S' T`. -/
@[simp]
def mapIso (i : S ≅ S') : StructuredArrow S T ≌ StructuredArrow S' T 
goal: CategoryTheory.StructuredArrow S T ≌ CategoryTheory.StructuredArrow S' T

full_name: CategoryTheory.StructuredArrow.mapNatIso
code: /-- A natural isomorphism `T ≅ T'` induces an equivalence
    `StructuredArrow S T ≌ StructuredArrow S T'`. -/
@[simp]
def mapNatIso (i : T ≅ T') : StructuredArrow S T ≌ StructuredArrow S T' 
goal: CategoryTheory.StructuredArrow S T ≌ CategoryTheory.StructuredArrow S T'

full_name: CategoryTheory.StructuredArrow.proj_reflectsIsomorphisms
code: instance proj_reflectsIsomorphisms : (proj S T).ReflectsIsomorphisms 
goal: (CategoryTheory.StructuredArrow.proj S T).ReflectsIsomorphisms

full_name: CategoryTheory.StructuredArrow.mkIdInitial
code: /-- The identity structured arrow is initial. -/
noncomputable def mkIdInitial [T.Full] [T.Faithful] : IsInitial (mk (𝟙 (T.obj Y))) 
goal: CategoryTheory.Limits.IsInitial (CategoryTheory.StructuredArrow.mk (CategoryTheory.CategoryStruct.id (T.obj Y)))

full_name: CategoryTheory.StructuredArrow.pre_obj_hom
code: /-- The functor `(S, F ⋙ G) ⥤ (S, G)`. -/
@[simps!]
def pre (S : D) (F : B ⥤ C) (G : C ⥤ D) : StructuredArrow S (F ⋙ G) ⥤ StructuredArrow S G 
goal: ((CategoryTheory.StructuredArrow.pre S F G).obj X).hom = X.hom

full_name: CategoryTheory.StructuredArrow.pre_obj_right
code: /-- The functor `(S, F ⋙ G) ⥤ (S, G)`. -/
@[simps!]
def pre (S : D) (F : B ⥤ C) (G : C ⥤ D) : StructuredArrow S (F ⋙ G) ⥤ StructuredArrow S G 
goal: ((CategoryTheory.StructuredArrow.pre S F G).obj X).right = F.obj X.right

full_name: CategoryTheory.StructuredArrow.pre_obj_left
code: /-- The functor `(S, F ⋙ G) ⥤ (S, G)`. -/
@[simps!]
def pre (S : D) (F : B ⥤ C) (G : C ⥤ D) : StructuredArrow S (F ⋙ G) ⥤ StructuredArrow S G 
goal: ((CategoryTheory.StructuredArrow.pre S F G).obj X).left = X.left

full_name: CategoryTheory.StructuredArrow.pre_map_right
code: /-- The functor `(S, F ⋙ G) ⥤ (S, G)`. -/
@[simps!]
def pre (S : D) (F : B ⥤ C) (G : C ⥤ D) : StructuredArrow S (F ⋙ G) ⥤ StructuredArrow S G 
goal: ∀ {X Y : CategoryTheory.Comma (CategoryTheory.Functor.fromPUnit S) (F.comp G)} (f : X ⟶ Y),
  ((CategoryTheory.StructuredArrow.pre S F G).map f).right = F.map f.right

full_name: CategoryTheory.StructuredArrow.pre
code: /-- The functor `(S, F ⋙ G) ⥤ (S, G)`. -/
@[simps!]
def pre (S : D) (F : B ⥤ C) (G : C ⥤ D) : StructuredArrow S (F ⋙ G) ⥤ StructuredArrow S G 
goal: CategoryTheory.Functor (CategoryTheory.StructuredArrow S (F.comp G)) (CategoryTheory.StructuredArrow S G)

full_name: CategoryTheory.StructuredArrow.pre_map_left
code: /-- The functor `(S, F ⋙ G) ⥤ (S, G)`. -/
@[simps!]
def pre (S : D) (F : B ⥤ C) (G : C ⥤ D) : StructuredArrow S (F ⋙ G) ⥤ StructuredArrow S G 
goal: ∀ {X Y : CategoryTheory.Comma (CategoryTheory.Functor.fromPUnit S) (F.comp G)} (f : X ⟶ Y),
  ((CategoryTheory.StructuredArrow.pre S F G).map f).left = CategoryTheory.CategoryStruct.id X.left

full_name: CategoryTheory.StructuredArrow.instFaithfulCompPre
code: instance (S : D) (F : B ⥤ C) (G : C ⥤ D) [F.Faithful] : (pre S F G).Faithful 
goal: (CategoryTheory.StructuredArrow.pre S F G).Faithful

full_name: CategoryTheory.StructuredArrow.instFullCompPre
code: instance (S : D) (F : B ⥤ C) (G : C ⥤ D) [F.Full] : (pre S F G).Full 
goal: (CategoryTheory.StructuredArrow.pre S F G).Full

full_name: CategoryTheory.StructuredArrow.instEssSurjCompPre
code: instance (S : D) (F : B ⥤ C) (G : C ⥤ D) [F.EssSurj] : (pre S F G).EssSurj 
goal: (CategoryTheory.StructuredArrow.pre S F G).EssSurj

full_name: CategoryTheory.StructuredArrow.isEquivalence_pre
code: /-- If `F` is an equivalence, then so is the functor `(S, F ⋙ G) ⥤ (S, G)`. -/
instance isEquivalence_pre (S : D) (F : B ⥤ C) (G : C ⥤ D) [F.IsEquivalence] :
    (pre S F G).IsEquivalence 
goal: (CategoryTheory.StructuredArrow.pre S F G).IsEquivalence

full_name: CategoryTheory.StructuredArrow.post_map
code: /-- The functor `(S, F) ⥤ (G(S), F ⋙ G)`. -/
@[simps]
def post (S : C) (F : B ⥤ C) (G : C ⥤ D) :
    StructuredArrow S F ⥤ StructuredArrow (G.obj S) (F ⋙ G) 
goal: ∀ {X Y : CategoryTheory.StructuredArrow S F} (f : X ⟶ Y),
  (CategoryTheory.StructuredArrow.post S F G).map f = CategoryTheory.StructuredArrow.homMk f.right ⋯

full_name: CategoryTheory.StructuredArrow.post_obj
code: /-- The functor `(S, F) ⥤ (G(S), F ⋙ G)`. -/
@[simps]
def post (S : C) (F : B ⥤ C) (G : C ⥤ D) :
    StructuredArrow S F ⥤ StructuredArrow (G.obj S) (F ⋙ G) 
goal: (CategoryTheory.StructuredArrow.post S F G).obj X = CategoryTheory.StructuredArrow.mk (G.map X.hom)

full_name: CategoryTheory.StructuredArrow.post
code: /-- The functor `(S, F) ⥤ (G(S), F ⋙ G)`. -/
@[simps]
def post (S : C) (F : B ⥤ C) (G : C ⥤ D) :
    StructuredArrow S F ⥤ StructuredArrow (G.obj S) (F ⋙ G) 
goal: CategoryTheory.Functor (CategoryTheory.StructuredArrow S F) (CategoryTheory.StructuredArrow (G.obj S) (F.comp G))

full_name: CategoryTheory.StructuredArrow.instFaithfulObjCompPost
code: instance (S : C) (F : B ⥤ C) (G : C ⥤ D) : (post S F G).Faithful 
goal: (CategoryTheory.StructuredArrow.post S F G).Faithful

full_name: CategoryTheory.StructuredArrow.instFullObjCompPostOfFaithful
code: instance (S : C) (F : B ⥤ C) (G : C ⥤ D) [G.Faithful] : (post S F G).Full 
goal: (CategoryTheory.StructuredArrow.post S F G).Full

full_name: CategoryTheory.StructuredArrow.instEssSurjObjCompPostOfFull
code: instance (S : C) (F : B ⥤ C) (G : C ⥤ D) [G.Full] : (post S F G).EssSurj 
goal: (CategoryTheory.StructuredArrow.post S F G).EssSurj

full_name: CategoryTheory.StructuredArrow.isEquivalence_post
code: /-- If `G` is fully faithful, then `post S F G : (S, F) ⥤ (G(S), F ⋙ G)` is an equivalence. -/
instance isEquivalence_post (S : C) (F : B ⥤ C) (G : C ⥤ D) [G.Full] [G.Faithful] :
    (post S F G).IsEquivalence 
goal: (CategoryTheory.StructuredArrow.post S F G).IsEquivalence

full_name: CategoryTheory.StructuredArrow.map₂_obj_left
code: /-- 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.` -/
@[simps!]
def map₂ : StructuredArrow L R ⥤ StructuredArrow L' R' 
goal: ((CategoryTheory.StructuredArrow.map₂ α β).obj X).left = X.left

full_name: CategoryTheory.StructuredArrow.map₂
code: /-- 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.` -/
@[simps!]
def map₂ : StructuredArrow L R ⥤ StructuredArrow L' R' 
goal: CategoryTheory.Functor (CategoryTheory.StructuredArrow L R) (CategoryTheory.StructuredArrow L' R')

full_name: CategoryTheory.StructuredArrow.map₂_obj_right
code: /-- 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.` -/
@[simps!]
def map₂ : StructuredArrow L R ⥤ StructuredArrow L' R' 
goal: ((CategoryTheory.StructuredArrow.map₂ α β).obj X).right = F.obj X.right

full_name: CategoryTheory.StructuredArrow.map₂_map_right
code: /-- 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.` -/
@[simps!]
def map₂ : StructuredArrow L R ⥤ StructuredArrow L' R' 
goal: ((CategoryTheory.StructuredArrow.map₂ α β).map φ).right = F.map φ.right

full_name: CategoryTheory.StructuredArrow.map₂_map_left
code: /-- 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.` -/
@[simps!]
def map₂ : StructuredArrow L R ⥤ StructuredArrow L' R' 
goal: ((CategoryTheory.StructuredArrow.map₂ α β).map φ).left = CategoryTheory.CategoryStruct.id X.left

full_name: CategoryTheory.StructuredArrow.map₂_obj_hom
code: /-- 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.` -/
@[simps!]
def map₂ : StructuredArrow L R ⥤ StructuredArrow L' R' 
goal: ((CategoryTheory.StructuredArrow.map₂ α β).obj X).hom =
  CategoryTheory.CategoryStruct.comp α (CategoryTheory.CategoryStruct.comp (G.map X.hom) (β.app X.right))

full_name: CategoryTheory.StructuredArrow.faithful_map₂
code: instance faithful_map₂ [F.Faithful] : (map₂ α β).Faithful 
goal: (CategoryTheory.StructuredArrow.map₂ α β).Faithful

full_name: CategoryTheory.StructuredArrow.full_map₂
code: instance full_map₂ [G.Faithful] [F.Full] [IsIso α] [IsIso β] : (map₂ α β).Full 
goal: (CategoryTheory.StructuredArrow.map₂ α β).Full

full_name: CategoryTheory.StructuredArrow.essSurj_map₂
code: instance essSurj_map₂ [F.EssSurj] [G.Full] [IsIso α] [IsIso β] : (map₂ α β).EssSurj 
goal: (CategoryTheory.StructuredArrow.map₂ α β).EssSurj

full_name: CategoryTheory.StructuredArrow.isEquivalenceMap₂
code: noncomputable instance isEquivalenceMap₂
    [F.IsEquivalence] [G.Faithful] [G.Full] [IsIso α] [IsIso β] :
    (map₂ α β).IsEquivalence 
goal: (CategoryTheory.StructuredArrow.map₂ α β).IsEquivalence

full_name: CategoryTheory.StructuredArrow.small_proj_preimage_of_locallySmall
code: instance small_proj_preimage_of_locallySmall {𝒢 : Set C} [Small.{v₁} 𝒢] [LocallySmall.{v₁} D] :
    Small.{v₁} ((proj S T).obj ⁻¹' 𝒢) 
goal: Small.{v₁, max u₁ v₂} ↑((CategoryTheory.StructuredArrow.proj S T).obj ⁻¹' 𝒢)

full_name: CategoryTheory.StructuredArrow.IsUniversal
code: /-- A structured arrow is called universal if it is initial. -/
abbrev IsUniversal (f : StructuredArrow S T) 
goal: Type (max (max u₁ v₂) v₁)

full_name: CategoryTheory.StructuredArrow.IsUniversal.uniq
code: theorem uniq (h : IsUniversal f) (η : f ⟶ g) : η = h.to g 
goal: η = CategoryTheory.Limits.IsInitial.to h g

full_name: CategoryTheory.StructuredArrow.IsUniversal.desc
code: /-- The family of morphisms out of a universal arrow. -/
def desc (h : IsUniversal f) (g : StructuredArrow S T) : f.right ⟶ g.right 
goal: f.right ⟶ g.right

full_name: CategoryTheory.StructuredArrow.IsUniversal.fac
code: /-- Any structured arrow factors through a universal arrow. -/
@[reassoc (attr := simp)]
theorem fac (h : IsUniversal f) (g : StructuredArrow S T) :
    f.hom ≫ T.map (h.desc g) = g.hom 
goal: CategoryTheory.CategoryStruct.comp f.hom (T.map (h.desc g)) = g.hom

full_name: CategoryTheory.StructuredArrow.IsUniversal.hom_desc
code: theorem hom_desc (h : IsUniversal f) {c : C} (η : f.right ⟶ c) :
    η = h.desc (mk <| f.hom ≫ T.map η) 
goal: η = h.desc (CategoryTheory.StructuredArrow.mk (CategoryTheory.CategoryStruct.comp f.hom (T.map η)))

full_name: CategoryTheory.StructuredArrow.IsUniversal.hom_ext
code: /-- Two morphisms out of a universal `T`-structured arrow are equal if their image under `T` are
equal after precomposing the universal arrow. -/
theorem hom_ext (h : IsUniversal f) {c : C} {η η' : f.right ⟶ c}
    (w : f.hom ≫ T.map η = f.hom ≫ T.map η') : η = η' 
goal: η = η'

full_name: CategoryTheory.StructuredArrow.IsUniversal.existsUnique
code: theorem existsUnique (h : IsUniversal f) (g : StructuredArrow S T) :
    ∃! η : f.right ⟶ g.right, f.hom ≫ T.map η = g.hom 
goal: ∃! η, CategoryTheory.CategoryStruct.comp f.hom (T.map η) = g.hom

full_name: CategoryTheory.CostructuredArrow
code: /-- 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.
-/
-- We explicitly come from `PUnit.{1}` here to obtain the correct universe for morphisms of
-- costructured arrows.
-- @[nolint has_nonempty_instance] -- Porting note(#5171): linter not ported yet
def CostructuredArrow (S : C ⥤ D) (T : D) 
goal: Type (max u₁ v₂)

full_name: CategoryTheory.instCategoryCostructuredArrow
code: instance (S : C ⥤ D) (T : D) : Category (CostructuredArrow S T) 
goal: CategoryTheory.Category.{v₁, max u₁ v₂} (CategoryTheory.CostructuredArrow S T)

full_name: CategoryTheory.CostructuredArrow.proj_obj
code: /-- The obvious projection functor from costructured arrows. -/
@[simps!]
def proj (S : C ⥤ D) (T : D) : CostructuredArrow S T ⥤ C 
goal: (CategoryTheory.CostructuredArrow.proj S T).obj X = X.left

full_name: CategoryTheory.CostructuredArrow.proj
code: /-- The obvious projection functor from costructured arrows. -/
@[simps!]
def proj (S : C ⥤ D) (T : D) : CostructuredArrow S T ⥤ C 
goal: CategoryTheory.Functor (CategoryTheory.CostructuredArrow S T) C

full_name: CategoryTheory.CostructuredArrow.proj_map
code: /-- The obvious projection functor from costructured arrows. -/
@[simps!]
def proj (S : C ⥤ D) (T : D) : CostructuredArrow S T ⥤ C 
goal: ∀ {X Y : CategoryTheory.Comma S (CategoryTheory.Functor.fromPUnit T)} (f : X ⟶ Y),
  (CategoryTheory.CostructuredArrow.proj S T).map f = f.left

full_name: CategoryTheory.CostructuredArrow.hom_ext
code: @[ext]
lemma hom_ext {X Y : CostructuredArrow S T} (f g : X ⟶ Y) (h : f.left = g.left) : f = g 
goal: f = g

full_name: CategoryTheory.CostructuredArrow.hom_eq_iff
code: @[simp]
theorem hom_eq_iff {X Y : CostructuredArrow S T} (f g : X ⟶ Y) : f = g ↔ f.left = g.left 
goal: f = g ↔ f.left = g.left

full_name: CategoryTheory.CostructuredArrow.mk
code: /-- Construct a costructured arrow from a morphism. -/
def mk (f : S.obj Y ⟶ T) : CostructuredArrow S T 
goal: CategoryTheory.CostructuredArrow S T

full_name: CategoryTheory.CostructuredArrow.mk_left
code: @[simp]
theorem mk_left (f : S.obj Y ⟶ T) : (mk f).left = Y 
goal: (CategoryTheory.CostructuredArrow.mk f).left = Y

full_name: CategoryTheory.CostructuredArrow.mk_right
code: @[simp]
theorem mk_right (f : S.obj Y ⟶ T) : (mk f).right = ⟨⟨⟩⟩ 
goal: (CategoryTheory.CostructuredArrow.mk f).right = { as := PUnit.unit }

full_name: CategoryTheory.CostructuredArrow.mk_hom_eq_self
code: @[simp]
theorem mk_hom_eq_self (f : S.obj Y ⟶ T) : (mk f).hom = f 
goal: (CategoryTheory.CostructuredArrow.mk f).hom = f

full_name: CategoryTheory.CostructuredArrow.w
code: @[reassoc]
theorem w {A B : CostructuredArrow S T} (f : A ⟶ B) : S.map f.left ≫ B.hom = A.hom 
goal: CategoryTheory.CategoryStruct.comp (S.map f.left) B.hom = A.hom

full_name: CategoryTheory.CostructuredArrow.comp_left
code: @[simp]
theorem comp_left {X Y Z : CostructuredArrow S T} (f : X ⟶ Y) (g : Y ⟶ Z) :
    (f ≫ g).left = f.left ≫ g.left 
goal: (CategoryTheory.CategoryStruct.comp f g).left = CategoryTheory.CategoryStruct.comp f.left g.left

full_name: CategoryTheory.CostructuredArrow.id_left
code: @[simp]
theorem id_left (X : CostructuredArrow S T) : (𝟙 X : X ⟶ X).left = 𝟙 X.left 
goal: (CategoryTheory.CategoryStruct.id X).left = CategoryTheory.CategoryStruct.id X.left

full_name: CategoryTheory.CostructuredArrow.eqToHom_left
code: @[simp]
theorem eqToHom_left {X Y : CostructuredArrow S T} (h : X = Y) :
    (eqToHom h).left = eqToHom (by rw [h]) 
goal: (CategoryTheory.eqToHom h).left = CategoryTheory.eqToHom ⋯

full_name: CategoryTheory.CostructuredArrow.right_eq_id
code: @[simp]
theorem right_eq_id {X Y : CostructuredArrow S T} (f : X ⟶ Y) : f.right = 𝟙 _ 
goal: f.right = CategoryTheory.CategoryStruct.id X.right

full_name: CategoryTheory.CostructuredArrow.homMk_right_down_down
code: /-- To construct a morphism of costructured arrows,
we need a morphism of the objects underlying the source,
and to check that the triangle commutes.
-/
@[simps!]
def homMk {f f' : CostructuredArrow S T} (g : f.left ⟶ f'.left)
    (w : S.map g ≫ f'.hom = f.hom := by aesop_cat) : f ⟶ f' 
goal: ⋯ = ⋯

full_name: CategoryTheory.CostructuredArrow.homMk_left
code: /-- To construct a morphism of costructured arrows,
we need a morphism of the objects underlying the source,
and to check that the triangle commutes.
-/
@[simps!]
def homMk {f f' : CostructuredArrow S T} (g : f.left ⟶ f'.left)
    (w : S.map g ≫ f'.hom = f.hom := by aesop_cat) : f ⟶ f' 
goal: (CategoryTheory.CostructuredArrow.homMk g w).left = g

full_name: CategoryTheory.CostructuredArrow.homMk
code: /-- To construct a morphism of costructured arrows,
we need a morphism of the objects underlying the source,
and to check that the triangle commutes.
-/
@[simps!]
def homMk {f f' : CostructuredArrow S T} (g : f.left ⟶ f'.left)
    (w : S.map g ≫ f'.hom = f.hom := by aesop_cat) : f ⟶ f' 
goal: f ⟶ f'

full_name: CategoryTheory.CostructuredArrow.homMk_surjective
code: theorem homMk_surjective {f f' : CostructuredArrow S T} (φ : f ⟶ f') :
    ∃ (ψ : f.left ⟶ f'.left) (hψ : S.map ψ ≫ f'.hom = f.hom),
      φ = CostructuredArrow.homMk ψ hψ 
goal: ∃ ψ,
  ∃ (hψ : CategoryTheory.CategoryStruct.comp (S.map ψ) f'.hom = f.hom), φ = CategoryTheory.CostructuredArrow.homMk ψ hψ

full_name: CategoryTheory.CostructuredArrow.homMk'_left
code: /-- 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)`. -/
@[simps]
def homMk' (f : CostructuredArrow S T) (g : Y' ⟶ f.left) : mk (S.map g ≫ f.hom) ⟶ f 
goal: (f.homMk' g).left = g

full_name: CategoryTheory.CostructuredArrow.homMk'_right
code: /-- 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)`. -/
@[simps]
def homMk' (f : CostructuredArrow S T) (g : Y' ⟶ f.left) : mk (S.map g ≫ f.hom) ⟶ f 
goal: (f.homMk' g).right =
  CategoryTheory.CategoryStruct.id
    (CategoryTheory.CostructuredArrow.mk (CategoryTheory.CategoryStruct.comp (S.map g) f.hom)).right

full_name: CategoryTheory.CostructuredArrow.homMk'
code: /-- 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)`. -/
@[simps]
def homMk' (f : CostructuredArrow S T) (g : Y' ⟶ f.left) : mk (S.map g ≫ f.hom) ⟶ f 
goal: CategoryTheory.CostructuredArrow.mk (CategoryTheory.CategoryStruct.comp (S.map g) f.hom) ⟶ f

full_name: CategoryTheory.CostructuredArrow.homMk'_id
code: lemma homMk'_id (f : CostructuredArrow S T) : homMk' f (𝟙 f.left) = eqToHom (by aesop_cat) 
goal: f.homMk' (CategoryTheory.CategoryStruct.id f.left) = CategoryTheory.eqToHom ⋯

full_name: CategoryTheory.CostructuredArrow.homMk'_mk_id
code: lemma homMk'_mk_id (f : S.obj Y ⟶ T) : homMk' (mk f) (𝟙 Y) = eqToHom (by aesop_cat) 
goal: (CategoryTheory.CostructuredArrow.mk f).homMk' (CategoryTheory.CategoryStruct.id Y) = CategoryTheory.eqToHom ⋯

full_name: CategoryTheory.CostructuredArrow.homMk'_comp
code: lemma homMk'_comp (f : CostructuredArrow S T) (g : Y' ⟶ f.left) (g' : Y'' ⟶ Y') :
    homMk' f (g' ≫ g) = eqToHom (by simp) ≫ homMk' (mk (S.map g ≫ f.hom)) g' ≫ homMk' f g 
goal: f.homMk' (CategoryTheory.CategoryStruct.comp g' g) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯)
    (CategoryTheory.CategoryStruct.comp
      ((CategoryTheory.CostructuredArrow.mk (CategoryTheory.CategoryStruct.comp (S.map g) f.hom)).homMk' g')
      (f.homMk' g))

full_name: CategoryTheory.CostructuredArrow.homMk'_mk_comp
code: lemma homMk'_mk_comp (f : S.obj Y ⟶ T) (g : Y' ⟶ Y) (g' : Y'' ⟶ Y') :
    homMk' (mk f) (g' ≫ g) = eqToHom (by simp) ≫ homMk' (mk (S.map g ≫ f)) g' ≫ homMk' (mk f) g 
goal: (CategoryTheory.CostructuredArrow.mk f).homMk' (CategoryTheory.CategoryStruct.comp g' g) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯)
    (CategoryTheory.CategoryStruct.comp
      ((CategoryTheory.CostructuredArrow.mk (CategoryTheory.CategoryStruct.comp (S.map g) f)).homMk' g')
      ((CategoryTheory.CostructuredArrow.mk f).homMk' g))

full_name: CategoryTheory.CostructuredArrow.mkPrecomp
code: /-- Variant of `homMk'` where both objects are applications of `mk`. -/
@[simps]
def mkPrecomp (f : S.obj Y ⟶ T) (g : Y' ⟶ Y) : mk (S.map g ≫ f) ⟶ mk f 
goal: CategoryTheory.CostructuredArrow.mk (CategoryTheory.CategoryStruct.comp (S.map g) f) ⟶
  CategoryTheory.CostructuredArrow.mk f

full_name: CategoryTheory.CostructuredArrow.mkPrecomp_right
code: /-- Variant of `homMk'` where both objects are applications of `mk`. -/
@[simps]
def mkPrecomp (f : S.obj Y ⟶ T) (g : Y' ⟶ Y) : mk (S.map g ≫ f) ⟶ mk f 
goal: (CategoryTheory.CostructuredArrow.mkPrecomp f g).right =
  CategoryTheory.CategoryStruct.id
    (CategoryTheory.CostructuredArrow.mk (CategoryTheory.CategoryStruct.comp (S.map g) f)).right

full_name: CategoryTheory.CostructuredArrow.mkPrecomp_left
code: /-- Variant of `homMk'` where both objects are applications of `mk`. -/
@[simps]
def mkPrecomp (f : S.obj Y ⟶ T) (g : Y' ⟶ Y) : mk (S.map g ≫ f) ⟶ mk f 
goal: (CategoryTheory.CostructuredArrow.mkPrecomp f g).left = g

full_name: CategoryTheory.CostructuredArrow.mkPrecomp_id
code: lemma mkPrecomp_id (f : S.obj Y ⟶ T) : mkPrecomp f (𝟙 Y) = eqToHom (by aesop_cat) 
goal: CategoryTheory.CostructuredArrow.mkPrecomp f (CategoryTheory.CategoryStruct.id Y) = CategoryTheory.eqToHom ⋯

full_name: CategoryTheory.CostructuredArrow.mkPrecomp_comp
code: lemma mkPrecomp_comp (f : S.obj Y ⟶ T) (g : Y' ⟶ Y) (g' : Y'' ⟶ Y') :
    mkPrecomp f (g' ≫ g) = eqToHom (by simp) ≫ mkPrecomp (S.map g ≫ f) g' ≫ mkPrecomp f g 
goal: CategoryTheory.CostructuredArrow.mkPrecomp f (CategoryTheory.CategoryStruct.comp g' g) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯)
    (CategoryTheory.CategoryStruct.comp
      (CategoryTheory.CostructuredArrow.mkPrecomp (CategoryTheory.CategoryStruct.comp (S.map g) f) g')
      (CategoryTheory.CostructuredArrow.mkPrecomp f g))

full_name: CategoryTheory.CostructuredArrow.isoMk_hom_right_down_down
code: /-- To construct an isomorphism of costructured arrows,
we need an isomorphism of the objects underlying the source,
and to check that the triangle commutes.
-/
@[simps!]
def isoMk {f f' : CostructuredArrow S T} (g : f.left ≅ f'.left)
    (w : S.map g.hom ≫ f'.hom = f.hom := by aesop_cat) : f ≅ f' 
goal: ⋯ = ⋯

full_name: CategoryTheory.CostructuredArrow.isoMk_inv_right_down_down
code: /-- To construct an isomorphism of costructured arrows,
we need an isomorphism of the objects underlying the source,
and to check that the triangle commutes.
-/
@[simps!]
def isoMk {f f' : CostructuredArrow S T} (g : f.left ≅ f'.left)
    (w : S.map g.hom ≫ f'.hom = f.hom := by aesop_cat) : f ≅ f' 
goal: ⋯ = ⋯

full_name: CategoryTheory.CostructuredArrow.isoMk
code: /-- To construct an isomorphism of costructured arrows,
we need an isomorphism of the objects underlying the source,
and to check that the triangle commutes.
-/
@[simps!]
def isoMk {f f' : CostructuredArrow S T} (g : f.left ≅ f'.left)
    (w : S.map g.hom ≫ f'.hom = f.hom := by aesop_cat) : f ≅ f' 
goal: f ≅ f'

full_name: CategoryTheory.CostructuredArrow.isoMk_hom_left
code: /-- To construct an isomorphism of costructured arrows,
we need an isomorphism of the objects underlying the source,
and to check that the triangle commutes.
-/
@[simps!]
def isoMk {f f' : CostructuredArrow S T} (g : f.left ≅ f'.left)
    (w : S.map g.hom ≫ f'.hom = f.hom := by aesop_cat) : f ≅ f' 
goal: (CategoryTheory.CostructuredArrow.isoMk g w).hom.left = g.hom

full_name: CategoryTheory.CostructuredArrow.isoMk_inv_left
code: /-- To construct an isomorphism of costructured arrows,
we need an isomorphism of the objects underlying the source,
and to check that the triangle commutes.
-/
@[simps!]
def isoMk {f f' : CostructuredArrow S T} (g : f.left ≅ f'.left)
    (w : S.map g.hom ≫ f'.hom = f.hom := by aesop_cat) : f ≅ f' 
goal: (CategoryTheory.CostructuredArrow.isoMk g w).inv.left = g.inv

full_name: CategoryTheory.CostructuredArrow.ext
code: theorem ext {A B : CostructuredArrow S T} (f g : A ⟶ B) (h : f.left = g.left) : f = g 
goal: f = g

full_name: CategoryTheory.CostructuredArrow.ext_iff
code: theorem ext_iff {A B : CostructuredArrow S T} (f g : A ⟶ B) : f = g ↔ f.left = g.left 
goal: f = g ↔ f.left = g.left

full_name: CategoryTheory.CostructuredArrow.proj_faithful
code: instance proj_faithful : (proj S T).Faithful 
goal: (CategoryTheory.CostructuredArrow.proj S T).Faithful

full_name: CategoryTheory.CostructuredArrow.mono_of_mono_left
code: theorem mono_of_mono_left {A B : CostructuredArrow S T} (f : A ⟶ B) [h : Mono f.left] : Mono f 
goal: CategoryTheory.Mono f

full_name: CategoryTheory.CostructuredArrow.epi_of_epi_left
code: /-- The converse of this is true with additional assumptions, see `epi_iff_epi_left`. -/
theorem epi_of_epi_left {A B : CostructuredArrow S T} (f : A ⟶ B) [h : Epi f.left] : Epi f 
goal: CategoryTheory.Epi f

full_name: CategoryTheory.CostructuredArrow.mono_homMk
code: instance mono_homMk {A B : CostructuredArrow S T} (f : A.left ⟶ B.left) (w) [h : Mono f] :
    Mono (homMk f w) 
goal: CategoryTheory.Mono (CategoryTheory.CostructuredArrow.homMk f w)

full_name: CategoryTheory.CostructuredArrow.epi_homMk
code: instance epi_homMk {A B : CostructuredArrow S T} (f : A.left ⟶ B.left) (w) [h : Epi f] :
    Epi (homMk f w) 
goal: CategoryTheory.Epi (CategoryTheory.CostructuredArrow.homMk f w)

full_name: CategoryTheory.CostructuredArrow.eq_mk
code: /-- Eta rule for costructured arrows. Prefer `CostructuredArrow.eta` for rewriting, as equality of
    objects tends to cause problems. -/
theorem eq_mk (f : CostructuredArrow S T) : f = mk f.hom 
goal: f = CategoryTheory.CostructuredArrow.mk f.hom

full_name: CategoryTheory.CostructuredArrow.eta
code: /-- Eta rule for costructured arrows. -/
@[simps!]
def eta (f : CostructuredArrow S T) : f ≅ mk f.hom 
goal: f ≅ CategoryTheory.CostructuredArrow.mk f.hom

full_name: CategoryTheory.CostructuredArrow.eta_hom_left
code: /-- Eta rule for costructured arrows. -/
@[simps!]
def eta (f : CostructuredArrow S T) : f ≅ mk f.hom 
goal: f.eta.hom.left = CategoryTheory.CategoryStruct.id f.left

full_name: CategoryTheory.CostructuredArrow.eta_inv_right_down_down
code: /-- Eta rule for costructured arrows. -/
@[simps!]
def eta (f : CostructuredArrow S T) : f ≅ mk f.hom 
goal: ⋯ = ⋯

full_name: CategoryTheory.CostructuredArrow.eta_hom_right_down_down
code: /-- Eta rule for costructured arrows. -/
@[simps!]
def eta (f : CostructuredArrow S T) : f ≅ mk f.hom 
goal: ⋯ = ⋯

full_name: CategoryTheory.CostructuredArrow.eta_inv_left
code: /-- Eta rule for costructured arrows. -/
@[simps!]
def eta (f : CostructuredArrow S T) : f ≅ mk f.hom 
goal: f.eta.inv.left = CategoryTheory.CategoryStruct.id f.left

full_name: CategoryTheory.CostructuredArrow.mk_surjective
code: lemma mk_surjective (f : CostructuredArrow S T) :
    ∃ (Y : C) (g : S.obj Y ⟶ T), f = mk g 
goal: ∃ Y g, f = CategoryTheory.CostructuredArrow.mk g

full_name: CategoryTheory.CostructuredArrow.map_obj_left
code: /-- 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`.
-/
@[simps!]
def map (f : T ⟶ T') : CostructuredArrow S T ⥤ CostructuredArrow S T' 
goal: ((CategoryTheory.CostructuredArrow.map f).obj X).left = X.left

full_name: CategoryTheory.CostructuredArrow.map_obj_right
code: /-- 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`.
-/
@[simps!]
def map (f : T ⟶ T') : CostructuredArrow S T ⥤ CostructuredArrow S T' 
goal: ((CategoryTheory.CostructuredArrow.map f).obj X).right = X.right

full_name: CategoryTheory.CostructuredArrow.map
code: /-- 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`.
-/
@[simps!]
def map (f : T ⟶ T') : CostructuredArrow S T ⥤ CostructuredArrow S T' 
goal: CategoryTheory.Functor (CategoryTheory.CostructuredArrow S T) (CategoryTheory.CostructuredArrow S T')

full_name: CategoryTheory.CostructuredArrow.map_map_right
code: /-- 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`.
-/
@[simps!]
def map (f : T ⟶ T') : CostructuredArrow S T ⥤ CostructuredArrow S T' 
goal: ∀ {X Y : CategoryTheory.Comma S (CategoryTheory.Functor.fromPUnit T)} (f_1 : X ⟶ Y),
  ((CategoryTheory.CostructuredArrow.map f).map f_1).right = CategoryTheory.CategoryStruct.id X.right

full_name: CategoryTheory.CostructuredArrow.map_map_left
code: /-- 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`.
-/
@[simps!]
def map (f : T ⟶ T') : CostructuredArrow S T ⥤ CostructuredArrow S T' 
goal: ∀ {X Y : CategoryTheory.Comma S (CategoryTheory.Functor.fromPUnit T)} (f_1 : X ⟶ Y),
  ((CategoryTheory.CostructuredArrow.map f).map f_1).left = f_1.left

full_name: CategoryTheory.CostructuredArrow.map_obj_hom
code: /-- 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`.
-/
@[simps!]
def map (f : T ⟶ T') : CostructuredArrow S T ⥤ CostructuredArrow S T' 
goal: ((CategoryTheory.CostructuredArrow.map f).obj X).hom = CategoryTheory.CategoryStruct.comp X.hom f

full_name: CategoryTheory.CostructuredArrow.map_mk
code: @[simp]
theorem map_mk {f : S.obj Y ⟶ T} (g : T ⟶ T') : (map g).obj (mk f) = mk (f ≫ g) 
goal: (CategoryTheory.CostructuredArrow.map g).obj (CategoryTheory.CostructuredArrow.mk f) =
  CategoryTheory.CostructuredArrow.mk (CategoryTheory.CategoryStruct.comp f g)

full_name: CategoryTheory.CostructuredArrow.map_id
code: @[simp]
theorem map_id {f : CostructuredArrow S T} : (map (𝟙 T)).obj f = f 
goal: (CategoryTheory.CostructuredArrow.map (CategoryTheory.CategoryStruct.id T)).obj f = f

full_name: CategoryTheory.CostructuredArrow.map_comp
code: @[simp]
theorem map_comp {f : T ⟶ T'} {f' : T' ⟶ T''} {h : CostructuredArrow S T} :
    (map (f ≫ f')).obj h = (map f').obj ((map f).obj h) 
goal: (CategoryTheory.CostructuredArrow.map (CategoryTheory.CategoryStruct.comp f f')).obj h =
  (CategoryTheory.CostructuredArrow.map f').obj ((CategoryTheory.CostructuredArrow.map f).obj h)

full_name: CategoryTheory.CostructuredArrow.mapIso
code: /-- An isomorphism `T ≅ T'` induces an equivalence
    `CostructuredArrow S T ≌ CostructuredArrow S T'`. -/
@[simp]
def mapIso (i : T ≅ T') : CostructuredArrow S T ≌ CostructuredArrow S T' 
goal: CategoryTheory.CostructuredArrow S T ≌ CategoryTheory.CostructuredArrow S T'

full_name: CategoryTheory.CostructuredArrow.mapNatIso
code: /-- A natural isomorphism `S ≅ S'` induces an equivalence
    `CostrucutredArrow S T ≌ CostructuredArrow S' T`. -/
@[simp]
def mapNatIso (i : S ≅ S') : CostructuredArrow S T ≌ CostructuredArrow S' T 
goal: CategoryTheory.CostructuredArrow S T ≌ CategoryTheory.CostructuredArrow S' T

full_name: CategoryTheory.CostructuredArrow.proj_reflectsIsomorphisms
code: instance proj_reflectsIsomorphisms : (proj S T).ReflectsIsomorphisms 
goal: (CategoryTheory.CostructuredArrow.proj S T).ReflectsIsomorphisms

full_name: CategoryTheory.CostructuredArrow.mkIdTerminal
code: /-- The identity costructured arrow is terminal. -/
noncomputable def mkIdTerminal [S.Full] [S.Faithful] : IsTerminal (mk (𝟙 (S.obj Y))) 
goal: CategoryTheory.Limits.IsTerminal (CategoryTheory.CostructuredArrow.mk (CategoryTheory.CategoryStruct.id (S.obj Y)))

full_name: CategoryTheory.CostructuredArrow.pre
code: /-- The functor `(F ⋙ G, S) ⥤ (G, S)`. -/
@[simps!]
def pre (F : B ⥤ C) (G : C ⥤ D) (S : D) : CostructuredArrow (F ⋙ G) S ⥤ CostructuredArrow G S 
goal: CategoryTheory.Functor (CategoryTheory.CostructuredArrow (F.comp G) S) (CategoryTheory.CostructuredArrow G S)

full_name: CategoryTheory.CostructuredArrow.pre_map_right
code: /-- The functor `(F ⋙ G, S) ⥤ (G, S)`. -/
@[simps!]
def pre (F : B ⥤ C) (G : C ⥤ D) (S : D) : CostructuredArrow (F ⋙ G) S ⥤ CostructuredArrow G S 
goal: ∀ {X Y : CategoryTheory.Comma (F.comp G) (CategoryTheory.Functor.fromPUnit S)} (f : X ⟶ Y),
  ((CategoryTheory.CostructuredArrow.pre F G S).map f).right = CategoryTheory.CategoryStruct.id X.right

full_name: CategoryTheory.CostructuredArrow.pre_obj_right
code: /-- The functor `(F ⋙ G, S) ⥤ (G, S)`. -/
@[simps!]
def pre (F : B ⥤ C) (G : C ⥤ D) (S : D) : CostructuredArrow (F ⋙ G) S ⥤ CostructuredArrow G S 
goal: ((CategoryTheory.CostructuredArrow.pre F G S).obj X).right = X.right

full_name: CategoryTheory.CostructuredArrow.pre_obj_left
code: /-- The functor `(F ⋙ G, S) ⥤ (G, S)`. -/
@[simps!]
def pre (F : B ⥤ C) (G : C ⥤ D) (S : D) : CostructuredArrow (F ⋙ G) S ⥤ CostructuredArrow G S 
goal: ((CategoryTheory.CostructuredArrow.pre F G S).obj X).left = F.obj X.left

full_name: CategoryTheory.CostructuredArrow.pre_map_left
code: /-- The functor `(F ⋙ G, S) ⥤ (G, S)`. -/
@[simps!]
def pre (F : B ⥤ C) (G : C ⥤ D) (S : D) : CostructuredArrow (F ⋙ G) S ⥤ CostructuredArrow G S 
goal: ∀ {X Y : CategoryTheory.Comma (F.comp G) (CategoryTheory.Functor.fromPUnit S)} (f : X ⟶ Y),
  ((CategoryTheory.CostructuredArrow.pre F G S).map f).left = F.map f.left

full_name: CategoryTheory.CostructuredArrow.pre_obj_hom
code: /-- The functor `(F ⋙ G, S) ⥤ (G, S)`. -/
@[simps!]
def pre (F : B ⥤ C) (G : C ⥤ D) (S : D) : CostructuredArrow (F ⋙ G) S ⥤ CostructuredArrow G S 
goal: ((CategoryTheory.CostructuredArrow.pre F G S).obj X).hom = X.hom

full_name: CategoryTheory.CostructuredArrow.instFaithfulCompPre
code: instance (F : B ⥤ C) (G : C ⥤ D) (S : D) [F.Faithful] : (pre F G S).Faithful 
goal: (CategoryTheory.CostructuredArrow.pre F G S).Faithful

full_name: CategoryTheory.CostructuredArrow.instFullCompPre
code: instance (F : B ⥤ C) (G : C ⥤ D) (S : D) [F.Full] : (pre F G S).Full 
goal: (CategoryTheory.CostructuredArrow.pre F G S).Full

full_name: CategoryTheory.CostructuredArrow.instEssSurjCompPre
code: instance (F : B ⥤ C) (G : C ⥤ D) (S : D) [F.EssSurj] : (pre F G S).EssSurj 
goal: (CategoryTheory.CostructuredArrow.pre F G S).EssSurj

full_name: CategoryTheory.CostructuredArrow.isEquivalence_pre
code: /-- If `F` is an equivalence, then so is the functor `(F ⋙ G, S) ⥤ (G, S)`. -/
instance isEquivalence_pre (F : B ⥤ C) (G : C ⥤ D) (S : D) [F.IsEquivalence] :
    (pre F G S).IsEquivalence 
goal: (CategoryTheory.CostructuredArrow.pre F G S).IsEquivalence

full_name: CategoryTheory.CostructuredArrow.post_obj
code: /-- The functor `(F, S) ⥤ (F ⋙ G, G(S))`. -/
@[simps]
def post (F : B ⥤ C) (G : C ⥤ D) (S : C) :
    CostructuredArrow F S ⥤ CostructuredArrow (F ⋙ G) (G.obj S) 
goal: (CategoryTheory.CostructuredArrow.post F G S).obj X = CategoryTheory.CostructuredArrow.mk (G.map X.hom)

full_name: CategoryTheory.CostructuredArrow.post_map
code: /-- The functor `(F, S) ⥤ (F ⋙ G, G(S))`. -/
@[simps]
def post (F : B ⥤ C) (G : C ⥤ D) (S : C) :
    CostructuredArrow F S ⥤ CostructuredArrow (F ⋙ G) (G.obj S) 
goal: ∀ {X Y : CategoryTheory.CostructuredArrow F S} (f : X ⟶ Y),
  (CategoryTheory.CostructuredArrow.post F G S).map f = CategoryTheory.CostructuredArrow.homMk f.left ⋯

full_name: CategoryTheory.CostructuredArrow.post
code: /-- The functor `(F, S) ⥤ (F ⋙ G, G(S))`. -/
@[simps]
def post (F : B ⥤ C) (G : C ⥤ D) (S : C) :
    CostructuredArrow F S ⥤ CostructuredArrow (F ⋙ G) (G.obj S) 
goal: CategoryTheory.Functor (CategoryTheory.CostructuredArrow F S) (CategoryTheory.CostructuredArrow (F.comp G) (G.obj S))

full_name: CategoryTheory.CostructuredArrow.instFaithfulCompObjPost
code: instance (F : B ⥤ C) (G : C ⥤ D) (S : C) : (post F G S).Faithful 
goal: (CategoryTheory.CostructuredArrow.post F G S).Faithful

full_name: CategoryTheory.CostructuredArrow.instFullCompObjPostOfFaithful
code: instance (F : B ⥤ C) (G : C ⥤ D) (S : C) [G.Faithful] : (post F G S).Full 
goal: (CategoryTheory.CostructuredArrow.post F G S).Full

full_name: CategoryTheory.CostructuredArrow.instEssSurjCompObjPostOfFull
code: instance (F : B ⥤ C) (G : C ⥤ D) (S : C) [G.Full] : (post F G S).EssSurj 
goal: (CategoryTheory.CostructuredArrow.post F G S).EssSurj

full_name: CategoryTheory.CostructuredArrow.isEquivalence_post
code: /-- If `G` is fully faithful, then `post F G S : (F, S) ⥤ (F ⋙ G, G(S))` is an equivalence. -/
instance isEquivalence_post (S : C) (F : B ⥤ C) (G : C ⥤ D) [G.Full] [G.Faithful] :
    (post F G S).IsEquivalence 
goal: (CategoryTheory.CostructuredArrow.post F G S).IsEquivalence

full_name: CategoryTheory.CostructuredArrow.map₂_obj_left
code: /-- 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` -/
@[simps!]
def map₂ : CostructuredArrow S T ⥤ CostructuredArrow U V 
goal: ((CategoryTheory.CostructuredArrow.map₂ α β).obj X).left = F.obj X.left

full_name: CategoryTheory.CostructuredArrow.map₂_obj_hom
code: /-- 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` -/
@[simps!]
def map₂ : CostructuredArrow S T ⥤ CostructuredArrow U V 
goal: ((CategoryTheory.CostructuredArrow.map₂ α β).obj X).hom =
  CategoryTheory.CategoryStruct.comp (α.app X.left) (CategoryTheory.CategoryStruct.comp (G.map X.hom) β)

full_name: CategoryTheory.CostructuredArrow.map₂_obj_right
code: /-- 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` -/
@[simps!]
def map₂ : CostructuredArrow S T ⥤ CostructuredArrow U V 
goal: ((CategoryTheory.CostructuredArrow.map₂ α β).obj X).right = X.right

full_name: CategoryTheory.CostructuredArrow.map₂
code: /-- 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` -/
@[simps!]
def map₂ : CostructuredArrow S T ⥤ CostructuredArrow U V 
goal: CategoryTheory.Functor (CategoryTheory.CostructuredArrow S T) (CategoryTheory.CostructuredArrow U V)

full_name: CategoryTheory.CostructuredArrow.map₂_map_right
code: /-- 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` -/
@[simps!]
def map₂ : CostructuredArrow S T ⥤ CostructuredArrow U V 
goal: ((CategoryTheory.CostructuredArrow.map₂ α β).map φ).right = CategoryTheory.CategoryStruct.id X.right

full_name: CategoryTheory.CostructuredArrow.map₂_map_left
code: /-- 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` -/
@[simps!]
def map₂ : CostructuredArrow S T ⥤ CostructuredArrow U V 
goal: ((CategoryTheory.CostructuredArrow.map₂ α β).map φ).left = F.map φ.left

full_name: CategoryTheory.CostructuredArrow.faithful_map₂
code: instance faithful_map₂ [F.Faithful] : (map₂ α β).Faithful 
goal: (CategoryTheory.CostructuredArrow.map₂ α β).Faithful

full_name: CategoryTheory.CostructuredArrow.full_map₂
code: instance full_map₂ [G.Faithful] [F.Full] [IsIso α] [IsIso β] : (map₂ α β).Full 
goal: (CategoryTheory.CostructuredArrow.map₂ α β).Full

full_name: CategoryTheory.CostructuredArrow.essSurj_map₂
code: instance essSurj_map₂ [F.EssSurj] [G.Full] [IsIso α] [IsIso β] : (map₂ α β).EssSurj 
goal: (CategoryTheory.CostructuredArrow.map₂ α β).EssSurj

full_name: CategoryTheory.CostructuredArrow.isEquivalenceMap₂
code: noncomputable instance isEquivalenceMap₂
    [F.IsEquivalence] [G.Faithful] [G.Full] [IsIso α] [IsIso β] :
    (map₂ α β).IsEquivalence 
goal: (CategoryTheory.CostructuredArrow.map₂ α β).IsEquivalence

full_name: CategoryTheory.CostructuredArrow.small_proj_preimage_of_locallySmall
code: instance small_proj_preimage_of_locallySmall {𝒢 : Set C} [Small.{v₁} 𝒢] [LocallySmall.{v₁} D] :
    Small.{v₁} ((proj S T).obj ⁻¹' 𝒢) 
goal: Small.{v₁, max u₁ v₂} ↑((CategoryTheory.CostructuredArrow.proj S T).obj ⁻¹' 𝒢)

full_name: CategoryTheory.CostructuredArrow.IsUniversal
code: /-- A costructured arrow is called universal if it is terminal. -/
abbrev IsUniversal (f : CostructuredArrow S T) 
goal: Type (max (max u₁ v₂) v₁)

full_name: CategoryTheory.CostructuredArrow.IsUniversal.uniq
code: theorem uniq (h : IsUniversal f) (η : g ⟶ f) : η = h.from g 
goal: η = CategoryTheory.Limits.IsTerminal.from h g

full_name: CategoryTheory.CostructuredArrow.IsUniversal.lift
code: /-- The family of morphisms into a universal arrow. -/
def lift (h : IsUniversal f) (g : CostructuredArrow S T) : g.left ⟶ f.left 
goal: g.left ⟶ f.left

full_name: CategoryTheory.CostructuredArrow.IsUniversal.fac
code: /-- Any costructured arrow factors through a universal arrow. -/
@[reassoc (attr := simp)]
theorem fac (h : IsUniversal f) (g : CostructuredArrow S T) :
    S.map (h.lift g) ≫ f.hom = g.hom 
goal: CategoryTheory.CategoryStruct.comp (S.map (h.lift g)) f.hom = g.hom

full_name: CategoryTheory.CostructuredArrow.IsUniversal.hom_desc
code: theorem hom_desc (h : IsUniversal f) {c : C} (η : c ⟶ f.left) :
    η = h.lift (mk <| S.map η ≫ f.hom) 
goal: η = h.lift (CategoryTheory.CostructuredArrow.mk (CategoryTheory.CategoryStruct.comp (S.map η) f.hom))

full_name: CategoryTheory.CostructuredArrow.IsUniversal.hom_ext
code: /-- Two morphisms into a universal `S`-costructured arrow are equal if their image under `S` are
equal after postcomposing the universal arrow. -/
theorem hom_ext (h : IsUniversal f) {c : C} {η η' : c ⟶ f.left}
    (w : S.map η ≫ f.hom = S.map η' ≫ f.hom) : η = η' 
goal: η = η'

full_name: CategoryTheory.CostructuredArrow.IsUniversal.existsUnique
code: theorem existsUnique (h : IsUniversal f) (g : CostructuredArrow S T) :
    ∃! η : g.left ⟶ f.left, S.map η ≫ f.hom = g.hom 
goal: ∃! η, CategoryTheory.CategoryStruct.comp (S.map η) f.hom = g.hom

full_name: CategoryTheory.Functor.toStructuredArrow_map
code: /-- 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`. -/
@[simps]
def toStructuredArrow (G : E ⥤ C) (X : D) (F : C ⥤ D) (f : (Y : E) → X ⟶ F.obj (G.obj Y))
    (h : ∀ {Y Z : E} (g : Y ⟶ Z), f Y ≫ F.map (G.map g) = f Z) : E ⥤ StructuredArrow X F 
goal: ∀ {X_1 Y : E} (g : X_1 ⟶ Y), (G.toStructuredArrow X F f h).map g = CategoryTheory.StructuredArrow.homMk (G.map g) ⋯

full_name: CategoryTheory.Functor.toStructuredArrow_obj
code: /-- 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`. -/
@[simps]
def toStructuredArrow (G : E ⥤ C) (X : D) (F : C ⥤ D) (f : (Y : E) → X ⟶ F.obj (G.obj Y))
    (h : ∀ {Y Z : E} (g : Y ⟶ Z), f Y ≫ F.map (G.map g) = f Z) : E ⥤ StructuredArrow X F 
goal: (G.toStructuredArrow X F f h).obj Y = CategoryTheory.StructuredArrow.mk (f Y)

full_name: CategoryTheory.Functor.toStructuredArrow
code: /-- 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`. -/
@[simps]
def toStructuredArrow (G : E ⥤ C) (X : D) (F : C ⥤ D) (f : (Y : E) → X ⟶ F.obj (G.obj Y))
    (h : ∀ {Y Z : E} (g : Y ⟶ Z), f Y ≫ F.map (G.map g) = f Z) : E ⥤ StructuredArrow X F 
goal: CategoryTheory.Functor E (CategoryTheory.StructuredArrow X F)

full_name: CategoryTheory.Functor.toStructuredArrowCompProj
code: /-- 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. -/
def toStructuredArrowCompProj (G : E ⥤ C) (X : D) (F : C ⥤ D) (f : (Y : E) → X ⟶ F.obj (G.obj Y))
    (h : ∀ {Y Z : E} (g : Y ⟶ Z), f Y ≫ F.map (G.map g) = f Z) :
    G.toStructuredArrow X F f h ⋙ StructuredArrow.proj _ _ ≅ G 
goal: (G.toStructuredArrow X F f ⋯).comp (CategoryTheory.StructuredArrow.proj X F) ≅ G

full_name: CategoryTheory.Functor.toStructuredArrow_comp_proj
code: @[simp]
lemma toStructuredArrow_comp_proj (G : E ⥤ C) (X : D) (F : C ⥤ D)
    (f : (Y : E) → X ⟶ F.obj (G.obj Y)) (h : ∀ {Y Z : E} (g : Y ⟶ Z), f Y ≫ F.map (G.map g) = f Z) :
    G.toStructuredArrow X F f h ⋙ StructuredArrow.proj _ _ = G 
goal: (G.toStructuredArrow X F f ⋯).comp (CategoryTheory.StructuredArrow.proj X F) = G

full_name: CategoryTheory.Functor.toCostructuredArrow
code: /-- 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`. -/
@[simps]
def toCostructuredArrow (G : E ⥤ C) (F : C ⥤ D) (X : D) (f : (Y : E) → F.obj (G.obj Y) ⟶ X)
    (h : ∀ {Y Z : E} (g : Y ⟶ Z), F.map (G.map g) ≫ f Z = f Y) : E ⥤ CostructuredArrow F X 
goal: CategoryTheory.Functor E (CategoryTheory.CostructuredArrow F X)

full_name: CategoryTheory.Functor.toCostructuredArrow_obj
code: /-- 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`. -/
@[simps]
def toCostructuredArrow (G : E ⥤ C) (F : C ⥤ D) (X : D) (f : (Y : E) → F.obj (G.obj Y) ⟶ X)
    (h : ∀ {Y Z : E} (g : Y ⟶ Z), F.map (G.map g) ≫ f Z = f Y) : E ⥤ CostructuredArrow F X 
goal: (G.toCostructuredArrow F X f h).obj Y = CategoryTheory.CostructuredArrow.mk (f Y)

full_name: CategoryTheory.Functor.toCostructuredArrow_map
code: /-- 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`. -/
@[simps]
def toCostructuredArrow (G : E ⥤ C) (F : C ⥤ D) (X : D) (f : (Y : E) → F.obj (G.obj Y) ⟶ X)
    (h : ∀ {Y Z : E} (g : Y ⟶ Z), F.map (G.map g) ≫ f Z = f Y) : E ⥤ CostructuredArrow F X 
goal: ∀ {X_1 Y : E} (g : X_1 ⟶ Y), (G.toCostructuredArrow F X f h).map g = CategoryTheory.CostructuredArrow.homMk (G.map g) ⋯

full_name: CategoryTheory.Functor.toCostructuredArrowCompProj
code: /-- 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. -/
def toCostructuredArrowCompProj (G : E ⥤ C) (F : C ⥤ D) (X : D)
    (f : (Y : E) → F.obj (G.obj Y) ⟶ X) (h : ∀ {Y Z : E} (g : Y ⟶ Z), F.map (G.map g) ≫ f Z = f Y) :
    G.toCostructuredArrow F X f h ⋙ CostructuredArrow.proj _ _ ≅ G 
goal: (G.toCostructuredArrow F X f ⋯).comp (CategoryTheory.CostructuredArrow.proj F X) ≅ G

full_name: CategoryTheory.Functor.toCostructuredArrow_comp_proj
code: @[simp]
lemma toCostructuredArrow_comp_proj (G : E ⥤ C) (F : C ⥤ D) (X : D)
    (f : (Y : E) → F.obj (G.obj Y) ⟶ X) (h : ∀ {Y Z : E} (g : Y ⟶ Z), F.map (G.map g) ≫ f Z = f Y) :
    G.toCostructuredArrow F X f h ⋙ CostructuredArrow.proj _ _ = G 
goal: (G.toCostructuredArrow F X f ⋯).comp (CategoryTheory.CostructuredArrow.proj F X) = G

full_name: CategoryTheory.StructuredArrow.toCostructuredArrow_obj
code: /-- 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)`.
-/
@[simps]
def toCostructuredArrow (F : C ⥤ D) (d : D) :
    (StructuredArrow d F)ᵒᵖ ⥤ CostructuredArrow F.op (op d) 
goal: (CategoryTheory.StructuredArrow.toCostructuredArrow F d).obj X =
  CategoryTheory.CostructuredArrow.mk (Opposite.unop X).hom.op

full_name: CategoryTheory.StructuredArrow.toCostructuredArrow_map
code: /-- 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)`.
-/
@[simps]
def toCostructuredArrow (F : C ⥤ D) (d : D) :
    (StructuredArrow d F)ᵒᵖ ⥤ CostructuredArrow F.op (op d) 
goal: ∀ {X Y : (CategoryTheory.StructuredArrow d F)ᵒᵖ} (f : X ⟶ Y),
  (CategoryTheory.StructuredArrow.toCostructuredArrow F d).map f =
    CategoryTheory.CostructuredArrow.homMk f.unop.right.op ⋯

full_name: CategoryTheory.StructuredArrow.toCostructuredArrow
code: /-- 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)`.
-/
@[simps]
def toCostructuredArrow (F : C ⥤ D) (d : D) :
    (StructuredArrow d F)ᵒᵖ ⥤ CostructuredArrow F.op (op d) 
goal: CategoryTheory.Functor (CategoryTheory.StructuredArrow d F)ᵒᵖ (CategoryTheory.CostructuredArrow F.op (Opposite.op d))

full_name: CategoryTheory.StructuredArrow.toCostructuredArrow'_map
code: /-- 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`.
-/
@[simps]
def toCostructuredArrow' (F : C ⥤ D) (d : D) :
    (StructuredArrow (op d) F.op)ᵒᵖ ⥤ CostructuredArrow F d 
goal: ∀ {X Y : (CategoryTheory.StructuredArrow (Opposite.op d) F.op)ᵒᵖ} (f : X ⟶ Y),
  (CategoryTheory.StructuredArrow.toCostructuredArrow' F d).map f =
    CategoryTheory.CostructuredArrow.homMk f.unop.right.unop ⋯

full_name: CategoryTheory.StructuredArrow.toCostructuredArrow'
code: /-- 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`.
-/
@[simps]
def toCostructuredArrow' (F : C ⥤ D) (d : D) :
    (StructuredArrow (op d) F.op)ᵒᵖ ⥤ CostructuredArrow F d 
goal: CategoryTheory.Functor (CategoryTheory.StructuredArrow (Opposite.op d) F.op)ᵒᵖ (CategoryTheory.CostructuredArrow F d)

full_name: CategoryTheory.StructuredArrow.toCostructuredArrow'_obj
code: /-- 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`.
-/
@[simps]
def toCostructuredArrow' (F : C ⥤ D) (d : D) :
    (StructuredArrow (op d) F.op)ᵒᵖ ⥤ CostructuredArrow F d 
goal: (CategoryTheory.StructuredArrow.toCostructuredArrow' F d).obj X =
  CategoryTheory.CostructuredArrow.mk (Opposite.unop X).hom.unop

full_name: CategoryTheory.CostructuredArrow.toStructuredArrow_obj
code: /-- 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`.
-/
@[simps]
def toStructuredArrow (F : C ⥤ D) (d : D) :
    (CostructuredArrow F d)ᵒᵖ ⥤ StructuredArrow (op d) F.op 
goal: (CategoryTheory.CostructuredArrow.toStructuredArrow F d).obj X =
  CategoryTheory.StructuredArrow.mk (Opposite.unop X).hom.op

full_name: CategoryTheory.CostructuredArrow.toStructuredArrow_map
code: /-- 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`.
-/
@[simps]
def toStructuredArrow (F : C ⥤ D) (d : D) :
    (CostructuredArrow F d)ᵒᵖ ⥤ StructuredArrow (op d) F.op 
goal: ∀ {X Y : (CategoryTheory.CostructuredArrow F d)ᵒᵖ} (f : X ⟶ Y),
  (CategoryTheory.CostructuredArrow.toStructuredArrow F d).map f = CategoryTheory.StructuredArrow.homMk f.unop.left.op ⋯

full_name: CategoryTheory.CostructuredArrow.toStructuredArrow
code: /-- 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`.
-/
@[simps]
def toStructuredArrow (F : C ⥤ D) (d : D) :
    (CostructuredArrow F d)ᵒᵖ ⥤ StructuredArrow (op d) F.op 
goal: CategoryTheory.Functor (CategoryTheory.CostructuredArrow F d)ᵒᵖ (CategoryTheory.StructuredArrow (Opposite.op d) F.op)

full_name: CategoryTheory.CostructuredArrow.toStructuredArrow'_map
code: /-- 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`.
-/
@[simps]
def toStructuredArrow' (F : C ⥤ D) (d : D) :
    (CostructuredArrow F.op (op d))ᵒᵖ ⥤ StructuredArrow d F 
goal: ∀ {X Y : (CategoryTheory.CostructuredArrow F.op (Opposite.op d))ᵒᵖ} (f : X ⟶ Y),
  (CategoryTheory.CostructuredArrow.toStructuredArrow' F d).map f =
    CategoryTheory.StructuredArrow.homMk f.unop.left.unop ⋯

full_name: CategoryTheory.CostructuredArrow.toStructuredArrow'_obj
code: /-- 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`.
-/
@[simps]
def toStructuredArrow' (F : C ⥤ D) (d : D) :
    (CostructuredArrow F.op (op d))ᵒᵖ ⥤ StructuredArrow d F 
goal: (CategoryTheory.CostructuredArrow.toStructuredArrow' F d).obj X =
  CategoryTheory.StructuredArrow.mk (Opposite.unop X).hom.unop

full_name: CategoryTheory.CostructuredArrow.toStructuredArrow'
code: /-- 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`.
-/
@[simps]
def toStructuredArrow' (F : C ⥤ D) (d : D) :
    (CostructuredArrow F.op (op d))ᵒᵖ ⥤ StructuredArrow d F 
goal: CategoryTheory.Functor (CategoryTheory.CostructuredArrow F.op (Opposite.op d))ᵒᵖ (CategoryTheory.StructuredArrow d F)

full_name: CategoryTheory.structuredArrowOpEquivalence
code: /-- 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 structuredArrowOpEquivalence (F : C ⥤ D) (d : D) :
    (StructuredArrow d F)ᵒᵖ ≌ CostructuredArrow F.op (op d) 
goal: (CategoryTheory.StructuredArrow d F)ᵒᵖ ≌ CategoryTheory.CostructuredArrow F.op (Opposite.op d)

full_name: CategoryTheory.costructuredArrowOpEquivalence
code: /-- 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 costructuredArrowOpEquivalence (F : C ⥤ D) (d : D) :
    (CostructuredArrow F d)ᵒᵖ ≌ StructuredArrow (op d) F.op 
goal: (CategoryTheory.CostructuredArrow F d)ᵒᵖ ≌ CategoryTheory.StructuredArrow (Opposite.op d) F.op