ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Functor.final_equivalence_comp
theorem final_equivalence_comp [IsEquivalence F] [Final G] : Final (F ⋙ G) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (F : CategoryTheory.Functor C D) (G : CategoryTheory.Functor D E) [F.IsEquivalence] [G.Final]
Goal: (F.comp G).Final
-- CategoryTheory.Functor.initial_equivalence_comp
theorem initial_equivalence_comp [IsEquivalence F] [Initial G] : Initial (F ⋙ G) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (F : CategoryTheory.Functor C D) (G : CategoryTheory.Functor D E) [F.IsEquivalence] [G.Initial]
Goal: (F.comp G).Initial
-- CategoryTheory.Functor.final_of_equivalence_comp
theorem final_of_equivalence_comp [IsEquivalence F] [Final (F ⋙ G)] : Final G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (F : CategoryTheory.Functor C D) (G : CategoryTheory.Functor D E) [F.IsEquivalence] [(F.comp G).Final]
Goal: G.Final
-- CategoryTheory.Functor.initial_of_equivalence_comp
theorem initial_of_equivalence_comp [IsEquivalence F] [Initial (F ⋙ G)] : Initial G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (F : CategoryTheory.Functor C D) (G : CategoryTheory.Functor D E) [F.IsEquivalence] [(F.comp G).Initial]
Goal: G.Initial
-- CategoryTheory.Functor.final_iff_comp_equivalence
theorem final_iff_comp_equivalence [IsEquivalence G] : Final F ↔ Final (F ⋙ G) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (F : CategoryTheory.Functor C D) (G : CategoryTheory.Functor D E) [G.IsEquivalence]
Goal: F.Final ↔ (F.comp G).Final
-- CategoryTheory.Functor.final_iff_equivalence_comp
theorem final_iff_equivalence_comp [IsEquivalence F] : Final G ↔ Final (F ⋙ G) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (F : CategoryTheory.Functor C D) (G : CategoryTheory.Functor D E) [F.IsEquivalence]
Goal: G.Final ↔ (F.comp G).Final
-- CategoryTheory.Functor.initial_iff_comp_equivalence
theorem initial_iff_comp_equivalence [IsEquivalence G] : Initial F ↔ Initial (F ⋙ G) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (F : CategoryTheory.Functor C D) (G : CategoryTheory.Functor D E) [G.IsEquivalence]
Goal: F.Initial ↔ (F.comp G).Initial
-- CategoryTheory.Functor.initial_iff_equivalence_comp
theorem initial_iff_equivalence_comp [IsEquivalence F] : Initial G ↔ Initial (F ⋙ G) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (F : CategoryTheory.Functor C D) (G : CategoryTheory.Functor D E) [F.IsEquivalence]
Goal: G.Initial ↔ (F.comp G).Initial
-- CategoryTheory.Functor.final_of_final_comp
theorem final_of_final_comp [hF : Final F] [hFG : Final (F ⋙ G)] : Final G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (F : CategoryTheory.Functor C D) (G : CategoryTheory.Functor D E) [hF : F.Final] [hFG : (F.comp G).Final]
Goal: G.Final
-- CategoryTheory.Functor.initial_of_initial_comp
theorem initial_of_initial_comp [Initial F] [Initial (F ⋙ G)] : Initial G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (F : CategoryTheory.Functor C D) (G : CategoryTheory.Functor D E) [F.Initial] [(F.comp G).Initial]
Goal: G.Initial
-- CategoryTheory.Functor.final_of_comp_full_faithful'
theorem final_of_comp_full_faithful' [Full G] [Faithful G] [Final (F ⋙ G)] : Final G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (F : CategoryTheory.Functor C D) (G : CategoryTheory.Functor D E) [G.Full] [G.Faithful] [(F.comp G).Final]
Goal: G.Final
-- CategoryTheory.Functor.initial_of_comp_full_faithful'
theorem initial_of_comp_full_faithful' [Full G] [Faithful G] [Initial (F ⋙ G)] : Initial G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (F : CategoryTheory.Functor C D) (G : CategoryTheory.Functor D E) [G.Full] [G.Faithful] [(F.comp G).Initial]
Goal: G.Initial
-- CategoryTheory.Functor.final_iff_comp_final_full_faithful
theorem final_iff_comp_final_full_faithful [Final G] [Full G] [Faithful G] :
    Final F ↔ Final (F ⋙ G) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (F : CategoryTheory.Functor C D) (G : CategoryTheory.Functor D E) [G.Final] [G.Full] [G.Faithful]
