ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.GlueData.diagramIso_inv_app_left
@[simp]
theorem diagramIso_inv_app_left (i : D.J × D.J) :
    (D.diagramIso F).inv.app (WalkingMultispan.left i) = 𝟙 _ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] {C' : Type u₂} [CategoryTheory.Category.{v, u₂} C'] (D : CategoryTheory.GlueData C) (F : CategoryTheory.Functor C C') [H : (i j k : D.J) → CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan (D.f i j) (D.f i k)) F] (i : D.J × D.J)
Goal: (D.diagramIso F).inv.app (CategoryTheory.Limits.WalkingMultispan.left i) =
  CategoryTheory.CategoryStruct.id
    ((D.mapGlueData F).diagram.multispan.obj (CategoryTheory.Limits.WalkingMultispan.left i))
-- CategoryTheory.GlueData.diagramIso_inv_app_right
@[simp]
theorem diagramIso_inv_app_right (i : D.J) :
    (D.diagramIso F).inv.app (WalkingMultispan.right i) = 𝟙 _ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] {C' : Type u₂} [CategoryTheory.Category.{v, u₂} C'] (D : CategoryTheory.GlueData C) (F : CategoryTheory.Functor C C') [H : (i j k : D.J) → CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan (D.f i j) (D.f i k)) F] (i : D.J)
Goal: (D.diagramIso F).inv.app (CategoryTheory.Limits.WalkingMultispan.right i) =
  CategoryTheory.CategoryStruct.id
    ((D.mapGlueData F).diagram.multispan.obj (CategoryTheory.Limits.WalkingMultispan.right i))
-- CategoryTheory.GlueData.hasColimit_multispan_comp
theorem hasColimit_multispan_comp : HasColimit (D.diagram.multispan ⋙ F) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] {C' : Type u₂} [CategoryTheory.Category.{v, u₂} C'] (D : CategoryTheory.GlueData C) (F : CategoryTheory.Functor C C') [CategoryTheory.Limits.HasMulticoequalizer D.diagram] [CategoryTheory.Limits.PreservesColimit D.diagram.multispan F]
Goal: CategoryTheory.Limits.HasColimit (D.diagram.multispan.comp F)
-- CategoryTheory.GlueData.hasColimit_mapGlueData_diagram
theorem hasColimit_mapGlueData_diagram : HasMulticoequalizer (D.mapGlueData F).diagram 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] {C' : Type u₂} [CategoryTheory.Category.{v, u₂} C'] (D : CategoryTheory.GlueData C) (F : CategoryTheory.Functor C C') [H : (i j k : D.J) → CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan (D.f i j) (D.f i k)) F] [CategoryTheory.Limits.HasMulticoequalizer D.diagram] [CategoryTheory.Limits.PreservesColimit D.diagram.multispan F]
Goal: CategoryTheory.Limits.HasMulticoequalizer (D.mapGlueData F).diagram
-- CategoryTheory.GlueData.ι_gluedIso_hom
@[reassoc (attr := simp)]
theorem ι_gluedIso_hom (i : D.J) : F.map (D.ι i) ≫ (D.gluedIso F).hom = (D.mapGlueData F).ι i 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] {C' : Type u₂} [CategoryTheory.Category.{v, u₂} C'] (D : CategoryTheory.GlueData C) (F : CategoryTheory.Functor C C') [H : (i j k : D.J) → CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan (D.f i j) (D.f i k)) F] [CategoryTheory.Limits.HasMulticoequalizer D.diagram] [CategoryTheory.Limits.PreservesColimit D.diagram.multispan F] (i : D.J)
Goal: CategoryTheory.CategoryStruct.comp (F.map (D.ι i)) (D.gluedIso F).hom = (D.mapGlueData F).ι i
-- CategoryTheory.GlueData.ι_gluedIso_inv
@[reassoc (attr := simp)]
theorem ι_gluedIso_inv (i : D.J) : (D.mapGlueData F).ι i ≫ (D.gluedIso F).inv = F.map (D.ι i) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] {C' : Type u₂} [CategoryTheory.Category.{v, u₂} C'] (D : CategoryTheory.GlueData C) (F : CategoryTheory.Functor C C') [H : (i j k : D.J) → CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan (D.f i j) (D.f i k)) F] [CategoryTheory.Limits.HasMulticoequalizer D.diagram] [CategoryTheory.Limits.PreservesColimit D.diagram.multispan F] (i : D.J)
Goal: CategoryTheory.CategoryStruct.comp ((D.mapGlueData F).ι i) (D.gluedIso F).inv = F.map (D.ι i)
-- CategoryTheory.GlueData.ι_jointly_surjective
theorem ι_jointly_surjective (F : C ⥤ Type v) [PreservesColimit D.diagram.multispan F]
    [∀ i j k : D.J, PreservesLimit (cospan (D.f i j) (D.f i k)) F] (x : F.obj D.glued) :
    ∃ (i : _) (y : F.obj (D.U i)), F.map (D.ι i) y = x 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] (D : CategoryTheory.GlueData C) [CategoryTheory.Limits.HasMulticoequalizer D.diagram] (F : CategoryTheory.Functor C (Type v)) [CategoryTheory.Limits.PreservesColimit D.diagram.multispan F] [(i j k : D.J) → CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan (D.f i j) (D.f i k)) F] (x : F.obj D.glued)
