ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.CostructuredArrow.homMk_right_down_down
@[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' 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {T : D} {S : CategoryTheory.Functor C D} {f f' : CategoryTheory.CostructuredArrow S T} (g : f.left ⟶ f'.left) (w : CategoryTheory.CategoryStruct.comp (S.map g) f'.hom = f.hom := by aesop_cat)
Goal: ⋯ = ⋯
-- CategoryTheory.CostructuredArrow.homMk_left
@[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' 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {T : D} {S : CategoryTheory.Functor C D} {f f' : CategoryTheory.CostructuredArrow S T} (g : f.left ⟶ f'.left) (w : CategoryTheory.CategoryStruct.comp (S.map g) f'.hom = f.hom := by aesop_cat)
Goal: (CategoryTheory.CostructuredArrow.homMk g w).left = g
-- CategoryTheory.CostructuredArrow.homMk_surjective
theorem homMk_surjective {f f' : CostructuredArrow S T} (φ : f ⟶ f') :
    ∃ (ψ : f.left ⟶ f'.left) (hψ : S.map ψ ≫ f'.hom = f.hom),
      φ = CostructuredArrow.homMk ψ hψ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {T : D} {S : CategoryTheory.Functor C D} {f f' : CategoryTheory.CostructuredArrow S T} (φ : f ⟶ f')
