ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Limits.wideEqualizer.trident_π_app_zero
@[simp 1100]
theorem wideEqualizer.trident_π_app_zero :
    (wideEqualizer.trident f).π.app zero = wideEqualizer.ι f 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : J → (X ⟶ Y)) [CategoryTheory.Limits.HasWideEqualizer f]
Goal: (CategoryTheory.Limits.wideEqualizer.trident f).π.app CategoryTheory.Limits.WalkingParallelFamily.zero =
  CategoryTheory.Limits.wideEqualizer.ι f
-- CategoryTheory.Limits.wideEqualizer.condition
@[reassoc]
theorem wideEqualizer.condition (j₁ j₂ : J) : wideEqualizer.ι f ≫ f j₁ = wideEqualizer.ι f ≫ f j₂ 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : J → (X ⟶ Y)) [CategoryTheory.Limits.HasWideEqualizer f] (j₁ j₂ : J)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.wideEqualizer.ι f) (f j₁) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.wideEqualizer.ι f) (f j₂)
-- CategoryTheory.Limits.wideEqualizer.lift_ι
@[reassoc (attr := simp 1100)]
theorem wideEqualizer.lift_ι [Nonempty J] {W : C} (k : W ⟶ X)
    (h : ∀ j₁ j₂, k ≫ f j₁ = k ≫ f j₂) :
    wideEqualizer.lift k h ≫ wideEqualizer.ι f = k 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : J → (X ⟶ Y)} [CategoryTheory.Limits.HasWideEqualizer f] [Nonempty J] {W : C} (k : W ⟶ X) (h : ∀ (j₁ j₂ : J), CategoryTheory.CategoryStruct.comp k (f j₁) = CategoryTheory.CategoryStruct.comp k (f j₂))
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.wideEqualizer.lift k h)
    (CategoryTheory.Limits.wideEqualizer.ι f) =
  k
-- CategoryTheory.Limits.wideEqualizer.hom_ext
@[ext]
theorem wideEqualizer.hom_ext [Nonempty J] {W : C} {k l : W ⟶ wideEqualizer f}
    (h : k ≫ wideEqualizer.ι f = l ≫ wideEqualizer.ι f) : k = l 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : J → (X ⟶ Y)} [CategoryTheory.Limits.HasWideEqualizer f] [Nonempty J] {W : C} {k l : W ⟶ CategoryTheory.Limits.wideEqualizer f} (h :
  CategoryTheory.CategoryStruct.comp k (CategoryTheory.Limits.wideEqualizer.ι f) =
    CategoryTheory.CategoryStruct.comp l (CategoryTheory.Limits.wideEqualizer.ι f))
Goal: k = l
-- CategoryTheory.Limits.mono_of_isLimit_parallelFamily
theorem mono_of_isLimit_parallelFamily [Nonempty J] {c : Cone (parallelFamily f)} (i : IsLimit c) :
    Mono (Trident.ι c) 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : J → (X ⟶ Y)} [Nonempty J] {c : CategoryTheory.Limits.Cone (CategoryTheory.Limits.parallelFamily f)} (i : CategoryTheory.Limits.IsLimit c)
Goal: CategoryTheory.Mono (CategoryTheory.Limits.Trident.ι c)
-- CategoryTheory.Limits.wideCoequalizer.cotrident_π
@[simp]
theorem wideCoequalizer.cotrident_π : (wideCoequalizer.cotrident f).π = wideCoequalizer.π f 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : J → (X ⟶ Y)) [CategoryTheory.Limits.HasWideCoequalizer f]
Goal: (CategoryTheory.Limits.wideCoequalizer.cotrident f).π = CategoryTheory.Limits.wideCoequalizer.π f
-- CategoryTheory.Limits.wideCoequalizer.cotrident_ι_app_one
@[simp 1100]
theorem wideCoequalizer.cotrident_ι_app_one :
    (wideCoequalizer.cotrident f).ι.app one = wideCoequalizer.π f 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : J → (X ⟶ Y)) [CategoryTheory.Limits.HasWideCoequalizer f]
Goal: (CategoryTheory.Limits.wideCoequalizer.cotrident f).ι.app CategoryTheory.Limits.WalkingParallelFamily.one =
  CategoryTheory.Limits.wideCoequalizer.π f
