ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Cat.whiskerRight_app
@[simp]
lemma whiskerRight_app {C D E : Cat} {F G : C ⟶ D} (H : D ⟶ E) (η : F ⟶ G) (X : C) :
    (η ▷ H).app X = H.map (η.app X) 
Arguments: {C D E : CategoryTheory.Cat} {F G : C ⟶ D} (H : D ⟶ E) (η : F ⟶ G) (X : ↑C)
Goal: (CategoryTheory.Bicategory.whiskerRight η H).app X = H.map (η.app X)
-- CategoryTheory.Cat.leftUnitor_hom_app
lemma leftUnitor_hom_app {B C : Cat} (F : B ⟶ C) (X : B) : (λ_ F).hom.app X = eqToHom (by simp) 
Arguments: {B C : CategoryTheory.Cat} (F : B ⟶ C) (X : ↑B)
Goal: (CategoryTheory.Bicategory.leftUnitor F).hom.app X = CategoryTheory.eqToHom ⋯
-- CategoryTheory.Cat.leftUnitor_inv_app
lemma leftUnitor_inv_app {B C : Cat} (F : B ⟶ C) (X : B) : (λ_ F).inv.app X = eqToHom (by simp) 
Arguments: {B C : CategoryTheory.Cat} (F : B ⟶ C) (X : ↑B)
Goal: (CategoryTheory.Bicategory.leftUnitor F).inv.app X = CategoryTheory.eqToHom ⋯
-- CategoryTheory.Cat.rightUnitor_hom_app
lemma rightUnitor_hom_app {B C : Cat} (F : B ⟶ C) (X : B) : (ρ_ F).hom.app X = eqToHom (by simp) 
Arguments: {B C : CategoryTheory.Cat} (F : B ⟶ C) (X : ↑B)
Goal: (CategoryTheory.Bicategory.rightUnitor F).hom.app X = CategoryTheory.eqToHom ⋯
-- CategoryTheory.Cat.rightUnitor_inv_app
lemma rightUnitor_inv_app {B C : Cat} (F : B ⟶ C) (X : B) : (ρ_ F).inv.app X = eqToHom (by simp) 
Arguments: {B C : CategoryTheory.Cat} (F : B ⟶ C) (X : ↑B)
Goal: (CategoryTheory.Bicategory.rightUnitor F).inv.app X = CategoryTheory.eqToHom ⋯
-- CategoryTheory.Cat.associator_hom_app
lemma associator_hom_app {B C D E : Cat} (F : B ⟶ C) (G : C ⟶ D) (H : D ⟶ E) (X : B) :
    (α_ F G H).hom.app X = eqToHom (by simp) 
Arguments: {B C D E : CategoryTheory.Cat} (F : B ⟶ C) (G : C ⟶ D) (H : D ⟶ E) (X : ↑B)
Goal: (CategoryTheory.Bicategory.associator F G H).hom.app X = CategoryTheory.eqToHom ⋯
-- CategoryTheory.Cat.associator_inv_app
lemma associator_inv_app {B C D E : Cat} (F : B ⟶ C) (G : C ⟶ D) (H : D ⟶ E) (X : B) :
    (α_ F G H).inv.app X = eqToHom (by simp) 