Goal: F.Final ↔ (F.comp G).Final
-- CategoryTheory.Functor.initial_iff_comp_initial_full_faithful
theorem initial_iff_comp_initial_full_faithful [Initial G] [Full G] [Faithful G] :
    Initial F ↔ Initial (F ⋙ G) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (F : CategoryTheory.Functor C D) (G : CategoryTheory.Functor D E) [G.Initial] [G.Full] [G.Faithful]
Goal: F.Initial ↔ (F.comp G).Initial
-- CategoryTheory.Functor.final_iff_final_comp
theorem final_iff_final_comp [Final F] : Final G ↔ Final (F ⋙ G) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (F : CategoryTheory.Functor C D) (G : CategoryTheory.Functor D E) [F.Final]
Goal: G.Final ↔ (F.comp G).Final
-- CategoryTheory.Functor.initial_iff_initial_comp
theorem initial_iff_initial_comp [Initial F] : Initial G ↔ Initial (F ⋙ G) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (F : CategoryTheory.Functor C D) (G : CategoryTheory.Functor D E) [F.Initial]
Goal: G.Initial ↔ (F.comp G).Initial
-- CategoryTheory.IsFilteredOrEmpty.of_final
theorem IsFilteredOrEmpty.of_final (F : C ⥤ D) [Final F] [IsFilteredOrEmpty C] :
    IsFilteredOrEmpty D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [F.Final] [CategoryTheory.IsFilteredOrEmpty C]
Goal: CategoryTheory.IsFilteredOrEmpty D
-- CategoryTheory.IsFiltered.of_final
theorem IsFiltered.of_final (F : C ⥤ D) [Final F] [IsFiltered C] : IsFiltered D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [F.Final] [CategoryTheory.IsFiltered C]
Goal: CategoryTheory.IsFiltered D
-- CategoryTheory.IsCofilteredOrEmpty.of_initial
theorem IsCofilteredOrEmpty.of_initial (F : C ⥤ D) [Initial F] [IsCofilteredOrEmpty C] :
    IsCofilteredOrEmpty D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [F.Initial] [CategoryTheory.IsCofilteredOrEmpty C]
Goal: CategoryTheory.IsCofilteredOrEmpty D
-- CategoryTheory.IsCofiltered.of_initial
theorem IsCofiltered.of_initial (F : C ⥤ D) [Initial F] [IsCofiltered C] : IsCofiltered D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [F.Initial] [CategoryTheory.IsCofiltered C]
Goal: CategoryTheory.IsCofiltered D
-- CategoryTheory.Dial.Hom.le
@[ext] structure Hom (X Y : Dial C) where
    f : X.src ⟶ Y.src
    F : X.src ⨯ Y.tgt ⟶ X.tgt
    le :
    (Subobject.pullback π(π₁, F)).obj X.rel ≤
    (Subobject.pullback (prod.map f (𝟙 _))).obj Y.rel
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasFiniteProducts C] [CategoryTheory.Limits.HasPullbacks C] {X Y : CategoryTheory.Dial C} (self : X.Hom Y)
Goal: (CategoryTheory.Subobject.pullback (CategoryTheory.Limits.prod.lift CategoryTheory.Limits.prod.fst self.F)).obj X.rel ≤
  (CategoryTheory.Subobject.pullback
        (CategoryTheory.Limits.prod.map self.f (CategoryTheory.CategoryStruct.id Y.tgt))).obj
    Y.rel
