ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Pretriangulated.preadditiveCoyoneda_homologySequenceδ_apply
lemma preadditiveCoyoneda_homologySequenceδ_apply
    (A : Cᵒᵖ) (T : Triangle C) (n₀ n₁ : ℤ) (h : n₀ + 1 = n₁) (x : A.unop ⟶ T.obj₃⟦n₀⟧) :
    (preadditiveCoyoneda.obj A).homologySequenceδ T n₀ n₁ h x =
      x ≫ T.mor₃⟦n₀⟧' ≫ (shiftFunctorAdd' C 1 n₀ n₁ (by omega)).inv.app _ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Preadditive C] [CategoryTheory.HasShift C ℤ] (A : Cᵒᵖ) (T : CategoryTheory.Pretriangulated.Triangle C) (n₀ n₁ : ℤ) (h : n₀ + 1 = n₁) (x : Opposite.unop A ⟶ (CategoryTheory.shiftFunctor C n₀).obj T.obj₃)
Goal: ((CategoryTheory.preadditiveCoyoneda.obj A).homologySequenceδ T n₀ n₁ h) x =
  CategoryTheory.CategoryStruct.comp x
    (CategoryTheory.CategoryStruct.comp ((CategoryTheory.shiftFunctor C n₀).map T.mor₃)
      ((CategoryTheory.shiftFunctorAdd' C 1 n₀ n₁ ⋯).inv.app T.obj₁))
-- CategoryTheory.CatCommSq.hComp_iso'_inv_app
@[simps! iso'_hom_app iso'_inv_app]
def hComp (T₁ : C₁ ⥤ C₂) (T₂ : C₂ ⥤ C₃) (V₁ : C₁ ⥤ C₄) (V₂ : C₂ ⥤ C₅) (V₃ : C₃ ⥤ C₆)
    (B₁ : C₄ ⥤ C₅) (B₂ : C₅ ⥤ C₆) [CatCommSq T₁ V₁ V₂ B₁] [CatCommSq T₂ V₂ V₃ B₂] :
    CatCommSq (T₁ ⋙ T₂) V₁ V₃ (B₁ ⋙ B₂) 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} {C₅ : Type u_5} {C₆ : Type u_6} [CategoryTheory.Category.{u_7, u_1} C₁] [CategoryTheory.Category.{u_8, u_2} C₂] [CategoryTheory.Category.{u_9, u_3} C₃] [CategoryTheory.Category.{u_10, u_4} C₄] [CategoryTheory.Category.{u_11, u_5} C₅] [CategoryTheory.Category.{u_12, u_6} C₆] (T₁ : CategoryTheory.Functor C₁ C₂) (T₂ : CategoryTheory.Functor C₂ C₃) (V₁ : CategoryTheory.Functor C₁ C₄) (V₂ : CategoryTheory.Functor C₂ C₅) (V₃ : CategoryTheory.Functor C₃ C₆) (B₁ : CategoryTheory.Functor C₄ C₅) (B₂ : CategoryTheory.Functor C₅ C₆) [CategoryTheory.CatCommSq T₁ V₁ V₂ B₁] [CategoryTheory.CatCommSq T₂ V₂ V₃ B₂] (X : C₁)
Goal: CategoryTheory.CatCommSq.iso'.inv.app X =
  CategoryTheory.CategoryStruct.comp (B₂.map ((CategoryTheory.CatCommSq.iso T₁ V₁ V₂ B₁).inv.app X))
    ((CategoryTheory.CatCommSq.iso T₂ V₂ V₃ B₂).inv.app (T₁.obj X))
-- CategoryTheory.CatCommSq.hComp_iso'_hom_app
@[simps! iso'_hom_app iso'_inv_app]
def hComp (T₁ : C₁ ⥤ C₂) (T₂ : C₂ ⥤ C₃) (V₁ : C₁ ⥤ C₄) (V₂ : C₂ ⥤ C₅) (V₃ : C₃ ⥤ C₆)
    (B₁ : C₄ ⥤ C₅) (B₂ : C₅ ⥤ C₆) [CatCommSq T₁ V₁ V₂ B₁] [CatCommSq T₂ V₂ V₃ B₂] :
    CatCommSq (T₁ ⋙ T₂) V₁ V₃ (B₁ ⋙ B₂) 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} {C₅ : Type u_5} {C₆ : Type u_6} [CategoryTheory.Category.{u_7, u_1} C₁] [CategoryTheory.Category.{u_8, u_2} C₂] [CategoryTheory.Category.{u_9, u_3} C₃] [CategoryTheory.Category.{u_10, u_4} C₄] [CategoryTheory.Category.{u_11, u_5} C₅] [CategoryTheory.Category.{u_12, u_6} C₆] (T₁ : CategoryTheory.Functor C₁ C₂) (T₂ : CategoryTheory.Functor C₂ C₃) (V₁ : CategoryTheory.Functor C₁ C₄) (V₂ : CategoryTheory.Functor C₂ C₅) (V₃ : CategoryTheory.Functor C₃ C₆) (B₁ : CategoryTheory.Functor C₄ C₅) (B₂ : CategoryTheory.Functor C₅ C₆) [CategoryTheory.CatCommSq T₁ V₁ V₂ B₁] [CategoryTheory.CatCommSq T₂ V₂ V₃ B₂] (X : C₁)
Goal: CategoryTheory.CatCommSq.iso'.hom.app X =
  CategoryTheory.CategoryStruct.comp ((CategoryTheory.CatCommSq.iso T₂ V₂ V₃ B₂).hom.app (T₁.obj X))
    (B₂.map ((CategoryTheory.CatCommSq.iso T₁ V₁ V₂ B₁).hom.app X))
-- CategoryTheory.CatCommSq.vComp_iso'_inv_app
@[simps! iso'_hom_app iso'_inv_app]
def vComp (L₁ : C₁ ⥤ C₂) (L₂ : C₂ ⥤ C₃) (H₁ : C₁ ⥤ C₄) (H₂ : C₂ ⥤ C₅) (H₃ : C₃ ⥤ C₆)
    (R₁ : C₄ ⥤ C₅) (R₂ : C₅ ⥤ C₆) [CatCommSq H₁ L₁ R₁ H₂] [CatCommSq H₂ L₂ R₂ H₃] :
    CatCommSq H₁ (L₁ ⋙ L₂) (R₁ ⋙ R₂) H₃ 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} {C₅ : Type u_5} {C₆ : Type u_6} [CategoryTheory.Category.{u_7, u_1} C₁] [CategoryTheory.Category.{u_8, u_2} C₂] [CategoryTheory.Category.{u_9, u_3} C₃] [CategoryTheory.Category.{u_10, u_4} C₄] [CategoryTheory.Category.{u_11, u_5} C₅] [CategoryTheory.Category.{u_12, u_6} C₆] (L₁ : CategoryTheory.Functor C₁ C₂) (L₂ : CategoryTheory.Functor C₂ C₃) (H₁ : CategoryTheory.Functor C₁ C₄) (H₂ : CategoryTheory.Functor C₂ C₅) (H₃ : CategoryTheory.Functor C₃ C₆) (R₁ : CategoryTheory.Functor C₄ C₅) (R₂ : CategoryTheory.Functor C₅ C₆) [CategoryTheory.CatCommSq H₁ L₁ R₁ H₂] [CategoryTheory.CatCommSq H₂ L₂ R₂ H₃] (X : C₁)