Arguments: {B C D E : CategoryTheory.Cat} (F : B ⟶ C) (G : C ⟶ D) (H : D ⟶ E) (X : ↑B)
Goal: (CategoryTheory.Bicategory.associator F G H).inv.app X = CategoryTheory.eqToHom ⋯
-- CategoryTheory.typeToCat_obj
@[simps]
def typeToCat : Type u ⥤ Cat 
Arguments: (X : Type u)
Goal: CategoryTheory.typeToCat.obj X = CategoryTheory.Cat.of (CategoryTheory.Discrete X)
-- CategoryTheory.typeToCat_map
@[simps]
def typeToCat : Type u ⥤ Cat 
Arguments: {X Y : Type u} (f : X ⟶ Y)
Goal: CategoryTheory.typeToCat.map f = id (CategoryTheory.Discrete.functor (CategoryTheory.Discrete.mk ∘ f))
-- CategoryTheory.IsFilteredOrEmpty.cocone_maps
class IsFilteredOrEmpty : Prop where
    cocone_objs : ∀ X Y : C, ∃ (Z : _) (_ : X ⟶ Z) (_ : Y ⟶ Z), True
    cocone_maps : ∀ ⦃X Y : C⦄ (f g : X ⟶ Y), ∃ (Z : _) (h : Y ⟶ Z), f ≫ h = g ≫ h
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [self : CategoryTheory.IsFilteredOrEmpty C] ⦃X Y : C⦄ (f g : X ⟶ Y)
Goal: ∃ Z h, CategoryTheory.CategoryStruct.comp f h = CategoryTheory.CategoryStruct.comp g h
-- CategoryTheory.IsFilteredOrEmpty.cocone_objs
class IsFilteredOrEmpty : Prop where
    cocone_objs : ∀ X Y : C, ∃ (Z : _) (_ : X ⟶ Z) (_ : Y ⟶ Z), True
    cocone_maps : ∀ ⦃X Y : C⦄ (f g : X ⟶ Y), ∃ (Z : _) (h : Y ⟶ Z), f ≫ h = g ≫ h
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [self : CategoryTheory.IsFilteredOrEmpty C] (X Y : C)
Goal: ∃ Z x x, True
-- CategoryTheory.IsFiltered.nonempty
class IsFiltered extends IsFilteredOrEmpty C : Prop where
    [nonempty : Nonempty C]
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [self : CategoryTheory.IsFiltered C]
Goal: Nonempty C
-- CategoryTheory.IsFiltered.coeq_condition
@[reassoc]
theorem coeq_condition {j j' : C} (f f' : j ⟶ j') : f ≫ coeqHom f f' = f' ≫ coeqHom f f' 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.IsFilteredOrEmpty C] {j j' : C} (f f' : j ⟶ j')
Goal: CategoryTheory.CategoryStruct.comp f (CategoryTheory.IsFiltered.coeqHom f f') =
  CategoryTheory.CategoryStruct.comp f' (CategoryTheory.IsFiltered.coeqHom f f')
-- CategoryTheory.IsFilteredOrEmpty.of_right_adjoint
theorem of_right_adjoint {L : D ⥤ C} {R : C ⥤ D} (h : L ⊣ R) : IsFilteredOrEmpty D 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.IsFilteredOrEmpty C] {D : Type u₁} [CategoryTheory.Category.{v₁, u₁} D] {L : CategoryTheory.Functor D C} {R : CategoryTheory.Functor C D} (h : L ⊣ R)
Goal: CategoryTheory.IsFilteredOrEmpty D
-- CategoryTheory.IsFilteredOrEmpty.of_isRightAdjoint
theorem of_isRightAdjoint (R : C ⥤ D) [R.IsRightAdjoint] : IsFilteredOrEmpty D 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.IsFilteredOrEmpty C] {D : Type u₁} [CategoryTheory.Category.{v₁, u₁} D] (R : CategoryTheory.Functor C D) [R.IsRightAdjoint]
Goal: CategoryTheory.IsFilteredOrEmpty D
-- CategoryTheory.IsFilteredOrEmpty.of_equivalence
theorem of_equivalence (h : C ≌ D) : IsFilteredOrEmpty D 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.IsFilteredOrEmpty C] {D : Type u₁} [CategoryTheory.Category.{v₁, u₁} D] (h : C ≌ D)
Goal: CategoryTheory.IsFilteredOrEmpty D
-- CategoryTheory.IsFiltered.sup_objs_exists
theorem sup_objs_exists (O : Finset C) : ∃ S : C, ∀ {X}, X ∈ O → Nonempty (X ⟶ S) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.IsFiltered C] (O : Finset C)
Goal: ∃ S, ∀ {X : C}, X ∈ O → Nonempty (X ⟶ S)
-- CategoryTheory.IsFiltered.sup_exists
theorem sup_exists :
    ∃ (S : C) (T : ∀ {X : C}, X ∈ O → (X ⟶ S)),
      ∀ {X Y : C} (mX : X ∈ O) (mY : Y ∈ O) {f : X ⟶ Y},
        (⟨X, Y, mX, mY, f⟩ : Σ' (X Y : C) (_ : X ∈ O) (_ : Y ∈ O), X ⟶ Y) ∈ H →
          f ≫ T mY = T mX 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.IsFiltered C] (O : Finset C) (H : Finset ((X : C) ×' (Y : C) ×' (_ : X ∈ O) ×' (_ : Y ∈ O) ×' (X ⟶ Y)))
