ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Idempotents.Karoubi.coe_p
@[simp]
theorem coe_p (X : C) : (X : Karoubi C).p = 𝟙 X 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] (X : C)
Goal: { X := X, p := CategoryTheory.CategoryStruct.id X, idem := ⋯ }.p = CategoryTheory.CategoryStruct.id X
-- CategoryTheory.Idempotents.Karoubi.eqToHom_f
@[simp]
theorem eqToHom_f {P Q : Karoubi C} (h : P = Q) :
    Karoubi.Hom.f (eqToHom h) = P.p ≫ eqToHom (congr_arg Karoubi.X h) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {P Q : CategoryTheory.Idempotents.Karoubi C} (h : P = Q)
Goal: (CategoryTheory.eqToHom h).f = CategoryTheory.CategoryStruct.comp P.p (CategoryTheory.eqToHom ⋯)
-- CategoryTheory.Idempotents.toKaroubi_obj_p
@[simps]
def toKaroubi : C ⥤ Karoubi C 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C] (X : C)
Goal: ((CategoryTheory.Idempotents.toKaroubi C).obj X).p = CategoryTheory.CategoryStruct.id X
-- CategoryTheory.Idempotents.toKaroubi_map_f
@[simps]
def toKaroubi : C ⥤ Karoubi C 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C]
Goal: ∀ {X Y : C} (f : X ⟶ Y), ((CategoryTheory.Idempotents.toKaroubi C).map f).f = f
-- CategoryTheory.Idempotents.toKaroubi_obj_X
@[simps]
def toKaroubi : C ⥤ Karoubi C 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C] (X : C)
Goal: ((CategoryTheory.Idempotents.toKaroubi C).obj X).X = X
-- CategoryTheory.Idempotents.instAdd_add
@[simps add]
instance instAdd [Preadditive C] {P Q : Karoubi C} : Add (P ⟶ Q) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Preadditive C] {P Q : CategoryTheory.Idempotents.Karoubi C} (f g : P ⟶ Q)
Goal: f + g = { f := f.f + g.f, comm := ⋯ }
-- CategoryTheory.Idempotents.instNeg_neg
@[simps neg]
instance instNeg [Preadditive C] {P Q : Karoubi C} : Neg (P ⟶ Q) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Preadditive C] {P Q : CategoryTheory.Idempotents.Karoubi C} (f : P ⟶ Q)
Goal: -f = { f := -f.f, comm := ⋯ }
-- CategoryTheory.Idempotents.instZero_zero
@[simps zero]
instance instZero [Preadditive C] {P Q : Karoubi C} : Zero (P ⟶ Q) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Preadditive C] {P Q : CategoryTheory.Idempotents.Karoubi C}
Goal: 0 = { f := 0, comm := ⋯ }
-- CategoryTheory.Idempotents.Karoubi.hom_eq_zero_iff
theorem hom_eq_zero_iff [Preadditive C] {P Q : Karoubi C} {f : P ⟶ Q} : f = 0 ↔ f.f = 0 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Preadditive C] {P Q : CategoryTheory.Idempotents.Karoubi C} {f : P ⟶ Q}
Goal: f = 0 ↔ f.f = 0
-- CategoryTheory.Idempotents.Karoubi.inclusionHom_apply
@[simps]
def inclusionHom [Preadditive C] (P Q : Karoubi C) : AddMonoidHom (P ⟶ Q) (P.X ⟶ Q.X) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Preadditive C] (P Q : CategoryTheory.Idempotents.Karoubi C) (f : P ⟶ Q)
Goal: (P.inclusionHom Q) f = f.f
-- CategoryTheory.Idempotents.Karoubi.sum_hom
@[simp]
theorem sum_hom [Preadditive C] {P Q : Karoubi C} {α : Type*} (s : Finset α) (f : α → (P ⟶ Q)) :
    (∑ x ∈ s, f x).f = ∑ x ∈ s, (f x).f 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Preadditive C] {P Q : CategoryTheory.Idempotents.Karoubi C} {α : Type u_2} (s : Finset α) (f : α → (P ⟶ Q))