Goal: CategoryTheory.CatCommSq.iso'.inv.app X =
  CategoryTheory.CategoryStruct.comp ((CategoryTheory.CatCommSq.iso H₂ L₂ R₂ H₃).inv.app (L₁.obj X))
    (R₂.map ((CategoryTheory.CatCommSq.iso H₁ L₁ R₁ H₂).inv.app X))
-- CategoryTheory.CatCommSq.vComp_iso'_hom_app
@[simps! iso'_hom_app iso'_inv_app]
def vComp (L₁ : C₁ ⥤ C₂) (L₂ : C₂ ⥤ C₃) (H₁ : C₁ ⥤ C₄) (H₂ : C₂ ⥤ C₅) (H₃ : C₃ ⥤ C₆)
    (R₁ : C₄ ⥤ C₅) (R₂ : C₅ ⥤ C₆) [CatCommSq H₁ L₁ R₁ H₂] [CatCommSq H₂ L₂ R₂ H₃] :
    CatCommSq H₁ (L₁ ⋙ L₂) (R₁ ⋙ R₂) H₃ 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} {C₅ : Type u_5} {C₆ : Type u_6} [CategoryTheory.Category.{u_7, u_1} C₁] [CategoryTheory.Category.{u_8, u_2} C₂] [CategoryTheory.Category.{u_9, u_3} C₃] [CategoryTheory.Category.{u_10, u_4} C₄] [CategoryTheory.Category.{u_11, u_5} C₅] [CategoryTheory.Category.{u_12, u_6} C₆] (L₁ : CategoryTheory.Functor C₁ C₂) (L₂ : CategoryTheory.Functor C₂ C₃) (H₁ : CategoryTheory.Functor C₁ C₄) (H₂ : CategoryTheory.Functor C₂ C₅) (H₃ : CategoryTheory.Functor C₃ C₆) (R₁ : CategoryTheory.Functor C₄ C₅) (R₂ : CategoryTheory.Functor C₅ C₆) [CategoryTheory.CatCommSq H₁ L₁ R₁ H₂] [CategoryTheory.CatCommSq H₂ L₂ R₂ H₃] (X : C₁)
