File: Mathlib/CategoryTheory/Limits/ConcreteCategory.lean

full_name: CategoryTheory.Limits.Concrete.small_sections_of_hasLimit
code: /-- If a functor `G : J ⥤ C` to a concrete category has a limit and that `forget C`
is corepresentable, then `(G ⋙ forget C).sections` is small. -/
lemma small_sections_of_hasLimit
    {C : Type u} [Category.{v} C] [ConcreteCategory.{v} C]
    [(forget C).Corepresentable] {J : Type w} [Category.{t} J] (G : J ⥤ C) [HasLimit G] :
    Small.{v} (G ⋙ forget C).sections 
goal: Small.{v, max v w} ↑(G ⋙ CategoryTheory.forget C).sections

full_name: CategoryTheory.Limits.Concrete.to_product_injective_of_isLimit
code: theorem to_product_injective_of_isLimit {D : Cone F} (hD : IsLimit D) :
    Function.Injective fun (x : D.pt) (j : J) => D.π.app j x 
goal: Function.Injective fun x j => (D.π.app j) x

full_name: CategoryTheory.Limits.Concrete.isLimit_ext
code: theorem isLimit_ext {D : Cone F} (hD : IsLimit D) (x y : D.pt) :
    (∀ j, D.π.app j x = D.π.app j y) → x = y 
goal: (∀ (j : J), (D.π.app j) x = (D.π.app j) y) → x = y

full_name: CategoryTheory.Limits.Concrete.limit_ext
code: theorem limit_ext [HasLimit F] (x y : ↑(limit F)) :
    (∀ j, limit.π F j x = limit.π F j y) → x = y 
goal: (∀ (j : J), (CategoryTheory.Limits.limit.π F j) x = (CategoryTheory.Limits.limit.π F j) y) → x = y

full_name: CategoryTheory.Limits.Concrete.surjective_π_app_zero_of_surjective_map
code: /--
Given surjections `⋯ ⟶ Xₙ₊₁ ⟶ Xₙ ⟶ ⋯ ⟶ X₀` in a concrete category whose forgetful functor
preserves sequential limits, the projection map `lim Xₙ ⟶ X₀` is surjective.
-/
lemma surjective_π_app_zero_of_surjective_map {C : Type u} [Category.{v} C] [ConcreteCategory.{v} C]
    [PreservesLimitsOfShape ℕᵒᵖ (forget C)] {F : ℕᵒᵖ ⥤ C} {c : Cone F}
    (hc : IsLimit c) (hF : ∀ n, Function.Surjective (F.map (homOfLE (Nat.le_succ n)).op)) :
    Function.Surjective (c.π.app ⟨0⟩) 
goal: Function.Surjective ⇑(c.π.app (Opposite.op 0))

full_name: CategoryTheory.Limits.Concrete.from_union_surjective_of_isColimit
code: theorem from_union_surjective_of_isColimit {D : Cocone F} (hD : IsColimit D) :
    let ff : (Σj : J, F.obj j) → D.pt := fun a => D.ι.app a.1 a.2
    Function.Surjective ff 
goal: let ff := fun a => (D.ι.app a.fst) a.snd;
Function.Surjective ff

full_name: CategoryTheory.Limits.Concrete.isColimit_exists_rep
code: theorem isColimit_exists_rep {D : Cocone F} (hD : IsColimit D) (x : D.pt) :
    ∃ (j : J) (y : F.obj j), D.ι.app j y = x 
goal: ∃ j y, (D.ι.app j) y = x

full_name: CategoryTheory.Limits.Concrete.colimit_exists_rep
code: theorem colimit_exists_rep [HasColimit F] (x : ↑(colimit F)) :
    ∃ (j : J) (y : F.obj j), colimit.ι F j y = x 
goal: ∃ j y, (CategoryTheory.Limits.colimit.ι F j) y = x

full_name: CategoryTheory.Limits.Concrete.isColimit_rep_eq_of_exists
code: theorem isColimit_rep_eq_of_exists {D : Cocone F} {i j : J} (x : F.obj i) (y : F.obj j)
    (h : ∃ (k : _) (f : i ⟶ k) (g : j ⟶ k), F.map f x = F.map g y) :
    D.ι.app i x = D.ι.app j y 
goal: (D.ι.app i) x = (D.ι.app j) y

full_name: CategoryTheory.Limits.Concrete.colimit_rep_eq_of_exists
code: theorem colimit_rep_eq_of_exists [HasColimit F] {i j : J} (x : F.obj i) (y : F.obj j)
    (h : ∃ (k : _) (f : i ⟶ k) (g : j ⟶ k), F.map f x = F.map g y) :
    colimit.ι F i x = colimit.ι F j y 
goal: (CategoryTheory.Limits.colimit.ι F i) x = (CategoryTheory.Limits.colimit.ι F j) y

full_name: CategoryTheory.Limits.Concrete.isColimit_exists_of_rep_eq
code: theorem isColimit_exists_of_rep_eq {D : Cocone F} {i j : J} (hD : IsColimit D)
    (x : F.obj i) (y : F.obj j) (h : D.ι.app _ x = D.ι.app _ y) :
    ∃ (k : _) (f : i ⟶ k) (g : j ⟶ k), F.map f x = F.map g y 
goal: ∃ k f g, (F.map f) x = (F.map g) y

full_name: CategoryTheory.Limits.Concrete.isColimit_rep_eq_iff_exists
code: theorem isColimit_rep_eq_iff_exists {D : Cocone F} {i j : J} (hD : IsColimit D)
    (x : F.obj i) (y : F.obj j) :
    D.ι.app i x = D.ι.app j y ↔ ∃ (k : _) (f : i ⟶ k) (g : j ⟶ k), F.map f x = F.map g y 
goal: (D.ι.app i) x = (D.ι.app j) y ↔ ∃ k f g, (F.map f) x = (F.map g) y

full_name: CategoryTheory.Limits.Concrete.colimit_exists_of_rep_eq
code: theorem colimit_exists_of_rep_eq [HasColimit F] {i j : J} (x : F.obj i) (y : F.obj j)
    (h : colimit.ι F _ x = colimit.ι F _ y) :
    ∃ (k : _) (f : i ⟶ k) (g : j ⟶ k), F.map f x = F.map g y 
goal: ∃ k f g, (F.map f) x = (F.map g) y

full_name: CategoryTheory.Limits.Concrete.colimit_rep_eq_iff_exists
code: theorem colimit_rep_eq_iff_exists [HasColimit F] {i j : J} (x : F.obj i) (y : F.obj j) :
    colimit.ι F i x = colimit.ι F j y ↔ ∃ (k : _) (f : i ⟶ k) (g : j ⟶ k), F.map f x = F.map g y 
goal: (CategoryTheory.Limits.colimit.ι F i) x = (CategoryTheory.Limits.colimit.ι F j) y ↔ ∃ k f g, (F.map f) x = (F.map g) y