ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Limits.PushoutCocone.ι_app_left
@[simp]
theorem ι_app_left (c : PushoutCocone f g) : c.ι.app WalkingSpan.left = c.inl 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} (c : CategoryTheory.Limits.PushoutCocone f g)
Goal: c.ι.app CategoryTheory.Limits.WalkingSpan.left = c.inl
-- CategoryTheory.Limits.PushoutCocone.ι_app_right
@[simp]
theorem ι_app_right (c : PushoutCocone f g) : c.ι.app WalkingSpan.right = c.inr 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} (c : CategoryTheory.Limits.PushoutCocone f g)
Goal: c.ι.app CategoryTheory.Limits.WalkingSpan.right = c.inr
-- CategoryTheory.Limits.PushoutCocone.condition_zero
@[simp]
theorem condition_zero (t : PushoutCocone f g) : t.ι.app WalkingSpan.zero = f ≫ t.inl 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} (t : CategoryTheory.Limits.PushoutCocone f g)
Goal: t.ι.app CategoryTheory.Limits.WalkingSpan.zero = f ≫ t.inl
-- CategoryTheory.Limits.PushoutCocone.mk_ι_app
@[simps]
def mk {W : C} (inl : Y ⟶ W) (inr : Z ⟶ W) (eq : f ≫ inl = g ≫ inr) : PushoutCocone f g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} {W : C} (inl : Y ⟶ W) (inr : Z ⟶ W) (eq : f ≫ inl = g ≫ inr) (j : CategoryTheory.Limits.WalkingSpan)
Goal: (CategoryTheory.Limits.PushoutCocone.mk inl inr eq).ι.app j =
  Option.casesOn j (f ≫ inl) fun j' => CategoryTheory.Limits.WalkingPair.casesOn j' inl inr
-- CategoryTheory.Limits.PushoutCocone.mk_pt
@[simps]
def mk {W : C} (inl : Y ⟶ W) (inr : Z ⟶ W) (eq : f ≫ inl = g ≫ inr) : PushoutCocone f g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} {W : C} (inl : Y ⟶ W) (inr : Z ⟶ W) (eq : f ≫ inl = g ≫ inr)
Goal: (CategoryTheory.Limits.PushoutCocone.mk inl inr eq).pt = W
-- CategoryTheory.Limits.PushoutCocone.mk_ι_app_left
@[simp]
theorem mk_ι_app_left {W : C} (inl : Y ⟶ W) (inr : Z ⟶ W) (eq : f ≫ inl = g ≫ inr) :
    (mk inl inr eq).ι.app WalkingSpan.left = inl 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} {W : C} (inl : Y ⟶ W) (inr : Z ⟶ W) (eq : f ≫ inl = g ≫ inr)
Goal: (CategoryTheory.Limits.PushoutCocone.mk inl inr eq).ι.app CategoryTheory.Limits.WalkingSpan.left = inl
-- CategoryTheory.Limits.PushoutCocone.mk_ι_app_right
@[simp]
theorem mk_ι_app_right {W : C} (inl : Y ⟶ W) (inr : Z ⟶ W) (eq : f ≫ inl = g ≫ inr) :
    (mk inl inr eq).ι.app WalkingSpan.right = inr 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} {W : C} (inl : Y ⟶ W) (inr : Z ⟶ W) (eq : f ≫ inl = g ≫ inr)
Goal: (CategoryTheory.Limits.PushoutCocone.mk inl inr eq).ι.app CategoryTheory.Limits.WalkingSpan.right = inr
-- CategoryTheory.Limits.PushoutCocone.mk_ι_app_zero
@[simp]
theorem mk_ι_app_zero {W : C} (inl : Y ⟶ W) (inr : Z ⟶ W) (eq : f ≫ inl = g ≫ inr) :
    (mk inl inr eq).ι.app WalkingSpan.zero = f ≫ inl 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} {W : C} (inl : Y ⟶ W) (inr : Z ⟶ W) (eq : f ≫ inl = g ≫ inr)