Goal: CategoryTheory.CatCommSq.iso'.hom.app X =
  CategoryTheory.CategoryStruct.comp (R₂.map ((CategoryTheory.CatCommSq.iso H₁ L₁ R₁ H₂).hom.app X))
    ((CategoryTheory.CatCommSq.iso H₂ L₂ R₂ H₃).hom.app (L₁.obj X))
-- CategoryTheory.CatCommSq.hInv_iso'_hom_app
@[simps! iso'_hom_app iso'_inv_app]
def hInv (_ : CatCommSq T.functor L R B.functor) : CatCommSq T.inverse R L B.inverse 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} [CategoryTheory.Category.{u_7, u_1} C₁] [CategoryTheory.Category.{u_8, u_2} C₂] [CategoryTheory.Category.{u_9, u_3} C₃] [CategoryTheory.Category.{u_10, u_4} C₄] (T : C₁ ≌ C₂) (L : CategoryTheory.Functor C₁ C₃) (R : CategoryTheory.Functor C₂ C₄) (B : C₃ ≌ C₄)
Goal: ∀ (x : CategoryTheory.CatCommSq T.functor L R B.functor) (X : C₂),
  CategoryTheory.CatCommSq.iso'.hom.app X =
    CategoryTheory.CategoryStruct.comp (B.unitIso.hom.app (L.obj (T.inverse.obj X)))
      (CategoryTheory.CategoryStruct.comp
        (B.inverse.map ((CategoryTheory.CatCommSq.iso T.functor L R B.functor).inv.app (T.inverse.obj X)))
        (B.inverse.map (R.map (T.counitIso.hom.app X))))
-- CategoryTheory.CatCommSq.hInv_iso'_inv_app
@[simps! iso'_hom_app iso'_inv_app]
def hInv (_ : CatCommSq T.functor L R B.functor) : CatCommSq T.inverse R L B.inverse 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} [CategoryTheory.Category.{u_7, u_1} C₁] [CategoryTheory.Category.{u_8, u_2} C₂] [CategoryTheory.Category.{u_9, u_3} C₃] [CategoryTheory.Category.{u_10, u_4} C₄] (T : C₁ ≌ C₂) (L : CategoryTheory.Functor C₁ C₃) (R : CategoryTheory.Functor C₂ C₄) (B : C₃ ≌ C₄)
Goal: ∀ (x : CategoryTheory.CatCommSq T.functor L R B.functor) (X : C₂),
  CategoryTheory.CatCommSq.iso'.inv.app X =
    CategoryTheory.CategoryStruct.comp (B.inverse.map (R.map (T.counitIso.inv.app X)))
      (CategoryTheory.CategoryStruct.comp
        (B.inverse.map ((CategoryTheory.CatCommSq.iso T.functor L R B.functor).hom.app (T.inverse.obj X)))
        (B.unitIso.inv.app (L.obj (T.inverse.obj X))))
