ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Limits.HasColimitOfHasCoproductsOfHasCoequalizers.buildColimit_pt
@[simps]
def buildColimit
    (hs : ∀ f : Σp : J × J, p.1 ⟶ p.2, c₁.ι.app ⟨f⟩ ≫ s = F.map f.2 ≫ c₂.ι.app ⟨f.1.2⟩)
    (ht : ∀ f : Σp : J × J, p.1 ⟶ p.2, c₁.ι.app ⟨f⟩ ≫ t = c₂.ι.app ⟨f.1.1⟩)
    (i : Cofork s t) : Cocone F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : Type w} [CategoryTheory.SmallCategory J] {F : J ⥤ C} {c₁ : CategoryTheory.Limits.Cofan fun f => F.obj f.fst.1} {c₂ : CategoryTheory.Limits.Cofan F.obj} (s t : c₁.pt ⟶ c₂.pt) (hs : ∀ (f : (p : J × J) × (p.1 ⟶ p.2)), c₁.ι.app { as := f } ≫ s = F.map f.snd ≫ c₂.ι.app { as := f.fst.2 }) (ht : ∀ (f : (p : J × J) × (p.1 ⟶ p.2)), c₁.ι.app { as := f } ≫ t = c₂.ι.app { as := f.fst.1 }) (i : CategoryTheory.Limits.Cofork s t)
Goal: (CategoryTheory.Limits.HasColimitOfHasCoproductsOfHasCoequalizers.buildColimit s t hs ht i).pt = i.pt
-- CategoryTheory.Limits.HasColimitOfHasCoproductsOfHasCoequalizers.buildColimit_ι_app
@[simps]
def buildColimit
    (hs : ∀ f : Σp : J × J, p.1 ⟶ p.2, c₁.ι.app ⟨f⟩ ≫ s = F.map f.2 ≫ c₂.ι.app ⟨f.1.2⟩)
    (ht : ∀ f : Σp : J × J, p.1 ⟶ p.2, c₁.ι.app ⟨f⟩ ≫ t = c₂.ι.app ⟨f.1.1⟩)
    (i : Cofork s t) : Cocone F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : Type w} [CategoryTheory.SmallCategory J] {F : J ⥤ C} {c₁ : CategoryTheory.Limits.Cofan fun f => F.obj f.fst.1} {c₂ : CategoryTheory.Limits.Cofan F.obj} (s t : c₁.pt ⟶ c₂.pt) (hs : ∀ (f : (p : J × J) × (p.1 ⟶ p.2)), c₁.ι.app { as := f } ≫ s = F.map f.snd ≫ c₂.ι.app { as := f.fst.2 }) (ht : ∀ (f : (p : J × J) × (p.1 ⟶ p.2)), c₁.ι.app { as := f } ≫ t = c₂.ι.app { as := f.fst.1 }) (i : CategoryTheory.Limits.Cofork s t) (j : J)
Goal: (CategoryTheory.Limits.HasColimitOfHasCoproductsOfHasCoequalizers.buildColimit s t hs ht i).ι.app j =
  c₂.ι.app { as := j } ≫ i.π
-- CategoryTheory.Limits.hasColimit_of_coequalizer_and_coproduct
theorem hasColimit_of_coequalizer_and_coproduct (F : J ⥤ C) [HasColimit (Discrete.functor F.obj)]
    [HasColimit (Discrete.functor fun f : Σp : J × J, p.1 ⟶ p.2 => F.obj f.1.1)]
    [HasCoequalizers C] : HasColimit F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : Type w} [CategoryTheory.SmallCategory J] (F : J ⥤ C) [CategoryTheory.Limits.HasColimit (CategoryTheory.Discrete.functor F.obj)] [CategoryTheory.Limits.HasColimit (CategoryTheory.Discrete.functor fun f => F.obj f.fst.1)] [CategoryTheory.Limits.HasCoequalizers C]
Goal: CategoryTheory.Limits.HasColimit F
-- CategoryTheory.Limits.has_colimits_of_hasCoequalizers_and_coproducts
theorem has_colimits_of_hasCoequalizers_and_coproducts [HasCoproducts.{w} C] [HasCoequalizers C] :
    HasColimitsOfSize.{w, w} C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasCoproducts C] [CategoryTheory.Limits.HasCoequalizers C]