-- CategoryTheory.Dial.comp_le_lemma
theorem comp_le_lemma {X Y Z : Dial C} (F : Dial.Hom X Y) (G : Dial.Hom Y Z) :
    (Subobject.pullback π(π₁, π(π₁, prod.map F.f (𝟙 _) ≫ G.F) ≫ F.F)).obj X.rel ≤
    (Subobject.pullback (prod.map (F.f ≫ G.f) (𝟙 Z.tgt))).obj Z.rel 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasFiniteProducts C] [CategoryTheory.Limits.HasPullbacks C] {X Y Z : CategoryTheory.Dial C} (F : X.Hom Y) (G : Y.Hom Z)
Goal: (CategoryTheory.Subobject.pullback
        (CategoryTheory.Limits.prod.lift CategoryTheory.Limits.prod.fst
          (CategoryTheory.CategoryStruct.comp
            (CategoryTheory.Limits.prod.lift CategoryTheory.Limits.prod.fst
              (CategoryTheory.CategoryStruct.comp
                (CategoryTheory.Limits.prod.map F.f (CategoryTheory.CategoryStruct.id Z.tgt)) G.F))
            F.F))).obj
    X.rel ≤
  (CategoryTheory.Subobject.pullback
        (CategoryTheory.Limits.prod.map (CategoryTheory.CategoryStruct.comp F.f G.f)
          (CategoryTheory.CategoryStruct.id Z.tgt))).obj
    Z.rel
-- CategoryTheory.Dial.instCategory_id_F
@[simps]
instance : Category (Dial C) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasFiniteProducts C] [CategoryTheory.Limits.HasPullbacks C] (X : CategoryTheory.Dial C)
Goal: (CategoryTheory.CategoryStruct.id X).F = CategoryTheory.Limits.prod.snd
-- CategoryTheory.Dial.instCategory_comp_F
@[simps]
instance : Category (Dial C) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasFiniteProducts C] [CategoryTheory.Limits.HasPullbacks C] {X Y Z : CategoryTheory.Dial C} (F : X.Hom Y) (G : Y.Hom Z)
Goal: (CategoryTheory.CategoryStruct.comp F G).F =
  CategoryTheory.CategoryStruct.comp
    (CategoryTheory.Limits.prod.lift CategoryTheory.Limits.prod.fst
      (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.prod.map F.f (CategoryTheory.CategoryStruct.id Z.tgt))
        G.F))
    F.F
-- CategoryTheory.Dial.instCategory_id_f
@[simps]
instance : Category (Dial C) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasFiniteProducts C] [CategoryTheory.Limits.HasPullbacks C] (X : CategoryTheory.Dial C)
Goal: (CategoryTheory.CategoryStruct.id X).f = CategoryTheory.CategoryStruct.id X.src
-- CategoryTheory.Dial.instCategory_comp_f
@[simps]
instance : Category (Dial C) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasFiniteProducts C] [CategoryTheory.Limits.HasPullbacks C] {X Y Z : CategoryTheory.Dial C} (F : X.Hom Y) (G : Y.Hom Z)
Goal: (CategoryTheory.CategoryStruct.comp F G).f = CategoryTheory.CategoryStruct.comp F.f G.f
-- CategoryTheory.Dial.hom_ext
@[ext] theorem hom_ext {X Y : Dial C} {x y : X ⟶ Y} (hf : x.f = y.f) (hF : x.F = y.F) : x = y 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasFiniteProducts C] [CategoryTheory.Limits.HasPullbacks C] {X Y : CategoryTheory.Dial C} {x y : X ⟶ Y} (hf : x.f = y.f) (hF : x.F = y.F)
Goal: x = y
-- CategoryTheory.Dial.isoMk_inv_F
@[simps] def isoMk {X Y : Dial C} (e₁ : X.src ≅ Y.src) (e₂ : X.tgt ≅ Y.tgt)
    (eq : X.rel = (Subobject.pullback (prod.map e₁.hom e₂.hom)).obj Y.rel) : X ≅ Y 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasFiniteProducts C] [CategoryTheory.Limits.HasPullbacks C] {X Y : CategoryTheory.Dial C} (e₁ : X.src ≅ Y.src) (e₂ : X.tgt ≅ Y.tgt) (eq : X.rel = (CategoryTheory.Subobject.pullback (CategoryTheory.Limits.prod.map e₁.hom e₂.hom)).obj Y.rel)
