File: Mathlib/CategoryTheory/Generator.lean

full_name: CategoryTheory.IsSeparating
code: /-- We say that `𝒢` is a separating set if the functors `C(G, -)` for `G ∈ 𝒢` are collectively
    faithful, i.e., if `h ≫ f = h ≫ g` for all `h` with domain in `𝒢` implies `f = g`. -/
def IsSeparating (𝒢 : Set C) : Prop 
goal: Prop

full_name: CategoryTheory.IsCoseparating
code: /-- We say that `𝒢` is a coseparating set if the functors `C(-, G)` for `G ∈ 𝒢` are collectively
    faithful, i.e., if `f ≫ h = g ≫ h` for all `h` with codomain in `𝒢` implies `f = g`. -/
def IsCoseparating (𝒢 : Set C) : Prop 
goal: Prop

full_name: CategoryTheory.IsDetecting
code: /-- We say that `𝒢` is a detecting set if the functors `C(G, -)` collectively reflect isomorphisms,
    i.e., if any `h` with domain in `𝒢` uniquely factors through `f`, then `f` is an isomorphism. -/
def IsDetecting (𝒢 : Set C) : Prop 
goal: Prop

full_name: CategoryTheory.IsCodetecting
code: /-- We say that `𝒢` is a codetecting set if the functors `C(-, G)` collectively reflect
    isomorphisms, i.e., if any `h` with codomain in `G` uniquely factors through `f`, then `f` is
    an isomorphism. -/
def IsCodetecting (𝒢 : Set C) : Prop 
goal: Prop

full_name: CategoryTheory.isSeparating_op_iff
code: theorem isSeparating_op_iff (𝒢 : Set C) : IsSeparating 𝒢.op ↔ IsCoseparating 𝒢 
goal: CategoryTheory.IsSeparating 𝒢.op ↔ CategoryTheory.IsCoseparating 𝒢

full_name: CategoryTheory.isCoseparating_op_iff
code: theorem isCoseparating_op_iff (𝒢 : Set C) : IsCoseparating 𝒢.op ↔ IsSeparating 𝒢 
goal: CategoryTheory.IsCoseparating 𝒢.op ↔ CategoryTheory.IsSeparating 𝒢

full_name: CategoryTheory.isCoseparating_unop_iff
code: theorem isCoseparating_unop_iff (𝒢 : Set Cᵒᵖ) : IsCoseparating 𝒢.unop ↔ IsSeparating 𝒢 
goal: CategoryTheory.IsCoseparating 𝒢.unop ↔ CategoryTheory.IsSeparating 𝒢

full_name: CategoryTheory.isSeparating_unop_iff
code: theorem isSeparating_unop_iff (𝒢 : Set Cᵒᵖ) : IsSeparating 𝒢.unop ↔ IsCoseparating 𝒢 
goal: CategoryTheory.IsSeparating 𝒢.unop ↔ CategoryTheory.IsCoseparating 𝒢

full_name: CategoryTheory.isDetecting_op_iff
code: theorem isDetecting_op_iff (𝒢 : Set C) : IsDetecting 𝒢.op ↔ IsCodetecting 𝒢 
goal: CategoryTheory.IsDetecting 𝒢.op ↔ CategoryTheory.IsCodetecting 𝒢

full_name: CategoryTheory.isCodetecting_op_iff
code: theorem isCodetecting_op_iff (𝒢 : Set C) : IsCodetecting 𝒢.op ↔ IsDetecting 𝒢 
goal: CategoryTheory.IsCodetecting 𝒢.op ↔ CategoryTheory.IsDetecting 𝒢

full_name: CategoryTheory.isDetecting_unop_iff
code: theorem isDetecting_unop_iff (𝒢 : Set Cᵒᵖ) : IsDetecting 𝒢.unop ↔ IsCodetecting 𝒢 
goal: CategoryTheory.IsDetecting 𝒢.unop ↔ CategoryTheory.IsCodetecting 𝒢

full_name: CategoryTheory.isCodetecting_unop_iff
code: theorem isCodetecting_unop_iff {𝒢 : Set Cᵒᵖ} : IsCodetecting 𝒢.unop ↔ IsDetecting 𝒢 
goal: CategoryTheory.IsCodetecting 𝒢.unop ↔ CategoryTheory.IsDetecting 𝒢