Goal: (CategoryTheory.Limits.PushoutCocone.mk inl inr eq).ι.app CategoryTheory.Limits.WalkingSpan.zero = f ≫ inl
-- CategoryTheory.Limits.PushoutCocone.mk_inl
@[simp]
theorem mk_inl {W : C} (inl : Y ⟶ W) (inr : Z ⟶ W) (eq : f ≫ inl = g ≫ inr) :
    (mk inl inr eq).inl = inl 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} {W : C} (inl : Y ⟶ W) (inr : Z ⟶ W) (eq : f ≫ inl = g ≫ inr)
Goal: (CategoryTheory.Limits.PushoutCocone.mk inl inr eq).inl = inl
-- CategoryTheory.Limits.PushoutCocone.mk_inr
@[simp]
theorem mk_inr {W : C} (inl : Y ⟶ W) (inr : Z ⟶ W) (eq : f ≫ inl = g ≫ inr) :
    (mk inl inr eq).inr = inr 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} {W : C} (inl : Y ⟶ W) (inr : Z ⟶ W) (eq : f ≫ inl = g ≫ inr)
Goal: (CategoryTheory.Limits.PushoutCocone.mk inl inr eq).inr = inr
-- CategoryTheory.Limits.PushoutCocone.condition
@[reassoc]
theorem condition (t : PushoutCocone f g) : f ≫ inl t = g ≫ inr t 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} (t : CategoryTheory.Limits.PushoutCocone f g)
Goal: f ≫ t.inl = g ≫ t.inr
-- CategoryTheory.Limits.PushoutCocone.coequalizer_ext
theorem coequalizer_ext (t : PushoutCocone f g) {W : C} {k l : t.pt ⟶ W}
    (h₀ : inl t ≫ k = inl t ≫ l) (h₁ : inr t ≫ k = inr t ≫ l) :
    ∀ j : WalkingSpan, t.ι.app j ≫ k = t.ι.app j ≫ l
  
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} (t : CategoryTheory.Limits.PushoutCocone f g) {W : C} {k l : t.pt ⟶ W} (h₀ : t.inl ≫ k = t.inl ≫ l) (h₁ : t.inr ≫ k = t.inr ≫ l) (j : CategoryTheory.Limits.WalkingSpan)
Goal: t.ι.app j ≫ k = t.ι.app j ≫ l
-- CategoryTheory.Limits.PushoutCocone.eta_inv_hom
@[simps!]
def eta (t : PushoutCocone f g) : t ≅ mk t.inl t.inr t.condition 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} (t : CategoryTheory.Limits.PushoutCocone f g)
Goal: t.eta.inv.hom = 𝟙 t.pt
-- CategoryTheory.Limits.PushoutCocone.eta_hom_hom
@[simps!]
def eta (t : PushoutCocone f g) : t ≅ mk t.inl t.inr t.condition 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} (t : CategoryTheory.Limits.PushoutCocone f g)
Goal: t.eta.hom.hom = 𝟙 t.pt
-- CategoryTheory.Limits.PushoutCocone.IsColimit.hom_ext
theorem IsColimit.hom_ext {t : PushoutCocone f g} (ht : IsColimit t) {W : C} {k l : t.pt ⟶ W}
    (h₀ : inl t ≫ k = inl t ≫ l) (h₁ : inr t ≫ k = inr t ≫ l) : k = l 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} {t : CategoryTheory.Limits.PushoutCocone f g} (ht : CategoryTheory.Limits.IsColimit t) {W : C} {k l : t.pt ⟶ W} (h₀ : t.inl ≫ k = t.inl ≫ l) (h₁ : t.inr ≫ k = t.inr ≫ l)
Goal: k = l
-- CategoryTheory.Limits.PushoutCocone.IsColimit.inl_desc
@[reassoc (attr := simp)]
lemma IsColimit.inl_desc {t : PushoutCocone f g} (ht : IsColimit t) {W : C} (h : Y ⟶ W) (k : Z ⟶ W)
    (w : f ≫ h = g ≫ k) : inl t ≫ IsColimit.desc ht h k w = h 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} {t : CategoryTheory.Limits.PushoutCocone f g} (ht : CategoryTheory.Limits.IsColimit t) {W : C} (h : Y ⟶ W) (k : Z ⟶ W) (w : f ≫ h = g ≫ k)