Goal: ∃ i y, F.map (D.ι i) y = x
-- CategoryTheory.GlueData'.t_inv
structure GlueData' where
    J : Type v
    U : J → C
    V : ∀ (i j : J), i ≠ j → C
    f : ∀ i j h, V i j h ⟶ U i
  f_mono : ∀ i j h, Mono (f i j h) := by infer_instance
  f_hasPullback : ∀ i j k hij hik, HasPullback (f i j hij) (f i k hik) := by infer_instance
    t : ∀ i j h, V i j h ⟶ V j i h.symm
    t' : ∀ i j k hij hik hjk,
    pullback (f i j hij) (f i k hik) ⟶ pullback (f j k hjk) (f j i hij.symm)
  t_fac : ∀ i j k hij hik hjk, t' i j k hij hik hjk ≫ pullback.snd _ _ =
    pullback.fst _ _ ≫ t i j hij
  t_inv : ∀ i j hij, t i j hij ≫ t j i hij.symm = 𝟙 _
  cocycle : ∀ i j k hij hik hjk, t' i j k hij hik hjk ≫
    t' j k i hjk hij.symm hik.symm ≫ t' k i j hik.symm hjk.symm hij = 𝟙 _
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] (self : CategoryTheory.GlueData' C) (i j : self.J) (hij : i ≠ j)
Goal: CategoryTheory.CategoryStruct.comp (self.t i j hij) (self.t j i ⋯) = CategoryTheory.CategoryStruct.id (self.V i j hij)
-- CategoryTheory.GlueData'.cocycle
structure GlueData' where
    J : Type v
    U : J → C
    V : ∀ (i j : J), i ≠ j → C
    f : ∀ i j h, V i j h ⟶ U i
  f_mono : ∀ i j h, Mono (f i j h) := by infer_instance
  f_hasPullback : ∀ i j k hij hik, HasPullback (f i j hij) (f i k hik) := by infer_instance
    t : ∀ i j h, V i j h ⟶ V j i h.symm
    t' : ∀ i j k hij hik hjk,
    pullback (f i j hij) (f i k hik) ⟶ pullback (f j k hjk) (f j i hij.symm)
  t_fac : ∀ i j k hij hik hjk, t' i j k hij hik hjk ≫ pullback.snd _ _ =
    pullback.fst _ _ ≫ t i j hij
  t_inv : ∀ i j hij, t i j hij ≫ t j i hij.symm = 𝟙 _
  cocycle : ∀ i j k hij hik hjk, t' i j k hij hik hjk ≫
    t' j k i hjk hij.symm hik.symm ≫ t' k i j hik.symm hjk.symm hij = 𝟙 _
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] (self : CategoryTheory.GlueData' C) (i j k : self.J) (hij : i ≠ j) (hik : i ≠ k) (hjk : j ≠ k)
Goal: CategoryTheory.CategoryStruct.comp (self.t' i j k hij hik hjk)
    (CategoryTheory.CategoryStruct.comp (self.t' j k i hjk ⋯ ⋯) (self.t' k i j ⋯ ⋯ hij)) =
  CategoryTheory.CategoryStruct.id (CategoryTheory.Limits.pullback (self.f i j hij) (self.f i k hik))
-- CategoryTheory.GlueData'.t_fac
structure GlueData' where
    J : Type v
    U : J → C
    V : ∀ (i j : J), i ≠ j → C
    f : ∀ i j h, V i j h ⟶ U i
  f_mono : ∀ i j h, Mono (f i j h) := by infer_instance
  f_hasPullback : ∀ i j k hij hik, HasPullback (f i j hij) (f i k hik) := by infer_instance
    t : ∀ i j h, V i j h ⟶ V j i h.symm
    t' : ∀ i j k hij hik hjk,
    pullback (f i j hij) (f i k hik) ⟶ pullback (f j k hjk) (f j i hij.symm)
  t_fac : ∀ i j k hij hik hjk, t' i j k hij hik hjk ≫ pullback.snd _ _ =
    pullback.fst _ _ ≫ t i j hij
  t_inv : ∀ i j hij, t i j hij ≫ t j i hij.symm = 𝟙 _
  cocycle : ∀ i j k hij hik hjk, t' i j k hij hik hjk ≫
    t' j k i hjk hij.symm hik.symm ≫ t' k i j hik.symm hjk.symm hij = 𝟙 _
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] (self : CategoryTheory.GlueData' C) (i j k : self.J) (hij : i ≠ j) (hik : i ≠ k) (hjk : j ≠ k)
Goal: CategoryTheory.CategoryStruct.comp (self.t' i j k hij hik hjk)
    (CategoryTheory.Limits.pullback.snd (self.f j k hjk) (self.f j i ⋯)) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.fst (self.f i j hij) (self.f i k hik))
    (self.t i j hij)
-- CategoryTheory.GlueData'.f_hasPullback
structure GlueData' where
    J : Type v
    U : J → C
    V : ∀ (i j : J), i ≠ j → C
    f : ∀ i j h, V i j h ⟶ U i
  f_mono : ∀ i j h, Mono (f i j h) := by infer_instance
  f_hasPullback : ∀ i j k hij hik, HasPullback (f i j hij) (f i k hik) := by infer_instance
    t : ∀ i j h, V i j h ⟶ V j i h.symm
    t' : ∀ i j k hij hik hjk,
    pullback (f i j hij) (f i k hik) ⟶ pullback (f j k hjk) (f j i hij.symm)
  t_fac : ∀ i j k hij hik hjk, t' i j k hij hik hjk ≫ pullback.snd _ _ =
    pullback.fst _ _ ≫ t i j hij
  t_inv : ∀ i j hij, t i j hij ≫ t j i hij.symm = 𝟙 _
  cocycle : ∀ i j k hij hik hjk, t' i j k hij hik hjk ≫
    t' j k i hjk hij.symm hik.symm ≫ t' k i j hik.symm hjk.symm hij = 𝟙 _
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] (self : CategoryTheory.GlueData' C) (i j k : self.J) (hij : i ≠ j) (hik : i ≠ k)
Goal: CategoryTheory.Limits.HasPullback (self.f i j hij) (self.f i k hik)
-- CategoryTheory.GlueData'.f_mono
structure GlueData' where
    J : Type v
    U : J → C
    V : ∀ (i j : J), i ≠ j → C
    f : ∀ i j h, V i j h ⟶ U i
  f_mono : ∀ i j h, Mono (f i j h) := by infer_instance
  f_hasPullback : ∀ i j k hij hik, HasPullback (f i j hij) (f i k hik) := by infer_instance
    t : ∀ i j h, V i j h ⟶ V j i h.symm
    t' : ∀ i j k hij hik hjk,
    pullback (f i j hij) (f i k hik) ⟶ pullback (f j k hjk) (f j i hij.symm)
  t_fac : ∀ i j k hij hik hjk, t' i j k hij hik hjk ≫ pullback.snd _ _ =
    pullback.fst _ _ ≫ t i j hij
  t_inv : ∀ i j hij, t i j hij ≫ t j i hij.symm = 𝟙 _
  cocycle : ∀ i j k hij hik hjk, t' i j k hij hik hjk ≫
    t' j k i hjk hij.symm hik.symm ≫ t' k i j hik.symm hjk.symm hij = 𝟙 _
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] (self : CategoryTheory.GlueData' C) (i j : self.J) (h : i ≠ j)
Goal: CategoryTheory.Mono (self.f i j h)
-- CategoryTheory.Limits.HasFiniteLimits.out
class HasFiniteLimits : Prop where
    out (J : Type) [𝒥 : SmallCategory J] [@FinCategory J 𝒥] : @HasLimitsOfShape J 𝒥 C _
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [self : CategoryTheory.Limits.HasFiniteLimits C] (J : Type) [𝒥 : CategoryTheory.SmallCategory J] [CategoryTheory.FinCategory J]
Goal: CategoryTheory.Limits.HasLimitsOfShape J C
-- CategoryTheory.Limits.hasFiniteLimits_of_hasLimitsOfSize
lemma hasFiniteLimits_of_hasLimitsOfSize [HasLimitsOfSize.{v', u'} C] :
    HasFiniteLimits C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasLimitsOfSize.{v', u', v, u} C]
Goal: CategoryTheory.Limits.HasFiniteLimits C
-- CategoryTheory.Limits.hasFiniteLimits_of_hasFiniteLimits_of_size
theorem hasFiniteLimits_of_hasFiniteLimits_of_size
    (h : ∀ (J : Type w) {𝒥 : SmallCategory J} (_ : @FinCategory J 𝒥), HasLimitsOfShape J C) :
    HasFiniteLimits C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] (h :
  ∀ (J : Type w) {𝒥 : CategoryTheory.SmallCategory J},
    CategoryTheory.FinCategory J → CategoryTheory.Limits.HasLimitsOfShape J C)
