ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.GradedObject.ι_mapBifunctorMapObjDesc
@[reassoc (attr := simp)]
lemma ι_mapBifunctorMapObjDesc {X : GradedObject I C₁} {Y : GradedObject J C₂} {A : C₃} {k : K}
    [HasMap (((mapBifunctor F I J).obj X).obj Y) p]
    (f : ∀ (i : I) (j : J) (_ : p ⟨i, j⟩ = k), (F.obj (X i)).obj (Y j) ⟶ A)
    (i : I) (j : J) (hij : p ⟨i, j⟩ = k) :
    ιMapBifunctorMapObj F p X Y i j k hij ≫ mapBifunctorMapObjDesc f = f i j hij 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} [CategoryTheory.Category.{u_9, u_1} C₁] [CategoryTheory.Category.{u_8, u_2} C₂] [CategoryTheory.Category.{u_7, u_3} C₃] (F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₃)) {I : Type u_4} {J : Type u_5} {K : Type u_6} (p : I × J → K) {X : CategoryTheory.GradedObject I C₁} {Y : CategoryTheory.GradedObject J C₂} {A : C₃} {k : K} [(((CategoryTheory.GradedObject.mapBifunctor F I J).obj X).obj Y).HasMap p] (f : (i : I) → (j : J) → p (i, j) = k → ((F.obj (X i)).obj (Y j) ⟶ A)) (i : I) (j : J) (hij : p (i, j) = k)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.GradedObject.ιMapBifunctorMapObj F p X Y i j k hij)
    (CategoryTheory.GradedObject.mapBifunctorMapObjDesc f) =
  f i j hij