Goal: t.inl ≫ CategoryTheory.Limits.PushoutCocone.IsColimit.desc ht h k w = h
-- CategoryTheory.Limits.PushoutCocone.IsColimit.inr_desc
@[reassoc (attr := simp)]
lemma IsColimit.inr_desc {t : PushoutCocone f g} (ht : IsColimit t) {W : C} (h : Y ⟶ W) (k : Z ⟶ W)
    (w : f ≫ h = g ≫ k) : inr t ≫ IsColimit.desc ht h k w = k 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} {t : CategoryTheory.Limits.PushoutCocone f g} (ht : CategoryTheory.Limits.IsColimit t) {W : C} (h : Y ⟶ W) (k : Z ⟶ W) (w : f ≫ h = g ≫ k)
Goal: t.inr ≫ CategoryTheory.Limits.PushoutCocone.IsColimit.desc ht h k w = k
-- CategoryTheory.Limits.PushoutCocone.flip_pt
@[simp] lemma flip_pt : t.flip.pt = t.pt 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} (t : CategoryTheory.Limits.PushoutCocone f g)
Goal: t.flip.pt = t.pt
-- CategoryTheory.Limits.PushoutCocone.flip_inl
@[simp] lemma flip_inl : t.flip.inl = t.inr 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} (t : CategoryTheory.Limits.PushoutCocone f g)
Goal: t.flip.inl = t.inr
-- CategoryTheory.Limits.PushoutCocone.flip_inr
@[simp] lemma flip_inr : t.flip.inr = t.inl 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} (t : CategoryTheory.Limits.PushoutCocone f g)
Goal: t.flip.inr = t.inl
-- CategoryTheory.Limits.Cocone.ofPushoutCocone_ι
@[simps]
def Cocone.ofPushoutCocone {F : WalkingSpan ⥤ C} (t : PushoutCocone (F.map fst) (F.map snd)) :
    Cocone F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Limits.WalkingSpan ⥤ C} (t :
  CategoryTheory.Limits.PushoutCocone (F.map CategoryTheory.Limits.WalkingSpan.Hom.fst)
    (F.map CategoryTheory.Limits.WalkingSpan.Hom.snd))
Goal: (CategoryTheory.Limits.Cocone.ofPushoutCocone t).ι = (CategoryTheory.Limits.diagramIsoSpan F).hom ≫ t.ι
-- CategoryTheory.Limits.Cocone.ofPushoutCocone_pt
@[simps]
def Cocone.ofPushoutCocone {F : WalkingSpan ⥤ C} (t : PushoutCocone (F.map fst) (F.map snd)) :
    Cocone F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Limits.WalkingSpan ⥤ C} (t :
  CategoryTheory.Limits.PushoutCocone (F.map CategoryTheory.Limits.WalkingSpan.Hom.fst)
    (F.map CategoryTheory.Limits.WalkingSpan.Hom.snd))
Goal: (CategoryTheory.Limits.Cocone.ofPushoutCocone t).pt = t.pt
-- CategoryTheory.Limits.PushoutCocone.ofCocone_pt
@[simps]
def PushoutCocone.ofCocone {F : WalkingSpan ⥤ C} (t : Cocone F) :
    PushoutCocone (F.map fst) (F.map snd) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Limits.WalkingSpan ⥤ C} (t : CategoryTheory.Limits.Cocone F)
Goal: (CategoryTheory.Limits.PushoutCocone.ofCocone t).pt = t.pt
-- CategoryTheory.Limits.PushoutCocone.ofCocone_ι
@[simps]
def PushoutCocone.ofCocone {F : WalkingSpan ⥤ C} (t : Cocone F) :
    PushoutCocone (F.map fst) (F.map snd) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Limits.WalkingSpan ⥤ C} (t : CategoryTheory.Limits.Cocone F)