Goal: ∃ ψ,
  ∃ (hψ : CategoryTheory.CategoryStruct.comp (S.map ψ) f'.hom = f.hom), φ = CategoryTheory.CostructuredArrow.homMk ψ hψ
-- CategoryTheory.CostructuredArrow.homMk'_left
@[simps]
def homMk' (f : CostructuredArrow S T) (g : Y' ⟶ f.left) : mk (S.map g ≫ f.hom) ⟶ f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {T : D} {Y' : C} {S : CategoryTheory.Functor C D} (f : CategoryTheory.CostructuredArrow S T) (g : Y' ⟶ f.left)
Goal: (f.homMk' g).left = g
-- CategoryTheory.CostructuredArrow.homMk'_right
@[simps]
def homMk' (f : CostructuredArrow S T) (g : Y' ⟶ f.left) : mk (S.map g ≫ f.hom) ⟶ f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {T : D} {Y' : C} {S : CategoryTheory.Functor C D} (f : CategoryTheory.CostructuredArrow S T) (g : Y' ⟶ f.left)
Goal: (f.homMk' g).right =
  CategoryTheory.CategoryStruct.id
    (CategoryTheory.CostructuredArrow.mk (CategoryTheory.CategoryStruct.comp (S.map g) f.hom)).right
-- CategoryTheory.CostructuredArrow.homMk'_id
lemma homMk'_id (f : CostructuredArrow S T) : homMk' f (𝟙 f.left) = eqToHom (by aesop_cat) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {T : D} {S : CategoryTheory.Functor C D} (f : CategoryTheory.CostructuredArrow S T)
Goal: f.homMk' (CategoryTheory.CategoryStruct.id f.left) = CategoryTheory.eqToHom ⋯
-- CategoryTheory.CostructuredArrow.homMk'_mk_id
lemma homMk'_mk_id (f : S.obj Y ⟶ T) : homMk' (mk f) (𝟙 Y) = eqToHom (by aesop_cat) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {T : D} {Y : C} {S : CategoryTheory.Functor C D} (f : S.obj Y ⟶ T)
Goal: (CategoryTheory.CostructuredArrow.mk f).homMk' (CategoryTheory.CategoryStruct.id Y) = CategoryTheory.eqToHom ⋯
-- CategoryTheory.CostructuredArrow.homMk'_comp
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 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {T : D} {Y' Y'' : C} {S : CategoryTheory.Functor C D} (f : CategoryTheory.CostructuredArrow S T) (g : Y' ⟶ f.left) (g' : Y'' ⟶ Y')
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))
-- CategoryTheory.CostructuredArrow.homMk'_mk_comp
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 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {T : D} {Y Y' Y'' : C} {S : CategoryTheory.Functor C D} (f : S.obj Y ⟶ T) (g : Y' ⟶ Y) (g' : Y'' ⟶ Y')
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))
-- CategoryTheory.CostructuredArrow.mkPrecomp_right
@[simps]
def mkPrecomp (f : S.obj Y ⟶ T) (g : Y' ⟶ Y) : mk (S.map g ≫ f) ⟶ mk f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {T : D} {Y Y' : C} {S : CategoryTheory.Functor C D} (f : S.obj Y ⟶ T) (g : Y' ⟶ Y)
Goal: (CategoryTheory.CostructuredArrow.mkPrecomp f g).right =
  CategoryTheory.CategoryStruct.id
    (CategoryTheory.CostructuredArrow.mk (CategoryTheory.CategoryStruct.comp (S.map g) f)).right
-- CategoryTheory.CostructuredArrow.mkPrecomp_left
@[simps]
def mkPrecomp (f : S.obj Y ⟶ T) (g : Y' ⟶ Y) : mk (S.map g ≫ f) ⟶ mk f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {T : D} {Y Y' : C} {S : CategoryTheory.Functor C D} (f : S.obj Y ⟶ T) (g : Y' ⟶ Y)
Goal: (CategoryTheory.CostructuredArrow.mkPrecomp f g).left = g
-- CategoryTheory.CostructuredArrow.mkPrecomp_id
lemma mkPrecomp_id (f : S.obj Y ⟶ T) : mkPrecomp f (𝟙 Y) = eqToHom (by aesop_cat) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {T : D} {Y : C} {S : CategoryTheory.Functor C D} (f : S.obj Y ⟶ T)
Goal: CategoryTheory.CostructuredArrow.mkPrecomp f (CategoryTheory.CategoryStruct.id Y) = CategoryTheory.eqToHom ⋯
-- CategoryTheory.CostructuredArrow.mkPrecomp_comp
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 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {T : D} {Y Y' Y'' : C} {S : CategoryTheory.Functor C D} (f : S.obj Y ⟶ T) (g : Y' ⟶ Y) (g' : Y'' ⟶ Y')
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))
-- CategoryTheory.CostructuredArrow.isoMk_hom_right_down_down
@[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' 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {T : D} {S : CategoryTheory.Functor C D} {f f' : CategoryTheory.CostructuredArrow S T} (g : f.left ≅ f'.left) (w : CategoryTheory.CategoryStruct.comp (S.map g.hom) f'.hom = f.hom := by aesop_cat)
Goal: ⋯ = ⋯
-- CategoryTheory.CostructuredArrow.isoMk_inv_right_down_down
@[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' 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {T : D} {S : CategoryTheory.Functor C D} {f f' : CategoryTheory.CostructuredArrow S T} (g : f.left ≅ f'.left) (w : CategoryTheory.CategoryStruct.comp (S.map g.hom) f'.hom = f.hom := by aesop_cat)
Goal: ⋯ = ⋯
-- CategoryTheory.CostructuredArrow.isoMk_hom_left
@[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' 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {T : D} {S : CategoryTheory.Functor C D} {f f' : CategoryTheory.CostructuredArrow S T} (g : f.left ≅ f'.left) (w : CategoryTheory.CategoryStruct.comp (S.map g.hom) f'.hom = f.hom := by aesop_cat)
Goal: (CategoryTheory.CostructuredArrow.isoMk g w).hom.left = g.hom
-- CategoryTheory.CostructuredArrow.isoMk_inv_left
@[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' 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {T : D} {S : CategoryTheory.Functor C D} {f f' : CategoryTheory.CostructuredArrow S T} (g : f.left ≅ f'.left) (w : CategoryTheory.CategoryStruct.comp (S.map g.hom) f'.hom = f.hom := by aesop_cat)
Goal: (CategoryTheory.CostructuredArrow.isoMk g w).inv.left = g.inv
-- CategoryTheory.CostructuredArrow.ext
theorem ext {A B : CostructuredArrow S T} (f g : A ⟶ B) (h : f.left = g.left) : f = g 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {T : D} {S : CategoryTheory.Functor C D} {A B : CategoryTheory.CostructuredArrow S T} (f g : A ⟶ B) (h : f.left = g.left)
Goal: f = g
-- CategoryTheory.CostructuredArrow.ext_iff
theorem ext_iff {A B : CostructuredArrow S T} (f g : A ⟶ B) : f = g ↔ f.left = g.left 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {T : D} {S : CategoryTheory.Functor C D} {A B : CategoryTheory.CostructuredArrow S T} (f g : A ⟶ B)
Goal: f = g ↔ f.left = g.left
-- CategoryTheory.CostructuredArrow.mono_of_mono_left
theorem mono_of_mono_left {A B : CostructuredArrow S T} (f : A ⟶ B) [h : Mono f.left] : Mono f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {T : D} {S : CategoryTheory.Functor C D} {A B : CategoryTheory.CostructuredArrow S T} (f : A ⟶ B) [h : CategoryTheory.Mono f.left]
Goal: CategoryTheory.Mono f
-- CategoryTheory.CostructuredArrow.epi_of_epi_left
theorem epi_of_epi_left {A B : CostructuredArrow S T} (f : A ⟶ B) [h : Epi f.left] : Epi f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {T : D} {S : CategoryTheory.Functor C D} {A B : CategoryTheory.CostructuredArrow S T} (f : A ⟶ B) [h : CategoryTheory.Epi f.left]
Goal: CategoryTheory.Epi f
-- CategoryTheory.CostructuredArrow.eq_mk
theorem eq_mk (f : CostructuredArrow S T) : f = mk f.hom 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {T : D} {S : CategoryTheory.Functor C D} (f : CategoryTheory.CostructuredArrow S T)
Goal: f = CategoryTheory.CostructuredArrow.mk f.hom
-- CategoryTheory.CostructuredArrow.eta_hom_left
@[simps!]
def eta (f : CostructuredArrow S T) : f ≅ mk f.hom 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {T : D} {S : CategoryTheory.Functor C D} (f : CategoryTheory.CostructuredArrow S T)
Goal: f.eta.hom.left = CategoryTheory.CategoryStruct.id f.left
-- CategoryTheory.CostructuredArrow.eta_inv_right_down_down
@[simps!]
def eta (f : CostructuredArrow S T) : f ≅ mk f.hom 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {T : D} {S : CategoryTheory.Functor C D} (f : CategoryTheory.CostructuredArrow S T)
Goal: ⋯ = ⋯
-- CategoryTheory.CostructuredArrow.eta_hom_right_down_down
@[simps!]
def eta (f : CostructuredArrow S T) : f ≅ mk f.hom 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {T : D} {S : CategoryTheory.Functor C D} (f : CategoryTheory.CostructuredArrow S T)
Goal: ⋯ = ⋯
-- CategoryTheory.CostructuredArrow.eta_inv_left
@[simps!]
def eta (f : CostructuredArrow S T) : f ≅ mk f.hom 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {T : D} {S : CategoryTheory.Functor C D} (f : CategoryTheory.CostructuredArrow S T)
Goal: f.eta.inv.left = CategoryTheory.CategoryStruct.id f.left
-- CategoryTheory.CostructuredArrow.mk_surjective
lemma mk_surjective (f : CostructuredArrow S T) :
    ∃ (Y : C) (g : S.obj Y ⟶ T), f = mk g 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {T : D} {S : CategoryTheory.Functor C D} (f : CategoryTheory.CostructuredArrow S T)
