ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.PreGaloisCategory.non_zero_card_fiber_of_not_initial
lemma non_zero_card_fiber_of_not_initial (X : C) (h : IsInitial X → False) :
    Nat.card (F.obj X) ≠ 0 
Arguments: {C : Type u₁} [CategoryTheory.Category.{u₂, u₁} C] [CategoryTheory.PreGaloisCategory C] (F : CategoryTheory.Functor C FintypeCat) [CategoryTheory.PreGaloisCategory.FiberFunctor F] (X : C) (h : CategoryTheory.Limits.IsInitial X → False)
Goal: Nat.card ↑(F.obj X) ≠ 0
-- CategoryTheory.PreGaloisCategory.card_fiber_coprod_eq_sum
lemma card_fiber_coprod_eq_sum (X Y : C) :
    Nat.card (F.obj (X ⨿ Y)) = Nat.card (F.obj X) + Nat.card (F.obj Y) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{u₂, u₁} C] [CategoryTheory.PreGaloisCategory C] (F : CategoryTheory.Functor C FintypeCat) [CategoryTheory.PreGaloisCategory.FiberFunctor F] (X Y : C)
Goal: Nat.card ↑(F.obj (X ⨿ Y)) = Nat.card ↑(F.obj X) + Nat.card ↑(F.obj Y)
-- CategoryTheory.PreGaloisCategory.card_fiber_eq_of_iso
lemma card_fiber_eq_of_iso {X Y : C} (i : X ≅ Y) : Nat.card (F.obj X) = Nat.card (F.obj Y) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{u₂, u₁} C] (F : CategoryTheory.Functor C FintypeCat) {X Y : C} (i : X ≅ Y)
Goal: Nat.card ↑(F.obj X) = Nat.card ↑(F.obj Y)
-- CategoryTheory.PreGaloisCategory.card_hom_le_card_fiber_of_connected
lemma card_hom_le_card_fiber_of_connected (A X : C) [IsConnected A] :
    Nat.card (A ⟶ X) ≤ Nat.card (F.obj X) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{u₂, u₁} C] [CategoryTheory.PreGaloisCategory C] (F : CategoryTheory.Functor C FintypeCat) [CategoryTheory.PreGaloisCategory.FiberFunctor F] (A X : C) [CategoryTheory.PreGaloisCategory.IsConnected A]
Goal: Nat.card (A ⟶ X) ≤ Nat.card ↑(F.obj X)
-- CategoryTheory.PreGaloisCategory.card_aut_le_card_fiber_of_connected
lemma card_aut_le_card_fiber_of_connected (A : C) [IsConnected A] :
    Nat.card (Aut A) ≤ Nat.card (F.obj A) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{u₂, u₁} C] [CategoryTheory.PreGaloisCategory C] (F : CategoryTheory.Functor C FintypeCat) [CategoryTheory.PreGaloisCategory.FiberFunctor F] (A : C) [CategoryTheory.PreGaloisCategory.IsConnected A]
Goal: Nat.card (CategoryTheory.Aut A) ≤ Nat.card ↑(F.obj A)
-- CategoryTheory.GaloisCategory.hasFiberFunctor
class GaloisCategory (C : Type u₁) [Category.{u₂, u₁} C]
    extends PreGaloisCategory C : Prop where
  hasFiberFunctor : ∃ F : C ⥤ FintypeCat.{u₂}, Nonempty (PreGaloisCategory.FiberFunctor F)