Goal: CategoryTheory.Limits.HasColimitsOfSize.{w, w, v, u} C
-- CategoryTheory.Limits.hasFiniteColimits_of_hasCoequalizers_and_finite_coproducts
theorem hasFiniteColimits_of_hasCoequalizers_and_finite_coproducts [HasFiniteCoproducts C]
    [HasCoequalizers C] : HasFiniteColimits C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasFiniteCoproducts C] [CategoryTheory.Limits.HasCoequalizers C]
Goal: CategoryTheory.Limits.HasFiniteColimits C
-- CategoryTheory.Limits.hasFiniteColimits_of_hasInitial_and_pushouts
theorem hasFiniteColimits_of_hasInitial_and_pushouts [HasInitial C] [HasPushouts C] :
    HasFiniteColimits C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasInitial C] [CategoryTheory.Limits.HasPushouts C]
Goal: CategoryTheory.Limits.HasFiniteColimits C
-- CategoryTheory.Limits.HasStrictInitialObjects.out
class HasStrictInitialObjects : Prop where
  out : ∀ {I A : C} (f : A ⟶ I), IsInitial I → IsIso f
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [self : CategoryTheory.Limits.HasStrictInitialObjects C] {I A : C} (f : A ⟶ I)
Goal: CategoryTheory.Limits.IsInitial I → CategoryTheory.IsIso f
-- CategoryTheory.Limits.IsInitial.isIso_to
theorem IsInitial.isIso_to (hI : IsInitial I) {A : C} (f : A ⟶ I) : IsIso f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasStrictInitialObjects C] {I : C} (hI : CategoryTheory.Limits.IsInitial I) {A : C} (f : A ⟶ I)
Goal: CategoryTheory.IsIso f
-- CategoryTheory.Limits.IsInitial.strict_hom_ext
theorem IsInitial.strict_hom_ext (hI : IsInitial I) {A : C} (f g : A ⟶ I) : f = g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasStrictInitialObjects C] {I : C} (hI : CategoryTheory.Limits.IsInitial I) {A : C} (f g : A ⟶ I)
Goal: f = g
-- CategoryTheory.Limits.IsInitial.subsingleton_to
theorem IsInitial.subsingleton_to (hI : IsInitial I) {A : C} : Subsingleton (A ⟶ I) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasStrictInitialObjects C] {I : C} (hI : CategoryTheory.Limits.IsInitial I) {A : C}
Goal: Subsingleton (A ⟶ I)
-- CategoryTheory.Limits.mulIsInitial_hom
@[simps! hom]
noncomputable def mulIsInitial (X : C) [HasBinaryProduct X I] (hI : IsInitial I) : X ⨯ I ≅ I 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasStrictInitialObjects C] {I : C} (X : C) [CategoryTheory.Limits.HasBinaryProduct X I] (hI : CategoryTheory.Limits.IsInitial I)
Goal: (CategoryTheory.Limits.mulIsInitial X hI).hom = CategoryTheory.Limits.prod.snd
-- CategoryTheory.Limits.mulIsInitial_inv
@[simp]
theorem mulIsInitial_inv (X : C) [HasBinaryProduct X I] (hI : IsInitial I) :
    (mulIsInitial X hI).inv = hI.to _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasStrictInitialObjects C] {I : C} (X : C) [CategoryTheory.Limits.HasBinaryProduct X I] (hI : CategoryTheory.Limits.IsInitial I)
Goal: (CategoryTheory.Limits.mulIsInitial X hI).inv = hI.to (X ⨯ I)
-- CategoryTheory.Limits.isInitialMul_hom
@[simps! hom]
noncomputable def isInitialMul (X : C) [HasBinaryProduct I X] (hI : IsInitial I) : I ⨯ X ≅ I 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasStrictInitialObjects C] {I : C} (X : C) [CategoryTheory.Limits.HasBinaryProduct I X] (hI : CategoryTheory.Limits.IsInitial I)
Goal: (CategoryTheory.Limits.isInitialMul X hI).hom = CategoryTheory.Limits.prod.fst
-- CategoryTheory.Limits.isInitialMul_inv
@[simp]
theorem isInitialMul_inv (X : C) [HasBinaryProduct I X] (hI : IsInitial I) :
    (isInitialMul X hI).inv = hI.to _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasStrictInitialObjects C] {I : C} (X : C) [CategoryTheory.Limits.HasBinaryProduct I X] (hI : CategoryTheory.Limits.IsInitial I)