Goal: CategoryTheory.Limits.HasFiniteLimits C
-- CategoryTheory.Limits.HasFiniteColimits.out
class HasFiniteColimits : Prop where
    out (J : Type) [𝒥 : SmallCategory J] [@FinCategory J 𝒥] : @HasColimitsOfShape J 𝒥 C _
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [self : CategoryTheory.Limits.HasFiniteColimits C] (J : Type) [𝒥 : CategoryTheory.SmallCategory J] [CategoryTheory.FinCategory J]
Goal: CategoryTheory.Limits.HasColimitsOfShape J C
-- CategoryTheory.Limits.hasFiniteColimits_of_hasColimitsOfSize
lemma hasFiniteColimits_of_hasColimitsOfSize [HasColimitsOfSize.{v', u'} C] :
    HasFiniteColimits C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimitsOfSize.{v', u', v, u} C]
Goal: CategoryTheory.Limits.HasFiniteColimits C
-- CategoryTheory.Limits.hasFiniteColimits_of_hasFiniteColimits_of_size
theorem hasFiniteColimits_of_hasFiniteColimits_of_size
    (h : ∀ (J : Type w) {𝒥 : SmallCategory J} (_ : @FinCategory J 𝒥), HasColimitsOfShape J C) :
    HasFiniteColimits C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] (h :
  ∀ (J : Type w) {𝒥 : CategoryTheory.SmallCategory J},
    CategoryTheory.FinCategory J → CategoryTheory.Limits.HasColimitsOfShape J C)