Goal: (∑ x ∈ s, f x).f = ∑ x ∈ s, (f x).f
-- CategoryTheory.Idempotents.Karoubi.decompId_i_f
@[simps]
def decompId_i (P : Karoubi C) : P ⟶ P.X 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] (P : CategoryTheory.Idempotents.Karoubi C)
Goal: P.decompId_i.f = P.p
-- CategoryTheory.Idempotents.Karoubi.decompId_p_f
@[simps]
def decompId_p (P : Karoubi C) : (P.X : Karoubi C) ⟶ P 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] (P : CategoryTheory.Idempotents.Karoubi C)
Goal: P.decompId_p.f = P.p
-- CategoryTheory.Idempotents.Karoubi.decompId
@[reassoc]
theorem decompId (P : Karoubi C) : 𝟙 P = decompId_i P ≫ decompId_p P 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] (P : CategoryTheory.Idempotents.Karoubi C)
Goal: CategoryTheory.CategoryStruct.id P = CategoryTheory.CategoryStruct.comp P.decompId_i P.decompId_p
-- CategoryTheory.Idempotents.Karoubi.decomp_p
theorem decomp_p (P : Karoubi C) : (toKaroubi C).map P.p = decompId_p P ≫ decompId_i P 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] (P : CategoryTheory.Idempotents.Karoubi C)
Goal: (CategoryTheory.Idempotents.toKaroubi C).map P.p = CategoryTheory.CategoryStruct.comp P.decompId_p P.decompId_i
-- CategoryTheory.Idempotents.Karoubi.decompId_i_toKaroubi
theorem decompId_i_toKaroubi (X : C) : decompId_i ((toKaroubi C).obj X) = 𝟙 _ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] (X : C)
Goal: ((CategoryTheory.Idempotents.toKaroubi C).obj X).decompId_i =
  CategoryTheory.CategoryStruct.id ((CategoryTheory.Idempotents.toKaroubi C).obj X)
-- CategoryTheory.Idempotents.Karoubi.decompId_p_toKaroubi
theorem decompId_p_toKaroubi (X : C) : decompId_p ((toKaroubi C).obj X) = 𝟙 _ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] (X : C)
Goal: ((CategoryTheory.Idempotents.toKaroubi C).obj X).decompId_p =
  CategoryTheory.CategoryStruct.id
    { X := ((CategoryTheory.Idempotents.toKaroubi C).obj X).X,
      p := CategoryTheory.CategoryStruct.id ((CategoryTheory.Idempotents.toKaroubi C).obj X).X, idem := ⋯ }
-- CategoryTheory.Idempotents.Karoubi.decompId_i_naturality
theorem decompId_i_naturality {P Q : Karoubi C} (f : P ⟶ Q) :
    f ≫ decompId_i Q = decompId_i P ≫ (by exact Hom.mk f.f (by simp)) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {P Q : CategoryTheory.Idempotents.Karoubi C} (f : P ⟶ Q)
Goal: CategoryTheory.CategoryStruct.comp f Q.decompId_i =
  CategoryTheory.CategoryStruct.comp P.decompId_i { f := f.f, comm := ⋯ }
-- CategoryTheory.Idempotents.Karoubi.decompId_p_naturality
theorem decompId_p_naturality {P Q : Karoubi C} (f : P ⟶ Q) :
    decompId_p P ≫ f = (by exact Hom.mk f.f (by simp)) ≫ decompId_p Q 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {P Q : CategoryTheory.Idempotents.Karoubi C} (f : P ⟶ Q)
Goal: CategoryTheory.CategoryStruct.comp P.decompId_p f =
  CategoryTheory.CategoryStruct.comp { f := f.f, comm := ⋯ } Q.decompId_p
