ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.StructuredArrow.isoMk_hom_left_down_down
@[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' 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S : D} {T : CategoryTheory.Functor C D} {f f' : CategoryTheory.StructuredArrow S T} (g : f.right ≅ f'.right) (w : CategoryTheory.CategoryStruct.comp f.hom (T.map g.hom) = f'.hom := by aesop_cat)
Goal: ⋯ = ⋯
-- CategoryTheory.StructuredArrow.isoMk_inv_right
@[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' 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S : D} {T : CategoryTheory.Functor C D} {f f' : CategoryTheory.StructuredArrow S T} (g : f.right ≅ f'.right) (w : CategoryTheory.CategoryStruct.comp f.hom (T.map g.hom) = f'.hom := by aesop_cat)
Goal: (CategoryTheory.StructuredArrow.isoMk g w).inv.right = g.inv
-- CategoryTheory.StructuredArrow.isoMk_hom_right
@[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' 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S : D} {T : CategoryTheory.Functor C D} {f f' : CategoryTheory.StructuredArrow S T} (g : f.right ≅ f'.right) (w : CategoryTheory.CategoryStruct.comp f.hom (T.map g.hom) = f'.hom := by aesop_cat)
Goal: (CategoryTheory.StructuredArrow.isoMk g w).hom.right = g.hom
-- CategoryTheory.StructuredArrow.isoMk_inv_left_down_down
@[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' 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S : D} {T : CategoryTheory.Functor C D} {f f' : CategoryTheory.StructuredArrow S T} (g : f.right ≅ f'.right) (w : CategoryTheory.CategoryStruct.comp f.hom (T.map g.hom) = f'.hom := by aesop_cat)
Goal: ⋯ = ⋯
-- CategoryTheory.StructuredArrow.ext
theorem ext {A B : StructuredArrow S T} (f g : A ⟶ B) : f.right = g.right → f = g 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S : D} {T : CategoryTheory.Functor C D} {A B : CategoryTheory.StructuredArrow S T} (f g : A ⟶ B)
Goal: f.right = g.right → f = g
-- CategoryTheory.StructuredArrow.ext_iff
theorem ext_iff {A B : StructuredArrow S T} (f g : A ⟶ B) : f = g ↔ f.right = g.right 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S : D} {T : CategoryTheory.Functor C D} {A B : CategoryTheory.StructuredArrow S T} (f g : A ⟶ B)
Goal: f = g ↔ f.right = g.right
-- CategoryTheory.StructuredArrow.mono_of_mono_right
theorem mono_of_mono_right {A B : StructuredArrow S T} (f : A ⟶ B) [h : Mono f.right] : Mono f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S : D} {T : CategoryTheory.Functor C D} {A B : CategoryTheory.StructuredArrow S T} (f : A ⟶ B) [h : CategoryTheory.Mono f.right]
Goal: CategoryTheory.Mono f
-- CategoryTheory.StructuredArrow.epi_of_epi_right
theorem epi_of_epi_right {A B : StructuredArrow S T} (f : A ⟶ B) [h : Epi f.right] : Epi f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S : D} {T : CategoryTheory.Functor C D} {A B : CategoryTheory.StructuredArrow S T} (f : A ⟶ B) [h : CategoryTheory.Epi f.right]
Goal: CategoryTheory.Epi f
-- CategoryTheory.StructuredArrow.eq_mk
theorem eq_mk (f : StructuredArrow S T) : f = mk f.hom 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S : D} {T : CategoryTheory.Functor C D} (f : CategoryTheory.StructuredArrow S T)
Goal: f = CategoryTheory.StructuredArrow.mk f.hom
-- CategoryTheory.StructuredArrow.eta_hom_right
@[simps!]
def eta (f : StructuredArrow S T) : f ≅ mk f.hom 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S : D} {T : CategoryTheory.Functor C D} (f : CategoryTheory.StructuredArrow S T)
Goal: f.eta.hom.right = CategoryTheory.CategoryStruct.id f.right
-- CategoryTheory.StructuredArrow.eta_hom_left_down_down
@[simps!]
def eta (f : StructuredArrow S T) : f ≅ mk f.hom 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S : D} {T : CategoryTheory.Functor C D} (f : CategoryTheory.StructuredArrow S T)
Goal: ⋯ = ⋯
-- CategoryTheory.StructuredArrow.eta_inv_left_down_down
@[simps!]
def eta (f : StructuredArrow S T) : f ≅ mk f.hom 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S : D} {T : CategoryTheory.Functor C D} (f : CategoryTheory.StructuredArrow S T)
Goal: ⋯ = ⋯
-- CategoryTheory.StructuredArrow.eta_inv_right
@[simps!]
def eta (f : StructuredArrow S T) : f ≅ mk f.hom 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S : D} {T : CategoryTheory.Functor C D} (f : CategoryTheory.StructuredArrow S T)
Goal: f.eta.inv.right = CategoryTheory.CategoryStruct.id f.right
-- CategoryTheory.StructuredArrow.mk_surjective
lemma mk_surjective (f : StructuredArrow S T) :
    ∃ (Y : C) (g : S ⟶ T.obj Y), f = mk g 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S : D} {T : CategoryTheory.Functor C D} (f : CategoryTheory.StructuredArrow S T)