Goal: (CategoryTheory.Limits.isInitialMul X hI).inv = hI.to (I ⨯ X)
-- CategoryTheory.Limits.initial.strict_hom_ext
@[ext]
theorem initial.strict_hom_ext {A : C} (f g : A ⟶ ⊥_ C) : f = g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasStrictInitialObjects C] [CategoryTheory.Limits.HasInitial C] {A : C} (f g : A ⟶ ⊥_ C)
Goal: f = g
-- CategoryTheory.Limits.initial.subsingleton_to
theorem initial.subsingleton_to {A : C} : Subsingleton (A ⟶ ⊥_ C) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasStrictInitialObjects C] [CategoryTheory.Limits.HasInitial C] {A : C}
Goal: Subsingleton (A ⟶ ⊥_ C)
-- CategoryTheory.Limits.mulInitial_hom
@[simps! hom]
noncomputable def mulInitial (X : C) [HasBinaryProduct X (⊥_ C)] : X ⨯ ⊥_ C ≅ ⊥_ C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasStrictInitialObjects C] [CategoryTheory.Limits.HasInitial C] (X : C) [CategoryTheory.Limits.HasBinaryProduct X (⊥_ C)]
Goal: (CategoryTheory.Limits.mulInitial X).hom = CategoryTheory.Limits.prod.snd
-- CategoryTheory.Limits.mulInitial_inv
@[simp]
theorem mulInitial_inv (X : C) [HasBinaryProduct X (⊥_ C)] : (mulInitial X).inv = initial.to _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasStrictInitialObjects C] [CategoryTheory.Limits.HasInitial C] (X : C) [CategoryTheory.Limits.HasBinaryProduct X (⊥_ C)]
Goal: (CategoryTheory.Limits.mulInitial X).inv = CategoryTheory.Limits.initial.to (X ⨯ ⊥_ C)
-- CategoryTheory.Limits.initialMul_hom
@[simps! hom]
noncomputable def initialMul (X : C) [HasBinaryProduct (⊥_ C) X] : (⊥_ C) ⨯ X ≅ ⊥_ C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasStrictInitialObjects C] [CategoryTheory.Limits.HasInitial C] (X : C) [CategoryTheory.Limits.HasBinaryProduct (⊥_ C) X]
Goal: (CategoryTheory.Limits.initialMul X).hom = CategoryTheory.Limits.prod.fst
-- CategoryTheory.Limits.initialMul_inv
@[simp]
theorem initialMul_inv (X : C) [HasBinaryProduct (⊥_ C) X] : (initialMul X).inv = initial.to _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasStrictInitialObjects C] [CategoryTheory.Limits.HasInitial C] (X : C) [CategoryTheory.Limits.HasBinaryProduct (⊥_ C) X]
Goal: (CategoryTheory.Limits.initialMul X).inv = CategoryTheory.Limits.initial.to ((⊥_ C) ⨯ X)
-- CategoryTheory.Limits.hasStrictInitialObjects_of_initial_is_strict
theorem hasStrictInitialObjects_of_initial_is_strict [HasInitial C]
    (h : ∀ (A) (f : A ⟶ ⊥_ C), IsIso f) : HasStrictInitialObjects C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasInitial C] (h : ∀ (A : C) (f : A ⟶ ⊥_ C), CategoryTheory.IsIso f)