full_name: CategoryTheory.IsDetecting.isSeparating
code: theorem IsDetecting.isSeparating [HasEqualizers C] {𝒢 : Set C} (h𝒢 : IsDetecting 𝒢) :
    IsSeparating 𝒢 
goal: CategoryTheory.IsSeparating 𝒢

full_name: CategoryTheory.IsCodetecting.isCoseparating
code: theorem IsCodetecting.isCoseparating [HasCoequalizers C] {𝒢 : Set C} :
    IsCodetecting 𝒢 → IsCoseparating 𝒢 
goal: CategoryTheory.IsCodetecting 𝒢 → CategoryTheory.IsCoseparating 𝒢

full_name: CategoryTheory.IsSeparating.isDetecting
code: theorem IsSeparating.isDetecting [Balanced C] {𝒢 : Set C} (h𝒢 : IsSeparating 𝒢) :
    IsDetecting 𝒢 
goal: CategoryTheory.IsDetecting 𝒢

full_name: CategoryTheory.IsCoseparating.isCodetecting
code: theorem IsCoseparating.isCodetecting [Balanced C] {𝒢 : Set C} :
    IsCoseparating 𝒢 → IsCodetecting 𝒢 
goal: CategoryTheory.IsCoseparating 𝒢 → CategoryTheory.IsCodetecting 𝒢

full_name: CategoryTheory.isDetecting_iff_isSeparating
code: theorem isDetecting_iff_isSeparating [HasEqualizers C] [Balanced C] (𝒢 : Set C) :
    IsDetecting 𝒢 ↔ IsSeparating 𝒢 
goal: CategoryTheory.IsDetecting 𝒢 ↔ CategoryTheory.IsSeparating 𝒢

full_name: CategoryTheory.isCodetecting_iff_isCoseparating
code: theorem isCodetecting_iff_isCoseparating [HasCoequalizers C] [Balanced C] {𝒢 : Set C} :
    IsCodetecting 𝒢 ↔ IsCoseparating 𝒢 
goal: CategoryTheory.IsCodetecting 𝒢 ↔ CategoryTheory.IsCoseparating 𝒢

full_name: CategoryTheory.IsSeparating.mono
code: theorem IsSeparating.mono {𝒢 : Set C} (h𝒢 : IsSeparating 𝒢) {ℋ : Set C} (h𝒢ℋ : 𝒢 ⊆ ℋ) :
    IsSeparating ℋ 
goal: CategoryTheory.IsSeparating ℋ

full_name: CategoryTheory.IsCoseparating.mono
code: theorem IsCoseparating.mono {𝒢 : Set C} (h𝒢 : IsCoseparating 𝒢) {ℋ : Set C} (h𝒢ℋ : 𝒢 ⊆ ℋ) :
    IsCoseparating ℋ 
goal: CategoryTheory.IsCoseparating ℋ

full_name: CategoryTheory.IsDetecting.mono
code: theorem IsDetecting.mono {𝒢 : Set C} (h𝒢 : IsDetecting 𝒢) {ℋ : Set C} (h𝒢ℋ : 𝒢 ⊆ ℋ) :
    IsDetecting ℋ 
goal: CategoryTheory.IsDetecting ℋ

full_name: CategoryTheory.IsCodetecting.mono
code: theorem IsCodetecting.mono {𝒢 : Set C} (h𝒢 : IsCodetecting 𝒢) {ℋ : Set C} (h𝒢ℋ : 𝒢 ⊆ ℋ) :
    IsCodetecting ℋ 
goal: CategoryTheory.IsCodetecting ℋ

full_name: CategoryTheory.thin_of_isSeparating_empty
code: theorem thin_of_isSeparating_empty (h : IsSeparating (∅ : Set C)) : Quiver.IsThin C 
goal: Quiver.IsThin C

full_name: CategoryTheory.isSeparating_empty_of_thin
code: theorem isSeparating_empty_of_thin [Quiver.IsThin C] : IsSeparating (∅ : Set C) 
goal: CategoryTheory.IsSeparating ∅

full_name: CategoryTheory.thin_of_isCoseparating_empty
code: theorem thin_of_isCoseparating_empty (h : IsCoseparating (∅ : Set C)) : Quiver.IsThin C 
goal: Quiver.IsThin C

full_name: CategoryTheory.isCoseparating_empty_of_thin
code: theorem isCoseparating_empty_of_thin [Quiver.IsThin C] : IsCoseparating (∅ : Set C) 
goal: CategoryTheory.IsCoseparating ∅