-- CategoryTheory.CatCommSq.hInv_hInv
lemma hInv_hInv (h : CatCommSq T.functor L R B.functor) :
    hInv T.symm R L B.symm (hInv T L R B h) = h 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} [CategoryTheory.Category.{u_8, u_1} C₁] [CategoryTheory.Category.{u_9, u_2} C₂] [CategoryTheory.Category.{u_10, u_3} C₃] [CategoryTheory.Category.{u_7, u_4} C₄] (T : C₁ ≌ C₂) (L : CategoryTheory.Functor C₁ C₃) (R : CategoryTheory.Functor C₂ C₄) (B : C₃ ≌ C₄) (h : CategoryTheory.CatCommSq T.functor L R B.functor)
Goal: CategoryTheory.CatCommSq.hInv T.symm R L B.symm (CategoryTheory.CatCommSq.hInv T L R B h) = h
-- CategoryTheory.CatCommSq.vInv_iso'_hom_app
@[simps! iso'_hom_app iso'_inv_app]
def vInv (_ : CatCommSq T L.functor R.functor B) : CatCommSq B L.inverse R.inverse T 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} [CategoryTheory.Category.{u_7, u_1} C₁] [CategoryTheory.Category.{u_8, u_2} C₂] [CategoryTheory.Category.{u_9, u_3} C₃] [CategoryTheory.Category.{u_10, u_4} C₄] (T : CategoryTheory.Functor C₁ C₂) (L : C₁ ≌ C₃) (R : C₂ ≌ C₄) (B : CategoryTheory.Functor C₃ C₄)
Goal: ∀ (x : CategoryTheory.CatCommSq T L.functor R.functor B) (X : C₃),
  CategoryTheory.CatCommSq.iso'.hom.app X =
    CategoryTheory.CategoryStruct.comp (R.inverse.map (B.map (L.counitIso.inv.app X)))
      (CategoryTheory.CategoryStruct.comp
        (R.inverse.map ((CategoryTheory.CatCommSq.iso T L.functor R.functor B).inv.app (L.inverse.obj X)))
        (R.unitIso.inv.app (T.obj (L.inverse.obj X))))
-- CategoryTheory.CatCommSq.vInv_iso'_inv_app
@[simps! iso'_hom_app iso'_inv_app]
def vInv (_ : CatCommSq T L.functor R.functor B) : CatCommSq B L.inverse R.inverse T 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} [CategoryTheory.Category.{u_7, u_1} C₁] [CategoryTheory.Category.{u_8, u_2} C₂] [CategoryTheory.Category.{u_9, u_3} C₃] [CategoryTheory.Category.{u_10, u_4} C₄] (T : CategoryTheory.Functor C₁ C₂) (L : C₁ ≌ C₃) (R : C₂ ≌ C₄) (B : CategoryTheory.Functor C₃ C₄)
Goal: ∀ (x : CategoryTheory.CatCommSq T L.functor R.functor B) (X : C₃),
  CategoryTheory.CatCommSq.iso'.inv.app X =
    CategoryTheory.CategoryStruct.comp (R.unitIso.hom.app (T.obj (L.inverse.obj X)))
      (CategoryTheory.CategoryStruct.comp
        (R.inverse.map ((CategoryTheory.CatCommSq.iso T L.functor R.functor B).hom.app (L.inverse.obj X)))
        (R.inverse.map (B.map (L.counitIso.hom.app X))))
-- CategoryTheory.CatCommSq.vInv_vInv
lemma vInv_vInv (h : CatCommSq T L.functor R.functor B) :
    vInv B L.symm R.symm T (vInv T L R B h) = h 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} [CategoryTheory.Category.{u_8, u_1} C₁] [CategoryTheory.Category.{u_9, u_2} C₂] [CategoryTheory.Category.{u_10, u_3} C₃] [CategoryTheory.Category.{u_7, u_4} C₄] (T : CategoryTheory.Functor C₁ C₂) (L : C₁ ≌ C₃) (R : C₂ ≌ C₄) (B : CategoryTheory.Functor C₃ C₄) (h : CategoryTheory.CatCommSq T L.functor R.functor B)