-- CategoryTheory.Limits.wideCoequalizer.condition
@[reassoc]
theorem wideCoequalizer.condition (j₁ j₂ : J) :
    f j₁ ≫ wideCoequalizer.π f = f j₂ ≫ wideCoequalizer.π f 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : J → (X ⟶ Y)) [CategoryTheory.Limits.HasWideCoequalizer f] (j₁ j₂ : J)
Goal: CategoryTheory.CategoryStruct.comp (f j₁) (CategoryTheory.Limits.wideCoequalizer.π f) =
  CategoryTheory.CategoryStruct.comp (f j₂) (CategoryTheory.Limits.wideCoequalizer.π f)
-- CategoryTheory.Limits.wideCoequalizer.π_desc
@[reassoc (attr := simp 1100)]
theorem wideCoequalizer.π_desc [Nonempty J] {W : C} (k : Y ⟶ W)
    (h : ∀ j₁ j₂, f j₁ ≫ k = f j₂ ≫ k) :
    wideCoequalizer.π f ≫ wideCoequalizer.desc k h = k 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : J → (X ⟶ Y)} [CategoryTheory.Limits.HasWideCoequalizer f] [Nonempty J] {W : C} (k : Y ⟶ W) (h : ∀ (j₁ j₂ : J), CategoryTheory.CategoryStruct.comp (f j₁) k = CategoryTheory.CategoryStruct.comp (f j₂) k)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.wideCoequalizer.π f)
    (CategoryTheory.Limits.wideCoequalizer.desc k h) =
  k
-- CategoryTheory.Limits.wideCoequalizer.hom_ext
@[ext]
theorem wideCoequalizer.hom_ext [Nonempty J] {W : C} {k l : wideCoequalizer f ⟶ W}
    (h : wideCoequalizer.π f ≫ k = wideCoequalizer.π f ≫ l) : k = l 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : J → (X ⟶ Y)} [CategoryTheory.Limits.HasWideCoequalizer f] [Nonempty J] {W : C} {k l : CategoryTheory.Limits.wideCoequalizer f ⟶ W} (h :
  CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.wideCoequalizer.π f) k =
    CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.wideCoequalizer.π f) l)
Goal: k = l
-- CategoryTheory.Limits.epi_of_isColimit_parallelFamily
theorem epi_of_isColimit_parallelFamily [Nonempty J] {c : Cocone (parallelFamily f)}
    (i : IsColimit c) : Epi (c.ι.app one) 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : J → (X ⟶ Y)} [Nonempty J] {c : CategoryTheory.Limits.Cocone (CategoryTheory.Limits.parallelFamily f)} (i : CategoryTheory.Limits.IsColimit c)
Goal: CategoryTheory.Epi (c.ι.app CategoryTheory.Limits.WalkingParallelFamily.one)
-- CategoryTheory.Limits.hasWideEqualizers_of_hasLimit_parallelFamily
theorem hasWideEqualizers_of_hasLimit_parallelFamily
    [∀ {J : Type w} {X Y : C} {f : J → (X ⟶ Y)}, HasLimit (parallelFamily f)] :
    HasWideEqualizers.{w} C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] [∀ {J : Type w} {X Y : C} {f : J → (X ⟶ Y)}, CategoryTheory.Limits.HasLimit (CategoryTheory.Limits.parallelFamily f)]
Goal: CategoryTheory.Limits.HasWideEqualizers C
-- CategoryTheory.Limits.hasWideCoequalizers_of_hasColimit_parallelFamily
theorem hasWideCoequalizers_of_hasColimit_parallelFamily
    [∀ {J : Type w} {X Y : C} {f : J → (X ⟶ Y)}, HasColimit (parallelFamily f)] :
    HasWideCoequalizers.{w} C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] [∀ {J : Type w} {X Y : C} {f : J → (X ⟶ Y)}, CategoryTheory.Limits.HasColimit (CategoryTheory.Limits.parallelFamily f)]
Goal: CategoryTheory.Limits.HasWideCoequalizers C
-- CategoryTheory.Limits.Types.pi_lift_π_apply
@[simp 1001]
theorem pi_lift_π_apply {β : Type v} [Small.{u} β] (f : β → Type u) {P : Type u}
    (s : ∀ b, P ⟶ f b) (b : β) (x : P) :
    (Pi.π f b : (piObj f) → f b) (@Pi.lift β _ _ f _ P s x) = s b x 