Goal: CategoryTheory.Limits.HasStrictInitialObjects C
-- CategoryTheory.Limits.HasStrictTerminalObjects.out
class HasStrictTerminalObjects : Prop where
  out : ∀ {I A : C} (f : I ⟶ A), IsTerminal I → IsIso f
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [self : CategoryTheory.Limits.HasStrictTerminalObjects C] {I A : C} (f : I ⟶ A)
Goal: CategoryTheory.Limits.IsTerminal I → CategoryTheory.IsIso f
-- CategoryTheory.Limits.IsTerminal.isIso_from
theorem IsTerminal.isIso_from (hI : IsTerminal I) {A : C} (f : I ⟶ A) : IsIso f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasStrictTerminalObjects C] {I : C} (hI : CategoryTheory.Limits.IsTerminal I) {A : C} (f : I ⟶ A)
Goal: CategoryTheory.IsIso f
-- CategoryTheory.Limits.IsTerminal.strict_hom_ext
theorem IsTerminal.strict_hom_ext (hI : IsTerminal I) {A : C} (f g : I ⟶ A) : f = g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasStrictTerminalObjects C] {I : C} (hI : CategoryTheory.Limits.IsTerminal I) {A : C} (f g : I ⟶ A)
Goal: f = g
-- CategoryTheory.Limits.IsTerminal.subsingleton_to
theorem IsTerminal.subsingleton_to (hI : IsTerminal I) {A : C} : Subsingleton (I ⟶ A) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasStrictTerminalObjects C] {I : C} (hI : CategoryTheory.Limits.IsTerminal I) {A : C}
Goal: Subsingleton (I ⟶ A)
-- CategoryTheory.Limits.limit_π_isIso_of_is_strict_terminal
theorem limit_π_isIso_of_is_strict_terminal (F : J ⥤ C) [HasLimit F] (i : J)
    (H : ∀ (j) (_ : j ≠ i), IsTerminal (F.obj j)) [Subsingleton (i ⟶ i)] : IsIso (limit.π F i) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasStrictTerminalObjects C] {J : Type v} [CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J C) [CategoryTheory.Limits.HasLimit F] (i : J) (H : (j : J) → j ≠ i → CategoryTheory.Limits.IsTerminal (F.obj j)) [Subsingleton (i ⟶ i)]
Goal: CategoryTheory.IsIso (CategoryTheory.Limits.limit.π F i)
-- CategoryTheory.Limits.terminal.strict_hom_ext
@[ext]
theorem terminal.strict_hom_ext {A : C} (f g : ⊤_ C ⟶ A) : f = g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasStrictTerminalObjects C] [CategoryTheory.Limits.HasTerminal C] {A : C} (f g : ⊤_ C ⟶ A)
Goal: f = g
-- CategoryTheory.Limits.terminal.subsingleton_to
theorem terminal.subsingleton_to {A : C} : Subsingleton (⊤_ C ⟶ A) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasStrictTerminalObjects C] [CategoryTheory.Limits.HasTerminal C] {A : C}
Goal: Subsingleton (⊤_ C ⟶ A)
-- CategoryTheory.Limits.hasStrictTerminalObjects_of_terminal_is_strict
theorem hasStrictTerminalObjects_of_terminal_is_strict (I : C) (h : ∀ (A) (f : I ⟶ A), IsIso f) :
    HasStrictTerminalObjects C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (I : C) (h : ∀ (A : C) (f : I ⟶ A), CategoryTheory.IsIso f)
Goal: CategoryTheory.Limits.HasStrictTerminalObjects C
-- CategoryTheory.Limits.Types.isLimit_iff
theorem isLimit_iff (c : Cone F) :
    Nonempty (IsLimit c) ↔ ∀ s ∈ F.sections, ∃! x : c.pt, ∀ j, c.π.app j x = s j 
Arguments: {J : Type v} [CategoryTheory.Category.{w, v} J] {F : J ⥤ Type u} (c : CategoryTheory.Limits.Cone F)
Goal: Nonempty (CategoryTheory.Limits.IsLimit c) ↔ ∀ s ∈ F.sections, ∃! x, ∀ (j : J), c.π.app j x = s j
-- CategoryTheory.Limits.Types.isLimit_iff_bijective_sectionOfCone
theorem isLimit_iff_bijective_sectionOfCone (c : Cone F) :
    Nonempty (IsLimit c) ↔ (Types.sectionOfCone c).Bijective 