-- CategoryTheory.GradedObject.mapBifunctorMapMapIso_inv
@[simps]
noncomputable def mapBifunctorMapMapIso (e : X₁ ≅ X₂) (e' : Y₁ ≅ Y₂) :
    mapBifunctorMapObj F p X₁ Y₁ ≅ mapBifunctorMapObj F p X₂ Y₂ 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} [CategoryTheory.Category.{u_7, u_1} C₁] [CategoryTheory.Category.{u_8, u_2} C₂] [CategoryTheory.Category.{u_9, u_3} C₃] (F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₃)) {I : Type u_4} {J : Type u_5} {K : Type u_6} (p : I × J → K) {X₁ X₂ : CategoryTheory.GradedObject I C₁} {Y₁ Y₂ : CategoryTheory.GradedObject J C₂} [(((CategoryTheory.GradedObject.mapBifunctor F I J).obj X₁).obj Y₁).HasMap p] [(((CategoryTheory.GradedObject.mapBifunctor F I J).obj X₂).obj Y₂).HasMap p] (e : X₁ ≅ X₂) (e' : Y₁ ≅ Y₂) (i : K)
Goal: (CategoryTheory.GradedObject.mapBifunctorMapMapIso F p e e').inv i =
  CategoryTheory.GradedObject.mapBifunctorMapMap F p e.inv e'.inv i
-- CategoryTheory.GradedObject.mapBifunctorMapMapIso_hom
@[simps]
noncomputable def mapBifunctorMapMapIso (e : X₁ ≅ X₂) (e' : Y₁ ≅ Y₂) :
    mapBifunctorMapObj F p X₁ Y₁ ≅ mapBifunctorMapObj F p X₂ Y₂ 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} [CategoryTheory.Category.{u_7, u_1} C₁] [CategoryTheory.Category.{u_8, u_2} C₂] [CategoryTheory.Category.{u_9, u_3} C₃] (F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₃)) {I : Type u_4} {J : Type u_5} {K : Type u_6} (p : I × J → K) {X₁ X₂ : CategoryTheory.GradedObject I C₁} {Y₁ Y₂ : CategoryTheory.GradedObject J C₂} [(((CategoryTheory.GradedObject.mapBifunctor F I J).obj X₁).obj Y₁).HasMap p] [(((CategoryTheory.GradedObject.mapBifunctor F I J).obj X₂).obj Y₂).HasMap p] (e : X₁ ≅ X₂) (e' : Y₁ ≅ Y₂) (i : K)
Goal: (CategoryTheory.GradedObject.mapBifunctorMapMapIso F p e e').hom i =
  CategoryTheory.GradedObject.mapBifunctorMapMap F p e.hom e'.hom i
-- CategoryTheory.GradedObject.mapBifunctorMap_obj_obj
@[simps]
noncomputable def mapBifunctorMap [∀ X Y, HasMap (((mapBifunctor F I J).obj X).obj Y) p] :
    GradedObject I C₁ ⥤ GradedObject J C₂ ⥤ GradedObject K C₃ 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} [CategoryTheory.Category.{u_7, u_1} C₁] [CategoryTheory.Category.{u_8, u_2} C₂] [CategoryTheory.Category.{u_9, u_3} C₃] (F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₃)) {I : Type u_4} {J : Type u_5} {K : Type u_6} (p : I × J → K) [∀ (X : CategoryTheory.GradedObject I C₁) (Y : CategoryTheory.GradedObject J C₂),
    (((CategoryTheory.GradedObject.mapBifunctor F I J).obj X).obj Y).HasMap p] (X : CategoryTheory.GradedObject I C₁) (Y : CategoryTheory.GradedObject J C₂)
Goal: ((CategoryTheory.GradedObject.mapBifunctorMap F p).obj X).obj Y = CategoryTheory.GradedObject.mapBifunctorMapObj F p X Y
-- CategoryTheory.GradedObject.mapBifunctorMap_obj_map
@[simps]
noncomputable def mapBifunctorMap [∀ X Y, HasMap (((mapBifunctor F I J).obj X).obj Y) p] :
    GradedObject I C₁ ⥤ GradedObject J C₂ ⥤ GradedObject K C₃ 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} [CategoryTheory.Category.{u_7, u_1} C₁] [CategoryTheory.Category.{u_8, u_2} C₂] [CategoryTheory.Category.{u_9, u_3} C₃] (F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₃)) {I : Type u_4} {J : Type u_5} {K : Type u_6} (p : I × J → K) [∀ (X : CategoryTheory.GradedObject I C₁) (Y : CategoryTheory.GradedObject J C₂),
    (((CategoryTheory.GradedObject.mapBifunctor F I J).obj X).obj Y).HasMap p] (X : CategoryTheory.GradedObject I C₁)
Goal: ∀ {X_1 Y : CategoryTheory.GradedObject J C₂} (ψ : X_1 ⟶ Y) (i : K),
  ((CategoryTheory.GradedObject.mapBifunctorMap F p).obj X).map ψ i =
    CategoryTheory.GradedObject.mapBifunctorMapMap F p (CategoryTheory.CategoryStruct.id X) ψ i
-- CategoryTheory.GradedObject.mapBifunctorMap_map_app
@[simps]
noncomputable def mapBifunctorMap [∀ X Y, HasMap (((mapBifunctor F I J).obj X).obj Y) p] :
    GradedObject I C₁ ⥤ GradedObject J C₂ ⥤ GradedObject K C₃ 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} [CategoryTheory.Category.{u_7, u_1} C₁] [CategoryTheory.Category.{u_8, u_2} C₂] [CategoryTheory.Category.{u_9, u_3} C₃] (F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₃)) {I : Type u_4} {J : Type u_5} {K : Type u_6} (p : I × J → K) [∀ (X : CategoryTheory.GradedObject I C₁) (Y : CategoryTheory.GradedObject J C₂),
    (((CategoryTheory.GradedObject.mapBifunctor F I J).obj X).obj Y).HasMap p] {X₁ X₂ : CategoryTheory.GradedObject I C₁} (φ : X₁ ⟶ X₂) (Y : CategoryTheory.GradedObject J C₂) (i : K)