Arguments: {β : Type v} [Small.{u, v} β] (f : β → Type u) {P : Type u} (s : (b : β) → P ⟶ f b) (b : β) (x : P)
Goal: CategoryTheory.Limits.Pi.π f b (CategoryTheory.Limits.Pi.lift s x) = s b x
-- CategoryTheory.Limits.Types.pi_lift_π_apply'
theorem pi_lift_π_apply' {β : Type v} (f : β → Type v) {P : Type v}
    (s : ∀ b, P ⟶ f b) (b : β) (x : P) :
    (Pi.π f b : (piObj f) → f b) (@Pi.lift β _ _ f _ P s x) = s b x 
Arguments: {β : Type v} (f : β → Type v) {P : Type v} (s : (b : β) → P ⟶ f b) (b : β) (x : P)
Goal: CategoryTheory.Limits.Pi.π f b (CategoryTheory.Limits.Pi.lift s x) = s b x
-- CategoryTheory.Limits.Types.pi_map_π_apply
@[simp 1001]
theorem pi_map_π_apply {β : Type v} [Small.{u} β] {f g : β → Type u}
    (α : ∀ j, f j ⟶ g j) (b : β) (x) :
    (Pi.π g b : ∏ᶜ g → g b) (Pi.map α x) = α b ((Pi.π f b : ∏ᶜ f → f b) x) 
Arguments: {β : Type v} [Small.{u, v} β] {f g : β → Type u} (α : (j : β) → f j ⟶ g j) (b : β) (x : ∏ᶜ f)
Goal: CategoryTheory.Limits.Pi.π g b (CategoryTheory.Limits.Pi.map α x) = α b (CategoryTheory.Limits.Pi.π f b x)
-- CategoryTheory.Limits.Types.pi_map_π_apply'
theorem pi_map_π_apply' {β : Type v} {f g : β → Type v} (α : ∀ j, f j ⟶ g j) (b : β) (x) :
    (Pi.π g b : ∏ᶜ g → g b) (Pi.map α x) = α b ((Pi.π f b : ∏ᶜ f → f b) x) 
Arguments: {β : Type v} {f g : β → Type v} (α : (j : β) → f j ⟶ g j) (b : β) (x : ∏ᶜ f)
Goal: CategoryTheory.Limits.Pi.π g b (CategoryTheory.Limits.Pi.map α x) = α b (CategoryTheory.Limits.Pi.π f b x)
-- CategoryTheory.Limits.Types.initial_iff_empty
lemma initial_iff_empty (X : Type u) : Nonempty (IsInitial X) ↔ IsEmpty X 
Arguments: (X : Type u)
Goal: Nonempty (CategoryTheory.Limits.IsInitial X) ↔ IsEmpty X
-- CategoryTheory.Limits.Types.binaryProductCone_pt
@[simps! pt]
def binaryProductCone (X Y : Type u) : BinaryFan X Y 
Arguments: (X Y : Type u)
Goal: (CategoryTheory.Limits.Types.binaryProductCone X Y).pt = (X × Y)
-- CategoryTheory.Limits.Types.binaryProductCone_fst
@[simp]
theorem binaryProductCone_fst (X Y : Type u) : (binaryProductCone X Y).fst = _root_.Prod.fst 
Arguments: (X Y : Type u)
Goal: (CategoryTheory.Limits.Types.binaryProductCone X Y).fst = Prod.fst
-- CategoryTheory.Limits.Types.binaryProductCone_snd
@[simp]
theorem binaryProductCone_snd (X Y : Type u) : (binaryProductCone X Y).snd = _root_.Prod.snd 
Arguments: (X Y : Type u)
Goal: (CategoryTheory.Limits.Types.binaryProductCone X Y).snd = Prod.snd
-- CategoryTheory.Limits.Types.binaryProductLimit_lift
@[simps]
def binaryProductLimit (X Y : Type u) : IsLimit (binaryProductCone X Y) 
Arguments: (X Y : Type u) (s : CategoryTheory.Limits.BinaryFan X Y) (x : s.pt)
Goal: (CategoryTheory.Limits.Types.binaryProductLimit X Y).lift s x = (s.fst x, s.snd x)
-- CategoryTheory.Limits.Types.binaryProductLimitCone_cone
@[simps]
def binaryProductLimitCone (X Y : Type u) : Limits.LimitCone (pair X Y) 
Arguments: (X Y : Type u)
Goal: (CategoryTheory.Limits.Types.binaryProductLimitCone X Y).cone = CategoryTheory.Limits.Types.binaryProductCone X Y
-- CategoryTheory.Limits.Types.binaryProductLimitCone_isLimit
@[simps]
def binaryProductLimitCone (X Y : Type u) : Limits.LimitCone (pair X Y) 
Arguments: (X Y : Type u)
Goal: (CategoryTheory.Limits.Types.binaryProductLimitCone X Y).isLimit = CategoryTheory.Limits.Types.binaryProductLimit X Y
-- CategoryTheory.Limits.Types.binaryProductIso_hom_comp_fst
@[elementwise (attr := simp)]
theorem binaryProductIso_hom_comp_fst (X Y : Type u) :
    (binaryProductIso X Y).hom ≫ _root_.Prod.fst = Limits.prod.fst 