Arguments: {J : Type v} [CategoryTheory.Category.{w, v} J] {F : J ⥤ Type u} (c : CategoryTheory.Limits.Cone F)
Goal: Nonempty (CategoryTheory.Limits.IsLimit c) ↔ Function.Bijective (CategoryTheory.Limits.Types.sectionOfCone c)
-- CategoryTheory.Limits.Types.isLimitEquivSections_apply
@[simp]
theorem isLimitEquivSections_apply {c : Cone F} (t : IsLimit c) (j : J)
    (x : c.pt) : (isLimitEquivSections t x : ∀ j, F.obj j) j = c.π.app j x 
Arguments: {J : Type v} [CategoryTheory.Category.{w, v} J] {F : J ⥤ Type u} {c : CategoryTheory.Limits.Cone F} (t : CategoryTheory.Limits.IsLimit c) (j : J) (x : c.pt)
Goal: ↑((CategoryTheory.Limits.Types.isLimitEquivSections t) x) j = c.π.app j x
-- CategoryTheory.Limits.Types.isLimitEquivSections_symm_apply
@[simp]
theorem isLimitEquivSections_symm_apply {c : Cone F} (t : IsLimit c)
    (x : F.sections) (j : J) :
    c.π.app j ((isLimitEquivSections t).symm x) = (x : ∀ j, F.obj j) j 
Arguments: {J : Type v} [CategoryTheory.Category.{w, v} J] {F : J ⥤ Type u} {c : CategoryTheory.Limits.Cone F} (t : CategoryTheory.Limits.IsLimit c) (x : ↑F.sections) (j : J)
Goal: c.π.app j ((CategoryTheory.Limits.Types.isLimitEquivSections t).symm x) = ↑x j
-- CategoryTheory.Limits.Types.Small.limitCone_pt
@[simps]
noncomputable def limitCone : Cone F 
Arguments: {J : Type v} [CategoryTheory.Category.{w, v} J] (F : J ⥤ Type u) [Small.{u, max u v} ↑F.sections]
Goal: (CategoryTheory.Limits.Types.Small.limitCone F).pt = Shrink.{u, max u v} ↑F.sections
-- CategoryTheory.Limits.Types.Small.limitCone_π_app
@[simps]
noncomputable def limitCone : Cone F 
Arguments: {J : Type v} [CategoryTheory.Category.{w, v} J] (F : J ⥤ Type u) [Small.{u, max u v} ↑F.sections] (j : J) (u : ((CategoryTheory.Functor.const J).obj (Shrink.{u, max u v} ↑F.sections)).obj j)
Goal: (CategoryTheory.Limits.Types.Small.limitCone F).π.app j u = ↑((equivShrink ↑F.sections).symm u) j
-- CategoryTheory.Limits.Types.Small.limitCone_pt_ext
@[ext]
lemma limitCone_pt_ext {x y : (limitCone F).pt}
    (w : (equivShrink F.sections).symm x = (equivShrink F.sections).symm y) : x = y 