-- CategoryTheory.Idempotents.Karoubi.zsmul_hom
@[simp]
theorem zsmul_hom [Preadditive C] {P Q : Karoubi C} (n : ℤ) (f : P ⟶ Q) : (n • f).f = n • f.f 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Preadditive C] {P Q : CategoryTheory.Idempotents.Karoubi C} (n : ℤ) (f : P ⟶ Q)
Goal: (n • f).f = n • f.f
-- CategoryTheory.Cat.HasLimits.homDiagram_map
@[simps]
def homDiagram {F : J ⥤ Cat.{v, v}} (X Y : limit (F ⋙ Cat.objects.{v, v})) : J ⥤ Type v 
Arguments: {J : Type v} [CategoryTheory.SmallCategory J] {F : CategoryTheory.Functor J CategoryTheory.Cat} (X Y : CategoryTheory.Limits.limit (F.comp CategoryTheory.Cat.objects))
Goal: ∀ {X_1 Y_1 : J} (f : X_1 ⟶ Y_1)
  (g :
    CategoryTheory.Limits.limit.π (F.comp CategoryTheory.Cat.objects) X_1 X ⟶
      CategoryTheory.Limits.limit.π (F.comp CategoryTheory.Cat.objects) X_1 Y),
  (CategoryTheory.Cat.HasLimits.homDiagram X Y).map f g =
    CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯)
      (CategoryTheory.CategoryStruct.comp ((F.map f).map g) (CategoryTheory.eqToHom ⋯))
-- CategoryTheory.Cat.HasLimits.homDiagram_obj
@[simps]
def homDiagram {F : J ⥤ Cat.{v, v}} (X Y : limit (F ⋙ Cat.objects.{v, v})) : J ⥤ Type v 
Arguments: {J : Type v} [CategoryTheory.SmallCategory J] {F : CategoryTheory.Functor J CategoryTheory.Cat} (X Y : CategoryTheory.Limits.limit (F.comp CategoryTheory.Cat.objects)) (j : J)
Goal: (CategoryTheory.Cat.HasLimits.homDiagram X Y).obj j =
  (CategoryTheory.Limits.limit.π (F.comp CategoryTheory.Cat.objects) j X ⟶
    CategoryTheory.Limits.limit.π (F.comp CategoryTheory.Cat.objects) j Y)
-- CategoryTheory.Cat.HasLimits.instCategoryLimitCompObjects_id
@[simps]
instance (F : J ⥤ Cat.{v, v}) : Category (limit (F ⋙ Cat.objects)) 
Arguments: {J : Type v} [CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J CategoryTheory.Cat) (X : CategoryTheory.Limits.limit (F.comp CategoryTheory.Cat.objects))
Goal: CategoryTheory.CategoryStruct.id X =
  CategoryTheory.Limits.Types.Limit.mk (CategoryTheory.Cat.HasLimits.homDiagram X X)
    (fun j => CategoryTheory.CategoryStruct.id (CategoryTheory.Limits.limit.π (F.comp CategoryTheory.Cat.objects) j X))
    ⋯
-- CategoryTheory.Cat.HasLimits.instCategoryLimitCompObjects_comp
@[simps]
instance (F : J ⥤ Cat.{v, v}) : Category (limit (F ⋙ Cat.objects)) 
Arguments: {J : Type v} [CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J CategoryTheory.Cat) {X Y Z : CategoryTheory.Limits.limit (F.comp CategoryTheory.Cat.objects)} (f : X ⟶ Y) (g : Y ⟶ Z)
Goal: CategoryTheory.CategoryStruct.comp f g =
  CategoryTheory.Limits.Types.Limit.mk (CategoryTheory.Cat.HasLimits.homDiagram X Z)
    (fun j =>
      CategoryTheory.CategoryStruct.comp
        (CategoryTheory.Limits.limit.π (CategoryTheory.Cat.HasLimits.homDiagram X Y) j f)
        (CategoryTheory.Limits.limit.π (CategoryTheory.Cat.HasLimits.homDiagram Y Z) j g))
    ⋯