Goal: CategoryTheory.Limits.HasFiniteColimits C
-- CategoryTheory.Limits.HasFiniteWidePullbacks.out
class HasFiniteWidePullbacks : Prop where
    out (J : Type) [Finite J] : HasLimitsOfShape (WidePullbackShape J) C
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [self : CategoryTheory.Limits.HasFiniteWidePullbacks C] (J : Type) [Finite J]
Goal: CategoryTheory.Limits.HasLimitsOfShape (CategoryTheory.Limits.WidePullbackShape J) C
-- CategoryTheory.Limits.HasFiniteWidePushouts.out
class HasFiniteWidePushouts : Prop where
    out (J : Type) [Finite J] : HasColimitsOfShape (WidePushoutShape J) C
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [self : CategoryTheory.Limits.HasFiniteWidePushouts C] (J : Type) [Finite J]
Goal: CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.Limits.WidePushoutShape J) C
-- CategoryTheory.Limits.hasFiniteWidePullbacks_of_hasFiniteLimits
theorem hasFiniteWidePullbacks_of_hasFiniteLimits [HasFiniteLimits C] : HasFiniteWidePullbacks C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasFiniteLimits C]
Goal: CategoryTheory.Limits.HasFiniteWidePullbacks C
-- CategoryTheory.Limits.hasFiniteWidePushouts_of_has_finite_limits
theorem hasFiniteWidePushouts_of_has_finite_limits [HasFiniteColimits C] :
    HasFiniteWidePushouts C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasFiniteColimits C]