Goal: ((CategoryTheory.GradedObject.mapBifunctorMap F p).map φ).app Y i =
  CategoryTheory.GradedObject.mapBifunctorMapMap F p φ (CategoryTheory.CategoryStruct.id Y) i
-- CategoryTheory.NatTrans.appLinearMap_apply
@[simps]
def appLinearMap (X : C) : (F ⟶ G) →ₗ[R] F.obj X ⟶ G.obj X 
Arguments: {R : Type u_1} [Semiring R] {C : Type u_2} {D : Type u_3} [CategoryTheory.Category.{u_4, u_2} C] [CategoryTheory.Category.{u_5, u_3} D] [CategoryTheory.Preadditive D] [CategoryTheory.Linear R D] {F G : CategoryTheory.Functor C D} (X : C) (α : F ⟶ G)
Goal: (CategoryTheory.NatTrans.appLinearMap X) α = α.app X
-- CategoryTheory.NatTrans.app_smul
@[simp]
theorem app_smul (X : C) (r : R) (α : F ⟶ G) : (r • α).app X = r • α.app X 
Arguments: {R : Type u_1} [Semiring R] {C : Type u_2} {D : Type u_3} [CategoryTheory.Category.{u_5, u_2} C] [CategoryTheory.Category.{u_4, u_3} D] [CategoryTheory.Preadditive D] [CategoryTheory.Linear R D] {F G : CategoryTheory.Functor C D} (X : C) (r : R) (α : F ⟶ G)
Goal: (r • α).app X = r • α.app X
-- CategoryTheory.FreeMonoidalCategory.inclusion_obj
@[simp]
theorem inclusion_obj (X : N C) :
    inclusion.obj X = inclusionObj X.as 
Arguments: {C : Type u} (X : (CategoryTheory.Discrete ∘ CategoryTheory.FreeMonoidalCategory.NormalMonoidalObject) C)
Goal: CategoryTheory.FreeMonoidalCategory.inclusion.obj X = CategoryTheory.FreeMonoidalCategory.inclusionObj X.as
-- CategoryTheory.FreeMonoidalCategory.inclusion_map
@[simp]
theorem inclusion_map {X Y : N C} (f : X ⟶ Y) :
    inclusion.map f = eqToHom (congr_arg _ (Discrete.ext _ _ (Discrete.eq_of_hom f))) 
Arguments: {C : Type u} {X Y : (CategoryTheory.Discrete ∘ CategoryTheory.FreeMonoidalCategory.NormalMonoidalObject) C} (f : X ⟶ Y)
Goal: CategoryTheory.FreeMonoidalCategory.inclusion.map f = CategoryTheory.eqToHom ⋯
-- CategoryTheory.FreeMonoidalCategory.normalizeObj_unitor
@[simp]
theorem normalizeObj_unitor (n : NormalMonoidalObject C) : normalizeObj (𝟙_ (F C)) n = n 
Arguments: {C : Type u} (n : CategoryTheory.FreeMonoidalCategory.NormalMonoidalObject C)
Goal: (𝟙_ (CategoryTheory.FreeMonoidalCategory C)).normalizeObj n = n
-- CategoryTheory.FreeMonoidalCategory.normalizeObj_tensor
@[simp]
theorem normalizeObj_tensor (X Y : F C) (n : NormalMonoidalObject C) :
    normalizeObj (X ⊗ Y) n = normalizeObj Y (normalizeObj X n) 