Goal: CategoryTheory.CatCommSq.vInv B L.symm R.symm T (CategoryTheory.CatCommSq.vInv T L R B h) = h
-- CategoryTheory.isSeparating_op_iff
theorem isSeparating_op_iff (𝒢 : Set C) : IsSeparating 𝒢.op ↔ IsCoseparating 𝒢 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (𝒢 : Set C)
Goal: CategoryTheory.IsSeparating 𝒢.op ↔ CategoryTheory.IsCoseparating 𝒢
-- CategoryTheory.isCoseparating_op_iff
theorem isCoseparating_op_iff (𝒢 : Set C) : IsCoseparating 𝒢.op ↔ IsSeparating 𝒢 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (𝒢 : Set C)
Goal: CategoryTheory.IsCoseparating 𝒢.op ↔ CategoryTheory.IsSeparating 𝒢
-- CategoryTheory.isCoseparating_unop_iff
theorem isCoseparating_unop_iff (𝒢 : Set Cᵒᵖ) : IsCoseparating 𝒢.unop ↔ IsSeparating 𝒢 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (𝒢 : Set Cᵒᵖ)
Goal: CategoryTheory.IsCoseparating 𝒢.unop ↔ CategoryTheory.IsSeparating 𝒢
-- CategoryTheory.isSeparating_unop_iff
theorem isSeparating_unop_iff (𝒢 : Set Cᵒᵖ) : IsSeparating 𝒢.unop ↔ IsCoseparating 𝒢 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (𝒢 : Set Cᵒᵖ)
Goal: CategoryTheory.IsSeparating 𝒢.unop ↔ CategoryTheory.IsCoseparating 𝒢
-- CategoryTheory.isDetecting_op_iff
theorem isDetecting_op_iff (𝒢 : Set C) : IsDetecting 𝒢.op ↔ IsCodetecting 𝒢 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (𝒢 : Set C)
Goal: CategoryTheory.IsDetecting 𝒢.op ↔ CategoryTheory.IsCodetecting 𝒢
-- CategoryTheory.isCodetecting_op_iff
theorem isCodetecting_op_iff (𝒢 : Set C) : IsCodetecting 𝒢.op ↔ IsDetecting 𝒢 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (𝒢 : Set C)
Goal: CategoryTheory.IsCodetecting 𝒢.op ↔ CategoryTheory.IsDetecting 𝒢
-- CategoryTheory.isDetecting_unop_iff
theorem isDetecting_unop_iff (𝒢 : Set Cᵒᵖ) : IsDetecting 𝒢.unop ↔ IsCodetecting 𝒢 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (𝒢 : Set Cᵒᵖ)
Goal: CategoryTheory.IsDetecting 𝒢.unop ↔ CategoryTheory.IsCodetecting 𝒢
-- CategoryTheory.isCodetecting_unop_iff
theorem isCodetecting_unop_iff {𝒢 : Set Cᵒᵖ} : IsCodetecting 𝒢.unop ↔ IsDetecting 𝒢 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {𝒢 : Set Cᵒᵖ}
Goal: CategoryTheory.IsCodetecting 𝒢.unop ↔ CategoryTheory.IsDetecting 𝒢
-- CategoryTheory.IsDetecting.isSeparating
theorem IsDetecting.isSeparating [HasEqualizers C] {𝒢 : Set C} (h𝒢 : IsDetecting 𝒢) :
    IsSeparating 𝒢 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasEqualizers C] {𝒢 : Set C} (h𝒢 : CategoryTheory.IsDetecting 𝒢)
Goal: CategoryTheory.IsSeparating 𝒢
-- CategoryTheory.IsCodetecting.isCoseparating
theorem IsCodetecting.isCoseparating [HasCoequalizers C] {𝒢 : Set C} :
    IsCodetecting 𝒢 → IsCoseparating 𝒢 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasCoequalizers C] {𝒢 : Set C}
Goal: CategoryTheory.IsCodetecting 𝒢 → CategoryTheory.IsCoseparating 𝒢
-- CategoryTheory.IsSeparating.isDetecting
theorem IsSeparating.isDetecting [Balanced C] {𝒢 : Set C} (h𝒢 : IsSeparating 𝒢) :
    IsDetecting 𝒢 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Balanced C] {𝒢 : Set C} (h𝒢 : CategoryTheory.IsSeparating 𝒢)