Arguments: (X Y : Type u)
Goal: (CategoryTheory.Limits.Types.binaryProductIso X Y).hom ≫ Prod.fst = CategoryTheory.Limits.prod.fst
-- CategoryTheory.Limits.Types.binaryProductIso_hom_comp_snd
@[elementwise (attr := simp)]
theorem binaryProductIso_hom_comp_snd (X Y : Type u) :
    (binaryProductIso X Y).hom ≫ _root_.Prod.snd = Limits.prod.snd 
Arguments: (X Y : Type u)
Goal: (CategoryTheory.Limits.Types.binaryProductIso X Y).hom ≫ Prod.snd = CategoryTheory.Limits.prod.snd
-- CategoryTheory.Limits.Types.binaryProductIso_inv_comp_fst
@[elementwise (attr := simp)]
theorem binaryProductIso_inv_comp_fst (X Y : Type u) :
    (binaryProductIso X Y).inv ≫ Limits.prod.fst = _root_.Prod.fst 
Arguments: (X Y : Type u)
Goal: (CategoryTheory.Limits.Types.binaryProductIso X Y).inv ≫ CategoryTheory.Limits.prod.fst = Prod.fst
-- CategoryTheory.Limits.Types.binaryProductIso_inv_comp_snd
@[elementwise (attr := simp)]
theorem binaryProductIso_inv_comp_snd (X Y : Type u) :
    (binaryProductIso X Y).inv ≫ Limits.prod.snd = _root_.Prod.snd 
Arguments: (X Y : Type u)
Goal: (CategoryTheory.Limits.Types.binaryProductIso X Y).inv ≫ CategoryTheory.Limits.prod.snd = Prod.snd
-- CategoryTheory.Limits.Types.binaryProductFunctor_obj_map
@[simps]
def binaryProductFunctor : Type u ⥤ Type u ⥤ Type u 
Arguments: (X : Type u) {Y₁ Y₂ : Type u} (f : Y₁ ⟶ Y₂)
Goal: ∀ (a : (CategoryTheory.Limits.BinaryFan.mk Prod.fst (Prod.snd ≫ f)).pt),
  (CategoryTheory.Limits.Types.binaryProductFunctor.obj X).map f a =
    (CategoryTheory.Limits.Types.binaryProductLimit X Y₂).lift
      (CategoryTheory.Limits.BinaryFan.mk Prod.fst (Prod.snd ≫ f)) a
-- CategoryTheory.Limits.Types.binaryProductFunctor_obj_obj
@[simps]
def binaryProductFunctor : Type u ⥤ Type u ⥤ Type u 
Arguments: (X Y : Type u)
Goal: (CategoryTheory.Limits.Types.binaryProductFunctor.obj X).obj Y = (X × Y)
-- CategoryTheory.Limits.Types.binaryProductFunctor_map_app
@[simps]
def binaryProductFunctor : Type u ⥤ Type u ⥤ Type u 
Arguments: {X₁ X₂ : Type u} (f : X₁ ⟶ X₂) (Y : Type u)
Goal: ∀ (a : (CategoryTheory.Limits.BinaryFan.mk (Prod.fst ≫ f) Prod.snd).pt),
  (CategoryTheory.Limits.Types.binaryProductFunctor.map f).app Y a =
    (CategoryTheory.Limits.Types.binaryProductLimit X₂ Y).lift
      (CategoryTheory.Limits.BinaryFan.mk (Prod.fst ≫ f) Prod.snd) a