Arguments: {C : Type u₁} [CategoryTheory.Category.{u₂, u₁} C] [self : CategoryTheory.GaloisCategory C]
Goal: ∃ F, Nonempty (CategoryTheory.PreGaloisCategory.FiberFunctor F)
-- CategoryTheory.Adjunction.gc
theorem Adjunction.gc {L : X ⥤ Y} {R : Y ⥤ X} (adj : L ⊣ R) : GaloisConnection L.obj R.obj 
Arguments: {X : Type u} {Y : Type v} [Preorder X] [Preorder Y] {L : CategoryTheory.Functor X Y} {R : CategoryTheory.Functor Y X} (adj : L ⊣ R)
Goal: GaloisConnection L.obj R.obj
-- CategoryTheory.evaluationLeftAdjoint_obj_map
@[simps]
def evaluationLeftAdjoint (c : C) : D ⥤ C ⥤ D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] [∀ (a b : C), CategoryTheory.Limits.HasCoproductsOfShape (a ⟶ b) D] (c : C) (d : D)
Goal: ∀ {X Y : C} (f : X ⟶ Y),
  ((CategoryTheory.evaluationLeftAdjoint D c).obj d).map f =
    CategoryTheory.Limits.Sigma.desc fun g =>
      CategoryTheory.Limits.Sigma.ι (fun x => d) (CategoryTheory.CategoryStruct.comp g f)
-- CategoryTheory.evaluationLeftAdjoint_obj_obj
@[simps]
def evaluationLeftAdjoint (c : C) : D ⥤ C ⥤ D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] [∀ (a b : C), CategoryTheory.Limits.HasCoproductsOfShape (a ⟶ b) D] (c : C) (d : D) (t : C)
Goal: ((CategoryTheory.evaluationLeftAdjoint D c).obj d).obj t = ∐ fun x => d
-- CategoryTheory.evaluationLeftAdjoint_map_app
@[simps]
def evaluationLeftAdjoint (c : C) : D ⥤ C ⥤ D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] [∀ (a b : C), CategoryTheory.Limits.HasCoproductsOfShape (a ⟶ b) D] (c : C)
Goal: ∀ {x d₂ : D} (f : x ⟶ d₂) (e : C),
  ((CategoryTheory.evaluationLeftAdjoint D c).map f).app e =
    CategoryTheory.Limits.Sigma.desc fun h =>
      CategoryTheory.CategoryStruct.comp f (CategoryTheory.Limits.Sigma.ι (fun x => d₂) h)
-- CategoryTheory.evaluationAdjunctionRight_counit_app_app
@[simps! unit_app counit_app_app]
def evaluationAdjunctionRight (c : C) : evaluationLeftAdjoint D c ⊣ (evaluation _ _).obj c 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] [∀ (a b : C), CategoryTheory.Limits.HasCoproductsOfShape (a ⟶ b) D] (c : C) (Y : CategoryTheory.Functor C D) (e : C)
Goal: ((CategoryTheory.evaluationAdjunctionRight D c).counit.app Y).app e = CategoryTheory.Limits.Sigma.desc fun h => Y.map h
-- CategoryTheory.evaluationAdjunctionRight_unit_app
@[simps! unit_app counit_app_app]
def evaluationAdjunctionRight (c : C) : evaluationLeftAdjoint D c ⊣ (evaluation _ _).obj c 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] [∀ (a b : C), CategoryTheory.Limits.HasCoproductsOfShape (a ⟶ b) D] (c : C) (X : D)
Goal: (CategoryTheory.evaluationAdjunctionRight D c).unit.app X =
  CategoryTheory.Limits.Sigma.ι (fun x => X) (CategoryTheory.CategoryStruct.id c)
-- CategoryTheory.NatTrans.mono_iff_mono_app
theorem NatTrans.mono_iff_mono_app {F G : C ⥤ D} (η : F ⟶ G) : Mono η ↔ ∀ c, Mono (η.app c) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] [∀ (a b : C), CategoryTheory.Limits.HasCoproductsOfShape (a ⟶ b) D] {F G : CategoryTheory.Functor C D} (η : F ⟶ G)
Goal: CategoryTheory.Mono η ↔ ∀ (c : C), CategoryTheory.Mono (η.app c)
-- CategoryTheory.evaluationRightAdjoint_map_app
@[simps]
def evaluationRightAdjoint (c : C) : D ⥤ C ⥤ D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] [∀ (a b : C), CategoryTheory.Limits.HasProductsOfShape (a ⟶ b) D] (c : C)
Goal: ∀ {X Y : D} (f : X ⟶ Y) (t : C),
  ((CategoryTheory.evaluationRightAdjoint D c).map f).app t =
    CategoryTheory.Limits.Pi.lift fun g =>
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Pi.π (fun x => X) g) f
-- CategoryTheory.evaluationRightAdjoint_obj_map
@[simps]
def evaluationRightAdjoint (c : C) : D ⥤ C ⥤ D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] [∀ (a b : C), CategoryTheory.Limits.HasProductsOfShape (a ⟶ b) D] (c : C) (d : D)
Goal: ∀ {X Y : C} (f : X ⟶ Y),
  ((CategoryTheory.evaluationRightAdjoint D c).obj d).map f =
    CategoryTheory.Limits.Pi.lift fun g =>
      CategoryTheory.Limits.Pi.π (fun x => d) (CategoryTheory.CategoryStruct.comp f g)