Goal: CategoryTheory.IsDetecting 𝒢
-- CategoryTheory.IsCoseparating.isCodetecting
theorem IsCoseparating.isCodetecting [Balanced C] {𝒢 : Set C} :
    IsCoseparating 𝒢 → IsCodetecting 𝒢 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Balanced C] {𝒢 : Set C}
Goal: CategoryTheory.IsCoseparating 𝒢 → CategoryTheory.IsCodetecting 𝒢
-- CategoryTheory.isDetecting_iff_isSeparating
theorem isDetecting_iff_isSeparating [HasEqualizers C] [Balanced C] (𝒢 : Set C) :
    IsDetecting 𝒢 ↔ IsSeparating 𝒢 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasEqualizers C] [CategoryTheory.Balanced C] (𝒢 : Set C)
Goal: CategoryTheory.IsDetecting 𝒢 ↔ CategoryTheory.IsSeparating 𝒢
-- CategoryTheory.isCodetecting_iff_isCoseparating
theorem isCodetecting_iff_isCoseparating [HasCoequalizers C] [Balanced C] {𝒢 : Set C} :
    IsCodetecting 𝒢 ↔ IsCoseparating 𝒢 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasCoequalizers C] [CategoryTheory.Balanced C] {𝒢 : Set C}
Goal: CategoryTheory.IsCodetecting 𝒢 ↔ CategoryTheory.IsCoseparating 𝒢
-- CategoryTheory.IsSeparating.mono
theorem IsSeparating.mono {𝒢 : Set C} (h𝒢 : IsSeparating 𝒢) {ℋ : Set C} (h𝒢ℋ : 𝒢 ⊆ ℋ) :
    IsSeparating ℋ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {𝒢 : Set C} (h𝒢 : CategoryTheory.IsSeparating 𝒢) {ℋ : Set C} (h𝒢ℋ : 𝒢 ⊆ ℋ)
Goal: CategoryTheory.IsSeparating ℋ
-- CategoryTheory.IsCoseparating.mono
theorem IsCoseparating.mono {𝒢 : Set C} (h𝒢 : IsCoseparating 𝒢) {ℋ : Set C} (h𝒢ℋ : 𝒢 ⊆ ℋ) :
    IsCoseparating ℋ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {𝒢 : Set C} (h𝒢 : CategoryTheory.IsCoseparating 𝒢) {ℋ : Set C} (h𝒢ℋ : 𝒢 ⊆ ℋ)
Goal: CategoryTheory.IsCoseparating ℋ
-- CategoryTheory.IsDetecting.mono
theorem IsDetecting.mono {𝒢 : Set C} (h𝒢 : IsDetecting 𝒢) {ℋ : Set C} (h𝒢ℋ : 𝒢 ⊆ ℋ) :
    IsDetecting ℋ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {𝒢 : Set C} (h𝒢 : CategoryTheory.IsDetecting 𝒢) {ℋ : Set C} (h𝒢ℋ : 𝒢 ⊆ ℋ)
Goal: CategoryTheory.IsDetecting ℋ
-- CategoryTheory.IsCodetecting.mono
theorem IsCodetecting.mono {𝒢 : Set C} (h𝒢 : IsCodetecting 𝒢) {ℋ : Set C} (h𝒢ℋ : 𝒢 ⊆ ℋ) :
    IsCodetecting ℋ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {𝒢 : Set C} (h𝒢 : CategoryTheory.IsCodetecting 𝒢) {ℋ : Set C} (h𝒢ℋ : 𝒢 ⊆ ℋ)