Goal: ∃ Y g, f = CategoryTheory.StructuredArrow.mk g
-- CategoryTheory.StructuredArrow.map_map_right
@[simps!]
def map (f : S ⟶ S') : StructuredArrow S' T ⥤ StructuredArrow S T 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S S' : D} {T : CategoryTheory.Functor C D} (f : S ⟶ S')
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
-- CategoryTheory.StructuredArrow.map_map_left
@[simps!]
def map (f : S ⟶ S') : StructuredArrow S' T ⥤ StructuredArrow S T 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S S' : D} {T : CategoryTheory.Functor C D} (f : S ⟶ S')
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
-- CategoryTheory.StructuredArrow.map_obj_hom
@[simps!]
def map (f : S ⟶ S') : StructuredArrow S' T ⥤ StructuredArrow S T 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S S' : D} {T : CategoryTheory.Functor C D} (f : S ⟶ S') (X : CategoryTheory.Comma (CategoryTheory.Functor.fromPUnit S') T)
Goal: ((CategoryTheory.StructuredArrow.map f).obj X).hom = CategoryTheory.CategoryStruct.comp f X.hom
-- CategoryTheory.StructuredArrow.map_obj_left
@[simps!]
def map (f : S ⟶ S') : StructuredArrow S' T ⥤ StructuredArrow S T 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S S' : D} {T : CategoryTheory.Functor C D} (f : S ⟶ S') (X : CategoryTheory.Comma (CategoryTheory.Functor.fromPUnit S') T)
Goal: ((CategoryTheory.StructuredArrow.map f).obj X).left = X.left
-- CategoryTheory.StructuredArrow.map_obj_right
@[simps!]
def map (f : S ⟶ S') : StructuredArrow S' T ⥤ StructuredArrow S T 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S S' : D} {T : CategoryTheory.Functor C D} (f : S ⟶ S') (X : CategoryTheory.Comma (CategoryTheory.Functor.fromPUnit S') T)
Goal: ((CategoryTheory.StructuredArrow.map f).obj X).right = X.right
-- CategoryTheory.StructuredArrow.map_mk
@[simp]
theorem map_mk {f : S' ⟶ T.obj Y} (g : S ⟶ S') : (map g).obj (mk f) = mk (g ≫ f) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S S' : D} {Y : C} {T : CategoryTheory.Functor C D} {f : S' ⟶ T.obj Y} (g : S ⟶ S')
Goal: (CategoryTheory.StructuredArrow.map g).obj (CategoryTheory.StructuredArrow.mk f) =
  CategoryTheory.StructuredArrow.mk (CategoryTheory.CategoryStruct.comp g f)
-- CategoryTheory.StructuredArrow.map_id
@[simp]
theorem map_id {f : StructuredArrow S T} : (map (𝟙 S)).obj f = f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S : D} {T : CategoryTheory.Functor C D} {f : CategoryTheory.StructuredArrow S T}
Goal: (CategoryTheory.StructuredArrow.map (CategoryTheory.CategoryStruct.id S)).obj f = f
-- CategoryTheory.StructuredArrow.map_comp
@[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) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S S' S'' : D} {T : CategoryTheory.Functor C D} {f : S ⟶ S'} {f' : S' ⟶ S''} {h : CategoryTheory.StructuredArrow S'' T}
Goal: (CategoryTheory.StructuredArrow.map (CategoryTheory.CategoryStruct.comp f f')).obj h =
  (CategoryTheory.StructuredArrow.map f).obj ((CategoryTheory.StructuredArrow.map f').obj h)
-- CategoryTheory.StructuredArrow.pre_obj_hom
@[simps!]
def pre (S : D) (F : B ⥤ C) (G : C ⥤ D) : StructuredArrow S (F ⋙ G) ⥤ StructuredArrow S G 
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] (S : D) (F : CategoryTheory.Functor B C) (G : CategoryTheory.Functor C D) (X : CategoryTheory.Comma (CategoryTheory.Functor.fromPUnit S) (F.comp G))
Goal: ((CategoryTheory.StructuredArrow.pre S F G).obj X).hom = X.hom
-- CategoryTheory.StructuredArrow.pre_obj_right
@[simps!]
def pre (S : D) (F : B ⥤ C) (G : C ⥤ D) : StructuredArrow S (F ⋙ G) ⥤ StructuredArrow S G 
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] (S : D) (F : CategoryTheory.Functor B C) (G : CategoryTheory.Functor C D) (X : CategoryTheory.Comma (CategoryTheory.Functor.fromPUnit S) (F.comp G))
Goal: ((CategoryTheory.StructuredArrow.pre S F G).obj X).right = F.obj X.right
-- CategoryTheory.StructuredArrow.pre_obj_left
@[simps!]
def pre (S : D) (F : B ⥤ C) (G : C ⥤ D) : StructuredArrow S (F ⋙ G) ⥤ StructuredArrow S G 
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] (S : D) (F : CategoryTheory.Functor B C) (G : CategoryTheory.Functor C D) (X : CategoryTheory.Comma (CategoryTheory.Functor.fromPUnit S) (F.comp G))
Goal: ((CategoryTheory.StructuredArrow.pre S F G).obj X).left = X.left
-- CategoryTheory.StructuredArrow.pre_map_right
@[simps!]
def pre (S : D) (F : B ⥤ C) (G : C ⥤ D) : StructuredArrow S (F ⋙ G) ⥤ StructuredArrow S G 
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] (S : D) (F : CategoryTheory.Functor B C) (G : CategoryTheory.Functor C D)
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
-- CategoryTheory.StructuredArrow.pre_map_left
@[simps!]
def pre (S : D) (F : B ⥤ C) (G : C ⥤ D) : StructuredArrow S (F ⋙ G) ⥤ StructuredArrow S G 
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] (S : D) (F : CategoryTheory.Functor B C) (G : CategoryTheory.Functor C D)
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
-- CategoryTheory.StructuredArrow.post_map
@[simps]
def post (S : C) (F : B ⥤ C) (G : C ⥤ D) :
    StructuredArrow S F ⥤ StructuredArrow (G.obj S) (F ⋙ G) 
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] (S : C) (F : CategoryTheory.Functor B C) (G : CategoryTheory.Functor C D)
Goal: ∀ {X Y : CategoryTheory.StructuredArrow S F} (f : X ⟶ Y),
  (CategoryTheory.StructuredArrow.post S F G).map f = CategoryTheory.StructuredArrow.homMk f.right ⋯
-- CategoryTheory.StructuredArrow.post_obj
@[simps]
def post (S : C) (F : B ⥤ C) (G : C ⥤ D) :
    StructuredArrow S F ⥤ StructuredArrow (G.obj S) (F ⋙ G) 
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] (S : C) (F : CategoryTheory.Functor B C) (G : CategoryTheory.Functor C D) (X : CategoryTheory.StructuredArrow S F)
Goal: (CategoryTheory.StructuredArrow.post S F G).obj X = CategoryTheory.StructuredArrow.mk (G.map X.hom)
-- CategoryTheory.StructuredArrow.map₂_obj_left
@[simps!]
def map₂ : StructuredArrow L R ⥤ StructuredArrow L' R' 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {A : Type u₃} [CategoryTheory.Category.{v₃, u₃} A] {B : Type u₄} [CategoryTheory.Category.{v₄, u₄} B] {L : D} {R : CategoryTheory.Functor C D} {L' : B} {R' : CategoryTheory.Functor A B} {F : CategoryTheory.Functor C A} {G : CategoryTheory.Functor D B} (α : L' ⟶ G.obj L) (β : R.comp G ⟶ F.comp R') (X : CategoryTheory.Comma (CategoryTheory.Functor.fromPUnit L) R)
Goal: ((CategoryTheory.StructuredArrow.map₂ α β).obj X).left = X.left
-- CategoryTheory.StructuredArrow.map₂_obj_right
@[simps!]
def map₂ : StructuredArrow L R ⥤ StructuredArrow L' R' 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {A : Type u₃} [CategoryTheory.Category.{v₃, u₃} A] {B : Type u₄} [CategoryTheory.Category.{v₄, u₄} B] {L : D} {R : CategoryTheory.Functor C D} {L' : B} {R' : CategoryTheory.Functor A B} {F : CategoryTheory.Functor C A} {G : CategoryTheory.Functor D B} (α : L' ⟶ G.obj L) (β : R.comp G ⟶ F.comp R') (X : CategoryTheory.Comma (CategoryTheory.Functor.fromPUnit L) R)
Goal: ((CategoryTheory.StructuredArrow.map₂ α β).obj X).right = F.obj X.right
-- CategoryTheory.StructuredArrow.map₂_map_right
@[simps!]
def map₂ : StructuredArrow L R ⥤ StructuredArrow L' R' 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {A : Type u₃} [CategoryTheory.Category.{v₃, u₃} A] {B : Type u₄} [CategoryTheory.Category.{v₄, u₄} B] {L : D} {R : CategoryTheory.Functor C D} {L' : B} {R' : CategoryTheory.Functor A B} {F : CategoryTheory.Functor C A} {G : CategoryTheory.Functor D B} (α : L' ⟶ G.obj L) (β : R.comp G ⟶ F.comp R') {X Y : CategoryTheory.Comma (CategoryTheory.Functor.fromPUnit L) R} (φ : X ⟶ Y)
Goal: ((CategoryTheory.StructuredArrow.map₂ α β).map φ).right = F.map φ.right
-- CategoryTheory.StructuredArrow.map₂_map_left
@[simps!]
def map₂ : StructuredArrow L R ⥤ StructuredArrow L' R' 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {A : Type u₃} [CategoryTheory.Category.{v₃, u₃} A] {B : Type u₄} [CategoryTheory.Category.{v₄, u₄} B] {L : D} {R : CategoryTheory.Functor C D} {L' : B} {R' : CategoryTheory.Functor A B} {F : CategoryTheory.Functor C A} {G : CategoryTheory.Functor D B} (α : L' ⟶ G.obj L) (β : R.comp G ⟶ F.comp R') {X Y : CategoryTheory.Comma (CategoryTheory.Functor.fromPUnit L) R} (φ : X ⟶ Y)
Goal: ((CategoryTheory.StructuredArrow.map₂ α β).map φ).left = CategoryTheory.CategoryStruct.id X.left
-- CategoryTheory.StructuredArrow.map₂_obj_hom
@[simps!]
def map₂ : StructuredArrow L R ⥤ StructuredArrow L' R' 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {A : Type u₃} [CategoryTheory.Category.{v₃, u₃} A] {B : Type u₄} [CategoryTheory.Category.{v₄, u₄} B] {L : D} {R : CategoryTheory.Functor C D} {L' : B} {R' : CategoryTheory.Functor A B} {F : CategoryTheory.Functor C A} {G : CategoryTheory.Functor D B} (α : L' ⟶ G.obj L) (β : R.comp G ⟶ F.comp R') (X : CategoryTheory.Comma (CategoryTheory.Functor.fromPUnit L) R)
Goal: ((CategoryTheory.StructuredArrow.map₂ α β).obj X).hom =
  CategoryTheory.CategoryStruct.comp α (CategoryTheory.CategoryStruct.comp (G.map X.hom) (β.app X.right))
-- CategoryTheory.StructuredArrow.IsUniversal.uniq
theorem uniq (h : IsUniversal f) (η : f ⟶ g) : η = h.to g 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S : D} {T : CategoryTheory.Functor C D} {f g : CategoryTheory.StructuredArrow S T} (h : f.IsUniversal) (η : f ⟶ g)
Goal: η = CategoryTheory.Limits.IsInitial.to h g
-- CategoryTheory.StructuredArrow.IsUniversal.fac
@[reassoc (attr := simp)]
theorem fac (h : IsUniversal f) (g : StructuredArrow S T) :
    f.hom ≫ T.map (h.desc g) = g.hom 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S : D} {T : CategoryTheory.Functor C D} {f : CategoryTheory.StructuredArrow S T} (h : f.IsUniversal) (g : CategoryTheory.StructuredArrow S T)