-- CategoryTheory.evaluationRightAdjoint_obj_obj
@[simps]
def evaluationRightAdjoint (c : C) : D ⥤ C ⥤ D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] [∀ (a b : C), CategoryTheory.Limits.HasProductsOfShape (a ⟶ b) D] (c : C) (d : D) (t : C)
Goal: ((CategoryTheory.evaluationRightAdjoint D c).obj d).obj t = ∏ᶜ fun x => d
-- CategoryTheory.evaluationAdjunctionLeft_counit_app
@[simps! unit_app_app counit_app]
def evaluationAdjunctionLeft (c : C) : (evaluation _ _).obj c ⊣ evaluationRightAdjoint D c 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] [∀ (a b : C), CategoryTheory.Limits.HasProductsOfShape (a ⟶ b) D] (c : C) (Y : D)
Goal: (CategoryTheory.evaluationAdjunctionLeft D c).counit.app Y =
  CategoryTheory.Limits.Pi.π (fun x => Y) (CategoryTheory.CategoryStruct.id c)
-- CategoryTheory.evaluationAdjunctionLeft_unit_app_app
@[simps! unit_app_app counit_app]
def evaluationAdjunctionLeft (c : C) : (evaluation _ _).obj c ⊣ evaluationRightAdjoint D c 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] [∀ (a b : C), CategoryTheory.Limits.HasProductsOfShape (a ⟶ b) D] (c : C) (X : CategoryTheory.Functor C D) (t : C)
Goal: ((CategoryTheory.evaluationAdjunctionLeft D c).unit.app X).app t = CategoryTheory.Limits.Pi.lift fun g => X.map g
-- CategoryTheory.NatTrans.epi_iff_epi_app
theorem NatTrans.epi_iff_epi_app {F G : C ⥤ D} (η : F ⟶ G) : Epi η ↔ ∀ c, Epi (η.app c) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] [∀ (a b : C), CategoryTheory.Limits.HasProductsOfShape (a ⟶ b) D] {F G : CategoryTheory.Functor C D} (η : F ⟶ G)
Goal: CategoryTheory.Epi η ↔ ∀ (c : C), CategoryTheory.Epi (η.app c)
-- CategoryTheory.Category.assoc
@[pp_with_univ]
class Category (obj : Type u) extends CategoryStruct.{v} obj : Type max u (v + 1) where
    id_comp : ∀ {X Y : obj} (f : X ⟶ Y), 𝟙 X ≫ f = f := by aesop_cat
    comp_id : ∀ {X Y : obj} (f : X ⟶ Y), f ≫ 𝟙 Y = f := by aesop_cat
    assoc : ∀ {W X Y Z : obj} (f : W ⟶ X) (g : X ⟶ Y) (h : Y ⟶ Z), (f ≫ g) ≫ h = f ≫ g ≫ h := by
    aesop_cat
Arguments: {obj : Type u} [self : CategoryTheory.Category.{v, u} obj] {W X Y Z : obj} (f : W ⟶ X) (g : X ⟶ Y) (h : Y ⟶ Z)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f g) h =
  CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp g h)
-- CategoryTheory.Category.comp_id
@[pp_with_univ]
class Category (obj : Type u) extends CategoryStruct.{v} obj : Type max u (v + 1) where
    id_comp : ∀ {X Y : obj} (f : X ⟶ Y), 𝟙 X ≫ f = f := by aesop_cat
    comp_id : ∀ {X Y : obj} (f : X ⟶ Y), f ≫ 𝟙 Y = f := by aesop_cat
    assoc : ∀ {W X Y Z : obj} (f : W ⟶ X) (g : X ⟶ Y) (h : Y ⟶ Z), (f ≫ g) ≫ h = f ≫ g ≫ h := by
    aesop_cat