Goal: CategoryTheory.Limits.HasFiniteWidePushouts C
-- CategoryTheory.IsReflexivePair.common_section'
class IsReflexivePair (f g : A ⟶ B) : Prop where
  common_section' : ∃ s : B ⟶ A, s ≫ f = 𝟙 B ∧ s ≫ g = 𝟙 B
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A B : C} {f g : A ⟶ B} [self : CategoryTheory.IsReflexivePair f g]
Goal: ∃ s,
  CategoryTheory.CategoryStruct.comp s f = CategoryTheory.CategoryStruct.id B ∧
    CategoryTheory.CategoryStruct.comp s g = CategoryTheory.CategoryStruct.id B
-- CategoryTheory.IsReflexivePair.common_section
theorem IsReflexivePair.common_section (f g : A ⟶ B) [IsReflexivePair f g] :
    ∃ s : B ⟶ A, s ≫ f = 𝟙 B ∧ s ≫ g = 𝟙 B 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A B : C} (f g : A ⟶ B) [CategoryTheory.IsReflexivePair f g]
Goal: ∃ s,
  CategoryTheory.CategoryStruct.comp s f = CategoryTheory.CategoryStruct.id B ∧
    CategoryTheory.CategoryStruct.comp s g = CategoryTheory.CategoryStruct.id B
-- CategoryTheory.IsCoreflexivePair.common_retraction'
class IsCoreflexivePair (f g : A ⟶ B) : Prop where
  common_retraction' : ∃ s : B ⟶ A, f ≫ s = 𝟙 A ∧ g ≫ s = 𝟙 A
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A B : C} {f g : A ⟶ B} [self : CategoryTheory.IsCoreflexivePair f g]
Goal: ∃ s,
  CategoryTheory.CategoryStruct.comp f s = CategoryTheory.CategoryStruct.id A ∧
    CategoryTheory.CategoryStruct.comp g s = CategoryTheory.CategoryStruct.id A
-- CategoryTheory.IsCoreflexivePair.common_retraction
theorem IsCoreflexivePair.common_retraction (f g : A ⟶ B) [IsCoreflexivePair f g] :
    ∃ s : B ⟶ A, f ≫ s = 𝟙 A ∧ g ≫ s = 𝟙 A 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A B : C} (f g : A ⟶ B) [CategoryTheory.IsCoreflexivePair f g]
Goal: ∃ s,
  CategoryTheory.CategoryStruct.comp f s = CategoryTheory.CategoryStruct.id A ∧
    CategoryTheory.CategoryStruct.comp g s = CategoryTheory.CategoryStruct.id A