Goal: ∃ S T,
  ∀ {X Y : C} (mX : X ∈ O) (mY : Y ∈ O) {f : X ⟶ Y},
    ⟨X, ⟨Y, ⟨mX, ⟨mY, f⟩⟩⟩⟩ ∈ H → CategoryTheory.CategoryStruct.comp f (T mY) = T mX
-- CategoryTheory.IsFiltered.toSup_commutes
theorem toSup_commutes {X Y : C} (mX : X ∈ O) (mY : Y ∈ O) {f : X ⟶ Y}
    (mf : (⟨X, Y, mX, mY, f⟩ : Σ' (X Y : C) (_ : X ∈ O) (_ : Y ∈ O), X ⟶ Y) ∈ H) :
    f ≫ toSup O H mY = toSup O H mX 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.IsFiltered C] (O : Finset C) (H : Finset ((X : C) ×' (Y : C) ×' (_ : X ∈ O) ×' (_ : Y ∈ O) ×' (X ⟶ Y))) {X Y : C} (mX : X ∈ O) (mY : Y ∈ O) {f : X ⟶ Y} (mf : ⟨X, ⟨Y, ⟨mX, ⟨mY, f⟩⟩⟩⟩ ∈ H)
Goal: CategoryTheory.CategoryStruct.comp f (CategoryTheory.IsFiltered.toSup O H mY) = CategoryTheory.IsFiltered.toSup O H mX
-- CategoryTheory.IsFiltered.cocone_nonempty
theorem cocone_nonempty (F : J ⥤ C) : Nonempty (Cocone F) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.IsFiltered C] {J : Type w} [CategoryTheory.SmallCategory J] [CategoryTheory.FinCategory J] (F : CategoryTheory.Functor J C)
Goal: Nonempty (CategoryTheory.Limits.Cocone F)
-- CategoryTheory.IsFiltered.of_right_adjoint
theorem of_right_adjoint {L : D ⥤ C} {R : C ⥤ D} (h : L ⊣ R) : IsFiltered D 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.IsFiltered C] {D : Type u₁} [CategoryTheory.Category.{v₁, u₁} D] {L : CategoryTheory.Functor D C} {R : CategoryTheory.Functor C D} (h : L ⊣ R)
Goal: CategoryTheory.IsFiltered D
-- CategoryTheory.IsFiltered.of_isRightAdjoint
theorem of_isRightAdjoint (R : C ⥤ D) [R.IsRightAdjoint] : IsFiltered D 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.IsFiltered C] {D : Type u₁} [CategoryTheory.Category.{v₁, u₁} D] (R : CategoryTheory.Functor C D) [R.IsRightAdjoint]
Goal: CategoryTheory.IsFiltered D
-- CategoryTheory.IsFiltered.of_equivalence
theorem of_equivalence (h : C ≌ D) : IsFiltered D 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.IsFiltered C] {D : Type u₁} [CategoryTheory.Category.{v₁, u₁} D] (h : C ≌ D)
Goal: CategoryTheory.IsFiltered D
-- CategoryTheory.IsFiltered.of_cocone_nonempty
theorem of_cocone_nonempty (h : ∀ {J : Type w} [SmallCategory J] [FinCategory J] (F : J ⥤ C),
    Nonempty (Cocone F)) : IsFiltered C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] (h :
  ∀ {J : Type w} [inst : CategoryTheory.SmallCategory J] [inst_1 : CategoryTheory.FinCategory J]
    (F : CategoryTheory.Functor J C), Nonempty (CategoryTheory.Limits.Cocone F))
Goal: CategoryTheory.IsFiltered C
-- CategoryTheory.IsFiltered.of_hasFiniteColimits
theorem of_hasFiniteColimits [HasFiniteColimits C] : IsFiltered C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasFiniteColimits C]
Goal: CategoryTheory.IsFiltered C
-- CategoryTheory.IsFiltered.of_isTerminal
theorem of_isTerminal {X : C} (h : IsTerminal X) : IsFiltered C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] {X : C} (h : CategoryTheory.Limits.IsTerminal X)
Goal: CategoryTheory.IsFiltered C
-- CategoryTheory.IsFiltered.iff_cocone_nonempty
theorem iff_cocone_nonempty : IsFiltered C ↔
    ∀ {J : Type w} [SmallCategory J] [FinCategory J] (F : J ⥤ C), Nonempty (Cocone F) 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C]