Goal: (CategoryTheory.Limits.PushoutCocone.ofCocone t).ι = (CategoryTheory.Limits.diagramIsoSpan F).inv ≫ t.ι
-- CategoryTheory.Limits.PushoutCocone.isoMk_hom_hom
@[simps!]
def PushoutCocone.isoMk {F : WalkingSpan ⥤ C} (t : Cocone F) :
    (Cocones.precompose (diagramIsoSpan.{v} _).inv).obj t ≅
      PushoutCocone.mk (t.ι.app WalkingSpan.left) (t.ι.app WalkingSpan.right)
        ((t.ι.naturality fst).trans (t.ι.naturality snd).symm) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Limits.WalkingSpan ⥤ C} (t : CategoryTheory.Limits.Cocone F)
Goal: (CategoryTheory.Limits.PushoutCocone.isoMk t).hom.hom = 𝟙 t.pt
-- CategoryTheory.Limits.PushoutCocone.isoMk_inv_hom
@[simps!]
def PushoutCocone.isoMk {F : WalkingSpan ⥤ C} (t : Cocone F) :
    (Cocones.precompose (diagramIsoSpan.{v} _).inv).obj t ≅
      PushoutCocone.mk (t.ι.app WalkingSpan.left) (t.ι.app WalkingSpan.right)
        ((t.ι.naturality fst).trans (t.ι.naturality snd).symm) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Limits.WalkingSpan ⥤ C} (t : CategoryTheory.Limits.Cocone F)
Goal: (CategoryTheory.Limits.PushoutCocone.isoMk t).inv.hom = 𝟙 t.pt
-- CategoryTheory.NormalMono.w
class NormalMono (f : X ⟶ Y) where
  Z : C -- Porting note: violates naming convention but can't think of a better one
  g : Y ⟶ Z
  w : f ≫ g = 0
  isLimit : IsLimit (KernelFork.ofι f w)
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} [CategoryTheory.Limits.HasZeroMorphisms C] {f : X ⟶ Y} [self : CategoryTheory.NormalMono f]
Goal: CategoryTheory.CategoryStruct.comp f CategoryTheory.NormalMono.g = 0
-- CategoryTheory.NormalEpi.w
class NormalEpi (f : X ⟶ Y) where
  W : C
  g : W ⟶ X
  w : g ≫ f = 0
  isColimit : IsColimit (CokernelCofork.ofπ f w)
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} [CategoryTheory.Limits.HasZeroMorphisms C] {f : X ⟶ Y} [self : CategoryTheory.NormalEpi f]
Goal: CategoryTheory.CategoryStruct.comp CategoryTheory.NormalEpi.g f = 0
-- CategoryTheory.IsKernelPair.id_of_mono
theorem id_of_mono [Mono f] : IsKernelPair f (𝟙 _) (𝟙 _) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Mono f]
Goal: CategoryTheory.IsKernelPair f (CategoryTheory.CategoryStruct.id X) (CategoryTheory.CategoryStruct.id X)
-- CategoryTheory.IsKernelPair.lift_fst
@[reassoc (attr := simp)]
lemma lift_fst {S : C} (k : IsKernelPair f a b) (p q : S ⟶ X) (w : p ≫ f = q ≫ f) :
    k.lift p q w ≫ a = p 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {R X Y : C} {f : X ⟶ Y} {a b : R ⟶ X} {S : C} (k : CategoryTheory.IsKernelPair f a b) (p q : S ⟶ X) (w : CategoryTheory.CategoryStruct.comp p f = CategoryTheory.CategoryStruct.comp q f)
Goal: CategoryTheory.CategoryStruct.comp (k.lift p q w) a = p
-- CategoryTheory.IsKernelPair.lift_snd
@[reassoc (attr := simp)]
lemma lift_snd {S : C} (k : IsKernelPair f a b) (p q : S ⟶ X) (w : p ≫ f = q ≫ f) :
    k.lift p q w ≫ b = q 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {R X Y : C} {f : X ⟶ Y} {a b : R ⟶ X} {S : C} (k : CategoryTheory.IsKernelPair f a b) (p q : S ⟶ X) (w : CategoryTheory.CategoryStruct.comp p f = CategoryTheory.CategoryStruct.comp q f)