-- CategoryTheory.IsReflexivePair.mk'
theorem IsReflexivePair.mk' (s : B ⟶ A) (sf : s ≫ f = 𝟙 B) (sg : s ≫ g = 𝟙 B) :
    IsReflexivePair f g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A B : C} {f g : A ⟶ B} (s : B ⟶ A) (sf : CategoryTheory.CategoryStruct.comp s f = CategoryTheory.CategoryStruct.id B) (sg : CategoryTheory.CategoryStruct.comp s g = CategoryTheory.CategoryStruct.id B)
Goal: CategoryTheory.IsReflexivePair f g
-- CategoryTheory.IsCoreflexivePair.mk'
theorem IsCoreflexivePair.mk' (s : B ⟶ A) (fs : f ≫ s = 𝟙 A) (gs : g ≫ s = 𝟙 A) :
    IsCoreflexivePair f g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A B : C} {f g : A ⟶ B} (s : B ⟶ A) (fs : CategoryTheory.CategoryStruct.comp f s = CategoryTheory.CategoryStruct.id A) (gs : CategoryTheory.CategoryStruct.comp g s = CategoryTheory.CategoryStruct.id A)
Goal: CategoryTheory.IsCoreflexivePair f g
-- CategoryTheory.section_comp_left
@[reassoc (attr := simp)]
theorem section_comp_left (f g : A ⟶ B) [IsReflexivePair f g] : commonSection f g ≫ f = 𝟙 B 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A B : C} (f g : A ⟶ B) [CategoryTheory.IsReflexivePair f g]
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.commonSection f g) f = CategoryTheory.CategoryStruct.id B
-- CategoryTheory.section_comp_right
@[reassoc (attr := simp)]
theorem section_comp_right (f g : A ⟶ B) [IsReflexivePair f g] : commonSection f g ≫ g = 𝟙 B 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A B : C} (f g : A ⟶ B) [CategoryTheory.IsReflexivePair f g]
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.commonSection f g) g = CategoryTheory.CategoryStruct.id B
-- CategoryTheory.left_comp_retraction
@[reassoc (attr := simp)]
theorem left_comp_retraction (f g : A ⟶ B) [IsCoreflexivePair f g] :
    f ≫ commonRetraction f g = 𝟙 A 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A B : C} (f g : A ⟶ B) [CategoryTheory.IsCoreflexivePair f g]
Goal: CategoryTheory.CategoryStruct.comp f (CategoryTheory.commonRetraction f g) = CategoryTheory.CategoryStruct.id A
-- CategoryTheory.right_comp_retraction
@[reassoc (attr := simp)]
theorem right_comp_retraction (f g : A ⟶ B) [IsCoreflexivePair f g] :
    g ≫ commonRetraction f g = 𝟙 A 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A B : C} (f g : A ⟶ B) [CategoryTheory.IsCoreflexivePair f g]
Goal: CategoryTheory.CategoryStruct.comp g (CategoryTheory.commonRetraction f g) = CategoryTheory.CategoryStruct.id A
-- CategoryTheory.IsKernelPair.isReflexivePair
theorem IsKernelPair.isReflexivePair {R : C} {f g : R ⟶ A} {q : A ⟶ B} (h : IsKernelPair q f g) :
    IsReflexivePair f g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A B R : C} {f g : R ⟶ A} {q : A ⟶ B} (h : CategoryTheory.IsKernelPair q f g)