Goal: CategoryTheory.CategoryStruct.comp f.hom (T.map (h.desc g)) = g.hom
-- CategoryTheory.StructuredArrow.IsUniversal.hom_desc
theorem hom_desc (h : IsUniversal f) {c : C} (η : f.right ⟶ c) :
    η = h.desc (mk <| f.hom ≫ T.map η) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S : D} {T : CategoryTheory.Functor C D} {f : CategoryTheory.StructuredArrow S T} (h : f.IsUniversal) {c : C} (η : f.right ⟶ c)
Goal: η = h.desc (CategoryTheory.StructuredArrow.mk (CategoryTheory.CategoryStruct.comp f.hom (T.map η)))
-- CategoryTheory.StructuredArrow.IsUniversal.hom_ext
theorem hom_ext (h : IsUniversal f) {c : C} {η η' : f.right ⟶ c}
    (w : f.hom ≫ T.map η = f.hom ≫ T.map η') : η = η' 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S : D} {T : CategoryTheory.Functor C D} {f : CategoryTheory.StructuredArrow S T} (h : f.IsUniversal) {c : C} {η η' : f.right ⟶ c} (w : CategoryTheory.CategoryStruct.comp f.hom (T.map η) = CategoryTheory.CategoryStruct.comp f.hom (T.map η'))