Arguments: {obj : Type u} [self : CategoryTheory.Category.{v, u} obj] {X Y : obj} (f : X ⟶ Y)
Goal: CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.id Y) = f
-- CategoryTheory.Category.id_comp
@[pp_with_univ]
class Category (obj : Type u) extends CategoryStruct.{v} obj : Type max u (v + 1) where
    id_comp : ∀ {X Y : obj} (f : X ⟶ Y), 𝟙 X ≫ f = f := by aesop_cat
    comp_id : ∀ {X Y : obj} (f : X ⟶ Y), f ≫ 𝟙 Y = f := by aesop_cat
    assoc : ∀ {W X Y Z : obj} (f : W ⟶ X) (g : X ⟶ Y) (h : Y ⟶ Z), (f ≫ g) ≫ h = f ≫ g ≫ h := by
    aesop_cat
Arguments: {obj : Type u} [self : CategoryTheory.Category.{v, u} obj] {X Y : obj} (f : X ⟶ Y)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id X) f = f
-- CategoryTheory.eq_whisker
theorem eq_whisker {f g : X ⟶ Y} (w : f = g) (h : Y ⟶ Z) : f ≫ h = g ≫ h 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {f g : X ⟶ Y} (w : f = g) (h : Y ⟶ Z)
Goal: CategoryTheory.CategoryStruct.comp f h = CategoryTheory.CategoryStruct.comp g h
-- CategoryTheory.whisker_eq
theorem whisker_eq (f : X ⟶ Y) {g h : Y ⟶ Z} (w : g = h) : f ≫ g = f ≫ h 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Y) {g h : Y ⟶ Z} (w : g = h)
Goal: CategoryTheory.CategoryStruct.comp f g = CategoryTheory.CategoryStruct.comp f h
-- CategoryTheory.eq_of_comp_left_eq
theorem eq_of_comp_left_eq {f g : X ⟶ Y} (w : ∀ {Z : C} (h : Y ⟶ Z), f ≫ h = g ≫ h) :
    f = g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} (w : ∀ {Z : C} (h : Y ⟶ Z), CategoryTheory.CategoryStruct.comp f h = CategoryTheory.CategoryStruct.comp g h)
Goal: f = g
-- CategoryTheory.eq_of_comp_right_eq
theorem eq_of_comp_right_eq {f g : Y ⟶ Z} (w : ∀ {X : C} (h : X ⟶ Y), h ≫ f = h ≫ g) :
    f = g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {Y Z : C} {f g : Y ⟶ Z} (w : ∀ {X : C} (h : X ⟶ Y), CategoryTheory.CategoryStruct.comp h f = CategoryTheory.CategoryStruct.comp h g)
Goal: f = g
-- CategoryTheory.eq_of_comp_left_eq'
theorem eq_of_comp_left_eq' (f g : X ⟶ Y)
    (w : (fun {Z} (h : Y ⟶ Z) => f ≫ h) = fun {Z} (h : Y ⟶ Z) => g ≫ h) : f = g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f g : X ⟶ Y) (w : (fun {Z} h => CategoryTheory.CategoryStruct.comp f h) = fun {Z} h => CategoryTheory.CategoryStruct.comp g h)
Goal: f = g
-- CategoryTheory.eq_of_comp_right_eq'
theorem eq_of_comp_right_eq' (f g : Y ⟶ Z)
    (w : (fun {X} (h : X ⟶ Y) => h ≫ f) = fun {X} (h : X ⟶ Y) => h ≫ g) : f = g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {Y Z : C} (f g : Y ⟶ Z) (w : (fun {X} h => CategoryTheory.CategoryStruct.comp h f) = fun {X} h => CategoryTheory.CategoryStruct.comp h g)