full_name: CategoryTheory.groupoid_of_isDetecting_empty
code: theorem groupoid_of_isDetecting_empty (h : IsDetecting (∅ : Set C)) {X Y : C} (f : X ⟶ Y) :
    IsIso f 
goal: CategoryTheory.IsIso f

full_name: CategoryTheory.isDetecting_empty_of_groupoid
code: theorem isDetecting_empty_of_groupoid [∀ {X Y : C} (f : X ⟶ Y), IsIso f] :
    IsDetecting (∅ : Set C) 
goal: CategoryTheory.IsDetecting ∅

full_name: CategoryTheory.groupoid_of_isCodetecting_empty
code: theorem groupoid_of_isCodetecting_empty (h : IsCodetecting (∅ : Set C)) {X Y : C} (f : X ⟶ Y) :
    IsIso f 
goal: CategoryTheory.IsIso f

full_name: CategoryTheory.isCodetecting_empty_of_groupoid
code: theorem isCodetecting_empty_of_groupoid [∀ {X Y : C} (f : X ⟶ Y), IsIso f] :
    IsCodetecting (∅ : Set C) 
goal: CategoryTheory.IsCodetecting ∅

full_name: CategoryTheory.isSeparating_iff_epi
code: theorem isSeparating_iff_epi (𝒢 : Set C)
    [∀ A : C, HasCoproduct fun f : ΣG : 𝒢, (G : C) ⟶ A => (f.1 : C)] :
    IsSeparating 𝒢 ↔ ∀ A : C, Epi (Sigma.desc (@Sigma.snd 𝒢 fun G => (G : C) ⟶ A)) 
goal: CategoryTheory.IsSeparating 𝒢 ↔ ∀ (A : C), CategoryTheory.Epi (CategoryTheory.Limits.Sigma.desc Sigma.snd)

full_name: CategoryTheory.isCoseparating_iff_mono
code: theorem isCoseparating_iff_mono (𝒢 : Set C)
    [∀ A : C, HasProduct fun f : ΣG : 𝒢, A ⟶ (G : C) => (f.1 : C)] :
    IsCoseparating 𝒢 ↔ ∀ A : C, Mono (Pi.lift (@Sigma.snd 𝒢 fun G => A ⟶ (G : C))) 
goal: CategoryTheory.IsCoseparating 𝒢 ↔ ∀ (A : C), CategoryTheory.Mono (CategoryTheory.Limits.Pi.lift Sigma.snd)

full_name: CategoryTheory.hasInitial_of_isCoseparating
code: /-- An ingredient of the proof of the Special Adjoint Functor Theorem: a complete well-powered
    category with a small coseparating set has an initial object.

    In fact, it follows from the Special Adjoint Functor Theorem that `C` is already cocomplete,
    see `hasColimits_of_hasLimits_of_isCoseparating`. -/
theorem hasInitial_of_isCoseparating [WellPowered C] [HasLimits C] {𝒢 : Set C} [Small.{v₁} 𝒢]
    (h𝒢 : IsCoseparating 𝒢) : HasInitial C 
goal: CategoryTheory.Limits.HasInitial C

full_name: CategoryTheory.hasTerminal_of_isSeparating
code: /-- An ingredient of the proof of the Special Adjoint Functor Theorem: a cocomplete well-copowered
    category with a small separating set has a terminal object.

    In fact, it follows from the Special Adjoint Functor Theorem that `C` is already complete, see
    `hasLimits_of_hasColimits_of_isSeparating`. -/
theorem hasTerminal_of_isSeparating [WellPowered Cᵒᵖ] [HasColimits C] {𝒢 : Set C} [Small.{v₁} 𝒢]
    (h𝒢 : IsSeparating 𝒢) : HasTerminal C 
goal: CategoryTheory.Limits.HasTerminal C

full_name: CategoryTheory.Subobject.eq_of_le_of_isDetecting
code: theorem eq_of_le_of_isDetecting {𝒢 : Set C} (h𝒢 : IsDetecting 𝒢) {X : C} (P Q : Subobject X)
    (h₁ : P ≤ Q) (h₂ : ∀ G ∈ 𝒢, ∀ {f : G ⟶ X}, Q.Factors f → P.Factors f) : P = Q 
goal: P = Q