Goal: CategoryTheory.IsFiltered C ↔
  ∀ {J : Type w} [inst : CategoryTheory.SmallCategory J] [inst_1 : CategoryTheory.FinCategory J]
    (F : CategoryTheory.Functor J C), Nonempty (CategoryTheory.Limits.Cocone F)
-- CategoryTheory.IsFiltered.coeq₃_condition₁
theorem coeq₃_condition₁ {j₁ j₂ : C} (f g h : j₁ ⟶ j₂) :
    f ≫ coeq₃Hom f g h = g ≫ coeq₃Hom f g h 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.IsFilteredOrEmpty C] {j₁ j₂ : C} (f g h : j₁ ⟶ j₂)
Goal: CategoryTheory.CategoryStruct.comp f (CategoryTheory.IsFiltered.coeq₃Hom f g h) =
  CategoryTheory.CategoryStruct.comp g (CategoryTheory.IsFiltered.coeq₃Hom f g h)
-- CategoryTheory.IsFiltered.coeq₃_condition₂
theorem coeq₃_condition₂ {j₁ j₂ : C} (f g h : j₁ ⟶ j₂) :
    g ≫ coeq₃Hom f g h = h ≫ coeq₃Hom f g h 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.IsFilteredOrEmpty C] {j₁ j₂ : C} (f g h : j₁ ⟶ j₂)
Goal: CategoryTheory.CategoryStruct.comp g (CategoryTheory.IsFiltered.coeq₃Hom f g h) =
  CategoryTheory.CategoryStruct.comp h (CategoryTheory.IsFiltered.coeq₃Hom f g h)
-- CategoryTheory.IsFiltered.coeq₃_condition₃
theorem coeq₃_condition₃ {j₁ j₂ : C} (f g h : j₁ ⟶ j₂) : f ≫ coeq₃Hom f g h = h ≫ coeq₃Hom f g h 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.IsFilteredOrEmpty C] {j₁ j₂ : C} (f g h : j₁ ⟶ j₂)
Goal: CategoryTheory.CategoryStruct.comp f (CategoryTheory.IsFiltered.coeq₃Hom f g h) =
  CategoryTheory.CategoryStruct.comp h (CategoryTheory.IsFiltered.coeq₃Hom f g h)
-- CategoryTheory.IsFiltered.span
theorem span {i j j' : C} (f : i ⟶ j) (f' : i ⟶ j') :
    ∃ (k : C) (g : j ⟶ k) (g' : j' ⟶ k), f ≫ g = f' ≫ g' 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.IsFilteredOrEmpty C] {i j j' : C} (f : i ⟶ j) (f' : i ⟶ j')
Goal: ∃ k g g', CategoryTheory.CategoryStruct.comp f g = CategoryTheory.CategoryStruct.comp f' g'
-- CategoryTheory.IsFiltered.bowtie
theorem bowtie {j₁ j₂ k₁ k₂ : C} (f₁ : j₁ ⟶ k₁) (g₁ : j₁ ⟶ k₂) (f₂ : j₂ ⟶ k₁) (g₂ : j₂ ⟶ k₂) :
    ∃ (s : C) (α : k₁ ⟶ s) (β : k₂ ⟶ s), f₁ ≫ α = g₁ ≫ β ∧ f₂ ≫ α = g₂ ≫ β 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.IsFilteredOrEmpty C] {j₁ j₂ k₁ k₂ : C} (f₁ : j₁ ⟶ k₁) (g₁ : j₁ ⟶ k₂) (f₂ : j₂ ⟶ k₁) (g₂ : j₂ ⟶ k₂)
Goal: ∃ s α β,
  CategoryTheory.CategoryStruct.comp f₁ α = CategoryTheory.CategoryStruct.comp g₁ β ∧
    CategoryTheory.CategoryStruct.comp f₂ α = CategoryTheory.CategoryStruct.comp g₂ β