-- CategoryTheory.Cat.HasLimits.limitConeX_str
@[simps]
def limitConeX (F : J ⥤ Cat.{v, v}) : Cat.{v, v} 
Arguments: {J : Type v} [CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J CategoryTheory.Cat)
Goal: (CategoryTheory.Cat.HasLimits.limitConeX F).str = inferInstance
-- CategoryTheory.Cat.HasLimits.limitConeX_α
@[simps]
def limitConeX (F : J ⥤ Cat.{v, v}) : Cat.{v, v} 
Arguments: {J : Type v} [CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J CategoryTheory.Cat)
Goal: ↑(CategoryTheory.Cat.HasLimits.limitConeX F) = CategoryTheory.Limits.limit (F.comp CategoryTheory.Cat.objects)
-- CategoryTheory.Cat.HasLimits.limitCone_π_app_map
@[simps]
def limitCone (F : J ⥤ Cat.{v, v}) : Cone F 
Arguments: {J : Type v} [CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J CategoryTheory.Cat) (j : J)
Goal: ∀ {X Y : ↑(((CategoryTheory.Functor.const J).obj (CategoryTheory.Cat.HasLimits.limitConeX F)).obj j)} (f : X ⟶ Y),
  ((CategoryTheory.Cat.HasLimits.limitCone F).π.app j).map f =
    CategoryTheory.Limits.limit.π (CategoryTheory.Cat.HasLimits.homDiagram X Y) j f
-- CategoryTheory.Cat.HasLimits.limitCone_π_app_obj
@[simps]
def limitCone (F : J ⥤ Cat.{v, v}) : Cone F 
Arguments: {J : Type v} [CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J CategoryTheory.Cat) (j : J)
Goal: ∀ (a : CategoryTheory.Limits.limit (F.comp CategoryTheory.Cat.objects)),
  ((CategoryTheory.Cat.HasLimits.limitCone F).π.app j).obj a =
    CategoryTheory.Limits.limit.π (F.comp CategoryTheory.Cat.objects) j a
-- CategoryTheory.Cat.HasLimits.limitCone_pt
@[simps]
def limitCone (F : J ⥤ Cat.{v, v}) : Cone F 
Arguments: {J : Type v} [CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J CategoryTheory.Cat)
Goal: (CategoryTheory.Cat.HasLimits.limitCone F).pt = CategoryTheory.Cat.HasLimits.limitConeX F
-- CategoryTheory.Cat.HasLimits.limitConeLift_obj
@[simps]
def limitConeLift (F : J ⥤ Cat.{v, v}) (s : Cone F) : s.pt ⟶ limitConeX F 
Arguments: {J : Type v} [CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J CategoryTheory.Cat) (s : CategoryTheory.Limits.Cone F)
Goal: ∀ (a : { pt := ↑s.pt, π := { app := fun j => (s.π.app j).obj, naturality := ⋯ } }.pt),
  (CategoryTheory.Cat.HasLimits.limitConeLift F s).obj a =
    CategoryTheory.Limits.limit.lift (F.comp CategoryTheory.Cat.objects)
      { pt := ↑s.pt, π := { app := fun j => (s.π.app j).obj, naturality := ⋯ } } a
-- CategoryTheory.Cat.HasLimits.limitConeLift_map
@[simps]
def limitConeLift (F : J ⥤ Cat.{v, v}) (s : Cone F) : s.pt ⟶ limitConeX F 
Arguments: {J : Type v} [CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J CategoryTheory.Cat) (s : CategoryTheory.Limits.Cone F)
Goal: ∀ {X Y : ↑s.pt} (f : X ⟶ Y),
  (CategoryTheory.Cat.HasLimits.limitConeLift F s).map f =
    CategoryTheory.Limits.Types.Limit.mk
      (CategoryTheory.Cat.HasLimits.homDiagram
        (CategoryTheory.Limits.limit.lift (F.comp CategoryTheory.Cat.objects)
          { pt := ↑s.pt, π := { app := fun j => (s.π.app j).obj, naturality := ⋯ } } X)
        (CategoryTheory.Limits.limit.lift (F.comp CategoryTheory.Cat.objects)
          { pt := ↑s.pt, π := { app := fun j => (s.π.app j).obj, naturality := ⋯ } } Y))
      (fun j =>
        CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯)
          (CategoryTheory.CategoryStruct.comp ((s.π.app j).map f) (CategoryTheory.eqToHom ⋯)))
      ⋯