Arguments: {J : Type v} [CategoryTheory.Category.{w, v} J] (F : J ⥤ Type u) [Small.{u, max u v} ↑F.sections] {x y : (CategoryTheory.Limits.Types.Small.limitCone F).pt} (w : (equivShrink ↑F.sections).symm x = (equivShrink ↑F.sections).symm y)
Goal: x = y
-- CategoryTheory.Limits.Types.Small.limitConeIsLimit_lift
@[simps]
noncomputable def limitConeIsLimit : IsLimit (limitCone.{v, u} F) 
Arguments: {J : Type v} [CategoryTheory.Category.{w, v} J] (F : J ⥤ Type u) [Small.{u, max u v} ↑F.sections] (s : CategoryTheory.Limits.Cone F) (v : s.pt)
Goal: (CategoryTheory.Limits.Types.Small.limitConeIsLimit F).lift s v = (equivShrink ↑F.sections) ⟨fun j => s.π.app j v, ⋯⟩
-- CategoryTheory.Limits.Types.hasLimit_iff_small_sections
theorem hasLimit_iff_small_sections (F : J ⥤ Type u) : HasLimit F ↔ Small.{u} F.sections 
Arguments: {J : Type v} [CategoryTheory.Category.{w, v} J] (F : J ⥤ Type u)
Goal: CategoryTheory.Limits.HasLimit F ↔ Small.{u, max u v} ↑F.sections
-- CategoryTheory.Limits.Types.limitCone_π_app
@[simps]
noncomputable def limitCone (F : J ⥤ TypeMax.{v, u}) : Cone F 
Arguments: {J : Type v} [CategoryTheory.Category.{w, v} J] (F : J ⥤ TypeMax) (j : J) (u : ((CategoryTheory.Functor.const J).obj ↑F.sections).obj j)
Goal: (CategoryTheory.Limits.Types.limitCone F).π.app j u = ↑u j
-- CategoryTheory.Limits.Types.limitCone_pt
@[simps]
noncomputable def limitCone (F : J ⥤ TypeMax.{v, u}) : Cone F 
Arguments: {J : Type v} [CategoryTheory.Category.{w, v} J] (F : J ⥤ TypeMax)
Goal: (CategoryTheory.Limits.Types.limitCone F).pt = ↑F.sections
-- CategoryTheory.Limits.Types.limitConeIsLimit_lift_coe
@[simps]
noncomputable def limitConeIsLimit (F : J ⥤ TypeMax.{v, u}) : IsLimit (limitCone F) 
Arguments: {J : Type v} [CategoryTheory.Category.{w, v} J] (F : J ⥤ TypeMax) (s : CategoryTheory.Limits.Cone F) (v : s.pt) (j : J)
Goal: ↑((CategoryTheory.Limits.Types.limitConeIsLimit F).lift s v) j = s.π.app j v
-- CategoryTheory.Limits.Types.limitEquivSections_apply
@[simp]
theorem limitEquivSections_apply (x : limit F) (j : J) :
    ((limitEquivSections F) x : ∀ j, F.obj j) j = limit.π F j x 
Arguments: {J : Type v} [CategoryTheory.Category.{w, v} J] (F : J ⥤ Type u) [CategoryTheory.Limits.HasLimit F] (x : CategoryTheory.Limits.limit F) (j : J)
Goal: ↑((CategoryTheory.Limits.Types.limitEquivSections F) x) j = CategoryTheory.Limits.limit.π F j x
-- CategoryTheory.Limits.Types.limitEquivSections_symm_apply
@[simp]
theorem limitEquivSections_symm_apply (x : F.sections) (j : J) :
    limit.π F j ((limitEquivSections F).symm x) = (x : ∀ j, F.obj j) j 