Goal: CategoryTheory.IsCodetecting ℋ
-- CategoryTheory.thin_of_isSeparating_empty
theorem thin_of_isSeparating_empty (h : IsSeparating (∅ : Set C)) : Quiver.IsThin C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (h : CategoryTheory.IsSeparating ∅)
Goal: Quiver.IsThin C
-- CategoryTheory.isSeparating_empty_of_thin
theorem isSeparating_empty_of_thin [Quiver.IsThin C] : IsSeparating (∅ : Set C) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [Quiver.IsThin C]
Goal: CategoryTheory.IsSeparating ∅
-- CategoryTheory.thin_of_isCoseparating_empty
theorem thin_of_isCoseparating_empty (h : IsCoseparating (∅ : Set C)) : Quiver.IsThin C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (h : CategoryTheory.IsCoseparating ∅)
Goal: Quiver.IsThin C
-- CategoryTheory.isCoseparating_empty_of_thin
theorem isCoseparating_empty_of_thin [Quiver.IsThin C] : IsCoseparating (∅ : Set C) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [Quiver.IsThin C]
Goal: CategoryTheory.IsCoseparating ∅
-- CategoryTheory.groupoid_of_isDetecting_empty
theorem groupoid_of_isDetecting_empty (h : IsDetecting (∅ : Set C)) {X Y : C} (f : X ⟶ Y) :
    IsIso f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (h : CategoryTheory.IsDetecting ∅) {X Y : C} (f : X ⟶ Y)
Goal: CategoryTheory.IsIso f
-- CategoryTheory.isDetecting_empty_of_groupoid
theorem isDetecting_empty_of_groupoid [∀ {X Y : C} (f : X ⟶ Y), IsIso f] :
    IsDetecting (∅ : Set C) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [∀ {X Y : C} (f : X ⟶ Y), CategoryTheory.IsIso f]
Goal: CategoryTheory.IsDetecting ∅
-- CategoryTheory.groupoid_of_isCodetecting_empty
theorem groupoid_of_isCodetecting_empty (h : IsCodetecting (∅ : Set C)) {X Y : C} (f : X ⟶ Y) :
    IsIso f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (h : CategoryTheory.IsCodetecting ∅) {X Y : C} (f : X ⟶ Y)
Goal: CategoryTheory.IsIso f
-- CategoryTheory.isCodetecting_empty_of_groupoid
theorem isCodetecting_empty_of_groupoid [∀ {X Y : C} (f : X ⟶ Y), IsIso f] :
    IsCodetecting (∅ : Set C) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [∀ {X Y : C} (f : X ⟶ Y), CategoryTheory.IsIso f]
Goal: CategoryTheory.IsCodetecting ∅
-- CategoryTheory.isSeparating_iff_epi
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)) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (𝒢 : Set C) [∀ (A : C), CategoryTheory.Limits.HasCoproduct fun f => ↑f.fst]
Goal: CategoryTheory.IsSeparating 𝒢 ↔ ∀ (A : C), CategoryTheory.Epi (CategoryTheory.Limits.Sigma.desc Sigma.snd)
-- CategoryTheory.isCoseparating_iff_mono
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))) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (𝒢 : Set C) [∀ (A : C), CategoryTheory.Limits.HasProduct fun f => ↑f.fst]
Goal: CategoryTheory.IsCoseparating 𝒢 ↔ ∀ (A : C), CategoryTheory.Mono (CategoryTheory.Limits.Pi.lift Sigma.snd)
-- CategoryTheory.hasInitial_of_isCoseparating
theorem hasInitial_of_isCoseparating [WellPowered C] [HasLimits C] {𝒢 : Set C} [Small.{v₁} 𝒢]
    (h𝒢 : IsCoseparating 𝒢) : HasInitial C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.WellPowered C] [CategoryTheory.Limits.HasLimits C] {𝒢 : Set C} [Small.{v₁, u₁} ↑𝒢] (h𝒢 : CategoryTheory.IsCoseparating 𝒢)
Goal: CategoryTheory.Limits.HasInitial C
-- CategoryTheory.hasTerminal_of_isSeparating
theorem hasTerminal_of_isSeparating [WellPowered Cᵒᵖ] [HasColimits C] {𝒢 : Set C} [Small.{v₁} 𝒢]
    (h𝒢 : IsSeparating 𝒢) : HasTerminal C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.WellPowered Cᵒᵖ] [CategoryTheory.Limits.HasColimits C] {𝒢 : Set C} [Small.{v₁, u₁} ↑𝒢] (h𝒢 : CategoryTheory.IsSeparating 𝒢)