Goal: CategoryTheory.CategoryStruct.comp (k.lift p q w) b = q
-- CategoryTheory.IsKernelPair.cancel_right
theorem cancel_right {f₁ : X ⟶ Y} {f₂ : Y ⟶ Z} (comm : a ≫ f₁ = b ≫ f₁)
    (big_k : IsKernelPair (f₁ ≫ f₂) a b) : IsKernelPair f₁ a b 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {R X Y Z : C} {a b : R ⟶ X} {f₁ : X ⟶ Y} {f₂ : Y ⟶ Z} (comm : CategoryTheory.CategoryStruct.comp a f₁ = CategoryTheory.CategoryStruct.comp b f₁) (big_k : CategoryTheory.IsKernelPair (CategoryTheory.CategoryStruct.comp f₁ f₂) a b)
Goal: CategoryTheory.IsKernelPair f₁ a b
-- CategoryTheory.IsKernelPair.cancel_right_of_mono
theorem cancel_right_of_mono {f₁ : X ⟶ Y} {f₂ : Y ⟶ Z} [Mono f₂]
    (big_k : IsKernelPair (f₁ ≫ f₂) a b) : IsKernelPair f₁ a b 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {R X Y Z : C} {a b : R ⟶ X} {f₁ : X ⟶ Y} {f₂ : Y ⟶ Z} [CategoryTheory.Mono f₂] (big_k : CategoryTheory.IsKernelPair (CategoryTheory.CategoryStruct.comp f₁ f₂) a b)
Goal: CategoryTheory.IsKernelPair f₁ a b
-- CategoryTheory.IsKernelPair.comp_of_mono
theorem comp_of_mono {f₁ : X ⟶ Y} {f₂ : Y ⟶ Z} [Mono f₂] (small_k : IsKernelPair f₁ a b) :
    IsKernelPair (f₁ ≫ f₂) a b 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {R X Y Z : C} {a b : R ⟶ X} {f₁ : X ⟶ Y} {f₂ : Y ⟶ Z} [CategoryTheory.Mono f₂] (small_k : CategoryTheory.IsKernelPair f₁ a b)
Goal: CategoryTheory.IsKernelPair (CategoryTheory.CategoryStruct.comp f₁ f₂) a b
-- CategoryTheory.IsKernelPair.pullback
protected theorem pullback {X Y Z A : C} {g : Y ⟶ Z} {a₁ a₂ : A ⟶ Y} (h : IsKernelPair g a₁ a₂)
    (f : X ⟶ Z) [HasPullback f g] [HasPullback f (a₁ ≫ g)] :
    IsKernelPair (pullback.fst f g)
      (pullback.map f _ f _ (𝟙 X) a₁ (𝟙 Z) (by simp) <| Category.comp_id _)
      (pullback.map _ _ _ _ (𝟙 X) a₂ (𝟙 Z) (by simp) <| (Category.comp_id _).trans h.1.1) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z A : C} {g : Y ⟶ Z} {a₁ a₂ : A ⟶ Y} (h : CategoryTheory.IsKernelPair g a₁ a₂) (f : X ⟶ Z) [CategoryTheory.Limits.HasPullback f g] [CategoryTheory.Limits.HasPullback f (CategoryTheory.CategoryStruct.comp a₁ g)]
Goal: CategoryTheory.IsKernelPair (CategoryTheory.Limits.pullback.fst f g)
  (CategoryTheory.Limits.pullback.map f (CategoryTheory.CategoryStruct.comp a₁ g) f g
    (CategoryTheory.CategoryStruct.id X) a₁ (CategoryTheory.CategoryStruct.id Z) ⋯ ⋯)
  (CategoryTheory.Limits.pullback.map f (CategoryTheory.CategoryStruct.comp a₁ g) f g
    (CategoryTheory.CategoryStruct.id X) a₂ (CategoryTheory.CategoryStruct.id Z) ⋯ ⋯)