Goal: f = g
-- CategoryTheory.id_of_comp_left_id
theorem id_of_comp_left_id (f : X ⟶ X) (w : ∀ {Y : C} (g : X ⟶ Y), f ≫ g = g) : f = 𝟙 X 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} (f : X ⟶ X) (w : ∀ {Y : C} (g : X ⟶ Y), CategoryTheory.CategoryStruct.comp f g = g)
Goal: f = CategoryTheory.CategoryStruct.id X
-- CategoryTheory.id_of_comp_right_id
theorem id_of_comp_right_id (f : X ⟶ X) (w : ∀ {Y : C} (g : Y ⟶ X), g ≫ f = g) : f = 𝟙 X 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} (f : X ⟶ X) (w : ∀ {Y : C} (g : Y ⟶ X), CategoryTheory.CategoryStruct.comp g f = g)
Goal: f = CategoryTheory.CategoryStruct.id X
-- CategoryTheory.comp_ite
theorem comp_ite {P : Prop} [Decidable P] {X Y Z : C} (f : X ⟶ Y) (g g' : Y ⟶ Z) :
    (f ≫ if P then g else g') = if P then f ≫ g else f ≫ g' 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {P : Prop} [Decidable P] {X Y Z : C} (f : X ⟶ Y) (g g' : Y ⟶ Z)
Goal: CategoryTheory.CategoryStruct.comp f (if P then g else g') =
  if P then CategoryTheory.CategoryStruct.comp f g else CategoryTheory.CategoryStruct.comp f g'
-- CategoryTheory.ite_comp
theorem ite_comp {P : Prop} [Decidable P] {X Y Z : C} (f f' : X ⟶ Y) (g : Y ⟶ Z) :
    (if P then f else f') ≫ g = if P then f ≫ g else f' ≫ g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {P : Prop} [Decidable P] {X Y Z : C} (f f' : X ⟶ Y) (g : Y ⟶ Z)
Goal: CategoryTheory.CategoryStruct.comp (if P then f else f') g =
  if P then CategoryTheory.CategoryStruct.comp f g else CategoryTheory.CategoryStruct.comp f' g
-- CategoryTheory.comp_dite
theorem comp_dite {P : Prop} [Decidable P]
    {X Y Z : C} (f : X ⟶ Y) (g : P → (Y ⟶ Z)) (g' : ¬P → (Y ⟶ Z)) :
    (f ≫ if h : P then g h else g' h) = if h : P then f ≫ g h else f ≫ g' h 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {P : Prop} [Decidable P] {X Y Z : C} (f : X ⟶ Y) (g : P → (Y ⟶ Z)) (g' : ¬P → (Y ⟶ Z))
Goal: CategoryTheory.CategoryStruct.comp f (if h : P then g h else g' h) =
  if h : P then CategoryTheory.CategoryStruct.comp f (g h) else CategoryTheory.CategoryStruct.comp f (g' h)
-- CategoryTheory.dite_comp
theorem dite_comp {P : Prop} [Decidable P]
    {X Y Z : C} (f : P → (X ⟶ Y)) (f' : ¬P → (X ⟶ Y)) (g : Y ⟶ Z) :
    (if h : P then f h else f' h) ≫ g = if h : P then f h ≫ g else f' h ≫ g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {P : Prop} [Decidable P] {X Y Z : C} (f : P → (X ⟶ Y)) (f' : ¬P → (X ⟶ Y)) (g : Y ⟶ Z)
Goal: CategoryTheory.CategoryStruct.comp (if h : P then f h else f' h) g =
  if h : P then CategoryTheory.CategoryStruct.comp (f h) g else CategoryTheory.CategoryStruct.comp (f' h) g
-- CategoryTheory.Epi.left_cancellation
class Epi (f : X ⟶ Y) : Prop where
    left_cancellation : ∀ {Z : C} (g h : Y ⟶ Z), f ≫ g = f ≫ h → g = h
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y} [self : CategoryTheory.Epi f] {Z : C} (g h : Y ⟶ Z)
Goal: CategoryTheory.CategoryStruct.comp f g = CategoryTheory.CategoryStruct.comp f h → g = h
-- CategoryTheory.Mono.right_cancellation
class Mono (f : X ⟶ Y) : Prop where
    right_cancellation : ∀ {Z : C} (g h : Z ⟶ X), g ≫ f = h ≫ f → g = h
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y} [self : CategoryTheory.Mono f] {Z : C} (g h : Z ⟶ X)
Goal: CategoryTheory.CategoryStruct.comp g f = CategoryTheory.CategoryStruct.comp h f → g = h
-- CategoryTheory.cancel_epi
theorem cancel_epi (f : X ⟶ Y) [Epi f] {g h : Y ⟶ Z} : f ≫ g = f ≫ h ↔ g = h 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Y) [CategoryTheory.Epi f] {g h : Y ⟶ Z}
Goal: CategoryTheory.CategoryStruct.comp f g = CategoryTheory.CategoryStruct.comp f h ↔ g = h
-- CategoryTheory.cancel_mono
theorem cancel_mono (f : X ⟶ Y) [Mono f] {g h : Z ⟶ X} : g ≫ f = h ≫ f ↔ g = h 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Y) [CategoryTheory.Mono f] {g h : Z ⟶ X}
Goal: CategoryTheory.CategoryStruct.comp g f = CategoryTheory.CategoryStruct.comp h f ↔ g = h
-- CategoryTheory.cancel_epi_id
theorem cancel_epi_id (f : X ⟶ Y) [Epi f] {h : Y ⟶ Y} : f ≫ h = f ↔ h = 𝟙 Y 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Epi f] {h : Y ⟶ Y}
Goal: CategoryTheory.CategoryStruct.comp f h = f ↔ h = CategoryTheory.CategoryStruct.id Y
-- CategoryTheory.cancel_mono_id
theorem cancel_mono_id (f : X ⟶ Y) [Mono f] {g : X ⟶ X} : g ≫ f = f ↔ g = 𝟙 X 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Mono f] {g : X ⟶ X}
Goal: CategoryTheory.CategoryStruct.comp g f = f ↔ g = CategoryTheory.CategoryStruct.id X
-- CategoryTheory.epi_comp
theorem epi_comp {X Y Z : C} (f : X ⟶ Y) [Epi f] (g : Y ⟶ Z) [Epi g] : Epi (f ≫ g) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Y) [CategoryTheory.Epi f] (g : Y ⟶ Z) [CategoryTheory.Epi g]
Goal: CategoryTheory.Epi (CategoryTheory.CategoryStruct.comp f g)
-- CategoryTheory.mono_comp
theorem mono_comp {X Y Z : C} (f : X ⟶ Y) [Mono f] (g : Y ⟶ Z) [Mono g] : Mono (f ≫ g) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Y) [CategoryTheory.Mono f] (g : Y ⟶ Z) [CategoryTheory.Mono g]
Goal: CategoryTheory.Mono (CategoryTheory.CategoryStruct.comp f g)
-- CategoryTheory.mono_of_mono
theorem mono_of_mono {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) [Mono (f ≫ g)] : Mono f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) [CategoryTheory.Mono (CategoryTheory.CategoryStruct.comp f g)]
Goal: CategoryTheory.Mono f
-- CategoryTheory.mono_of_mono_fac
theorem mono_of_mono_fac {X Y Z : C} {f : X ⟶ Y} {g : Y ⟶ Z} {h : X ⟶ Z} [Mono h]
    (w : f ≫ g = h) : Mono f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Y} {g : Y ⟶ Z} {h : X ⟶ Z} [CategoryTheory.Mono h] (w : CategoryTheory.CategoryStruct.comp f g = h)
Goal: CategoryTheory.Mono f
-- CategoryTheory.epi_of_epi
theorem epi_of_epi {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) [Epi (f ≫ g)] : Epi g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) [CategoryTheory.Epi (CategoryTheory.CategoryStruct.comp f g)]
Goal: CategoryTheory.Epi g
-- CategoryTheory.epi_of_epi_fac
theorem epi_of_epi_fac {X Y Z : C} {f : X ⟶ Y} {g : Y ⟶ Z} {h : X ⟶ Z} [Epi h]
    (w : f ≫ g = h) : Epi g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Y} {g : Y ⟶ Z} {h : X ⟶ Z} [CategoryTheory.Epi h] (w : CategoryTheory.CategoryStruct.comp f g = h)
Goal: CategoryTheory.Epi g
-- CategoryTheory.Quiv.forget_map
@[simps]
def forget : Cat.{v, u} ⥤ Quiv.{v, u} 
Goal: ∀ {X Y : CategoryTheory.Cat} (F : X ⟶ Y), CategoryTheory.Quiv.forget.map F = F.toPrefunctor
-- CategoryTheory.Quiv.forget_obj
@[simps]
def forget : Cat.{v, u} ⥤ Quiv.{v, u} 
Arguments: (C : CategoryTheory.Cat)
Goal: CategoryTheory.Quiv.forget.obj C = CategoryTheory.Quiv.of ↑C
-- CategoryTheory.Cat.free_map_map
@[simps]
def free : Quiv.{v, u} ⥤ Cat.{max u v, u} 
Goal: ∀ {X Y : CategoryTheory.Quiv} (F : X ⟶ Y) {X_1 Y_1 : ↑((fun V => CategoryTheory.Cat.of (CategoryTheory.Paths ↑V)) X)}
  (f : X_1 ⟶ Y_1), (CategoryTheory.Cat.free.map F).map f = Prefunctor.mapPath F f
-- CategoryTheory.Cat.free_obj
@[simps]
def free : Quiv.{v, u} ⥤ Cat.{max u v, u} 
Arguments: (V : CategoryTheory.Quiv)
Goal: CategoryTheory.Cat.free.obj V = CategoryTheory.Cat.of (CategoryTheory.Paths ↑V)
-- CategoryTheory.Cat.free_map_obj
@[simps]
def free : Quiv.{v, u} ⥤ Cat.{max u v, u} 
Goal: ∀ {X Y : CategoryTheory.Quiv} (F : X ⟶ Y) (X_1 : ↑((fun V => CategoryTheory.Cat.of (CategoryTheory.Paths ↑V)) X)),
  (CategoryTheory.Cat.free.map F).obj X_1 = F.obj X_1
-- CategoryTheory.Quiv.lift_map
@[simps]
def lift {V : Type u} [Quiver.{v + 1} V] {C : Type*} [Category C] (F : Prefunctor V C) :
    Paths V ⥤ C 
Arguments: {V : Type u} [Quiver V] {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] (F : V ⥤q C)
Goal: ∀ {X Y : CategoryTheory.Paths V} (f : X ⟶ Y),
  (CategoryTheory.Quiv.lift F).map f = CategoryTheory.composePath (F.mapPath f)
-- CategoryTheory.Quiv.lift_obj
@[simps]
def lift {V : Type u} [Quiver.{v + 1} V] {C : Type*} [Category C] (F : Prefunctor V C) :
    Paths V ⥤ C 
Arguments: {V : Type u} [Quiver V] {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] (F : V ⥤q C) (X : CategoryTheory.Paths V)
Goal: (CategoryTheory.Quiv.lift F).obj X = F.obj X
-- CategoryTheory.Grpd.coe_of
@[simp]
theorem coe_of (C : Type u) [Groupoid C] : (of C : Type u) = C 
Arguments: (C : Type u) [CategoryTheory.Groupoid C]
Goal: ↑(CategoryTheory.Grpd.of C) = C
-- CategoryTheory.Grpd.hom_to_functor
theorem hom_to_functor {C D E : Grpd.{v, u}} (f : C ⟶ D) (g : D ⟶ E) : f ≫ g = f ⋙ g 
Arguments: {C D E : CategoryTheory.Grpd} (f : C ⟶ D) (g : D ⟶ E)
Goal: CategoryTheory.CategoryStruct.comp f g = CategoryTheory.Functor.comp f g
-- CategoryTheory.Grpd.id_to_functor
theorem id_to_functor {C : Grpd.{v, u}} : 𝟭 C = 𝟙 C 
Arguments: {C : CategoryTheory.Grpd}
Goal: CategoryTheory.Functor.id ↑C = CategoryTheory.CategoryStruct.id C
-- CategoryTheory.Grpd.piIsoPi_hom_π
@[simp]
theorem piIsoPi_hom_π (J : Type u) (f : J → Grpd.{u, u}) (j : J) :
    (piIsoPi J f).hom ≫ Limits.Pi.π f j = CategoryTheory.Pi.eval _ j 
Arguments: (J : Type u) (f : J → CategoryTheory.Grpd) (j : J)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Grpd.piIsoPi J f).hom (CategoryTheory.Limits.Pi.π f j) =
  CategoryTheory.Pi.eval (fun i => ↑(f i)) j
-- CategoryTheory.Limits.Bicone.ι_π
-- @[nolint has_nonempty_instance] Porting note (#5171): removed
structure Bicone (F : J → C) where
  pt : C
  π : ∀ j, pt ⟶ F j
  ι : ∀ j, F j ⟶ pt
  ι_π : ∀ j j', ι j ≫ π j' =
    if h : j = j' then eqToHom (congrArg F h) else 0 := by aesop
Arguments: {J : Type w} {C : Type uC} [CategoryTheory.Category.{uC', uC} C] [CategoryTheory.Limits.HasZeroMorphisms C] {F : J → C} (self : CategoryTheory.Limits.Bicone F) (j j' : J)
Goal: self.ι j ≫ self.π j' = if h : j = j' then CategoryTheory.eqToHom ⋯ else 0
-- CategoryTheory.Limits.bicone_ι_π_self
@[reassoc (attr := simp)]
theorem bicone_ι_π_self {F : J → C} (B : Bicone F) (j : J) : B.ι j ≫ B.π j = 𝟙 (F j) 
Arguments: {J : Type w} {C : Type uC} [CategoryTheory.Category.{uC', uC} C] [CategoryTheory.Limits.HasZeroMorphisms C] {F : J → C} (B : CategoryTheory.Limits.Bicone F) (j : J)
Goal: B.ι j ≫ B.π j = 𝟙 (F j)
-- CategoryTheory.Limits.bicone_ι_π_ne
@[reassoc (attr := simp)]
theorem bicone_ι_π_ne {F : J → C} (B : Bicone F) {j j' : J} (h : j ≠ j') : B.ι j ≫ B.π j' = 0 
Arguments: {J : Type w} {C : Type uC} [CategoryTheory.Category.{uC', uC} C] [CategoryTheory.Limits.HasZeroMorphisms C] {F : J → C} (B : CategoryTheory.Limits.Bicone F) {j j' : J} (h : j ≠ j')
Goal: B.ι j ≫ B.π j' = 0
-- CategoryTheory.Limits.BiconeMorphism.wι
structure BiconeMorphism {F : J → C} (A B : Bicone F) where
    hom : A.pt ⟶ B.pt
    wπ : ∀ j : J, hom ≫ B.π j = A.π j := by aesop_cat
    wι : ∀ j : J, A.ι j ≫ hom = B.ι j := by aesop_cat
Arguments: {J : Type w} {C : Type uC} [CategoryTheory.Category.{uC', uC} C] [CategoryTheory.Limits.HasZeroMorphisms C] {F : J → C} {A B : CategoryTheory.Limits.Bicone F} (self : CategoryTheory.Limits.BiconeMorphism A B) (j : J)
Goal: A.ι j ≫ self.hom = B.ι j
-- CategoryTheory.Limits.BiconeMorphism.wπ
structure BiconeMorphism {F : J → C} (A B : Bicone F) where
    hom : A.pt ⟶ B.pt
    wπ : ∀ j : J, hom ≫ B.π j = A.π j := by aesop_cat
    wι : ∀ j : J, A.ι j ≫ hom = B.ι j := by aesop_cat
Arguments: {J : Type w} {C : Type uC} [CategoryTheory.Category.{uC', uC} C] [CategoryTheory.Limits.HasZeroMorphisms C] {F : J → C} {A B : CategoryTheory.Limits.Bicone F} (self : CategoryTheory.Limits.BiconeMorphism A B) (j : J)
Goal: self.hom ≫ B.π j = A.π j