-- CategoryTheory.IsFiltered.tulip
theorem tulip {j₁ j₂ j₃ k₁ k₂ l : C} (f₁ : j₁ ⟶ k₁) (f₂ : j₂ ⟶ k₁) (f₃ : j₂ ⟶ k₂) (f₄ : j₃ ⟶ k₂)
    (g₁ : j₁ ⟶ l) (g₂ : j₃ ⟶ l) :
    ∃ (s : C) (α : k₁ ⟶ s) (β : l ⟶ s) (γ : k₂ ⟶ s),
      f₁ ≫ α = g₁ ≫ β ∧ f₂ ≫ α = f₃ ≫ γ ∧ f₄ ≫ γ = g₂ ≫ β 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.IsFilteredOrEmpty C] {j₁ j₂ j₃ k₁ k₂ l : C} (f₁ : j₁ ⟶ k₁) (f₂ : j₂ ⟶ k₁) (f₃ : j₂ ⟶ k₂) (f₄ : j₃ ⟶ k₂) (g₁ : j₁ ⟶ l) (g₂ : j₃ ⟶ l)
Goal: ∃ s α β γ,
  CategoryTheory.CategoryStruct.comp f₁ α = CategoryTheory.CategoryStruct.comp g₁ β ∧
    CategoryTheory.CategoryStruct.comp f₂ α = CategoryTheory.CategoryStruct.comp f₃ γ ∧
      CategoryTheory.CategoryStruct.comp f₄ γ = CategoryTheory.CategoryStruct.comp g₂ β
-- CategoryTheory.IsCofilteredOrEmpty.cone_maps
class IsCofilteredOrEmpty : Prop where
    cone_objs : ∀ X Y : C, ∃ (W : _) (_ : W ⟶ X) (_ : W ⟶ Y), True
    cone_maps : ∀ ⦃X Y : C⦄ (f g : X ⟶ Y), ∃ (W : _) (h : W ⟶ X), h ≫ f = h ≫ g
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [self : CategoryTheory.IsCofilteredOrEmpty C] ⦃X Y : C⦄ (f g : X ⟶ Y)
Goal: ∃ W h, CategoryTheory.CategoryStruct.comp h f = CategoryTheory.CategoryStruct.comp h g
-- CategoryTheory.IsCofilteredOrEmpty.cone_objs
class IsCofilteredOrEmpty : Prop where
    cone_objs : ∀ X Y : C, ∃ (W : _) (_ : W ⟶ X) (_ : W ⟶ Y), True
    cone_maps : ∀ ⦃X Y : C⦄ (f g : X ⟶ Y), ∃ (W : _) (h : W ⟶ X), h ≫ f = h ≫ g
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [self : CategoryTheory.IsCofilteredOrEmpty C] (X Y : C)
Goal: ∃ W x x, True
-- CategoryTheory.IsCofiltered.nonempty
class IsCofiltered extends IsCofilteredOrEmpty C : Prop where
    [nonempty : Nonempty C]
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [self : CategoryTheory.IsCofiltered C]
Goal: Nonempty C
-- CategoryTheory.IsCofiltered.eq_condition
@[reassoc]
theorem eq_condition {j j' : C} (f f' : j ⟶ j') : eqHom f f' ≫ f = eqHom f f' ≫ f' 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.IsCofilteredOrEmpty C] {j j' : C} (f f' : j ⟶ j')
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.IsCofiltered.eqHom f f') f =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.IsCofiltered.eqHom f f') f'
-- CategoryTheory.IsCofiltered.cospan
theorem cospan {i j j' : C} (f : j ⟶ i) (f' : j' ⟶ i) :
    ∃ (k : C) (g : k ⟶ j) (g' : k ⟶ j'), g ≫ f = g' ≫ f' 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.IsCofilteredOrEmpty C] {i j j' : C} (f : j ⟶ i) (f' : j' ⟶ i)
Goal: ∃ k g g', CategoryTheory.CategoryStruct.comp g f = CategoryTheory.CategoryStruct.comp g' f'
-- CategoryTheory.Functor.ranges_directed
theorem _root_.CategoryTheory.Functor.ranges_directed (F : C ⥤ Type*) (j : C) :
    Directed (· ⊇ ·) fun f : Σ'i, i ⟶ j => Set.range (F.map f.2) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.IsCofilteredOrEmpty C] (F : CategoryTheory.Functor C (Type u_1)) (j : C)
Goal: Directed (fun x x_1 => x ⊇ x_1) fun f => Set.range (F.map f.snd)
-- CategoryTheory.IsCofilteredOrEmpty.of_left_adjoint
theorem of_left_adjoint {L : C ⥤ D} {R : D ⥤ C} (h : L ⊣ R) : IsCofilteredOrEmpty D 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.IsCofilteredOrEmpty C] {D : Type u₁} [CategoryTheory.Category.{v₁, u₁} D] {L : CategoryTheory.Functor C D} {R : CategoryTheory.Functor D C} (h : L ⊣ R)
Goal: CategoryTheory.IsCofilteredOrEmpty D
-- CategoryTheory.IsCofilteredOrEmpty.of_isLeftAdjoint
theorem of_isLeftAdjoint (L : C ⥤ D) [L.IsLeftAdjoint] : IsCofilteredOrEmpty D 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.IsCofilteredOrEmpty C] {D : Type u₁} [CategoryTheory.Category.{v₁, u₁} D] (L : CategoryTheory.Functor C D) [L.IsLeftAdjoint]
Goal: CategoryTheory.IsCofilteredOrEmpty D
-- CategoryTheory.IsCofilteredOrEmpty.of_equivalence
theorem of_equivalence (h : C ≌ D) : IsCofilteredOrEmpty D 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.IsCofilteredOrEmpty C] {D : Type u₁} [CategoryTheory.Category.{v₁, u₁} D] (h : C ≌ D)
Goal: CategoryTheory.IsCofilteredOrEmpty D
-- CategoryTheory.IsCofiltered.inf_objs_exists
theorem inf_objs_exists (O : Finset C) : ∃ S : C, ∀ {X}, X ∈ O → Nonempty (S ⟶ X) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.IsCofiltered C] (O : Finset C)
Goal: ∃ S, ∀ {X : C}, X ∈ O → Nonempty (S ⟶ X)
-- CategoryTheory.IsCofiltered.inf_exists
theorem inf_exists :
    ∃ (S : C) (T : ∀ {X : C}, X ∈ O → (S ⟶ X)),
      ∀ {X Y : C} (mX : X ∈ O) (mY : Y ∈ O) {f : X ⟶ Y},
        (⟨X, Y, mX, mY, f⟩ : Σ' (X Y : C) (_ : X ∈ O) (_ : Y ∈ O), X ⟶ Y) ∈ H →
          T mX ≫ f = T mY 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.IsCofiltered C] (O : Finset C) (H : Finset ((X : C) ×' (Y : C) ×' (_ : X ∈ O) ×' (_ : Y ∈ O) ×' (X ⟶ Y)))