Goal: CategoryTheory.IsReflexivePair f g
-- CategoryTheory.IsReflexivePair.swap
theorem IsReflexivePair.swap [IsReflexivePair f g] : IsReflexivePair g f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A B : C} {f g : A ⟶ B} [CategoryTheory.IsReflexivePair f g]
Goal: CategoryTheory.IsReflexivePair g f
-- CategoryTheory.IsCoreflexivePair.swap
theorem IsCoreflexivePair.swap [IsCoreflexivePair f g] : IsCoreflexivePair g f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A B : C} {f g : A ⟶ B} [CategoryTheory.IsCoreflexivePair f g]
Goal: CategoryTheory.IsCoreflexivePair g f
-- CategoryTheory.Limits.HasReflexiveCoequalizers.has_coeq
class HasReflexiveCoequalizers : Prop where
  has_coeq : ∀ ⦃A B : C⦄ (f g : A ⟶ B) [IsReflexivePair f g], HasCoequalizer f g
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [self : CategoryTheory.Limits.HasReflexiveCoequalizers C] ⦃A B : C⦄ (f g : A ⟶ B) [CategoryTheory.IsReflexivePair f g]
Goal: CategoryTheory.Limits.HasCoequalizer f g
-- CategoryTheory.Limits.HasCoreflexiveEqualizers.has_eq
class HasCoreflexiveEqualizers : Prop where
  has_eq : ∀ ⦃A B : C⦄ (f g : A ⟶ B) [IsCoreflexivePair f g], HasEqualizer f g
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [self : CategoryTheory.Limits.HasCoreflexiveEqualizers C] ⦃A B : C⦄ (f g : A ⟶ B) [CategoryTheory.IsCoreflexivePair f g]
Goal: CategoryTheory.Limits.HasEqualizer f g
-- CategoryTheory.Limits.hasCoequalizer_of_common_section
theorem hasCoequalizer_of_common_section [HasReflexiveCoequalizers C] {A B : C} {f g : A ⟶ B}
    (r : B ⟶ A) (rf : r ≫ f = 𝟙 _) (rg : r ≫ g = 𝟙 _) : HasCoequalizer f g 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasReflexiveCoequalizers C] {A B : C} {f g : A ⟶ B} (r : B ⟶ A) (rf : CategoryTheory.CategoryStruct.comp r f = CategoryTheory.CategoryStruct.id B) (rg : CategoryTheory.CategoryStruct.comp r g = CategoryTheory.CategoryStruct.id B)
Goal: CategoryTheory.Limits.HasCoequalizer f g
-- CategoryTheory.Limits.hasEqualizer_of_common_retraction
theorem hasEqualizer_of_common_retraction [HasCoreflexiveEqualizers C] {A B : C} {f g : A ⟶ B}
    (r : B ⟶ A) (fr : f ≫ r = 𝟙 _) (gr : g ≫ r = 𝟙 _) : HasEqualizer f g 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasCoreflexiveEqualizers C] {A B : C} {f g : A ⟶ B} (r : B ⟶ A) (fr : CategoryTheory.CategoryStruct.comp f r = CategoryTheory.CategoryStruct.id A) (gr : CategoryTheory.CategoryStruct.comp g r = CategoryTheory.CategoryStruct.id A)
Goal: CategoryTheory.Limits.HasEqualizer f g
-- CategoryTheory.Limits.HasLimitOfHasProductsOfHasEqualizers.buildLimit_pt
@[simps]
def buildLimit
    (hs : ∀ f : Σp : J × J, p.1 ⟶ p.2, s ≫ c₂.π.app ⟨f⟩ = c₁.π.app ⟨f.1.1⟩ ≫ F.map f.2)
    (ht : ∀ f : Σp : J × J, p.1 ⟶ p.2, t ≫ c₂.π.app ⟨f⟩ = c₁.π.app ⟨f.1.2⟩)
    (i : Fork s t) : Cone F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : Type w} [CategoryTheory.SmallCategory J] {F : J ⥤ C} {c₁ : CategoryTheory.Limits.Fan F.obj} {c₂ : CategoryTheory.Limits.Fan fun f => F.obj f.fst.2} (s t : c₁.pt ⟶ c₂.pt) (hs : ∀ (f : (p : J × J) × (p.1 ⟶ p.2)), s ≫ c₂.π.app { as := f } = c₁.π.app { as := f.fst.1 } ≫ F.map f.snd) (ht : ∀ (f : (p : J × J) × (p.1 ⟶ p.2)), t ≫ c₂.π.app { as := f } = c₁.π.app { as := f.fst.2 }) (i : CategoryTheory.Limits.Fork s t)