-- CategoryTheory.Limits.Types.binaryCoproductCocone_pt
@[simps!]
def binaryCoproductCocone (X Y : Type u) : Cocone (pair X Y) 
Arguments: (X Y : Type u)
Goal: (CategoryTheory.Limits.Types.binaryCoproductCocone X Y).pt = (X ⊕ Y)
-- CategoryTheory.Limits.Types.binaryCoproductCocone_ι_app
@[simps!]
def binaryCoproductCocone (X Y : Type u) : Cocone (pair X Y) 
Arguments: (X Y : Type u)
Goal: ∀ (x : CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair) (a : (CategoryTheory.Limits.pair X Y).obj x),
  (CategoryTheory.Limits.Types.binaryCoproductCocone X Y).ι.app x a =
    (match x.as with
      | CategoryTheory.Limits.WalkingPair.left => Sum.inl
      | CategoryTheory.Limits.WalkingPair.right => Sum.inr)
      a
-- CategoryTheory.Limits.Types.binaryCoproductColimit_desc
@[simps]
def binaryCoproductColimit (X Y : Type u) : IsColimit (binaryCoproductCocone X Y) 
Arguments: (X Y : Type u) (s : CategoryTheory.Limits.BinaryCofan X Y)
Goal: ∀ (a : X ⊕ Y), (CategoryTheory.Limits.Types.binaryCoproductColimit X Y).desc s a = Sum.elim s.inl s.inr a
-- CategoryTheory.Limits.Types.binaryCoproductIso_inl_comp_hom
@[elementwise (attr := simp)]
theorem binaryCoproductIso_inl_comp_hom (X Y : Type u) :
    Limits.coprod.inl ≫ (binaryCoproductIso X Y).hom = Sum.inl 
Arguments: (X Y : Type u)
Goal: CategoryTheory.Limits.coprod.inl ≫ (CategoryTheory.Limits.Types.binaryCoproductIso X Y).hom = Sum.inl
-- CategoryTheory.Limits.Types.binaryCoproductIso_inr_comp_hom
@[elementwise (attr := simp)]
theorem binaryCoproductIso_inr_comp_hom (X Y : Type u) :
    Limits.coprod.inr ≫ (binaryCoproductIso X Y).hom = Sum.inr 
Arguments: (X Y : Type u)
Goal: CategoryTheory.Limits.coprod.inr ≫ (CategoryTheory.Limits.Types.binaryCoproductIso X Y).hom = Sum.inr
-- CategoryTheory.Limits.Types.binaryCoproductIso_inl_comp_inv
@[elementwise (attr := simp)]
theorem binaryCoproductIso_inl_comp_inv (X Y : Type u) :
    ↾(Sum.inl : X ⟶ X ⊕ Y) ≫ (binaryCoproductIso X Y).inv = Limits.coprod.inl 
Arguments: (X Y : Type u)
Goal: ↾Sum.inl ≫ (CategoryTheory.Limits.Types.binaryCoproductIso X Y).inv = CategoryTheory.Limits.coprod.inl
-- CategoryTheory.Limits.Types.binaryCoproductIso_inr_comp_inv
@[elementwise (attr := simp)]
theorem binaryCoproductIso_inr_comp_inv (X Y : Type u) :
    ↾(Sum.inr : Y ⟶ X ⊕ Y) ≫ (binaryCoproductIso X Y).inv = Limits.coprod.inr 
Arguments: (X Y : Type u)
Goal: ↾Sum.inr ≫ (CategoryTheory.Limits.Types.binaryCoproductIso X Y).inv = CategoryTheory.Limits.coprod.inr
-- CategoryTheory.Limits.Types.binaryCofan_isColimit_iff
theorem binaryCofan_isColimit_iff {X Y : Type u} (c : BinaryCofan X Y) :
    Nonempty (IsColimit c) ↔
      Injective c.inl ∧ Injective c.inr ∧ IsCompl (Set.range c.inl) (Set.range c.inr) 
Arguments: {X Y : Type u} (c : CategoryTheory.Limits.BinaryCofan X Y)
Goal: Nonempty (CategoryTheory.Limits.IsColimit c) ↔
  Function.Injective c.inl ∧ Function.Injective c.inr ∧ IsCompl (Set.range c.inl) (Set.range c.inr)