Goal: η = η'
-- CategoryTheory.StructuredArrow.IsUniversal.existsUnique
theorem existsUnique (h : IsUniversal f) (g : StructuredArrow S T) :
    ∃! η : f.right ⟶ g.right, f.hom ≫ T.map η = g.hom 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S : D} {T : CategoryTheory.Functor C D} {f : CategoryTheory.StructuredArrow S T} (h : f.IsUniversal) (g : CategoryTheory.StructuredArrow S T)
Goal: ∃! η, CategoryTheory.CategoryStruct.comp f.hom (T.map η) = g.hom
-- CategoryTheory.CostructuredArrow.proj_obj
@[simps!]
def proj (S : C ⥤ D) (T : D) : CostructuredArrow S T ⥤ C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (S : CategoryTheory.Functor C D) (T : D) (X : CategoryTheory.Comma S (CategoryTheory.Functor.fromPUnit T))
Goal: (CategoryTheory.CostructuredArrow.proj S T).obj X = X.left
-- CategoryTheory.CostructuredArrow.proj_map
@[simps!]
def proj (S : C ⥤ D) (T : D) : CostructuredArrow S T ⥤ C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (S : CategoryTheory.Functor C D) (T : D)
Goal: ∀ {X Y : CategoryTheory.Comma S (CategoryTheory.Functor.fromPUnit T)} (f : X ⟶ Y),
  (CategoryTheory.CostructuredArrow.proj S T).map f = f.left