Goal: ∃ S T,
  ∀ {X Y : C} (mX : X ∈ O) (mY : Y ∈ O) {f : X ⟶ Y},
    ⟨X, ⟨Y, ⟨mX, ⟨mY, f⟩⟩⟩⟩ ∈ H → CategoryTheory.CategoryStruct.comp (T mX) f = T mY
-- CategoryTheory.IsCofiltered.infTo_commutes
theorem infTo_commutes {X Y : C} (mX : X ∈ O) (mY : Y ∈ O) {f : X ⟶ Y}
    (mf : (⟨X, Y, mX, mY, f⟩ : Σ' (X Y : C) (_ : X ∈ O) (_ : Y ∈ O), X ⟶ Y) ∈ H) :
    infTo O H mX ≫ f = infTo O H mY 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.IsCofiltered C] (O : Finset C) (H : Finset ((X : C) ×' (Y : C) ×' (_ : X ∈ O) ×' (_ : Y ∈ O) ×' (X ⟶ Y))) {X Y : C} (mX : X ∈ O) (mY : Y ∈ O) {f : X ⟶ Y} (mf : ⟨X, ⟨Y, ⟨mX, ⟨mY, f⟩⟩⟩⟩ ∈ H)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.IsCofiltered.infTo O H mX) f =
  CategoryTheory.IsCofiltered.infTo O H mY