-- CategoryTheory.Limits.Types.productIso_hom_comp_eval
@[simp]
theorem productIso_hom_comp_eval {J : Type v} (F : J → TypeMax.{v, u}) (j : J) :
    ((productIso.{v, u} F).hom ≫ fun f => f j) = Pi.π F j 
Arguments: {J : Type v} (F : J → TypeMax) (j : J)
Goal: ((CategoryTheory.Limits.Types.productIso F).hom ≫ fun f => f j) = CategoryTheory.Limits.Pi.π F j
-- CategoryTheory.Limits.Types.productIso_hom_comp_eval_apply
@[simp]
theorem productIso_hom_comp_eval_apply {J : Type v} (F : J → TypeMax.{v, u}) (j : J) (x) :
    ((productIso.{v, u} F).hom x) j = Pi.π F j x 
Arguments: {J : Type v} (F : J → TypeMax) (j : J) (x : ∏ᶜ F)
Goal: (CategoryTheory.Limits.Types.productIso F).hom x j = CategoryTheory.Limits.Pi.π F j x
-- CategoryTheory.Limits.Types.productIso_inv_comp_π
@[elementwise (attr := simp)]
theorem productIso_inv_comp_π {J : Type v} (F : J → TypeMax.{v, u}) (j : J) :
    (productIso.{v, u} F).inv ≫ Pi.π F j = fun f => f j 
Arguments: {J : Type v} (F : J → TypeMax) (j : J)
Goal: (CategoryTheory.Limits.Types.productIso F).inv ≫ CategoryTheory.Limits.Pi.π F j = fun f => f j
-- CategoryTheory.Limits.Types.Small.productIso_hom_comp_eval
@[simp]
theorem productIso_hom_comp_eval (j : J) :
    ((productIso.{v, u} F).hom ≫ fun f => (equivShrink (∀ j, F j)).symm f j) = Pi.π F j 
Arguments: {J : Type v} (F : J → Type u) [Small.{u, v} J] (j : J)
Goal: ((CategoryTheory.Limits.Types.Small.productIso F).hom ≫ fun f => (equivShrink ((j : J) → F j)).symm f j) =
  CategoryTheory.Limits.Pi.π F j
-- CategoryTheory.Limits.Types.Small.productIso_hom_comp_eval_apply
@[simp]
theorem productIso_hom_comp_eval_apply (j : J) (x) :
    (equivShrink (∀ j, F j)).symm ((productIso F).hom x) j = Pi.π F j x 
Arguments: {J : Type v} (F : J → Type u) [Small.{u, v} J] (j : J) (x : ∏ᶜ F)
Goal: (equivShrink ((j : J) → F j)).symm ((CategoryTheory.Limits.Types.Small.productIso F).hom x) j =
  CategoryTheory.Limits.Pi.π F j x
-- CategoryTheory.Limits.Types.Small.productIso_inv_comp_π
@[elementwise (attr := simp)]
theorem productIso_inv_comp_π (j : J) :
    (productIso.{v, u} F).inv ≫ Pi.π F j = fun f => ((equivShrink (∀ j, F j)).symm f) j 
Arguments: {J : Type v} (F : J → Type u) [Small.{u, v} J] (j : J)
Goal: (CategoryTheory.Limits.Types.Small.productIso F).inv ≫ CategoryTheory.Limits.Pi.π F j = fun f =>
  (equivShrink ((j : J) → F j)).symm f j
-- CategoryTheory.Limits.Types.coproductIso_ι_comp_hom
@[elementwise (attr := simp)]
theorem coproductIso_ι_comp_hom {J : Type v} (F : J → TypeMax.{v, u}) (j : J) :
    Sigma.ι F j ≫ (coproductIso F).hom = fun x : F j => (⟨j, x⟩ : Σj, F j) 
Arguments: {J : Type v} (F : J → TypeMax) (j : J)
Goal: CategoryTheory.Limits.Sigma.ι F j ≫ (CategoryTheory.Limits.Types.coproductIso F).hom = fun x => ⟨j, x⟩
-- CategoryTheory.Limits.Types.coproductIso_mk_comp_inv
theorem coproductIso_mk_comp_inv {J : Type v} (F : J → TypeMax.{v, u}) (j : J) :
    (↾fun x : F j => (⟨j, x⟩ : Σj, F j)) ≫ (coproductIso F).inv = Sigma.ι F j 