-- CategoryTheory.CostructuredArrow.hom_ext
@[ext]
lemma hom_ext {X Y : CostructuredArrow S T} (f g : X ⟶ Y) (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} {X Y : CategoryTheory.CostructuredArrow S T} (f g : X ⟶ Y) (h : f.left = g.left)
Goal: f = g
-- CategoryTheory.CostructuredArrow.hom_eq_iff
@[simp]
theorem hom_eq_iff {X Y : CostructuredArrow S T} (f g : X ⟶ Y) : 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} {X Y : CategoryTheory.CostructuredArrow S T} (f g : X ⟶ Y)
Goal: f = g ↔ f.left = g.left
-- CategoryTheory.CostructuredArrow.mk_left
@[simp]
theorem mk_left (f : S.obj Y ⟶ T) : (mk f).left = Y 
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).left = Y
-- CategoryTheory.CostructuredArrow.mk_right
@[simp]
theorem mk_right (f : S.obj Y ⟶ T) : (mk f).right = ⟨⟨⟩⟩ 
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).right = { as := PUnit.unit }
-- CategoryTheory.CostructuredArrow.mk_hom_eq_self
@[simp]
theorem mk_hom_eq_self (f : S.obj Y ⟶ T) : (mk 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 : S.obj Y ⟶ T)
Goal: (CategoryTheory.CostructuredArrow.mk f).hom = f
-- CategoryTheory.CostructuredArrow.w
@[reassoc]
theorem w {A B : CostructuredArrow S T} (f : A ⟶ B) : S.map f.left ≫ B.hom = A.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} {A B : CategoryTheory.CostructuredArrow S T} (f : A ⟶ B)
Goal: CategoryTheory.CategoryStruct.comp (S.map f.left) B.hom = A.hom
-- CategoryTheory.CostructuredArrow.comp_left
@[simp]
theorem comp_left {X Y Z : CostructuredArrow S T} (f : X ⟶ Y) (g : Y ⟶ Z) :
    (f ≫ g).left = 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} {X Y Z : CategoryTheory.CostructuredArrow S T} (f : X ⟶ Y) (g : Y ⟶ Z)