Goal: ∃ Y g, f = CategoryTheory.CostructuredArrow.mk g
-- CategoryTheory.CostructuredArrow.map_obj_left
@[simps!]
def map (f : T ⟶ T') : CostructuredArrow S T ⥤ CostructuredArrow S T' 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {T T' : D} {S : CategoryTheory.Functor C D} (f : T ⟶ T') (X : CategoryTheory.Comma S (CategoryTheory.Functor.fromPUnit T))
Goal: ((CategoryTheory.CostructuredArrow.map f).obj X).left = X.left
-- CategoryTheory.CostructuredArrow.map_obj_right
@[simps!]
def map (f : T ⟶ T') : CostructuredArrow S T ⥤ CostructuredArrow S T' 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {T T' : D} {S : CategoryTheory.Functor C D} (f : T ⟶ T') (X : CategoryTheory.Comma S (CategoryTheory.Functor.fromPUnit T))
Goal: ((CategoryTheory.CostructuredArrow.map f).obj X).right = X.right
-- CategoryTheory.CostructuredArrow.map_map_right
@[simps!]
def map (f : T ⟶ T') : CostructuredArrow S T ⥤ CostructuredArrow S T' 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {T T' : D} {S : CategoryTheory.Functor C D} (f : T ⟶ 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
-- CategoryTheory.CostructuredArrow.map_map_left
@[simps!]
def map (f : T ⟶ T') : CostructuredArrow S T ⥤ CostructuredArrow S T' 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {T T' : D} {S : CategoryTheory.Functor C D} (f : T ⟶ 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
-- CategoryTheory.CostructuredArrow.map_obj_hom
@[simps!]
def map (f : T ⟶ T') : CostructuredArrow S T ⥤ CostructuredArrow S T' 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {T T' : D} {S : CategoryTheory.Functor C D} (f : T ⟶ T') (X : CategoryTheory.Comma S (CategoryTheory.Functor.fromPUnit T))
Goal: ((CategoryTheory.CostructuredArrow.map f).obj X).hom = CategoryTheory.CategoryStruct.comp X.hom f
-- CategoryTheory.CostructuredArrow.map_mk
@[simp]
theorem map_mk {f : S.obj Y ⟶ T} (g : T ⟶ T') : (map g).obj (mk f) = mk (f ≫ g) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {T T' : D} {Y : C} {S : CategoryTheory.Functor C D} {f : S.obj Y ⟶ T} (g : T ⟶ T')
Goal: (CategoryTheory.CostructuredArrow.map g).obj (CategoryTheory.CostructuredArrow.mk f) =
  CategoryTheory.CostructuredArrow.mk (CategoryTheory.CategoryStruct.comp f g)
-- CategoryTheory.CostructuredArrow.map_id
@[simp]
theorem map_id {f : CostructuredArrow S T} : (map (𝟙 T)).obj f = f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {T : D} {S : CategoryTheory.Functor C D} {f : CategoryTheory.CostructuredArrow S T}
Goal: (CategoryTheory.CostructuredArrow.map (CategoryTheory.CategoryStruct.id T)).obj f = f
-- CategoryTheory.CostructuredArrow.map_comp
@[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) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {T T' T'' : D} {S : CategoryTheory.Functor C D} {f : T ⟶ T'} {f' : T' ⟶ T''} {h : CategoryTheory.CostructuredArrow S T}
Goal: (CategoryTheory.CostructuredArrow.map (CategoryTheory.CategoryStruct.comp f f')).obj h =
  (CategoryTheory.CostructuredArrow.map f').obj ((CategoryTheory.CostructuredArrow.map f).obj h)
-- CategoryTheory.CostructuredArrow.pre_map_right
@[simps!]
def pre (F : B ⥤ C) (G : C ⥤ D) (S : D) : CostructuredArrow (F ⋙ G) S ⥤ CostructuredArrow G S 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {B : Type u₄} [CategoryTheory.Category.{v₄, u₄} B] (F : CategoryTheory.Functor B C) (G : CategoryTheory.Functor C D) (S : D)
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
-- CategoryTheory.CostructuredArrow.pre_obj_right
@[simps!]
def pre (F : B ⥤ C) (G : C ⥤ D) (S : D) : CostructuredArrow (F ⋙ G) S ⥤ CostructuredArrow G S 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {B : Type u₄} [CategoryTheory.Category.{v₄, u₄} B] (F : CategoryTheory.Functor B C) (G : CategoryTheory.Functor C D) (S : D) (X : CategoryTheory.Comma (F.comp G) (CategoryTheory.Functor.fromPUnit S))
Goal: ((CategoryTheory.CostructuredArrow.pre F G S).obj X).right = X.right
-- CategoryTheory.CostructuredArrow.pre_obj_left
@[simps!]
def pre (F : B ⥤ C) (G : C ⥤ D) (S : D) : CostructuredArrow (F ⋙ G) S ⥤ CostructuredArrow G S 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {B : Type u₄} [CategoryTheory.Category.{v₄, u₄} B] (F : CategoryTheory.Functor B C) (G : CategoryTheory.Functor C D) (S : D) (X : CategoryTheory.Comma (F.comp G) (CategoryTheory.Functor.fromPUnit S))
Goal: ((CategoryTheory.CostructuredArrow.pre F G S).obj X).left = F.obj X.left
-- CategoryTheory.CostructuredArrow.pre_map_left
@[simps!]
def pre (F : B ⥤ C) (G : C ⥤ D) (S : D) : CostructuredArrow (F ⋙ G) S ⥤ CostructuredArrow G S 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {B : Type u₄} [CategoryTheory.Category.{v₄, u₄} B] (F : CategoryTheory.Functor B C) (G : CategoryTheory.Functor C D) (S : D)
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
-- CategoryTheory.CostructuredArrow.pre_obj_hom
@[simps!]
def pre (F : B ⥤ C) (G : C ⥤ D) (S : D) : CostructuredArrow (F ⋙ G) S ⥤ CostructuredArrow G S 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {B : Type u₄} [CategoryTheory.Category.{v₄, u₄} B] (F : CategoryTheory.Functor B C) (G : CategoryTheory.Functor C D) (S : D) (X : CategoryTheory.Comma (F.comp G) (CategoryTheory.Functor.fromPUnit S))
Goal: ((CategoryTheory.CostructuredArrow.pre F G S).obj X).hom = X.hom
-- CategoryTheory.CostructuredArrow.post_obj
@[simps]
def post (F : B ⥤ C) (G : C ⥤ D) (S : C) :
    CostructuredArrow F S ⥤ CostructuredArrow (F ⋙ G) (G.obj S) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {B : Type u₄} [CategoryTheory.Category.{v₄, u₄} B] (F : CategoryTheory.Functor B C) (G : CategoryTheory.Functor C D) (S : C) (X : CategoryTheory.CostructuredArrow F S)
Goal: (CategoryTheory.CostructuredArrow.post F G S).obj X = CategoryTheory.CostructuredArrow.mk (G.map X.hom)
-- CategoryTheory.CostructuredArrow.post_map
@[simps]
def post (F : B ⥤ C) (G : C ⥤ D) (S : C) :
    CostructuredArrow F S ⥤ CostructuredArrow (F ⋙ G) (G.obj S) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {B : Type u₄} [CategoryTheory.Category.{v₄, u₄} B] (F : CategoryTheory.Functor B C) (G : CategoryTheory.Functor C D) (S : C)
Goal: ∀ {X Y : CategoryTheory.CostructuredArrow F S} (f : X ⟶ Y),
  (CategoryTheory.CostructuredArrow.post F G S).map f = CategoryTheory.CostructuredArrow.homMk f.left ⋯
-- CategoryTheory.CostructuredArrow.map₂_obj_left
@[simps!]
def map₂ : CostructuredArrow S T ⥤ CostructuredArrow U V 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {T : D} {S : CategoryTheory.Functor C D} {A : Type u₃} [CategoryTheory.Category.{v₃, u₃} A] {B : Type u₄} [CategoryTheory.Category.{v₄, u₄} B] {U : CategoryTheory.Functor A B} {V : B} {F : CategoryTheory.Functor C A} {G : CategoryTheory.Functor D B} (α : F.comp U ⟶ S.comp G) (β : G.obj T ⟶ V) (X : CategoryTheory.Comma S (CategoryTheory.Functor.fromPUnit T))
Goal: ((CategoryTheory.CostructuredArrow.map₂ α β).obj X).left = F.obj X.left
-- CategoryTheory.CostructuredArrow.map₂_obj_hom
@[simps!]
def map₂ : CostructuredArrow S T ⥤ CostructuredArrow U V 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {T : D} {S : CategoryTheory.Functor C D} {A : Type u₃} [CategoryTheory.Category.{v₃, u₃} A] {B : Type u₄} [CategoryTheory.Category.{v₄, u₄} B] {U : CategoryTheory.Functor A B} {V : B} {F : CategoryTheory.Functor C A} {G : CategoryTheory.Functor D B} (α : F.comp U ⟶ S.comp G) (β : G.obj T ⟶ V) (X : CategoryTheory.Comma S (CategoryTheory.Functor.fromPUnit T))
Goal: ((CategoryTheory.CostructuredArrow.map₂ α β).obj X).hom =
  CategoryTheory.CategoryStruct.comp (α.app X.left) (CategoryTheory.CategoryStruct.comp (G.map X.hom) β)
-- CategoryTheory.CostructuredArrow.map₂_obj_right
@[simps!]
def map₂ : CostructuredArrow S T ⥤ CostructuredArrow U V 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {T : D} {S : CategoryTheory.Functor C D} {A : Type u₃} [CategoryTheory.Category.{v₃, u₃} A] {B : Type u₄} [CategoryTheory.Category.{v₄, u₄} B] {U : CategoryTheory.Functor A B} {V : B} {F : CategoryTheory.Functor C A} {G : CategoryTheory.Functor D B} (α : F.comp U ⟶ S.comp G) (β : G.obj T ⟶ V) (X : CategoryTheory.Comma S (CategoryTheory.Functor.fromPUnit T))
Goal: ((CategoryTheory.CostructuredArrow.map₂ α β).obj X).right = X.right
-- CategoryTheory.CostructuredArrow.map₂_map_right
@[simps!]
def map₂ : CostructuredArrow S T ⥤ CostructuredArrow U V 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {T : D} {S : CategoryTheory.Functor C D} {A : Type u₃} [CategoryTheory.Category.{v₃, u₃} A] {B : Type u₄} [CategoryTheory.Category.{v₄, u₄} B] {U : CategoryTheory.Functor A B} {V : B} {F : CategoryTheory.Functor C A} {G : CategoryTheory.Functor D B} (α : F.comp U ⟶ S.comp G) (β : G.obj T ⟶ V) {X Y : CategoryTheory.Comma S (CategoryTheory.Functor.fromPUnit T)} (φ : X ⟶ Y)
Goal: ((CategoryTheory.CostructuredArrow.map₂ α β).map φ).right = CategoryTheory.CategoryStruct.id X.right
-- CategoryTheory.CostructuredArrow.map₂_map_left
@[simps!]
def map₂ : CostructuredArrow S T ⥤ CostructuredArrow U V 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {T : D} {S : CategoryTheory.Functor C D} {A : Type u₃} [CategoryTheory.Category.{v₃, u₃} A] {B : Type u₄} [CategoryTheory.Category.{v₄, u₄} B] {U : CategoryTheory.Functor A B} {V : B} {F : CategoryTheory.Functor C A} {G : CategoryTheory.Functor D B} (α : F.comp U ⟶ S.comp G) (β : G.obj T ⟶ V) {X Y : CategoryTheory.Comma S (CategoryTheory.Functor.fromPUnit T)} (φ : X ⟶ Y)
Goal: ((CategoryTheory.CostructuredArrow.map₂ α β).map φ).left = F.map φ.left