Arguments: {J : Type v} (F : J → TypeMax) (j : J)
Goal: (↾fun x => ⟨j, x⟩) ≫ (CategoryTheory.Limits.Types.coproductIso F).inv = CategoryTheory.Limits.Sigma.ι F j
-- CategoryTheory.Limits.Types.unique_of_type_equalizer
theorem unique_of_type_equalizer (t : IsLimit (Fork.ofι _ w)) (y : Y) (hy : g y = h y) :
    ∃! x : X, f x = y 
Arguments: {X Y Z : Type u} (f : X ⟶ Y) {g h : Y ⟶ Z} (w : f ≫ g = f ≫ h) (t : CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.Fork.ofι f w)) (y : Y) (hy : g y = h y)
Goal: ∃! x, f x = y
-- CategoryTheory.Limits.Types.type_equalizer_iff_unique
theorem type_equalizer_iff_unique :
    Nonempty (IsLimit (Fork.ofι _ w)) ↔ ∀ y : Y, g y = h y → ∃! x : X, f x = y 
Arguments: {X Y Z : Type u} (f : X ⟶ Y) {g h : Y ⟶ Z} (w : f ≫ g = f ≫ h)
Goal: Nonempty (CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.Fork.ofι f w)) ↔ ∀ (y : Y), g y = h y → ∃! x, f x = y
-- CategoryTheory.Limits.Types.equalizerIso_hom_comp_subtype
@[simp]
theorem equalizerIso_hom_comp_subtype : (equalizerIso g h).hom ≫ Subtype.val = equalizer.ι g h 
Arguments: {Y Z : Type u} (g h : Y ⟶ Z)
Goal: (CategoryTheory.Limits.Types.equalizerIso g h).hom ≫ Subtype.val = CategoryTheory.Limits.equalizer.ι g h
-- CategoryTheory.Limits.Types.equalizerIso_inv_comp_ι
@[elementwise (attr := simp)]
theorem equalizerIso_inv_comp_ι : (equalizerIso g h).inv ≫ equalizer.ι g h = Subtype.val 
Arguments: {Y Z : Type u} (g h : Y ⟶ Z)
Goal: (CategoryTheory.Limits.Types.equalizerIso g h).inv ≫ CategoryTheory.Limits.equalizer.ι g h = Subtype.val
-- CategoryTheory.Limits.Types.coequalizer_preimage_image_eq_of_preimage_eq
theorem coequalizer_preimage_image_eq_of_preimage_eq (π : Y ⟶ Z) (e : f ≫ π = g ≫ π)
    (h : IsColimit (Cofork.ofπ π e)) (U : Set Y) (H : f ⁻¹' U = g ⁻¹' U) : π ⁻¹' (π '' U) = U 
Arguments: {X Y Z : Type u} (f g : X ⟶ Y) (π : Y ⟶ Z) (e : f ≫ π = g ≫ π) (h : CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.Cofork.ofπ π e)) (U : Set Y) (H : f ⁻¹' U = g ⁻¹' U)
Goal: π ⁻¹' (π '' U) = U
-- CategoryTheory.Limits.Types.coequalizerIso_π_comp_hom
@[elementwise (attr := simp)]
theorem coequalizerIso_π_comp_hom :
    coequalizer.π f g ≫ (coequalizerIso f g).hom = Quot.mk (CoequalizerRel f g) 
Arguments: {X Y : Type u} (f g : X ⟶ Y)
Goal: CategoryTheory.Limits.coequalizer.π f g ≫ (CategoryTheory.Limits.Types.coequalizerIso f g).hom =
  Quot.mk (CategoryTheory.Limits.Types.CoequalizerRel f g)
-- CategoryTheory.Limits.Types.coequalizerIso_quot_comp_inv
@[simp]
theorem coequalizerIso_quot_comp_inv :
    ↾Quot.mk (CoequalizerRel f g) ≫ (coequalizerIso f g).inv = coequalizer.π f g 
Arguments: {X Y : Type u} (f g : X ⟶ Y)
Goal: ↾Quot.mk (CategoryTheory.Limits.Types.CoequalizerRel f g) ≫ (CategoryTheory.Limits.Types.coequalizerIso f g).inv =
  CategoryTheory.Limits.coequalizer.π f g