Goal: (CategoryTheory.CategoryStruct.comp f g).left = CategoryTheory.CategoryStruct.comp f.left g.left
-- CategoryTheory.CostructuredArrow.id_left
@[simp]
theorem id_left (X : CostructuredArrow S T) : (𝟙 X : X ⟶ X).left = 𝟙 X.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} (X : CategoryTheory.CostructuredArrow S T)
Goal: (CategoryTheory.CategoryStruct.id X).left = CategoryTheory.CategoryStruct.id X.left
-- CategoryTheory.CostructuredArrow.eqToHom_left
@[simp]
theorem eqToHom_left {X Y : CostructuredArrow S T} (h : X = Y) :
    (eqToHom h).left = eqToHom (by rw [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} {X Y : CategoryTheory.CostructuredArrow S T} (h : X = Y)
Goal: (CategoryTheory.eqToHom h).left = CategoryTheory.eqToHom ⋯
-- CategoryTheory.CostructuredArrow.right_eq_id
@[simp]
theorem right_eq_id {X Y : CostructuredArrow S T} (f : X ⟶ Y) : f.right = 𝟙 _ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {T : D} {S : CategoryTheory.Functor C D} {X Y : CategoryTheory.CostructuredArrow S T} (f : X ⟶ Y)
Goal: f.right = CategoryTheory.CategoryStruct.id X.right