-- CategoryTheory.IsCofiltered.cone_nonempty
theorem cone_nonempty (F : J ⥤ C) : Nonempty (Cone F) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.IsCofiltered C] {J : Type w} [CategoryTheory.SmallCategory J] [CategoryTheory.FinCategory J] (F : CategoryTheory.Functor J C)
Goal: Nonempty (CategoryTheory.Limits.Cone F)
-- CategoryTheory.IsCofiltered.of_left_adjoint
theorem of_left_adjoint {L : C ⥤ D} {R : D ⥤ C} (h : L ⊣ R) : IsCofiltered D 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.IsCofiltered C] {D : Type u₁} [CategoryTheory.Category.{v₁, u₁} D] {L : CategoryTheory.Functor C D} {R : CategoryTheory.Functor D C} (h : L ⊣ R)
Goal: CategoryTheory.IsCofiltered D
-- CategoryTheory.IsCofiltered.of_isLeftAdjoint
theorem of_isLeftAdjoint (L : C ⥤ D) [L.IsLeftAdjoint] : IsCofiltered D 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.IsCofiltered C] {D : Type u₁} [CategoryTheory.Category.{v₁, u₁} D] (L : CategoryTheory.Functor C D) [L.IsLeftAdjoint]
Goal: CategoryTheory.IsCofiltered D
-- CategoryTheory.IsCofiltered.of_equivalence
theorem of_equivalence (h : C ≌ D) : IsCofiltered D 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.IsCofiltered C] {D : Type u₁} [CategoryTheory.Category.{v₁, u₁} D] (h : C ≌ D)
Goal: CategoryTheory.IsCofiltered D
-- CategoryTheory.IsCofiltered.of_cone_nonempty
theorem of_cone_nonempty (h : ∀ {J : Type w} [SmallCategory J] [FinCategory J] (F : J ⥤ C),
    Nonempty (Cone F)) : IsCofiltered C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] (h :
  ∀ {J : Type w} [inst : CategoryTheory.SmallCategory J] [inst_1 : CategoryTheory.FinCategory J]
    (F : CategoryTheory.Functor J C), Nonempty (CategoryTheory.Limits.Cone F))
Goal: CategoryTheory.IsCofiltered C
-- CategoryTheory.IsCofiltered.of_hasFiniteLimits
theorem of_hasFiniteLimits [HasFiniteLimits C] : IsCofiltered C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasFiniteLimits C]
Goal: CategoryTheory.IsCofiltered C
-- CategoryTheory.IsCofiltered.of_isInitial
theorem of_isInitial {X : C} (h : IsInitial X) : IsCofiltered C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] {X : C} (h : CategoryTheory.Limits.IsInitial X)
Goal: CategoryTheory.IsCofiltered C
-- CategoryTheory.IsCofiltered.iff_cone_nonempty
theorem iff_cone_nonempty : IsCofiltered C ↔
    ∀ {J : Type w} [SmallCategory J] [FinCategory J] (F : J ⥤ C), Nonempty (Cone F) 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C]
Goal: CategoryTheory.IsCofiltered C ↔
  ∀ {J : Type w} [inst : CategoryTheory.SmallCategory J] [inst_1 : CategoryTheory.FinCategory J]
    (F : CategoryTheory.Functor J C), Nonempty (CategoryTheory.Limits.Cone F)
-- CategoryTheory.isCofilteredOrEmpty_of_isFilteredOrEmpty_op
lemma isCofilteredOrEmpty_of_isFilteredOrEmpty_op [IsFilteredOrEmpty Cᵒᵖ] : IsCofilteredOrEmpty C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.IsFilteredOrEmpty Cᵒᵖ]
Goal: CategoryTheory.IsCofilteredOrEmpty C
-- CategoryTheory.isFilteredOrEmpty_of_isCofilteredOrEmpty_op
lemma isFilteredOrEmpty_of_isCofilteredOrEmpty_op [IsCofilteredOrEmpty Cᵒᵖ] : IsFilteredOrEmpty C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.IsCofilteredOrEmpty Cᵒᵖ]
Goal: CategoryTheory.IsFilteredOrEmpty C
-- CategoryTheory.isCofiltered_of_isFiltered_op
lemma isCofiltered_of_isFiltered_op [IsFiltered Cᵒᵖ] : IsCofiltered C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.IsFiltered Cᵒᵖ]
Goal: CategoryTheory.IsCofiltered C
-- CategoryTheory.isFiltered_of_isCofiltered_op
lemma isFiltered_of_isCofiltered_op [IsCofiltered Cᵒᵖ] : IsFiltered C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.IsCofiltered Cᵒᵖ]
Goal: CategoryTheory.IsFiltered C
-- CategoryTheory.RelCat.hom_ext
@[ext] theorem hom_ext {X Y : RelCat} (f g : X ⟶ Y) (h : ∀ a b, f a b ↔ g a b) : f = g 
Arguments: {X Y : CategoryTheory.RelCat} (f g : X ⟶ Y) (h : ∀ (a : X) (b : Y), f a b ↔ g a b)
Goal: f = g
-- CategoryTheory.RelCat.Hom.rel_id
protected theorem rel_id (X : RelCat) : 𝟙 X = (· = ·) 
Arguments: (X : CategoryTheory.RelCat)
Goal: CategoryTheory.CategoryStruct.id X = fun x x_1 => x = x_1
-- CategoryTheory.RelCat.Hom.rel_comp
protected theorem rel_comp {X Y Z : RelCat} (f : X ⟶ Y) (g : Y ⟶ Z) : f ≫ g = Rel.comp f g 
Arguments: {X Y Z : CategoryTheory.RelCat} (f : X ⟶ Y) (g : Y ⟶ Z)
Goal: CategoryTheory.CategoryStruct.comp f g = Rel.comp f g
-- CategoryTheory.RelCat.Hom.rel_id_apply₂
theorem rel_id_apply₂ (X : RelCat) (x y : X) : (𝟙 X) x y ↔ x = y 
Arguments: (X : CategoryTheory.RelCat) (x y : X)
Goal: CategoryTheory.CategoryStruct.id X x y ↔ x = y
-- CategoryTheory.RelCat.Hom.rel_comp_apply₂
theorem rel_comp_apply₂ {X Y Z : RelCat} (f : X ⟶ Y) (g : Y ⟶ Z) (x : X) (z : Z) :
    (f ≫ g) x z ↔ ∃ y, f x y ∧ g y z 