-- CategoryTheory.Cat.HasLimits.limit_π_homDiagram_eqToHom
@[simp]
theorem limit_π_homDiagram_eqToHom {F : J ⥤ Cat.{v, v}} (X Y : limit (F ⋙ Cat.objects.{v, v}))
    (j : J) (h : X = Y) :
    limit.π (homDiagram X Y) j (eqToHom h) =
      eqToHom (congr_arg (limit.π (F ⋙ Cat.objects.{v, v}) j) h) 
Arguments: {J : Type v} [CategoryTheory.SmallCategory J] {F : CategoryTheory.Functor J CategoryTheory.Cat} (X Y : CategoryTheory.Limits.limit (F.comp CategoryTheory.Cat.objects)) (j : J) (h : X = Y)
Goal: CategoryTheory.Limits.limit.π (CategoryTheory.Cat.HasLimits.homDiagram X Y) j (CategoryTheory.eqToHom h) =
  CategoryTheory.eqToHom ⋯
-- CategoryTheory.CommaMorphism.w
@[ext]
structure CommaMorphism (X Y : Comma L R) where
  left : X.left ⟶ Y.left
  right : X.right ⟶ Y.right
  w : L.map left ≫ Y.hom = X.hom ≫ R.map right := by aesop_cat
Arguments: {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [CategoryTheory.Category.{v₂, u₂} B] {T : Type u₃} [CategoryTheory.Category.{v₃, u₃} T] {L : CategoryTheory.Functor A T} {R : CategoryTheory.Functor B T} {X Y : CategoryTheory.Comma L R} (self : CategoryTheory.CommaMorphism X Y)
Goal: CategoryTheory.CategoryStruct.comp (L.map self.left) Y.hom = CategoryTheory.CategoryStruct.comp X.hom (R.map self.right)
-- CategoryTheory.Comma.hom_ext
@[ext]
lemma hom_ext (f g : X ⟶ Y) (h₁ : f.left = g.left) (h₂ : f.right = g.right) : f = g 
Arguments: {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [CategoryTheory.Category.{v₂, u₂} B] {T : Type u₃} [CategoryTheory.Category.{v₃, u₃} T] {L : CategoryTheory.Functor A T} {R : CategoryTheory.Functor B T} {X Y : CategoryTheory.Comma L R} (f g : X ⟶ Y) (h₁ : f.left = g.left) (h₂ : f.right = g.right)
Goal: f = g
-- CategoryTheory.Comma.id_left
@[simp]
theorem id_left : (𝟙 X : CommaMorphism X X).left = 𝟙 X.left 
Arguments: {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [CategoryTheory.Category.{v₂, u₂} B] {T : Type u₃} [CategoryTheory.Category.{v₃, u₃} T] {L : CategoryTheory.Functor A T} {R : CategoryTheory.Functor B T} {X : CategoryTheory.Comma L R}
Goal: (CategoryTheory.CategoryStruct.id X).left = CategoryTheory.CategoryStruct.id X.left
-- CategoryTheory.Comma.id_right
@[simp]
theorem id_right : (𝟙 X : CommaMorphism X X).right = 𝟙 X.right 
Arguments: {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [CategoryTheory.Category.{v₂, u₂} B] {T : Type u₃} [CategoryTheory.Category.{v₃, u₃} T] {L : CategoryTheory.Functor A T} {R : CategoryTheory.Functor B T} {X : CategoryTheory.Comma L R}
Goal: (CategoryTheory.CategoryStruct.id X).right = CategoryTheory.CategoryStruct.id X.right
-- CategoryTheory.Comma.comp_left
@[simp]
theorem comp_left : (f ≫ g).left = f.left ≫ g.left 
Arguments: {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [CategoryTheory.Category.{v₂, u₂} B] {T : Type u₃} [CategoryTheory.Category.{v₃, u₃} T] {L : CategoryTheory.Functor A T} {R : CategoryTheory.Functor B T} {X Y Z : CategoryTheory.Comma L R} {f : X ⟶ Y} {g : Y ⟶ Z}
Goal: (CategoryTheory.CategoryStruct.comp f g).left = CategoryTheory.CategoryStruct.comp f.left g.left
-- CategoryTheory.Comma.comp_right
@[simp]
theorem comp_right : (f ≫ g).right = f.right ≫ g.right 
Arguments: {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [CategoryTheory.Category.{v₂, u₂} B] {T : Type u₃} [CategoryTheory.Category.{v₃, u₃} T] {L : CategoryTheory.Functor A T} {R : CategoryTheory.Functor B T} {X Y Z : CategoryTheory.Comma L R} {f : X ⟶ Y} {g : Y ⟶ Z}
Goal: (CategoryTheory.CategoryStruct.comp f g).right = CategoryTheory.CategoryStruct.comp f.right g.right
-- CategoryTheory.Comma.fst_obj
@[simps]
def fst : Comma L R ⥤ A 
Arguments: {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [CategoryTheory.Category.{v₂, u₂} B] {T : Type u₃} [CategoryTheory.Category.{v₃, u₃} T] (L : CategoryTheory.Functor A T) (R : CategoryTheory.Functor B T) (X : CategoryTheory.Comma L R)
Goal: (CategoryTheory.Comma.fst L R).obj X = X.left
-- CategoryTheory.Comma.fst_map
@[simps]
def fst : Comma L R ⥤ A 
Arguments: {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [CategoryTheory.Category.{v₂, u₂} B] {T : Type u₃} [CategoryTheory.Category.{v₃, u₃} T] (L : CategoryTheory.Functor A T) (R : CategoryTheory.Functor B T)
Goal: ∀ {X Y : CategoryTheory.Comma L R} (f : X ⟶ Y), (CategoryTheory.Comma.fst L R).map f = f.left
-- CategoryTheory.Comma.snd_obj
@[simps]
def snd : Comma L R ⥤ B 
Arguments: {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [CategoryTheory.Category.{v₂, u₂} B] {T : Type u₃} [CategoryTheory.Category.{v₃, u₃} T] (L : CategoryTheory.Functor A T) (R : CategoryTheory.Functor B T) (X : CategoryTheory.Comma L R)
Goal: (CategoryTheory.Comma.snd L R).obj X = X.right
-- CategoryTheory.Comma.snd_map
@[simps]
def snd : Comma L R ⥤ B 
Arguments: {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [CategoryTheory.Category.{v₂, u₂} B] {T : Type u₃} [CategoryTheory.Category.{v₃, u₃} T] (L : CategoryTheory.Functor A T) (R : CategoryTheory.Functor B T)
Goal: ∀ {X Y : CategoryTheory.Comma L R} (f : X ⟶ Y), (CategoryTheory.Comma.snd L R).map f = f.right
-- CategoryTheory.Comma.natTrans_app
@[simps]
def natTrans : fst L R ⋙ L ⟶ snd L R ⋙ R 
Arguments: {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [CategoryTheory.Category.{v₂, u₂} B] {T : Type u₃} [CategoryTheory.Category.{v₃, u₃} T] (L : CategoryTheory.Functor A T) (R : CategoryTheory.Functor B T) (X : CategoryTheory.Comma L R)
Goal: (CategoryTheory.Comma.natTrans L R).app X = X.hom
-- CategoryTheory.Comma.eqToHom_left
@[simp]
theorem eqToHom_left (X Y : Comma L R) (H : X = Y) :
    CommaMorphism.left (eqToHom H) = eqToHom (by cases H; rfl) 
Arguments: {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [CategoryTheory.Category.{v₂, u₂} B] {T : Type u₃} [CategoryTheory.Category.{v₃, u₃} T] (L : CategoryTheory.Functor A T) (R : CategoryTheory.Functor B T) (X Y : CategoryTheory.Comma L R) (H : X = Y)
Goal: (CategoryTheory.eqToHom H).left = CategoryTheory.eqToHom ⋯
-- CategoryTheory.Comma.eqToHom_right
@[simp]
theorem eqToHom_right (X Y : Comma L R) (H : X = Y) :
    CommaMorphism.right (eqToHom H) = eqToHom (by cases H; rfl) 
Arguments: {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [CategoryTheory.Category.{v₂, u₂} B] {T : Type u₃} [CategoryTheory.Category.{v₃, u₃} T] (L : CategoryTheory.Functor A T) (R : CategoryTheory.Functor B T) (X Y : CategoryTheory.Comma L R) (H : X = Y)
Goal: (CategoryTheory.eqToHom H).right = CategoryTheory.eqToHom ⋯
-- CategoryTheory.Comma.leftIso_inv
@[simps!]
def leftIso {X Y : Comma L₁ R₁} (α : X ≅ Y) : X.left ≅ Y.left 
Arguments: {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [CategoryTheory.Category.{v₂, u₂} B] {T : Type u₃} [CategoryTheory.Category.{v₃, u₃} T] {L₁ : CategoryTheory.Functor A T} {R₁ : CategoryTheory.Functor B T} {X Y : CategoryTheory.Comma L₁ R₁} (α : X ≅ Y)
Goal: (CategoryTheory.Comma.leftIso α).inv = α.inv.left
-- CategoryTheory.Comma.leftIso_hom
@[simps!]
def leftIso {X Y : Comma L₁ R₁} (α : X ≅ Y) : X.left ≅ Y.left 
Arguments: {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [CategoryTheory.Category.{v₂, u₂} B] {T : Type u₃} [CategoryTheory.Category.{v₃, u₃} T] {L₁ : CategoryTheory.Functor A T} {R₁ : CategoryTheory.Functor B T} {X Y : CategoryTheory.Comma L₁ R₁} (α : X ≅ Y)
Goal: (CategoryTheory.Comma.leftIso α).hom = α.hom.left
-- CategoryTheory.Comma.rightIso_hom
@[simps!]
def rightIso {X Y : Comma L₁ R₁} (α : X ≅ Y) : X.right ≅ Y.right 
Arguments: {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [CategoryTheory.Category.{v₂, u₂} B] {T : Type u₃} [CategoryTheory.Category.{v₃, u₃} T] {L₁ : CategoryTheory.Functor A T} {R₁ : CategoryTheory.Functor B T} {X Y : CategoryTheory.Comma L₁ R₁} (α : X ≅ Y)
Goal: (CategoryTheory.Comma.rightIso α).hom = α.hom.right
-- CategoryTheory.Comma.rightIso_inv
@[simps!]
def rightIso {X Y : Comma L₁ R₁} (α : X ≅ Y) : X.right ≅ Y.right 
Arguments: {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [CategoryTheory.Category.{v₂, u₂} B] {T : Type u₃} [CategoryTheory.Category.{v₃, u₃} T] {L₁ : CategoryTheory.Functor A T} {R₁ : CategoryTheory.Functor B T} {X Y : CategoryTheory.Comma L₁ R₁} (α : X ≅ Y)
Goal: (CategoryTheory.Comma.rightIso α).inv = α.inv.right
-- CategoryTheory.Comma.isoMk_hom_right
@[simps]
def isoMk {X Y : Comma L₁ R₁} (l : X.left ≅ Y.left) (r : X.right ≅ Y.right)
    (h : L₁.map l.hom ≫ Y.hom = X.hom ≫ R₁.map r.hom := by aesop_cat) : X ≅ Y 
Arguments: {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [CategoryTheory.Category.{v₂, u₂} B] {T : Type u₃} [CategoryTheory.Category.{v₃, u₃} T] {L₁ : CategoryTheory.Functor A T} {R₁ : CategoryTheory.Functor B T} {X Y : CategoryTheory.Comma L₁ R₁} (l : X.left ≅ Y.left) (r : X.right ≅ Y.right) (h :
  CategoryTheory.CategoryStruct.comp (L₁.map l.hom) Y.hom =
    CategoryTheory.CategoryStruct.comp X.hom (R₁.map r.hom) := by
  aesop_cat)
Goal: (CategoryTheory.Comma.isoMk l r h).hom.right = r.hom
-- CategoryTheory.Comma.isoMk_inv_right
@[simps]
def isoMk {X Y : Comma L₁ R₁} (l : X.left ≅ Y.left) (r : X.right ≅ Y.right)
    (h : L₁.map l.hom ≫ Y.hom = X.hom ≫ R₁.map r.hom := by aesop_cat) : X ≅ Y 
Arguments: {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [CategoryTheory.Category.{v₂, u₂} B] {T : Type u₃} [CategoryTheory.Category.{v₃, u₃} T] {L₁ : CategoryTheory.Functor A T} {R₁ : CategoryTheory.Functor B T} {X Y : CategoryTheory.Comma L₁ R₁} (l : X.left ≅ Y.left) (r : X.right ≅ Y.right) (h :
  CategoryTheory.CategoryStruct.comp (L₁.map l.hom) Y.hom =
    CategoryTheory.CategoryStruct.comp X.hom (R₁.map r.hom) := by
  aesop_cat)
Goal: (CategoryTheory.Comma.isoMk l r h).inv.right = r.inv
-- CategoryTheory.Comma.isoMk_inv_left
@[simps]
def isoMk {X Y : Comma L₁ R₁} (l : X.left ≅ Y.left) (r : X.right ≅ Y.right)
    (h : L₁.map l.hom ≫ Y.hom = X.hom ≫ R₁.map r.hom := by aesop_cat) : X ≅ Y 
Arguments: {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [CategoryTheory.Category.{v₂, u₂} B] {T : Type u₃} [CategoryTheory.Category.{v₃, u₃} T] {L₁ : CategoryTheory.Functor A T} {R₁ : CategoryTheory.Functor B T} {X Y : CategoryTheory.Comma L₁ R₁} (l : X.left ≅ Y.left) (r : X.right ≅ Y.right) (h :
  CategoryTheory.CategoryStruct.comp (L₁.map l.hom) Y.hom =
    CategoryTheory.CategoryStruct.comp X.hom (R₁.map r.hom) := by
  aesop_cat)
Goal: (CategoryTheory.Comma.isoMk l r h).inv.left = l.inv
-- CategoryTheory.Comma.isoMk_hom_left
@[simps]
def isoMk {X Y : Comma L₁ R₁} (l : X.left ≅ Y.left) (r : X.right ≅ Y.right)
    (h : L₁.map l.hom ≫ Y.hom = X.hom ≫ R₁.map r.hom := by aesop_cat) : X ≅ Y 
Arguments: {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [CategoryTheory.Category.{v₂, u₂} B] {T : Type u₃} [CategoryTheory.Category.{v₃, u₃} T] {L₁ : CategoryTheory.Functor A T} {R₁ : CategoryTheory.Functor B T} {X Y : CategoryTheory.Comma L₁ R₁} (l : X.left ≅ Y.left) (r : X.right ≅ Y.right) (h :
  CategoryTheory.CategoryStruct.comp (L₁.map l.hom) Y.hom =
    CategoryTheory.CategoryStruct.comp X.hom (R₁.map r.hom) := by
  aesop_cat)
Goal: (CategoryTheory.Comma.isoMk l r h).hom.left = l.hom