full_name: CategoryTheory.Subobject.inf_eq_of_isDetecting
code: theorem inf_eq_of_isDetecting [HasPullbacks C] {𝒢 : Set C} (h𝒢 : IsDetecting 𝒢) {X : C}
    (P Q : Subobject X) (h : ∀ G ∈ 𝒢, ∀ {f : G ⟶ X}, P.Factors f → Q.Factors f) : P ⊓ Q = P 
goal: P ⊓ Q = P

full_name: CategoryTheory.Subobject.eq_of_isDetecting
code: theorem eq_of_isDetecting [HasPullbacks C] {𝒢 : Set C} (h𝒢 : IsDetecting 𝒢) {X : C}
    (P Q : Subobject X) (h : ∀ G ∈ 𝒢, ∀ {f : G ⟶ X}, P.Factors f ↔ Q.Factors f) : P = Q 
goal: P = Q

full_name: CategoryTheory.wellPowered_of_isDetecting
code: /-- A category with pullbacks and a small detecting set is well-powered. -/
theorem wellPowered_of_isDetecting [HasPullbacks C] {𝒢 : Set C} [Small.{v₁} 𝒢]
    (h𝒢 : IsDetecting 𝒢) : WellPowered C 
goal: CategoryTheory.WellPowered C

full_name: CategoryTheory.StructuredArrow.isCoseparating_proj_preimage
code: theorem isCoseparating_proj_preimage {𝒢 : Set C} (h𝒢 : IsCoseparating 𝒢) :
    IsCoseparating ((proj S T).obj ⁻¹' 𝒢) 
goal: CategoryTheory.IsCoseparating ((CategoryTheory.StructuredArrow.proj S T).obj ⁻¹' 𝒢)

full_name: CategoryTheory.CostructuredArrow.isSeparating_proj_preimage
code: theorem isSeparating_proj_preimage {𝒢 : Set C} (h𝒢 : IsSeparating 𝒢) :
    IsSeparating ((proj S T).obj ⁻¹' 𝒢) 
goal: CategoryTheory.IsSeparating ((CategoryTheory.CostructuredArrow.proj S T).obj ⁻¹' 𝒢)

full_name: CategoryTheory.IsSeparator
code: /-- We say that `G` is a separator if the functor `C(G, -)` is faithful. -/
def IsSeparator (G : C) : Prop 
goal: Prop

full_name: CategoryTheory.IsCoseparator
code: /-- We say that `G` is a coseparator if the functor `C(-, G)` is faithful. -/
def IsCoseparator (G : C) : Prop 
goal: Prop

full_name: CategoryTheory.IsDetector
code: /-- We say that `G` is a detector if the functor `C(G, -)` reflects isomorphisms. -/
def IsDetector (G : C) : Prop 
goal: Prop

full_name: CategoryTheory.IsCodetector
code: /-- We say that `G` is a codetector if the functor `C(-, G)` reflects isomorphisms. -/
def IsCodetector (G : C) : Prop 
goal: Prop

full_name: CategoryTheory.isSeparator_op_iff
code: theorem isSeparator_op_iff (G : C) : IsSeparator (op G) ↔ IsCoseparator G 
goal: CategoryTheory.IsSeparator (Opposite.op G) ↔ CategoryTheory.IsCoseparator G

full_name: CategoryTheory.isCoseparator_op_iff
code: theorem isCoseparator_op_iff (G : C) : IsCoseparator (op G) ↔ IsSeparator G 
goal: CategoryTheory.IsCoseparator (Opposite.op G) ↔ CategoryTheory.IsSeparator G

full_name: CategoryTheory.isCoseparator_unop_iff
code: theorem isCoseparator_unop_iff (G : Cᵒᵖ) : IsCoseparator (unop G) ↔ IsSeparator G 
goal: CategoryTheory.IsCoseparator (Opposite.unop G) ↔ CategoryTheory.IsSeparator G

full_name: CategoryTheory.isSeparator_unop_iff
code: theorem isSeparator_unop_iff (G : Cᵒᵖ) : IsSeparator (unop G) ↔ IsCoseparator G 
goal: CategoryTheory.IsSeparator (Opposite.unop G) ↔ CategoryTheory.IsCoseparator G

full_name: CategoryTheory.isDetector_op_iff
code: theorem isDetector_op_iff (G : C) : IsDetector (op G) ↔ IsCodetector G 
goal: CategoryTheory.IsDetector (Opposite.op G) ↔ CategoryTheory.IsCodetector G

full_name: CategoryTheory.isCodetector_op_iff
code: theorem isCodetector_op_iff (G : C) : IsCodetector (op G) ↔ IsDetector G 
goal: CategoryTheory.IsCodetector (Opposite.op G) ↔ CategoryTheory.IsDetector G

full_name: CategoryTheory.isCodetector_unop_iff
code: theorem isCodetector_unop_iff (G : Cᵒᵖ) : IsCodetector (unop G) ↔ IsDetector G 
goal: CategoryTheory.IsCodetector (Opposite.unop G) ↔ CategoryTheory.IsDetector G

full_name: CategoryTheory.isDetector_unop_iff
code: theorem isDetector_unop_iff (G : Cᵒᵖ) : IsDetector (unop G) ↔ IsCodetector G 
goal: CategoryTheory.IsDetector (Opposite.unop G) ↔ CategoryTheory.IsCodetector G

full_name: CategoryTheory.IsDetector.isSeparator
code: theorem IsDetector.isSeparator [HasEqualizers C] {G : C} : IsDetector G → IsSeparator G 
goal: CategoryTheory.IsDetector G → CategoryTheory.IsSeparator G

full_name: CategoryTheory.IsCodetector.isCoseparator
code: theorem IsCodetector.isCoseparator [HasCoequalizers C] {G : C} : IsCodetector G → IsCoseparator G 
goal: CategoryTheory.IsCodetector G → CategoryTheory.IsCoseparator G

full_name: CategoryTheory.IsSeparator.isDetector
code: theorem IsSeparator.isDetector [Balanced C] {G : C} : IsSeparator G → IsDetector G 
goal: CategoryTheory.IsSeparator G → CategoryTheory.IsDetector G

full_name: CategoryTheory.IsCospearator.isCodetector
code: theorem IsCospearator.isCodetector [Balanced C] {G : C} : IsCoseparator G → IsCodetector G 
goal: CategoryTheory.IsCoseparator G → CategoryTheory.IsCodetector G

full_name: CategoryTheory.isSeparator_def
code: theorem isSeparator_def (G : C) :
    IsSeparator G ↔ ∀ ⦃X Y : C⦄ (f g : X ⟶ Y), (∀ h : G ⟶ X, h ≫ f = h ≫ g) → f = g 
goal: CategoryTheory.IsSeparator G ↔
  ∀ ⦃X Y : C⦄ (f g : X ⟶ Y),
    (∀ (h : G ⟶ X), CategoryTheory.CategoryStruct.comp h f = CategoryTheory.CategoryStruct.comp h g) → f = g

full_name: CategoryTheory.IsSeparator.def
code: theorem IsSeparator.def {G : C} :
    IsSeparator G → ∀ ⦃X Y : C⦄ (f g : X ⟶ Y), (∀ h : G ⟶ X, h ≫ f = h ≫ g) → f = g 
goal: CategoryTheory.IsSeparator G →
  ∀ ⦃X Y : C⦄ (f g : X ⟶ Y),
    (∀ (h : G ⟶ X), CategoryTheory.CategoryStruct.comp h f = CategoryTheory.CategoryStruct.comp h g) → f = g

full_name: CategoryTheory.isCoseparator_def
code: theorem isCoseparator_def (G : C) :
    IsCoseparator G ↔ ∀ ⦃X Y : C⦄ (f g : X ⟶ Y), (∀ h : Y ⟶ G, f ≫ h = g ≫ h) → f = g 
goal: CategoryTheory.IsCoseparator G ↔
  ∀ ⦃X Y : C⦄ (f g : X ⟶ Y),
    (∀ (h : Y ⟶ G), CategoryTheory.CategoryStruct.comp f h = CategoryTheory.CategoryStruct.comp g h) → f = g

full_name: CategoryTheory.IsCoseparator.def
code: theorem IsCoseparator.def {G : C} :
    IsCoseparator G → ∀ ⦃X Y : C⦄ (f g : X ⟶ Y), (∀ h : Y ⟶ G, f ≫ h = g ≫ h) → f = g 
goal: CategoryTheory.IsCoseparator G →
  ∀ ⦃X Y : C⦄ (f g : X ⟶ Y),
    (∀ (h : Y ⟶ G), CategoryTheory.CategoryStruct.comp f h = CategoryTheory.CategoryStruct.comp g h) → f = g

full_name: CategoryTheory.isDetector_def
code: theorem isDetector_def (G : C) :
    IsDetector G ↔ ∀ ⦃X Y : C⦄ (f : X ⟶ Y), (∀ h : G ⟶ Y, ∃! h', h' ≫ f = h) → IsIso f 
goal: CategoryTheory.IsDetector G ↔
  ∀ ⦃X Y : C⦄ (f : X ⟶ Y), (∀ (h : G ⟶ Y), ∃! h', CategoryTheory.CategoryStruct.comp h' f = h) → CategoryTheory.IsIso f

full_name: CategoryTheory.IsDetector.def
code: theorem IsDetector.def {G : C} :
    IsDetector G → ∀ ⦃X Y : C⦄ (f : X ⟶ Y), (∀ h : G ⟶ Y, ∃! h', h' ≫ f = h) → IsIso f 
goal: CategoryTheory.IsDetector G →
  ∀ ⦃X Y : C⦄ (f : X ⟶ Y), (∀ (h : G ⟶ Y), ∃! h', CategoryTheory.CategoryStruct.comp h' f = h) → CategoryTheory.IsIso f

full_name: CategoryTheory.isCodetector_def
code: theorem isCodetector_def (G : C) :
    IsCodetector G ↔ ∀ ⦃X Y : C⦄ (f : X ⟶ Y), (∀ h : X ⟶ G, ∃! h', f ≫ h' = h) → IsIso f 
goal: CategoryTheory.IsCodetector G ↔
  ∀ ⦃X Y : C⦄ (f : X ⟶ Y), (∀ (h : X ⟶ G), ∃! h', CategoryTheory.CategoryStruct.comp f h' = h) → CategoryTheory.IsIso f

full_name: CategoryTheory.IsCodetector.def
code: theorem IsCodetector.def {G : C} :
    IsCodetector G → ∀ ⦃X Y : C⦄ (f : X ⟶ Y), (∀ h : X ⟶ G, ∃! h', f ≫ h' = h) → IsIso f 
goal: CategoryTheory.IsCodetector G →
  ∀ ⦃X Y : C⦄ (f : X ⟶ Y), (∀ (h : X ⟶ G), ∃! h', CategoryTheory.CategoryStruct.comp f h' = h) → CategoryTheory.IsIso f

full_name: CategoryTheory.isSeparator_iff_faithful_coyoneda_obj
code: theorem isSeparator_iff_faithful_coyoneda_obj (G : C) :
    IsSeparator G ↔ (coyoneda.obj (op G)).Faithful 
goal: CategoryTheory.IsSeparator G ↔ (CategoryTheory.coyoneda.obj (Opposite.op G)).Faithful

full_name: CategoryTheory.isCoseparator_iff_faithful_yoneda_obj
code: theorem isCoseparator_iff_faithful_yoneda_obj (G : C) : IsCoseparator G ↔ (yoneda.obj G).Faithful 
goal: CategoryTheory.IsCoseparator G ↔ (CategoryTheory.yoneda.obj G).Faithful

full_name: CategoryTheory.isSeparator_iff_epi
code: theorem isSeparator_iff_epi (G : C) [∀ A : C, HasCoproduct fun _ : G ⟶ A => G] :
    IsSeparator G ↔ ∀ A : C, Epi (Sigma.desc fun f : G ⟶ A => f) 
goal: CategoryTheory.IsSeparator G ↔ ∀ (A : C), CategoryTheory.Epi (CategoryTheory.Limits.Sigma.desc fun f => f)

full_name: CategoryTheory.isCoseparator_iff_mono
code: theorem isCoseparator_iff_mono (G : C) [∀ A : C, HasProduct fun _ : A ⟶ G => G] :
    IsCoseparator G ↔ ∀ A : C, Mono (Pi.lift fun f : A ⟶ G => f) 
goal: CategoryTheory.IsCoseparator G ↔ ∀ (A : C), CategoryTheory.Mono (CategoryTheory.Limits.Pi.lift fun f => f)

full_name: CategoryTheory.isSeparator_coprod
code: theorem isSeparator_coprod (G H : C) [HasBinaryCoproduct G H] :
    IsSeparator (G ⨿ H) ↔ IsSeparating ({G, H} : Set C) 
goal: CategoryTheory.IsSeparator (G ⨿ H) ↔ CategoryTheory.IsSeparating {G, H}

full_name: CategoryTheory.isSeparator_coprod_of_isSeparator_left
code: theorem isSeparator_coprod_of_isSeparator_left (G H : C) [HasBinaryCoproduct G H]
    (hG : IsSeparator G) : IsSeparator (G ⨿ H) 
goal: CategoryTheory.IsSeparator (G ⨿ H)

full_name: CategoryTheory.isSeparator_coprod_of_isSeparator_right
code: theorem isSeparator_coprod_of_isSeparator_right (G H : C) [HasBinaryCoproduct G H]
    (hH : IsSeparator H) : IsSeparator (G ⨿ H) 
goal: CategoryTheory.IsSeparator (G ⨿ H)

full_name: CategoryTheory.isSeparator_sigma
code: theorem isSeparator_sigma {β : Type w} (f : β → C) [HasCoproduct f] :
    IsSeparator (∐ f) ↔ IsSeparating (Set.range f) 
goal: CategoryTheory.IsSeparator (∐ f) ↔ CategoryTheory.IsSeparating (Set.range f)

full_name: CategoryTheory.isSeparator_sigma_of_isSeparator
code: theorem isSeparator_sigma_of_isSeparator {β : Type w} (f : β → C) [HasCoproduct f] (b : β)
    (hb : IsSeparator (f b)) : IsSeparator (∐ f) 
goal: CategoryTheory.IsSeparator (∐ f)

full_name: CategoryTheory.isCoseparator_prod
code: theorem isCoseparator_prod (G H : C) [HasBinaryProduct G H] :
    IsCoseparator (G ⨯ H) ↔ IsCoseparating ({G, H} : Set C) 
goal: CategoryTheory.IsCoseparator (G ⨯ H) ↔ CategoryTheory.IsCoseparating {G, H}

full_name: CategoryTheory.isCoseparator_prod_of_isCoseparator_left
code: theorem isCoseparator_prod_of_isCoseparator_left (G H : C) [HasBinaryProduct G H]
    (hG : IsCoseparator G) : IsCoseparator (G ⨯ H) 
goal: CategoryTheory.IsCoseparator (G ⨯ H)

full_name: CategoryTheory.isCoseparator_prod_of_isCoseparator_right
code: theorem isCoseparator_prod_of_isCoseparator_right (G H : C) [HasBinaryProduct G H]
    (hH : IsCoseparator H) : IsCoseparator (G ⨯ H) 
goal: CategoryTheory.IsCoseparator (G ⨯ H)

full_name: CategoryTheory.isCoseparator_pi
code: theorem isCoseparator_pi {β : Type w} (f : β → C) [HasProduct f] :
    IsCoseparator (∏ᶜ f) ↔ IsCoseparating (Set.range f) 
goal: CategoryTheory.IsCoseparator (∏ᶜ f) ↔ CategoryTheory.IsCoseparating (Set.range f)

full_name: CategoryTheory.isCoseparator_pi_of_isCoseparator
code: theorem isCoseparator_pi_of_isCoseparator {β : Type w} (f : β → C) [HasProduct f] (b : β)
    (hb : IsCoseparator (f b)) : IsCoseparator (∏ᶜ f) 
goal: CategoryTheory.IsCoseparator (∏ᶜ f)

full_name: CategoryTheory.isDetector_iff_reflectsIsomorphisms_coyoneda_obj
code: theorem isDetector_iff_reflectsIsomorphisms_coyoneda_obj (G : C) :
    IsDetector G ↔ (coyoneda.obj (op G)).ReflectsIsomorphisms 
goal: CategoryTheory.IsDetector G ↔ (CategoryTheory.coyoneda.obj (Opposite.op G)).ReflectsIsomorphisms

full_name: CategoryTheory.isCodetector_iff_reflectsIsomorphisms_yoneda_obj
code: theorem isCodetector_iff_reflectsIsomorphisms_yoneda_obj (G : C) :
    IsCodetector G ↔ (yoneda.obj G).ReflectsIsomorphisms 
goal: CategoryTheory.IsCodetector G ↔ (CategoryTheory.yoneda.obj G).ReflectsIsomorphisms

full_name: CategoryTheory.wellPowered_of_isDetector
code: theorem wellPowered_of_isDetector [HasPullbacks C] (G : C) (hG : IsDetector G) : WellPowered C 
goal: CategoryTheory.WellPowered C