Arguments: {C : Type u} (X Y : CategoryTheory.FreeMonoidalCategory C) (n : CategoryTheory.FreeMonoidalCategory.NormalMonoidalObject C)
Goal: (CategoryTheory.MonoidalCategory.tensorObj X Y).normalizeObj n = Y.normalizeObj (X.normalizeObj n)
-- CategoryTheory.FreeMonoidalCategory.tensorFunc_map_app
theorem tensorFunc_map_app {X Y : F C} (f : X ⟶ Y) (n) : ((tensorFunc C).map f).app n = _ ◁ f 
Arguments: (C : Type u) {X Y : CategoryTheory.FreeMonoidalCategory C} (f : X ⟶ Y) (n : (CategoryTheory.Discrete ∘ CategoryTheory.FreeMonoidalCategory.NormalMonoidalObject) C)
Goal: ((CategoryTheory.FreeMonoidalCategory.tensorFunc C).map f).app n =
  CategoryTheory.MonoidalCategory.whiskerLeft (CategoryTheory.FreeMonoidalCategory.inclusion.obj { as := n.as }) f
-- CategoryTheory.FreeMonoidalCategory.tensorFunc_obj_map
theorem tensorFunc_obj_map (Z : F C) {n n' : N C} (f : n ⟶ n') :
    ((tensorFunc C).obj Z).map f = inclusion.map f ▷ Z 
Arguments: (C : Type u) (Z : CategoryTheory.FreeMonoidalCategory C) {n n' : (CategoryTheory.Discrete ∘ CategoryTheory.FreeMonoidalCategory.NormalMonoidalObject) C} (f : n ⟶ n')
Goal: ((CategoryTheory.FreeMonoidalCategory.tensorFunc C).obj Z).map f =
  CategoryTheory.MonoidalCategory.whiskerRight (CategoryTheory.FreeMonoidalCategory.inclusion.map f) Z
-- CategoryTheory.FreeMonoidalCategory.normalizeIsoApp_eq
theorem normalizeIsoApp_eq :
    ∀ (X : F C) (n : N C), normalizeIsoApp C X n = normalizeIsoApp' C X n.as
  
Arguments: (C : Type u) (X : CategoryTheory.FreeMonoidalCategory C) (n : (CategoryTheory.Discrete ∘ CategoryTheory.FreeMonoidalCategory.NormalMonoidalObject) C)
Goal: CategoryTheory.FreeMonoidalCategory.normalizeIsoApp C X n =
  CategoryTheory.FreeMonoidalCategory.normalizeIsoApp' C X n.as
-- CategoryTheory.FreeMonoidalCategory.normalizeIsoApp_tensor
@[simp]
theorem normalizeIsoApp_tensor (X Y : F C) (n : N C) :
    normalizeIsoApp C (X ⊗ Y) n =
      (α_ _ _ _).symm ≪≫ whiskerRightIso (normalizeIsoApp C X n) Y ≪≫ normalizeIsoApp _ _ _ 
Arguments: (C : Type u) (X Y : CategoryTheory.FreeMonoidalCategory C) (n : (CategoryTheory.Discrete ∘ CategoryTheory.FreeMonoidalCategory.NormalMonoidalObject) C)
Goal: CategoryTheory.FreeMonoidalCategory.normalizeIsoApp C (CategoryTheory.MonoidalCategory.tensorObj X Y) n =
  (CategoryTheory.MonoidalCategory.associator (CategoryTheory.FreeMonoidalCategory.inclusion.obj { as := n.as }) X
        Y).symm ≪≫
    CategoryTheory.MonoidalCategory.whiskerRightIso (CategoryTheory.FreeMonoidalCategory.normalizeIsoApp C X n) Y ≪≫
      CategoryTheory.FreeMonoidalCategory.normalizeIsoApp C Y { as := X.normalizeObj n.as }
-- CategoryTheory.FreeMonoidalCategory.normalizeIsoApp_unitor
@[simp]
theorem normalizeIsoApp_unitor (n : N C) : normalizeIsoApp C (𝟙_ (F C)) n = ρ_ _ 
Arguments: (C : Type u) (n : (CategoryTheory.Discrete ∘ CategoryTheory.FreeMonoidalCategory.NormalMonoidalObject) C)
Goal: CategoryTheory.FreeMonoidalCategory.normalizeIsoApp C (𝟙_ (CategoryTheory.FreeMonoidalCategory C)) n =
  CategoryTheory.MonoidalCategory.rightUnitor (CategoryTheory.FreeMonoidalCategory.inclusion.obj { as := n.as })