Arguments: {X Y Z : CategoryTheory.RelCat} (f : X ⟶ Y) (g : Y ⟶ Z) (x : X) (z : Z)
Goal: CategoryTheory.CategoryStruct.comp f g x z ↔ ∃ y, f x y ∧ g y z
-- CategoryTheory.RelCat.graphFunctor_map
@[simp] theorem graphFunctor_map {X Y : Type u} (f : X ⟶ Y) (x : X) (y : Y) :
    graphFunctor.map f x y ↔ f x = y 
Arguments: {X Y : Type u} (f : X ⟶ Y) (x : X) (y : Y)
Goal: CategoryTheory.RelCat.graphFunctor.map f x y ↔ f x = y
-- CategoryTheory.RelCat.rel_iso_iff
theorem rel_iso_iff {X Y : RelCat} (r : X ⟶ Y) :
    IsIso (C := RelCat) r ↔ ∃ f : (Iso (C := Type) X Y), graphFunctor.map f.hom = r 
Arguments: {X Y : CategoryTheory.RelCat} (r : X ⟶ Y)
Goal: CategoryTheory.IsIso r ↔ ∃ f, CategoryTheory.RelCat.graphFunctor.map f.hom = r
-- CategoryTheory.RelCat.opFunctor_comp_unopFunctor_eq
@[simp] theorem opFunctor_comp_unopFunctor_eq :
    Functor.comp opFunctor unopFunctor = Functor.id _ 
Goal: CategoryTheory.RelCat.opFunctor.comp CategoryTheory.RelCat.unopFunctor = CategoryTheory.Functor.id CategoryTheory.RelCat
-- CategoryTheory.RelCat.unopFunctor_comp_opFunctor_eq
@[simp] theorem unopFunctor_comp_opFunctor_eq :
    Functor.comp unopFunctor opFunctor = Functor.id _ 
Goal: CategoryTheory.RelCat.unopFunctor.comp CategoryTheory.RelCat.opFunctor =
  CategoryTheory.Functor.id CategoryTheory.RelCatᵒᵖ
-- CategoryTheory.RelCat.opEquivalence_unitIso
@[simps]
def opEquivalence : Equivalence RelCat RelCatᵒᵖ 
Goal: CategoryTheory.RelCat.opEquivalence.unitIso = CategoryTheory.Iso.refl (CategoryTheory.Functor.id CategoryTheory.RelCat)
-- CategoryTheory.RelCat.opEquivalence_counitIso
@[simps]
def opEquivalence : Equivalence RelCat RelCatᵒᵖ 
Goal: CategoryTheory.RelCat.opEquivalence.counitIso =
  CategoryTheory.Iso.refl (CategoryTheory.RelCat.unopFunctor.comp CategoryTheory.RelCat.opFunctor)
-- CategoryTheory.RelCat.opEquivalence_functor
@[simps]
def opEquivalence : Equivalence RelCat RelCatᵒᵖ 
Goal: CategoryTheory.RelCat.opEquivalence.functor = CategoryTheory.RelCat.opFunctor