Arguments: {J : Type v} [CategoryTheory.Category.{w, v} J] (F : J ⥤ Type u) [CategoryTheory.Limits.HasLimit F] (x : ↑F.sections) (j : J)
Goal: CategoryTheory.Limits.limit.π F j ((CategoryTheory.Limits.Types.limitEquivSections F).symm x) = ↑x j
-- CategoryTheory.Limits.Types.Limit.π_mk
@[simp]
theorem Limit.π_mk (x : ∀ j, F.obj j) (h : ∀ (j j') (f : j ⟶ j'), F.map f (x j) = x j') (j) :
    limit.π F j (Limit.mk F x h) = x j 
Arguments: {J : Type v} [CategoryTheory.Category.{w, v} J] (F : J ⥤ Type u) [CategoryTheory.Limits.HasLimit F] (x : (j : J) → F.obj j) (h : ∀ (j j' : J) (f : j ⟶ j'), F.map f (x j) = x j') (j : J)
Goal: CategoryTheory.Limits.limit.π F j (CategoryTheory.Limits.Types.Limit.mk F x h) = x j
-- CategoryTheory.Limits.Types.limit_ext
@[ext]
theorem limit_ext (x y : limit F) (w : ∀ j, limit.π F j x = limit.π F j y) : x = y 
Arguments: {J : Type v} [CategoryTheory.Category.{w, v} J] (F : J ⥤ Type u) [CategoryTheory.Limits.HasLimit F] (x y : CategoryTheory.Limits.limit F) (w : ∀ (j : J), CategoryTheory.Limits.limit.π F j x = CategoryTheory.Limits.limit.π F j y)
Goal: x = y
-- CategoryTheory.Limits.Types.limit_ext'
@[ext]
theorem limit_ext' (F : J ⥤ Type v) (x y : limit F) (w : ∀ j, limit.π F j x = limit.π F j y) :
    x = y 
Arguments: {J : Type v} [CategoryTheory.Category.{w, v} J] (F : J ⥤ Type v) (x y : CategoryTheory.Limits.limit F) (w : ∀ (j : J), CategoryTheory.Limits.limit.π F j x = CategoryTheory.Limits.limit.π F j y)
Goal: x = y
-- CategoryTheory.Limits.Types.limit_ext_iff
theorem limit_ext_iff (x y : limit F) : x = y ↔ ∀ j, limit.π F j x = limit.π F j y 
Arguments: {J : Type v} [CategoryTheory.Category.{w, v} J] (F : J ⥤ Type u) [CategoryTheory.Limits.HasLimit F] (x y : CategoryTheory.Limits.limit F)
Goal: x = y ↔ ∀ (j : J), CategoryTheory.Limits.limit.π F j x = CategoryTheory.Limits.limit.π F j y
-- CategoryTheory.Limits.Types.limit_ext_iff'
theorem limit_ext_iff' (F : J ⥤ Type v) (x y : limit F) :
    x = y ↔ ∀ j, limit.π F j x = limit.π F j y 
Arguments: {J : Type v} [CategoryTheory.Category.{w, v} J] (F : J ⥤ Type v) (x y : CategoryTheory.Limits.limit F)
Goal: x = y ↔ ∀ (j : J), CategoryTheory.Limits.limit.π F j x = CategoryTheory.Limits.limit.π F j y
-- CategoryTheory.Limits.Types.Limit.w_apply
theorem Limit.w_apply {j j' : J} {x : limit F} (f : j ⟶ j') :
    F.map f (limit.π F j x) = limit.π F j' x 
Arguments: {J : Type v} [CategoryTheory.Category.{w, v} J] {F : J ⥤ Type u} [CategoryTheory.Limits.HasLimit F] {j j' : J} {x : CategoryTheory.Limits.limit F} (f : j ⟶ j')
Goal: F.map f (CategoryTheory.Limits.limit.π F j x) = CategoryTheory.Limits.limit.π F j' x
-- CategoryTheory.Limits.Types.Limit.lift_π_apply
theorem Limit.lift_π_apply (s : Cone F) (j : J) (x : s.pt) :
    limit.π F j (limit.lift F s x) = s.π.app j x 
Arguments: {J : Type v} [CategoryTheory.Category.{w, v} J] (F : J ⥤ Type u) [CategoryTheory.Limits.HasLimit F] (s : CategoryTheory.Limits.Cone F) (j : J) (x : s.pt)
Goal: CategoryTheory.Limits.limit.π F j (CategoryTheory.Limits.limit.lift F s x) = s.π.app j x
-- CategoryTheory.Limits.Types.Limit.map_π_apply
theorem Limit.map_π_apply {F G : J ⥤ Type u} [HasLimit F] [HasLimit G] (α : F ⟶ G) (j : J)
    (x : limit F) : limit.π G j (limMap α x) = α.app j (limit.π F j x) 
Arguments: {J : Type v} [CategoryTheory.Category.{w, v} J] {F G : J ⥤ Type u} [CategoryTheory.Limits.HasLimit F] [CategoryTheory.Limits.HasLimit G] (α : F ⟶ G) (j : J) (x : CategoryTheory.Limits.limit F)
Goal: CategoryTheory.Limits.limit.π G j (CategoryTheory.Limits.limMap α x) = α.app j (CategoryTheory.Limits.limit.π F j x)
-- CategoryTheory.Limits.Types.Limit.w_apply'
@[simp]
theorem Limit.w_apply' {F : J ⥤ Type v} {j j' : J} {x : limit F} (f : j ⟶ j') :
    F.map f (limit.π F j x) = limit.π F j' x 
Arguments: {J : Type v} [CategoryTheory.Category.{w, v} J] {F : J ⥤ Type v} {j j' : J} {x : CategoryTheory.Limits.limit F} (f : j ⟶ j')
Goal: F.map f (CategoryTheory.Limits.limit.π F j x) = CategoryTheory.Limits.limit.π F j' x
-- CategoryTheory.Limits.Types.Limit.lift_π_apply'
@[simp]
theorem Limit.lift_π_apply' (F : J ⥤ Type v) (s : Cone F) (j : J) (x : s.pt) :
    limit.π F j (limit.lift F s x) = s.π.app j x 
Arguments: {J : Type v} [CategoryTheory.Category.{w, v} J] (F : J ⥤ Type v) (s : CategoryTheory.Limits.Cone F) (j : J) (x : s.pt)
Goal: CategoryTheory.Limits.limit.π F j (CategoryTheory.Limits.limit.lift F s x) = s.π.app j x
-- CategoryTheory.Limits.Types.Limit.map_π_apply'
@[simp]
theorem Limit.map_π_apply' {F G : J ⥤ Type v} (α : F ⟶ G) (j : J) (x : limit F) :
    limit.π G j (limMap α x) = α.app j (limit.π F j x) 
Arguments: {J : Type v} [CategoryTheory.Category.{w, v} J] {F G : J ⥤ Type v} (α : F ⟶ G) (j : J) (x : CategoryTheory.Limits.limit F)
Goal: CategoryTheory.Limits.limit.π G j (CategoryTheory.Limits.limMap α x) = α.app j (CategoryTheory.Limits.limit.π F j x)
-- CategoryTheory.Limits.Types.Quot.jointly_surjective
lemma Quot.jointly_surjective {F : J ⥤ Type u} (x : Quot F) : ∃ j y, x = Quot.ι F j y 
Arguments: {J : Type v} [CategoryTheory.Category.{w, v} J] {F : J ⥤ Type u} (x : CategoryTheory.Limits.Types.Quot F)
Goal: ∃ j y, x = CategoryTheory.Limits.Types.Quot.ι F j y
-- CategoryTheory.Limits.Types.Quot.ι_desc
@[simp]
lemma Quot.ι_desc (j : J) (x : F.obj j) : Quot.desc c (Quot.ι F j x) = c.ι.app j x 
Arguments: {J : Type v} [CategoryTheory.Category.{w, v} J] {F : J ⥤ Type u} (c : CategoryTheory.Limits.Cocone F) (j : J) (x : F.obj j)
Goal: CategoryTheory.Limits.Types.Quot.desc c (CategoryTheory.Limits.Types.Quot.ι F j x) = c.ι.app j x
-- CategoryTheory.Limits.Types.Quot.map_ι
@[simp]
lemma Quot.map_ι {j j' : J} {f : j ⟶ j'} (x : F.obj j) : Quot.ι F j' (F.map f x) = Quot.ι F j x 
Arguments: {J : Type v} [CategoryTheory.Category.{w, v} J] {F : J ⥤ Type u} {j j' : J} {f : j ⟶ j'} (x : F.obj j)
Goal: CategoryTheory.Limits.Types.Quot.ι F j' (F.map f x) = CategoryTheory.Limits.Types.Quot.ι F j x
-- CategoryTheory.Limits.Types.toCocone_pt
@[simps]
def toCocone {α : Type u} (f : Quot F → α) : Cocone F 
Arguments: {J : Type v} [CategoryTheory.Category.{w, v} J] {F : J ⥤ Type u} {α : Type u} (f : CategoryTheory.Limits.Types.Quot F → α)
Goal: (CategoryTheory.Limits.Types.toCocone f).pt = α
-- CategoryTheory.Limits.Types.toCocone_ι_app
@[simps]
def toCocone {α : Type u} (f : Quot F → α) : Cocone F 
Arguments: {J : Type v} [CategoryTheory.Category.{w, v} J] {F : J ⥤ Type u} {α : Type u} (f : CategoryTheory.Limits.Types.Quot F → α) (j : J)
Goal: ∀ (a : F.obj j), (CategoryTheory.Limits.Types.toCocone f).ι.app j a = (f ∘ CategoryTheory.Limits.Types.Quot.ι F j) a