-- CategoryTheory.FreeMonoidalCategory.normalizeObj_congr
theorem normalizeObj_congr (n : NormalMonoidalObject C) {X Y : F C} (f : X ⟶ Y) :
    normalizeObj X n = normalizeObj Y n 
Arguments: {C : Type u} (n : CategoryTheory.FreeMonoidalCategory.NormalMonoidalObject C) {X Y : CategoryTheory.FreeMonoidalCategory C} (f : X ⟶ Y)
Goal: X.normalizeObj n = Y.normalizeObj n
-- CategoryTheory.FreeMonoidalCategory.normalize_naturality
theorem normalize_naturality (n : NormalMonoidalObject C) {X Y : F C} (f : X ⟶ Y) :
    inclusionObj n ◁ f ≫ (normalizeIsoApp' C Y n).hom =
      (normalizeIsoApp' C X n).hom ≫
        inclusion.map (eqToHom (Discrete.ext _ _ (normalizeObj_congr n f))) 
Arguments: {C : Type u} (n : CategoryTheory.FreeMonoidalCategory.NormalMonoidalObject C) {X Y : CategoryTheory.FreeMonoidalCategory C} (f : X ⟶ Y)
Goal: CategoryTheory.CategoryStruct.comp
    (CategoryTheory.MonoidalCategory.whiskerLeft (CategoryTheory.FreeMonoidalCategory.inclusionObj n) f)
    (CategoryTheory.FreeMonoidalCategory.normalizeIsoApp' C Y n).hom =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.FreeMonoidalCategory.normalizeIsoApp' C X n).hom
    (CategoryTheory.FreeMonoidalCategory.inclusion.map (CategoryTheory.eqToHom ⋯))
-- CategoryTheory.StructuredArrow.proj_map
@[simps!]
def proj (S : D) (T : C ⥤ D) : StructuredArrow S T ⥤ C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (S : D) (T : CategoryTheory.Functor C D)
Goal: ∀ {X Y : CategoryTheory.Comma (CategoryTheory.Functor.fromPUnit S) T} (f : X ⟶ Y),
  (CategoryTheory.StructuredArrow.proj S T).map f = f.right
-- CategoryTheory.StructuredArrow.proj_obj
@[simps!]
def proj (S : D) (T : C ⥤ D) : StructuredArrow S T ⥤ C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (S : D) (T : CategoryTheory.Functor C D) (X : CategoryTheory.Comma (CategoryTheory.Functor.fromPUnit S) T)
Goal: (CategoryTheory.StructuredArrow.proj S T).obj X = X.right
-- CategoryTheory.StructuredArrow.hom_ext
@[ext]
lemma hom_ext {X Y : StructuredArrow S T} (f g : X ⟶ Y) (h : 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} {X Y : CategoryTheory.StructuredArrow S T} (f g : X ⟶ Y) (h : f.right = g.right)
Goal: f = g
-- CategoryTheory.StructuredArrow.hom_eq_iff
@[simp]
theorem hom_eq_iff {X Y : StructuredArrow S T} (f g : X ⟶ Y) : 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} {X Y : CategoryTheory.StructuredArrow S T} (f g : X ⟶ Y)
Goal: f = g ↔ f.right = g.right
-- CategoryTheory.StructuredArrow.mk_left
@[simp]
theorem mk_left (f : S ⟶ T.obj Y) : (mk f).left = ⟨⟨⟩⟩ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S : D} {Y : C} {T : CategoryTheory.Functor C D} (f : S ⟶ T.obj Y)
Goal: (CategoryTheory.StructuredArrow.mk f).left = { as := PUnit.unit }
-- CategoryTheory.StructuredArrow.mk_right
@[simp]
theorem mk_right (f : S ⟶ T.obj Y) : (mk f).right = Y 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S : D} {Y : C} {T : CategoryTheory.Functor C D} (f : S ⟶ T.obj Y)
Goal: (CategoryTheory.StructuredArrow.mk f).right = Y
-- CategoryTheory.StructuredArrow.mk_hom_eq_self
@[simp]
theorem mk_hom_eq_self (f : S ⟶ T.obj Y) : (mk f).hom = f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S : D} {Y : C} {T : CategoryTheory.Functor C D} (f : S ⟶ T.obj Y)
Goal: (CategoryTheory.StructuredArrow.mk f).hom = f
-- CategoryTheory.StructuredArrow.w
@[reassoc (attr := simp)]
theorem w {A B : StructuredArrow S T} (f : A ⟶ B) : A.hom ≫ T.map f.right = B.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} {A B : CategoryTheory.StructuredArrow S T} (f : A ⟶ B)
Goal: CategoryTheory.CategoryStruct.comp A.hom (T.map f.right) = B.hom
-- CategoryTheory.StructuredArrow.comp_right
@[simp]
theorem comp_right {X Y Z : StructuredArrow S T} (f : X ⟶ Y) (g : Y ⟶ Z) :
    (f ≫ g).right = 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} {X Y Z : CategoryTheory.StructuredArrow S T} (f : X ⟶ Y) (g : Y ⟶ Z)