Goal: CategoryTheory.Limits.HasTerminal C
-- CategoryTheory.Subobject.eq_of_le_of_isDetecting
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 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {𝒢 : Set C} (h𝒢 : CategoryTheory.IsDetecting 𝒢) {X : C} (P Q : CategoryTheory.Subobject X) (h₁ : P ≤ Q) (h₂ : ∀ G ∈ 𝒢, ∀ {f : G ⟶ X}, Q.Factors f → P.Factors f)
Goal: P = Q
-- CategoryTheory.Subobject.inf_eq_of_isDetecting
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 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasPullbacks C] {𝒢 : Set C} (h𝒢 : CategoryTheory.IsDetecting 𝒢) {X : C} (P Q : CategoryTheory.Subobject X) (h : ∀ G ∈ 𝒢, ∀ {f : G ⟶ X}, P.Factors f → Q.Factors f)
Goal: P ⊓ Q = P
-- CategoryTheory.Subobject.eq_of_isDetecting
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 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasPullbacks C] {𝒢 : Set C} (h𝒢 : CategoryTheory.IsDetecting 𝒢) {X : C} (P Q : CategoryTheory.Subobject X) (h : ∀ G ∈ 𝒢, ∀ {f : G ⟶ X}, P.Factors f ↔ Q.Factors f)
Goal: P = Q
-- CategoryTheory.wellPowered_of_isDetecting
theorem wellPowered_of_isDetecting [HasPullbacks C] {𝒢 : Set C} [Small.{v₁} 𝒢]
    (h𝒢 : IsDetecting 𝒢) : WellPowered C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasPullbacks C] {𝒢 : Set C} [Small.{v₁, u₁} ↑𝒢] (h𝒢 : CategoryTheory.IsDetecting 𝒢)
Goal: CategoryTheory.WellPowered C
-- CategoryTheory.StructuredArrow.isCoseparating_proj_preimage
theorem isCoseparating_proj_preimage {𝒢 : Set C} (h𝒢 : IsCoseparating 𝒢) :
    IsCoseparating ((proj S T).obj ⁻¹' 𝒢) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (S : D) (T : CategoryTheory.Functor C D) {𝒢 : Set C} (h𝒢 : CategoryTheory.IsCoseparating 𝒢)
Goal: CategoryTheory.IsCoseparating ((CategoryTheory.StructuredArrow.proj S T).obj ⁻¹' 𝒢)
-- CategoryTheory.CostructuredArrow.isSeparating_proj_preimage
theorem isSeparating_proj_preimage {𝒢 : Set C} (h𝒢 : IsSeparating 𝒢) :
    IsSeparating ((proj S T).obj ⁻¹' 𝒢) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (S : CategoryTheory.Functor C D) (T : D) {𝒢 : Set C} (h𝒢 : CategoryTheory.IsSeparating 𝒢)
Goal: CategoryTheory.IsSeparating ((CategoryTheory.CostructuredArrow.proj S T).obj ⁻¹' 𝒢)
-- CategoryTheory.isSeparator_op_iff
theorem isSeparator_op_iff (G : C) : IsSeparator (op G) ↔ IsCoseparator G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (G : C)
Goal: CategoryTheory.IsSeparator (Opposite.op G) ↔ CategoryTheory.IsCoseparator G
-- CategoryTheory.isCoseparator_op_iff
theorem isCoseparator_op_iff (G : C) : IsCoseparator (op G) ↔ IsSeparator G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (G : C)
Goal: CategoryTheory.IsCoseparator (Opposite.op G) ↔ CategoryTheory.IsSeparator G
-- CategoryTheory.isCoseparator_unop_iff
theorem isCoseparator_unop_iff (G : Cᵒᵖ) : IsCoseparator (unop G) ↔ IsSeparator G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (G : Cᵒᵖ)
Goal: CategoryTheory.IsCoseparator (Opposite.unop G) ↔ CategoryTheory.IsSeparator G
-- CategoryTheory.isSeparator_unop_iff
theorem isSeparator_unop_iff (G : Cᵒᵖ) : IsSeparator (unop G) ↔ IsCoseparator G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (G : Cᵒᵖ)
Goal: CategoryTheory.IsSeparator (Opposite.unop G) ↔ CategoryTheory.IsCoseparator G
-- CategoryTheory.isDetector_op_iff
theorem isDetector_op_iff (G : C) : IsDetector (op G) ↔ IsCodetector G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (G : C)
Goal: CategoryTheory.IsDetector (Opposite.op G) ↔ CategoryTheory.IsCodetector G