Goal: (CategoryTheory.Dial.isoMk e₁ e₂ eq).inv.F = CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.prod.snd e₂.hom
-- CategoryTheory.Dial.isoMk_hom_f
@[simps] def isoMk {X Y : Dial C} (e₁ : X.src ≅ Y.src) (e₂ : X.tgt ≅ Y.tgt)
    (eq : X.rel = (Subobject.pullback (prod.map e₁.hom e₂.hom)).obj Y.rel) : X ≅ Y 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasFiniteProducts C] [CategoryTheory.Limits.HasPullbacks C] {X Y : CategoryTheory.Dial C} (e₁ : X.src ≅ Y.src) (e₂ : X.tgt ≅ Y.tgt) (eq : X.rel = (CategoryTheory.Subobject.pullback (CategoryTheory.Limits.prod.map e₁.hom e₂.hom)).obj Y.rel)
Goal: (CategoryTheory.Dial.isoMk e₁ e₂ eq).hom.f = e₁.hom
-- CategoryTheory.Dial.isoMk_hom_F
@[simps] def isoMk {X Y : Dial C} (e₁ : X.src ≅ Y.src) (e₂ : X.tgt ≅ Y.tgt)
    (eq : X.rel = (Subobject.pullback (prod.map e₁.hom e₂.hom)).obj Y.rel) : X ≅ Y 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasFiniteProducts C] [CategoryTheory.Limits.HasPullbacks C] {X Y : CategoryTheory.Dial C} (e₁ : X.src ≅ Y.src) (e₂ : X.tgt ≅ Y.tgt) (eq : X.rel = (CategoryTheory.Subobject.pullback (CategoryTheory.Limits.prod.map e₁.hom e₂.hom)).obj Y.rel)
Goal: (CategoryTheory.Dial.isoMk e₁ e₂ eq).hom.F = CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.prod.snd e₂.inv
-- CategoryTheory.Dial.isoMk_inv_f
@[simps] def isoMk {X Y : Dial C} (e₁ : X.src ≅ Y.src) (e₂ : X.tgt ≅ Y.tgt)
    (eq : X.rel = (Subobject.pullback (prod.map e₁.hom e₂.hom)).obj Y.rel) : X ≅ Y 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasFiniteProducts C] [CategoryTheory.Limits.HasPullbacks C] {X Y : CategoryTheory.Dial C} (e₁ : X.src ≅ Y.src) (e₂ : X.tgt ≅ Y.tgt) (eq : X.rel = (CategoryTheory.Subobject.pullback (CategoryTheory.Limits.prod.map e₁.hom e₂.hom)).obj Y.rel)
Goal: (CategoryTheory.Dial.isoMk e₁ e₂ eq).inv.f = e₁.inv
-- CategoryTheory.Functor.final_of_isFiltered_structuredArrow
theorem Functor.final_of_isFiltered_structuredArrow [∀ d, IsFiltered (StructuredArrow d F)] :
    Final F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [∀ (d : D), CategoryTheory.IsFiltered (CategoryTheory.StructuredArrow d F)]
Goal: F.Final
-- CategoryTheory.Functor.initial_of_isCofiltered_costructuredArrow
theorem Functor.initial_of_isCofiltered_costructuredArrow
    [∀ d, IsCofiltered (CostructuredArrow F d)] : Initial F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [∀ (d : D), CategoryTheory.IsCofiltered (CategoryTheory.CostructuredArrow F d)]