-- CategoryTheory.IsKernelPair.mono_of_isIso_fst
theorem mono_of_isIso_fst (h : IsKernelPair f a b) [IsIso a] : Mono f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {R X Y : C} {f : X ⟶ Y} {a b : R ⟶ X} (h : CategoryTheory.IsKernelPair f a b) [CategoryTheory.IsIso a]
Goal: CategoryTheory.Mono f
-- CategoryTheory.IsKernelPair.isIso_of_mono
theorem isIso_of_mono (h : IsKernelPair f a b) [Mono f] : IsIso a 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {R X Y : C} {f : X ⟶ Y} {a b : R ⟶ X} (h : CategoryTheory.IsKernelPair f a b) [CategoryTheory.Mono f]
Goal: CategoryTheory.IsIso a
-- CategoryTheory.IsKernelPair.of_isIso_of_mono
theorem of_isIso_of_mono [IsIso a] [Mono f] : IsKernelPair f a a 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {R X Y : C} {f : X ⟶ Y} {a : R ⟶ X} [CategoryTheory.IsIso a] [CategoryTheory.Mono f]
Goal: CategoryTheory.IsKernelPair f a a
-- CategoryTheory.Limits.SingleObj.Types.sections.equivFixedPoints_apply_coe
@[simps]
def Types.sections.equivFixedPoints :
    J.sections ≃ MulAction.fixedPoints M (J.obj (SingleObj.star M)) 
Arguments: {M : Type v} [Monoid M] (J : CategoryTheory.Functor (CategoryTheory.SingleObj M) (Type u)) (s : ↑J.sections)
Goal: ↑((CategoryTheory.Limits.SingleObj.Types.sections.equivFixedPoints J) s) = ↑s (CategoryTheory.SingleObj.star M)
-- CategoryTheory.Limits.SingleObj.Types.sections.equivFixedPoints_symm_apply_coe
@[simps]
def Types.sections.equivFixedPoints :
    J.sections ≃ MulAction.fixedPoints M (J.obj (SingleObj.star M)) 
Arguments: {M : Type v} [Monoid M] (J : CategoryTheory.Functor (CategoryTheory.SingleObj M) (Type u)) (p : ↑(MulAction.fixedPoints M (J.obj (CategoryTheory.SingleObj.star M))))
Goal: ∀ (x : CategoryTheory.SingleObj M), ↑((CategoryTheory.Limits.SingleObj.Types.sections.equivFixedPoints J).symm p) x = ↑p
-- CategoryTheory.Limits.SingleObj.Types.limitEquivFixedPoints_apply_coe
@[simps!]
noncomputable def Types.limitEquivFixedPoints :
    limit J ≃ MulAction.fixedPoints M (J.obj (SingleObj.star M)) 
Arguments: {M : Type v} [Monoid M] (J : CategoryTheory.Functor (CategoryTheory.SingleObj M) (Type u))
Goal: ∀ (a : CategoryTheory.Limits.limit J),
  ↑((CategoryTheory.Limits.SingleObj.Types.limitEquivFixedPoints J) a) =
    CategoryTheory.Limits.limit.π J (CategoryTheory.SingleObj.star M) a
-- CategoryTheory.Limits.SingleObj.Types.limitEquivFixedPoints_symm_apply
@[simps!]
noncomputable def Types.limitEquivFixedPoints :
    limit J ≃ MulAction.fixedPoints M (J.obj (SingleObj.star M)) 
Arguments: {M : Type v} [Monoid M] (J : CategoryTheory.Functor (CategoryTheory.SingleObj M) (Type u))
Goal: ∀ (a : ↑(MulAction.fixedPoints M (J.obj (CategoryTheory.SingleObj.star M)))),
  (CategoryTheory.Limits.SingleObj.Types.limitEquivFixedPoints J).symm a =
    (CategoryTheory.Limits.Types.limitEquivSections J).symm
      ((CategoryTheory.Limits.SingleObj.Types.sections.equivFixedPoints J).symm a)