-- CategoryTheory.Limits.Types.pullbackLimitCone_cone
@[simps]
def pullbackLimitCone (f : X ⟶ Z) (g : Y ⟶ Z) : Limits.LimitCone (cospan f g) 
Arguments: {X Y Z : Type u} (f : X ⟶ Z) (g : Y ⟶ Z)
Goal: (CategoryTheory.Limits.Types.pullbackLimitCone f g).cone = CategoryTheory.Limits.Types.pullbackCone f g
-- CategoryTheory.Limits.Types.pullbackLimitCone_isLimit
@[simps]
def pullbackLimitCone (f : X ⟶ Z) (g : Y ⟶ Z) : Limits.LimitCone (cospan f g) 
Arguments: {X Y Z : Type u} (f : X ⟶ Z) (g : Y ⟶ Z)
Goal: (CategoryTheory.Limits.Types.pullbackLimitCone f g).isLimit =
  (CategoryTheory.Limits.Types.pullbackCone f g).isLimitAux (fun s x => ⟨(s.fst x, s.snd x), ⋯⟩) ⋯ ⋯ ⋯
-- CategoryTheory.Limits.PullbackCone.IsLimit.equivPullbackObj_apply_fst
@[simp]
lemma equivPullbackObj_apply_fst (x : c.pt) : (equivPullbackObj hc x).1.1 = c.fst x 
Arguments: {X Y S : Type v} {f : X ⟶ S} {g : Y ⟶ S} {c : CategoryTheory.Limits.PullbackCone f g} (hc : CategoryTheory.Limits.IsLimit c) (x : c.pt)
Goal: (↑((CategoryTheory.Limits.PullbackCone.IsLimit.equivPullbackObj hc) x)).1 = c.fst x
-- CategoryTheory.Limits.PullbackCone.IsLimit.equivPullbackObj_apply_snd
@[simp]
lemma equivPullbackObj_apply_snd (x : c.pt) : (equivPullbackObj hc x).1.2 = c.snd x 
Arguments: {X Y S : Type v} {f : X ⟶ S} {g : Y ⟶ S} {c : CategoryTheory.Limits.PullbackCone f g} (hc : CategoryTheory.Limits.IsLimit c) (x : c.pt)
Goal: (↑((CategoryTheory.Limits.PullbackCone.IsLimit.equivPullbackObj hc) x)).2 = c.snd x
-- CategoryTheory.Limits.PullbackCone.IsLimit.equivPullbackObj_symm_apply_fst
@[simp]
lemma equivPullbackObj_symm_apply_fst (x : Types.PullbackObj f g) :
    c.fst ((equivPullbackObj hc).symm x) = x.1.1 
Arguments: {X Y S : Type v} {f : X ⟶ S} {g : Y ⟶ S} {c : CategoryTheory.Limits.PullbackCone f g} (hc : CategoryTheory.Limits.IsLimit c) (x : CategoryTheory.Limits.Types.PullbackObj f g)
Goal: c.fst ((CategoryTheory.Limits.PullbackCone.IsLimit.equivPullbackObj hc).symm x) = (↑x).1
-- CategoryTheory.Limits.PullbackCone.IsLimit.equivPullbackObj_symm_apply_snd
@[simp]
lemma equivPullbackObj_symm_apply_snd (x : Types.PullbackObj f g) :
    c.snd ((equivPullbackObj hc).symm x) = x.1.2 
Arguments: {X Y S : Type v} {f : X ⟶ S} {g : Y ⟶ S} {c : CategoryTheory.Limits.PullbackCone f g} (hc : CategoryTheory.Limits.IsLimit c) (x : CategoryTheory.Limits.Types.PullbackObj f g)
Goal: c.snd ((CategoryTheory.Limits.PullbackCone.IsLimit.equivPullbackObj hc).symm x) = (↑x).2
-- CategoryTheory.Limits.PullbackCone.IsLimit.type_ext
lemma type_ext {x y : c.pt} (h₁ : c.fst x = c.fst y) (h₂ : c.snd x = c.snd y) : x = y 
Arguments: {X Y S : Type v} {f : X ⟶ S} {g : Y ⟶ S} {c : CategoryTheory.Limits.PullbackCone f g} (hc : CategoryTheory.Limits.IsLimit c) {x y : c.pt} (h₁ : c.fst x = c.fst y) (h₂ : c.snd x = c.snd y)
Goal: x = y