Goal: F.Initial
-- CategoryTheory.isFiltered_structuredArrow_of_isFiltered_of_exists
theorem isFiltered_structuredArrow_of_isFiltered_of_exists [IsFilteredOrEmpty C]
    (h₁ : ∀ d, ∃ c, Nonempty (d ⟶ F.obj c)) (h₂ : ∀ {d : D} {c : C} (s s' : d ⟶ F.obj c),
      ∃ (c' : C) (t : c ⟶ c'), s ≫ F.map t = s' ≫ F.map t) (d : D) :
    IsFiltered (StructuredArrow d F) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [CategoryTheory.IsFilteredOrEmpty C] (h₁ : ∀ (d : D), ∃ c, Nonempty (d ⟶ F.obj c)) (h₂ :
  ∀ {d : D} {c : C} (s s' : d ⟶ F.obj c),
    ∃ c' t, CategoryTheory.CategoryStruct.comp s (F.map t) = CategoryTheory.CategoryStruct.comp s' (F.map t)) (d : D)
Goal: CategoryTheory.IsFiltered (CategoryTheory.StructuredArrow d F)
-- CategoryTheory.isCofiltered_costructuredArrow_of_isCofiltered_of_exists
theorem isCofiltered_costructuredArrow_of_isCofiltered_of_exists [IsCofilteredOrEmpty C]
    (h₁ : ∀ d, ∃ c, Nonempty (F.obj c ⟶ d)) (h₂ : ∀ {d : D} {c : C} (s s' : F.obj c ⟶ d),
      ∃ (c' : C) (t : c' ⟶ c), F.map t ≫ s = F.map t ≫ s') (d : D) :
    IsCofiltered (CostructuredArrow F d) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [CategoryTheory.IsCofilteredOrEmpty C] (h₁ : ∀ (d : D), ∃ c, Nonempty (F.obj c ⟶ d)) (h₂ :
  ∀ {d : D} {c : C} (s s' : F.obj c ⟶ d),
    ∃ c' t, CategoryTheory.CategoryStruct.comp (F.map t) s = CategoryTheory.CategoryStruct.comp (F.map t) s') (d : D)
Goal: CategoryTheory.IsCofiltered (CategoryTheory.CostructuredArrow F d)
-- CategoryTheory.Functor.final_of_exists_of_isFiltered
theorem Functor.final_of_exists_of_isFiltered [IsFilteredOrEmpty C]
    (h₁ : ∀ d, ∃ c, Nonempty (d ⟶ F.obj c)) (h₂ : ∀ {d : D} {c : C} (s s' : d ⟶ F.obj c),
      ∃ (c' : C) (t : c ⟶ c'), s ≫ F.map t = s' ≫ F.map t) : Functor.Final F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [CategoryTheory.IsFilteredOrEmpty C] (h₁ : ∀ (d : D), ∃ c, Nonempty (d ⟶ F.obj c)) (h₂ :
  ∀ {d : D} {c : C} (s s' : d ⟶ F.obj c),
    ∃ c' t, CategoryTheory.CategoryStruct.comp s (F.map t) = CategoryTheory.CategoryStruct.comp s' (F.map t))
Goal: F.Final
-- CategoryTheory.Functor.initial_of_exists_of_isCofiltered
theorem Functor.initial_of_exists_of_isCofiltered [IsCofilteredOrEmpty C]
    (h₁ : ∀ d, ∃ c, Nonempty (F.obj c ⟶ d)) (h₂ : ∀ {d : D} {c : C} (s s' : F.obj c ⟶ d),
      ∃ (c' : C) (t : c' ⟶ c), F.map t ≫ s = F.map t ≫ s') : Functor.Initial F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [CategoryTheory.IsCofilteredOrEmpty C] (h₁ : ∀ (d : D), ∃ c, Nonempty (F.obj c ⟶ d)) (h₂ :
  ∀ {d : D} {c : C} (s s' : F.obj c ⟶ d),
    ∃ c' t, CategoryTheory.CategoryStruct.comp (F.map t) s = CategoryTheory.CategoryStruct.comp (F.map t) s')
Goal: F.Initial
-- CategoryTheory.IsFilteredOrEmpty.of_exists_of_isFiltered_of_fullyFaithful
theorem IsFilteredOrEmpty.of_exists_of_isFiltered_of_fullyFaithful [IsFilteredOrEmpty D] [F.Full]
    [F.Faithful] (h : ∀ d, ∃ c, Nonempty (d ⟶ F.obj c)) : IsFilteredOrEmpty C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [CategoryTheory.IsFilteredOrEmpty D] [F.Full] [F.Faithful] (h : ∀ (d : D), ∃ c, Nonempty (d ⟶ F.obj c))
Goal: CategoryTheory.IsFilteredOrEmpty C
-- CategoryTheory.IsCofilteredOrEmpty.of_exists_of_isCofiltered_of_fullyFaithful
theorem IsCofilteredOrEmpty.of_exists_of_isCofiltered_of_fullyFaithful [IsCofilteredOrEmpty D]
    [F.Full] [F.Faithful] (h : ∀ d, ∃ c, Nonempty (F.obj c ⟶ d)) : IsCofilteredOrEmpty C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [CategoryTheory.IsCofilteredOrEmpty D] [F.Full] [F.Faithful] (h : ∀ (d : D), ∃ c, Nonempty (F.obj c ⟶ d))
Goal: CategoryTheory.IsCofilteredOrEmpty C
-- CategoryTheory.IsFiltered.of_exists_of_isFiltered_of_fullyFaithful
theorem IsFiltered.of_exists_of_isFiltered_of_fullyFaithful [IsFiltered D] [F.Full] [F.Faithful]
    (h : ∀ d, ∃ c, Nonempty (d ⟶ F.obj c)) : IsFiltered C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [CategoryTheory.IsFiltered D] [F.Full] [F.Faithful] (h : ∀ (d : D), ∃ c, Nonempty (d ⟶ F.obj c))
Goal: CategoryTheory.IsFiltered C
-- CategoryTheory.IsCofiltered.of_exists_of_isCofiltered_of_fullyFaithful
theorem IsCofiltered.of_exists_of_isCofiltered_of_fullyFaithful [IsCofiltered D] [F.Full]
    [F.Faithful] (h : ∀ d, ∃ c, Nonempty (F.obj c ⟶ d)) : IsCofiltered C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [CategoryTheory.IsCofiltered D] [F.Full] [F.Faithful] (h : ∀ (d : D), ∃ c, Nonempty (F.obj c ⟶ d))
Goal: CategoryTheory.IsCofiltered C
-- CategoryTheory.Functor.final_of_exists_of_isFiltered_of_fullyFaithful
theorem Functor.final_of_exists_of_isFiltered_of_fullyFaithful [IsFilteredOrEmpty D] [F.Full]
    [F.Faithful] (h : ∀ d, ∃ c, Nonempty (d ⟶ F.obj c)) : Final F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [CategoryTheory.IsFilteredOrEmpty D] [F.Full] [F.Faithful] (h : ∀ (d : D), ∃ c, Nonempty (d ⟶ F.obj c))
Goal: F.Final
-- CategoryTheory.Functor.initial_of_exists_of_isCofiltered_of_fullyFaithful
theorem Functor.initial_of_exists_of_isCofiltered_of_fullyFaithful [IsCofilteredOrEmpty D] [F.Full]
    [Faithful F] (h : ∀ d, ∃ c, Nonempty (F.obj c ⟶ d)) : Initial F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [CategoryTheory.IsCofilteredOrEmpty D] [F.Full] [F.Faithful] (h : ∀ (d : D), ∃ c, Nonempty (F.obj c ⟶ d))
Goal: F.Initial
-- CategoryTheory.Functor.final_iff_of_isFiltered
theorem Functor.final_iff_of_isFiltered [IsFilteredOrEmpty C] :
    Final F ↔ (∀ d, ∃ c, Nonempty (d ⟶ F.obj c)) ∧ (∀ {d : D} {c : C} (s s' : d ⟶ F.obj c),
      ∃ (c' : C) (t : c ⟶ c'), s ≫ F.map t = s' ≫ F.map t) 
Arguments: {C : Type v₁} [CategoryTheory.Category.{v₁, v₁} C] {D : Type u₂} [CategoryTheory.Category.{v₁, u₂} D] (F : CategoryTheory.Functor C D) [CategoryTheory.IsFilteredOrEmpty C]
Goal: F.Final ↔
  (∀ (d : D), ∃ c, Nonempty (d ⟶ F.obj c)) ∧
    ∀ {d : D} {c : C} (s s' : d ⟶ F.obj c),
      ∃ c' t, CategoryTheory.CategoryStruct.comp s (F.map t) = CategoryTheory.CategoryStruct.comp s' (F.map t)
-- CategoryTheory.Functor.initial_iff_of_isCofiltered
theorem Functor.initial_iff_of_isCofiltered [IsCofilteredOrEmpty C] :
    Initial F ↔ (∀ d, ∃ c, Nonempty (F.obj c ⟶ d)) ∧ (∀ {d : D} {c : C} (s s' : F.obj c ⟶ d),
      ∃ (c' : C) (t : c' ⟶ c), F.map t ≫ s = F.map t ≫ s') 
Arguments: {C : Type v₁} [CategoryTheory.Category.{v₁, v₁} C] {D : Type u₂} [CategoryTheory.Category.{v₁, u₂} D] (F : CategoryTheory.Functor C D) [CategoryTheory.IsCofilteredOrEmpty C]
Goal: F.Initial ↔
  (∀ (d : D), ∃ c, Nonempty (F.obj c ⟶ d)) ∧
    ∀ {d : D} {c : C} (s s' : F.obj c ⟶ d),
      ∃ c' t, CategoryTheory.CategoryStruct.comp (F.map t) s = CategoryTheory.CategoryStruct.comp (F.map t) s'
-- CategoryTheory.Functor.Final.exists_coeq
theorem Functor.Final.exists_coeq [IsFilteredOrEmpty C] [Final F] {d : D} {c : C}
    (s s' : d ⟶ F.obj c) : ∃ (c' : C) (t : c ⟶ c'), s ≫ F.map t = s' ≫ F.map t 
Arguments: {C : Type v₁} [CategoryTheory.Category.{v₁, v₁} C] {D : Type u₂} [CategoryTheory.Category.{v₁, u₂} D] (F : CategoryTheory.Functor C D) [CategoryTheory.IsFilteredOrEmpty C] [F.Final] {d : D} {c : C} (s s' : d ⟶ F.obj c)
Goal: ∃ c' t, CategoryTheory.CategoryStruct.comp s (F.map t) = CategoryTheory.CategoryStruct.comp s' (F.map t)
-- CategoryTheory.Functor.Initial.exists_eq
theorem Functor.Initial.exists_eq [IsCofilteredOrEmpty C] [Initial F] {d : D} {c : C}
    (s s' : F.obj c ⟶ d) : ∃ (c' : C) (t : c' ⟶ c), F.map t ≫ s = F.map t ≫ s' 
Arguments: {C : Type v₁} [CategoryTheory.Category.{v₁, v₁} C] {D : Type u₂} [CategoryTheory.Category.{v₁, u₂} D] (F : CategoryTheory.Functor C D) [CategoryTheory.IsCofilteredOrEmpty C] [F.Initial] {d : D} {c : C} (s s' : F.obj c ⟶ d)
Goal: ∃ c' t, CategoryTheory.CategoryStruct.comp (F.map t) s = CategoryTheory.CategoryStruct.comp (F.map t) s'
-- CategoryTheory.Functor.final_iff_isFiltered_structuredArrow
theorem Functor.final_iff_isFiltered_structuredArrow [IsFilteredOrEmpty C] :
    Final F ↔ ∀ d, IsFiltered (StructuredArrow d F) 
Arguments: {C : Type v₁} [CategoryTheory.Category.{v₁, v₁} C] {D : Type u₂} [CategoryTheory.Category.{v₁, u₂} D] (F : CategoryTheory.Functor C D) [CategoryTheory.IsFilteredOrEmpty C]
Goal: F.Final ↔ ∀ (d : D), CategoryTheory.IsFiltered (CategoryTheory.StructuredArrow d F)