-- CategoryTheory.Limits.SingleObj.Types.Quot.Rel.iff_orbitRel
lemma Types.Quot.Rel.iff_orbitRel (x y : J.obj (SingleObj.star G)) :
    Types.Quot.Rel J ⟨SingleObj.star G, x⟩ ⟨SingleObj.star G, y⟩
    ↔ Setoid.Rel (MulAction.orbitRel G (J.obj (SingleObj.star G))) x y 
Arguments: {G : Type v} [Group G] (J : CategoryTheory.Functor (CategoryTheory.SingleObj G) (Type u)) (x y : J.obj (CategoryTheory.SingleObj.star G))
Goal: CategoryTheory.Limits.Types.Quot.Rel J ⟨CategoryTheory.SingleObj.star G, x⟩ ⟨CategoryTheory.SingleObj.star G, y⟩ ↔
  (MulAction.orbitRel G (J.obj (CategoryTheory.SingleObj.star G))).Rel x y
-- CategoryTheory.Limits.SingleObj.Types.Quot.equivOrbitRelQuotient_apply
@[simps]
def Types.Quot.equivOrbitRelQuotient :
    Types.Quot J ≃ MulAction.orbitRel.Quotient G (J.obj (SingleObj.star G)) 
Arguments: {G : Type v} [Group G] (J : CategoryTheory.Functor (CategoryTheory.SingleObj G) (Type u)) (a : Quot (CategoryTheory.Limits.Types.Quot.Rel J))
Goal: (CategoryTheory.Limits.SingleObj.Types.Quot.equivOrbitRelQuotient J) a = Quot.lift (fun p => ⟦p.snd⟧) ⋯ a
-- CategoryTheory.Limits.SingleObj.Types.Quot.equivOrbitRelQuotient_symm_apply
@[simps]
def Types.Quot.equivOrbitRelQuotient :
    Types.Quot J ≃ MulAction.orbitRel.Quotient G (J.obj (SingleObj.star G)) 
Arguments: {G : Type v} [Group G] (J : CategoryTheory.Functor (CategoryTheory.SingleObj G) (Type u)) (a : Quot Setoid.r)
Goal: (CategoryTheory.Limits.SingleObj.Types.Quot.equivOrbitRelQuotient J).symm a =
  Quot.lift (fun x => Quot.mk (CategoryTheory.Limits.Types.Quot.Rel J) ⟨CategoryTheory.SingleObj.star G, x⟩) ⋯ a
-- CategoryTheory.Limits.SingleObj.Types.colimitEquivQuotient_apply
@[simps!]
noncomputable def Types.colimitEquivQuotient :
    colimit J ≃ MulAction.orbitRel.Quotient G (J.obj (SingleObj.star G)) 
Arguments: {G : Type v} [Group G] (J : CategoryTheory.Functor (CategoryTheory.SingleObj G) (Type u))
Goal: ∀ (a : CategoryTheory.Limits.colimit J),
  (CategoryTheory.Limits.SingleObj.Types.colimitEquivQuotient J) a =
    Quot.lift (fun p => ⟦p.snd⟧) ⋯ ((CategoryTheory.Limits.Types.colimitEquivQuot J) a)
-- CategoryTheory.Limits.SingleObj.Types.colimitEquivQuotient_symm_apply
@[simps!]
noncomputable def Types.colimitEquivQuotient :
    colimit J ≃ MulAction.orbitRel.Quotient G (J.obj (SingleObj.star G)) 
Arguments: {G : Type v} [Group G] (J : CategoryTheory.Functor (CategoryTheory.SingleObj G) (Type u))
Goal: ∀ (a : MulAction.orbitRel.Quotient G (J.obj (CategoryTheory.SingleObj.star G))),
  (CategoryTheory.Limits.SingleObj.Types.colimitEquivQuotient J).symm a =
    (CategoryTheory.Limits.Types.colimitEquivQuot J).symm
      (Quot.lift (fun x => Quot.mk (CategoryTheory.Limits.Types.Quot.Rel J) ⟨CategoryTheory.SingleObj.star G, x⟩) ⋯ a)