Goal: (CategoryTheory.CategoryStruct.comp f g).right = CategoryTheory.CategoryStruct.comp f.right g.right
-- CategoryTheory.StructuredArrow.id_right
@[simp]
theorem id_right (X : StructuredArrow S T) : (𝟙 X : X ⟶ X).right = 𝟙 X.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} (X : CategoryTheory.StructuredArrow S T)
Goal: (CategoryTheory.CategoryStruct.id X).right = CategoryTheory.CategoryStruct.id X.right
-- CategoryTheory.StructuredArrow.eqToHom_right
@[simp]
theorem eqToHom_right {X Y : StructuredArrow S T} (h : X = Y) :
    (eqToHom h).right = eqToHom (by rw [h]) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S : D} {T : CategoryTheory.Functor C D} {X Y : CategoryTheory.StructuredArrow S T} (h : X = Y)
Goal: (CategoryTheory.eqToHom h).right = CategoryTheory.eqToHom ⋯
-- CategoryTheory.StructuredArrow.left_eq_id
@[simp]
theorem left_eq_id {X Y : StructuredArrow S T} (f : X ⟶ Y) : f.left = 𝟙 _ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S : D} {T : CategoryTheory.Functor C D} {X Y : CategoryTheory.StructuredArrow S T} (f : X ⟶ Y)
Goal: f.left = CategoryTheory.CategoryStruct.id X.left
-- CategoryTheory.StructuredArrow.homMk_left
@[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' 
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) = f'.hom := by aesop_cat)
Goal: (CategoryTheory.StructuredArrow.homMk g w).left = CategoryTheory.CategoryStruct.id f.left
-- CategoryTheory.StructuredArrow.homMk_right
@[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' 
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) = f'.hom := by aesop_cat)
Goal: (CategoryTheory.StructuredArrow.homMk g w).right = g
-- CategoryTheory.StructuredArrow.homMk_surjective
theorem homMk_surjective {f f' : StructuredArrow S T} (φ : f ⟶ f') :
    ∃ (ψ : f.right ⟶ f'.right) (hψ : f.hom ≫ T.map ψ = f'.hom),
      φ = StructuredArrow.homMk ψ hψ 
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} (φ : f ⟶ f')
Goal: ∃ ψ, ∃ (hψ : CategoryTheory.CategoryStruct.comp f.hom (T.map ψ) = f'.hom), φ = CategoryTheory.StructuredArrow.homMk ψ hψ
-- CategoryTheory.StructuredArrow.homMk'_right
@[simps]
def homMk' (f : StructuredArrow S T) (g : f.right ⟶ Y') : f ⟶ mk (f.hom ≫ T.map g) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S : D} {Y' : C} {T : CategoryTheory.Functor C D} (f : CategoryTheory.StructuredArrow S T) (g : f.right ⟶ Y')
Goal: (f.homMk' g).right = g
-- CategoryTheory.StructuredArrow.homMk'_left
@[simps]
def homMk' (f : StructuredArrow S T) (g : f.right ⟶ Y') : f ⟶ mk (f.hom ≫ T.map g) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S : D} {Y' : C} {T : CategoryTheory.Functor C D} (f : CategoryTheory.StructuredArrow S T) (g : f.right ⟶ Y')
Goal: (f.homMk' g).left = CategoryTheory.CategoryStruct.id f.left
-- CategoryTheory.StructuredArrow.homMk'_id
lemma homMk'_id (f : StructuredArrow S T) : homMk' f (𝟙 f.right) = eqToHom (by aesop_cat) 
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.homMk' (CategoryTheory.CategoryStruct.id f.right) = CategoryTheory.eqToHom ⋯
-- CategoryTheory.StructuredArrow.homMk'_mk_id
lemma homMk'_mk_id (f : S ⟶ T.obj Y) : 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] {S : D} {Y : C} {T : CategoryTheory.Functor C D} (f : S ⟶ T.obj Y)
Goal: (CategoryTheory.StructuredArrow.mk f).homMk' (CategoryTheory.CategoryStruct.id Y) = CategoryTheory.eqToHom ⋯
-- CategoryTheory.StructuredArrow.homMk'_comp
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) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S : D} {Y' Y'' : C} {T : CategoryTheory.Functor C D} (f : CategoryTheory.StructuredArrow S T) (g : f.right ⟶ Y') (g' : Y' ⟶ Y'')
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 ⋯))
-- CategoryTheory.StructuredArrow.homMk'_mk_comp
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) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S : D} {Y Y' Y'' : C} {T : CategoryTheory.Functor C D} (f : S ⟶ T.obj Y) (g : Y ⟶ Y') (g' : Y' ⟶ Y'')
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 ⋯))
-- CategoryTheory.StructuredArrow.mkPostcomp_left
@[simps]
def mkPostcomp (f : S ⟶ T.obj Y) (g : Y ⟶ Y') : mk f ⟶ mk (f ≫ T.map g) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S : D} {Y Y' : C} {T : CategoryTheory.Functor C D} (f : S ⟶ T.obj Y) (g : Y ⟶ Y')
Goal: (CategoryTheory.StructuredArrow.mkPostcomp f g).left =
  CategoryTheory.CategoryStruct.id (CategoryTheory.StructuredArrow.mk f).left
-- CategoryTheory.StructuredArrow.mkPostcomp_right
@[simps]
def mkPostcomp (f : S ⟶ T.obj Y) (g : Y ⟶ Y') : mk f ⟶ mk (f ≫ T.map g) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S : D} {Y Y' : C} {T : CategoryTheory.Functor C D} (f : S ⟶ T.obj Y) (g : Y ⟶ Y')
Goal: (CategoryTheory.StructuredArrow.mkPostcomp f g).right = g
-- CategoryTheory.StructuredArrow.mkPostcomp_id
lemma mkPostcomp_id (f : S ⟶ T.obj Y) : mkPostcomp f (𝟙 Y) = eqToHom (by aesop_cat) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S : D} {Y : C} {T : CategoryTheory.Functor C D} (f : S ⟶ T.obj Y)
Goal: CategoryTheory.StructuredArrow.mkPostcomp f (CategoryTheory.CategoryStruct.id Y) = CategoryTheory.eqToHom ⋯
-- CategoryTheory.StructuredArrow.mkPostcomp_comp
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) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S : D} {Y Y' Y'' : C} {T : CategoryTheory.Functor C D} (f : S ⟶ T.obj Y) (g : Y ⟶ Y') (g' : Y' ⟶ Y'')
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 ⋯))