Goal: (CategoryTheory.Limits.HasLimitOfHasProductsOfHasEqualizers.buildLimit s t hs ht i).pt = i.pt
-- CategoryTheory.Limits.HasLimitOfHasProductsOfHasEqualizers.buildLimit_π_app
@[simps]
def buildLimit
    (hs : ∀ f : Σp : J × J, p.1 ⟶ p.2, s ≫ c₂.π.app ⟨f⟩ = c₁.π.app ⟨f.1.1⟩ ≫ F.map f.2)
    (ht : ∀ f : Σp : J × J, p.1 ⟶ p.2, t ≫ c₂.π.app ⟨f⟩ = c₁.π.app ⟨f.1.2⟩)
    (i : Fork s t) : Cone F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : Type w} [CategoryTheory.SmallCategory J] {F : J ⥤ C} {c₁ : CategoryTheory.Limits.Fan F.obj} {c₂ : CategoryTheory.Limits.Fan fun f => F.obj f.fst.2} (s t : c₁.pt ⟶ c₂.pt) (hs : ∀ (f : (p : J × J) × (p.1 ⟶ p.2)), s ≫ c₂.π.app { as := f } = c₁.π.app { as := f.fst.1 } ≫ F.map f.snd) (ht : ∀ (f : (p : J × J) × (p.1 ⟶ p.2)), t ≫ c₂.π.app { as := f } = c₁.π.app { as := f.fst.2 }) (i : CategoryTheory.Limits.Fork s t) (j : J)
Goal: (CategoryTheory.Limits.HasLimitOfHasProductsOfHasEqualizers.buildLimit s t hs ht i).π.app j = i.ι ≫ c₁.π.app { as := j }
-- CategoryTheory.Limits.hasLimit_of_equalizer_and_product
theorem hasLimit_of_equalizer_and_product (F : J ⥤ C) [HasLimit (Discrete.functor F.obj)]
    [HasLimit (Discrete.functor fun f : Σp : J × J, p.1 ⟶ p.2 => F.obj f.1.2)] [HasEqualizers C] :
    HasLimit F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : Type w} [CategoryTheory.SmallCategory J] (F : J ⥤ C) [CategoryTheory.Limits.HasLimit (CategoryTheory.Discrete.functor F.obj)] [CategoryTheory.Limits.HasLimit (CategoryTheory.Discrete.functor fun f => F.obj f.fst.2)] [CategoryTheory.Limits.HasEqualizers C]
Goal: CategoryTheory.Limits.HasLimit F
-- CategoryTheory.Limits.has_limits_of_hasEqualizers_and_products
theorem has_limits_of_hasEqualizers_and_products [HasProducts.{w} C] [HasEqualizers C] :
    HasLimitsOfSize.{w, w} C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasProducts C] [CategoryTheory.Limits.HasEqualizers C]
Goal: CategoryTheory.Limits.HasLimitsOfSize.{w, w, v, u} C
-- CategoryTheory.Limits.hasFiniteLimits_of_hasEqualizers_and_finite_products
theorem hasFiniteLimits_of_hasEqualizers_and_finite_products [HasFiniteProducts C]
    [HasEqualizers C] : HasFiniteLimits C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasFiniteProducts C] [CategoryTheory.Limits.HasEqualizers C]
Goal: CategoryTheory.Limits.HasFiniteLimits C
-- CategoryTheory.Limits.hasFiniteLimits_of_hasTerminal_and_pullbacks
theorem hasFiniteLimits_of_hasTerminal_and_pullbacks [HasTerminal C] [HasPullbacks C] :
    HasFiniteLimits C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasTerminal C] [CategoryTheory.Limits.HasPullbacks C]
Goal: CategoryTheory.Limits.HasFiniteLimits C