-- CategoryTheory.IsSplitCoequalizer.leftSection_top
structure IsSplitCoequalizer {Z : C} (π : Y ⟶ Z) where
    rightSection : Z ⟶ Y
    leftSection : Y ⟶ X
    condition : f ≫ π = g ≫ π := by aesop_cat
    rightSection_π : rightSection ≫ π = 𝟙 Z := by aesop_cat
    leftSection_bottom : leftSection ≫ g = 𝟙 Y := by aesop_cat
    leftSection_top : leftSection ≫ f = π ≫ rightSection := by aesop_cat
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} {Z : C} {π : Y ⟶ Z} (self : CategoryTheory.IsSplitCoequalizer f g π)
Goal: CategoryTheory.CategoryStruct.comp self.leftSection f = CategoryTheory.CategoryStruct.comp π self.rightSection
-- CategoryTheory.IsSplitCoequalizer.rightSection_π
structure IsSplitCoequalizer {Z : C} (π : Y ⟶ Z) where
    rightSection : Z ⟶ Y
    leftSection : Y ⟶ X
    condition : f ≫ π = g ≫ π := by aesop_cat
    rightSection_π : rightSection ≫ π = 𝟙 Z := by aesop_cat
    leftSection_bottom : leftSection ≫ g = 𝟙 Y := by aesop_cat
    leftSection_top : leftSection ≫ f = π ≫ rightSection := by aesop_cat
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} {Z : C} {π : Y ⟶ Z} (self : CategoryTheory.IsSplitCoequalizer f g π)
Goal: CategoryTheory.CategoryStruct.comp self.rightSection π = CategoryTheory.CategoryStruct.id Z
-- CategoryTheory.IsSplitCoequalizer.condition
structure IsSplitCoequalizer {Z : C} (π : Y ⟶ Z) where
    rightSection : Z ⟶ Y
    leftSection : Y ⟶ X
    condition : f ≫ π = g ≫ π := by aesop_cat
    rightSection_π : rightSection ≫ π = 𝟙 Z := by aesop_cat
    leftSection_bottom : leftSection ≫ g = 𝟙 Y := by aesop_cat
    leftSection_top : leftSection ≫ f = π ≫ rightSection := by aesop_cat
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} {Z : C} {π : Y ⟶ Z} (self : CategoryTheory.IsSplitCoequalizer f g π)
Goal: CategoryTheory.CategoryStruct.comp f π = CategoryTheory.CategoryStruct.comp g π
-- CategoryTheory.IsSplitCoequalizer.leftSection_bottom
structure IsSplitCoequalizer {Z : C} (π : Y ⟶ Z) where
    rightSection : Z ⟶ Y
    leftSection : Y ⟶ X
    condition : f ≫ π = g ≫ π := by aesop_cat
    rightSection_π : rightSection ≫ π = 𝟙 Z := by aesop_cat
    leftSection_bottom : leftSection ≫ g = 𝟙 Y := by aesop_cat
    leftSection_top : leftSection ≫ f = π ≫ rightSection := by aesop_cat
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} {Z : C} {π : Y ⟶ Z} (self : CategoryTheory.IsSplitCoequalizer f g π)
Goal: CategoryTheory.CategoryStruct.comp self.leftSection g = CategoryTheory.CategoryStruct.id Y
-- CategoryTheory.IsSplitCoequalizer.map_leftSection
@[simps]
def IsSplitCoequalizer.map {Z : C} {π : Y ⟶ Z} (q : IsSplitCoequalizer f g π) (F : C ⥤ D) :
    IsSplitCoequalizer (F.map f) (F.map g) (F.map π) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X Y : C} {f g : X ⟶ Y} {Z : C} {π : Y ⟶ Z} (q : CategoryTheory.IsSplitCoequalizer f g π) (F : CategoryTheory.Functor C D)
Goal: (q.map F).leftSection = F.map q.leftSection