ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Sieve.pushforward_le_bind_of_mem
theorem pushforward_le_bind_of_mem (S : Presieve X) (R : ∀ ⦃Y : C⦄ ⦃f : Y ⟶ X⦄, S f → Sieve Y)
    (f : Y ⟶ X) (h : S f) : (R h).pushforward f ≤ bind S R 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (S : CategoryTheory.Presieve X) (R : ⦃Y : C⦄ → ⦃f : Y ⟶ X⦄ → S f → CategoryTheory.Sieve Y) (f : Y ⟶ X) (h : S f)
Goal: CategoryTheory.Sieve.pushforward f (R h) ≤ CategoryTheory.Sieve.bind S R
-- CategoryTheory.Sieve.le_pullback_bind
theorem le_pullback_bind (S : Presieve X) (R : ∀ ⦃Y : C⦄ ⦃f : Y ⟶ X⦄, S f → Sieve Y) (f : Y ⟶ X)
    (h : S f) : R h ≤ (bind S R).pullback f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (S : CategoryTheory.Presieve X) (R : ⦃Y : C⦄ → ⦃f : Y ⟶ X⦄ → S f → CategoryTheory.Sieve Y) (f : Y ⟶ X) (h : S f)
Goal: R h ≤ CategoryTheory.Sieve.pullback f (CategoryTheory.Sieve.bind S R)
-- CategoryTheory.Sieve.pullbackArrows_comm
theorem pullbackArrows_comm [HasPullbacks C] {X Y : C} (f : Y ⟶ X) (R : Presieve X) :
    Sieve.generate (R.pullbackArrows f) = (Sieve.generate R).pullback f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasPullbacks C] {X Y : C} (f : Y ⟶ X) (R : CategoryTheory.Presieve X)
Goal: CategoryTheory.Sieve.generate (CategoryTheory.Presieve.pullbackArrows f R) =
  CategoryTheory.Sieve.pullback f (CategoryTheory.Sieve.generate R)
-- CategoryTheory.Sieve.functorPullback_apply
@[simps]
def functorPullback (R : Sieve (F.obj X)) : Sieve X 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) {X : C} (R : CategoryTheory.Sieve (F.obj X))
Goal: (CategoryTheory.Sieve.functorPullback F R).arrows = CategoryTheory.Presieve.functorPullback F R.arrows
-- CategoryTheory.Sieve.functorPullback_arrows
@[simp]
theorem functorPullback_arrows (R : Sieve (F.obj X)) :
    (R.functorPullback F).arrows = R.arrows.functorPullback F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) {X : C} (R : CategoryTheory.Sieve (F.obj X))
Goal: (CategoryTheory.Sieve.functorPullback F R).arrows = CategoryTheory.Presieve.functorPullback F R.arrows
-- CategoryTheory.Sieve.functorPullback_id
@[simp]
theorem functorPullback_id (R : Sieve X) : R.functorPullback (𝟭 _) = R 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} (R : CategoryTheory.Sieve X)
Goal: CategoryTheory.Sieve.functorPullback (CategoryTheory.Functor.id C) R = R
-- CategoryTheory.Sieve.functorPullback_comp
theorem functorPullback_comp (R : Sieve ((F ⋙ G).obj X)) :
    R.functorPullback (F ⋙ G) = (R.functorPullback G).functorPullback F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) {X : C} {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (G : CategoryTheory.Functor D E) (R : CategoryTheory.Sieve ((F.comp G).obj X))
Goal: CategoryTheory.Sieve.functorPullback (F.comp G) R =
  CategoryTheory.Sieve.functorPullback F (CategoryTheory.Sieve.functorPullback G R)
-- CategoryTheory.Sieve.functorPushforward_extend_eq
theorem functorPushforward_extend_eq {R : Presieve X} :
    (generate R).arrows.functorPushforward F = R.functorPushforward F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) {X : C} {R : CategoryTheory.Presieve X}
Goal: CategoryTheory.Presieve.functorPushforward F (CategoryTheory.Sieve.generate R).arrows =
  CategoryTheory.Presieve.functorPushforward F R
-- CategoryTheory.Sieve.functorPushforward_apply
@[simps]
def functorPushforward (R : Sieve X) : Sieve (F.obj X) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) {X : C} (R : CategoryTheory.Sieve X)
Goal: (CategoryTheory.Sieve.functorPushforward F R).arrows = CategoryTheory.Presieve.functorPushforward F R.arrows
-- CategoryTheory.Sieve.functorPushforward_id
@[simp]
theorem functorPushforward_id (R : Sieve X) : R.functorPushforward (𝟭 _) = R 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} (R : CategoryTheory.Sieve X)
Goal: CategoryTheory.Sieve.functorPushforward (CategoryTheory.Functor.id C) R = R
-- CategoryTheory.Sieve.functorPushforward_comp
theorem functorPushforward_comp (R : Sieve X) :
    R.functorPushforward (F ⋙ G) = (R.functorPushforward F).functorPushforward G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) {X : C} {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (G : CategoryTheory.Functor D E) (R : CategoryTheory.Sieve X)
Goal: CategoryTheory.Sieve.functorPushforward (F.comp G) R =
  CategoryTheory.Sieve.functorPushforward G (CategoryTheory.Sieve.functorPushforward F R)
-- CategoryTheory.Sieve.functor_galoisConnection
theorem functor_galoisConnection (X : C) :
    GaloisConnection (Sieve.functorPushforward F : Sieve X → Sieve (F.obj X))
      (Sieve.functorPullback F) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) (X : C)
Goal: GaloisConnection (CategoryTheory.Sieve.functorPushforward F) (CategoryTheory.Sieve.functorPullback F)
-- CategoryTheory.Sieve.functorPullback_monotone
theorem functorPullback_monotone (X : C) :
    Monotone (Sieve.functorPullback F : Sieve (F.obj X) → Sieve X) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) (X : C)
Goal: Monotone (CategoryTheory.Sieve.functorPullback F)
-- CategoryTheory.Sieve.functorPushforward_monotone
theorem functorPushforward_monotone (X : C) :
    Monotone (Sieve.functorPushforward F : Sieve X → Sieve (F.obj X)) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) (X : C)
Goal: Monotone (CategoryTheory.Sieve.functorPushforward F)
-- CategoryTheory.Sieve.le_functorPushforward_pullback
theorem le_functorPushforward_pullback (R : Sieve X) :
    R ≤ (R.functorPushforward F).functorPullback F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) {X : C} (R : CategoryTheory.Sieve X)
Goal: R ≤ CategoryTheory.Sieve.functorPullback F (CategoryTheory.Sieve.functorPushforward F R)
-- CategoryTheory.Sieve.functorPullback_pushforward_le
theorem functorPullback_pushforward_le (R : Sieve (F.obj X)) :
    (R.functorPullback F).functorPushforward F ≤ R 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) {X : C} (R : CategoryTheory.Sieve (F.obj X))
Goal: CategoryTheory.Sieve.functorPushforward F (CategoryTheory.Sieve.functorPullback F R) ≤ R
-- CategoryTheory.Sieve.functorPushforward_union
theorem functorPushforward_union (S R : Sieve X) :
    (S ⊔ R).functorPushforward F = S.functorPushforward F ⊔ R.functorPushforward F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) {X : C} (S R : CategoryTheory.Sieve X)
Goal: CategoryTheory.Sieve.functorPushforward F (S ⊔ R) =
  CategoryTheory.Sieve.functorPushforward F S ⊔ CategoryTheory.Sieve.functorPushforward F R
-- CategoryTheory.Sieve.functorPullback_union
theorem functorPullback_union (S R : Sieve (F.obj X)) :
    (S ⊔ R).functorPullback F = S.functorPullback F ⊔ R.functorPullback F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) {X : C} (S R : CategoryTheory.Sieve (F.obj X))
Goal: CategoryTheory.Sieve.functorPullback F (S ⊔ R) =
  CategoryTheory.Sieve.functorPullback F S ⊔ CategoryTheory.Sieve.functorPullback F R
-- CategoryTheory.Sieve.functorPullback_inter
theorem functorPullback_inter (S R : Sieve (F.obj X)) :
    (S ⊓ R).functorPullback F = S.functorPullback F ⊓ R.functorPullback F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) {X : C} (S R : CategoryTheory.Sieve (F.obj X))
Goal: CategoryTheory.Sieve.functorPullback F (S ⊓ R) =
  CategoryTheory.Sieve.functorPullback F S ⊓ CategoryTheory.Sieve.functorPullback F R
-- CategoryTheory.Sieve.functorPushforward_bot
@[simp]
theorem functorPushforward_bot (F : C ⥤ D) (X : C) : (⊥ : Sieve X).functorPushforward F = ⊥ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) (X : C)
Goal: CategoryTheory.Sieve.functorPushforward F ⊥ = ⊥
-- CategoryTheory.Sieve.functorPushforward_top
@[simp]
theorem functorPushforward_top (F : C ⥤ D) (X : C) : (⊤ : Sieve X).functorPushforward F = ⊤ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) (X : C)
Goal: CategoryTheory.Sieve.functorPushforward F ⊤ = ⊤
-- CategoryTheory.Sieve.functorPullback_bot
@[simp]
theorem functorPullback_bot (F : C ⥤ D) (X : C) : (⊥ : Sieve (F.obj X)).functorPullback F = ⊥ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) (X : C)
Goal: CategoryTheory.Sieve.functorPullback F ⊥ = ⊥
-- CategoryTheory.Sieve.functorPullback_top
@[simp]
theorem functorPullback_top (F : C ⥤ D) (X : C) : (⊤ : Sieve (F.obj X)).functorPullback F = ⊤ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) (X : C)
Goal: CategoryTheory.Sieve.functorPullback F ⊤ = ⊤
-- CategoryTheory.Sieve.image_mem_functorPushforward
theorem image_mem_functorPushforward (R : Sieve X) {V} {f : V ⟶ X} (h : R f) :
    R.functorPushforward F (F.map f) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) {X : C} (R : CategoryTheory.Sieve X) {V : C} {f : V ⟶ X} (h : R.arrows f)
Goal: (CategoryTheory.Sieve.functorPushforward F R).arrows (F.map f)
-- CategoryTheory.Sieve.functorPushforward_functor
lemma functorPushforward_functor (S : Sieve X) (e : C ≌ D) :
    S.functorPushforward e.functor = (S.pullback (e.unitInv.app X)).functorPullback e.inverse 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X : C} (S : CategoryTheory.Sieve X) (e : C ≌ D)
Goal: CategoryTheory.Sieve.functorPushforward e.functor S =
  CategoryTheory.Sieve.functorPullback e.inverse (CategoryTheory.Sieve.pullback (e.unitInv.app X) S)
-- CategoryTheory.Sieve.mem_functorPushforward_functor
@[simp]
lemma mem_functorPushforward_functor {Y : D} {S : Sieve X} {e : C ≌ D} {f : Y ⟶ e.functor.obj X} :
    S.functorPushforward e.functor f ↔ S (e.inverse.map f ≫ e.unitInv.app X) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X : C} {Y : D} {S : CategoryTheory.Sieve X} {e : C ≌ D} {f : Y ⟶ e.functor.obj X}
Goal: (CategoryTheory.Sieve.functorPushforward e.functor S).arrows f ↔
  S.arrows (CategoryTheory.CategoryStruct.comp (e.inverse.map f) (e.unitInv.app X))
-- CategoryTheory.Sieve.functorPushforward_inverse
lemma functorPushforward_inverse {X : D} (S : Sieve X) (e : C ≌ D) :
    S.functorPushforward e.inverse = (S.pullback (e.counit.app X)).functorPullback e.functor 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X : D} (S : CategoryTheory.Sieve X) (e : C ≌ D)
Goal: CategoryTheory.Sieve.functorPushforward e.inverse S =
  CategoryTheory.Sieve.functorPullback e.functor (CategoryTheory.Sieve.pullback (e.counit.app X) S)
-- CategoryTheory.Sieve.mem_functorPushforward_inverse
@[simp]
lemma mem_functorPushforward_inverse {X : D} {S : Sieve X} {e : C ≌ D} {f : Y ⟶ e.inverse.obj X} :
    S.functorPushforward e.inverse f ↔ S (e.functor.map f ≫ e.counit.app X) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {Y : C} {X : D} {S : CategoryTheory.Sieve X} {e : C ≌ D} {f : Y ⟶ e.inverse.obj X}
Goal: (CategoryTheory.Sieve.functorPushforward e.inverse S).arrows f ↔
  S.arrows (CategoryTheory.CategoryStruct.comp (e.functor.map f) (e.counit.app X))
-- CategoryTheory.Sieve.functor_map_coe
@[simps]
def functor (S : Sieve X) : Cᵒᵖ ⥤ Type v₁ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} (S : CategoryTheory.Sieve X)
Goal: ∀ {X_1 Y : Cᵒᵖ} (f : X_1 ⟶ Y) (g : { g // S.arrows g }),
  ↑(S.functor.map f g) = CategoryTheory.CategoryStruct.comp f.unop ↑g
-- CategoryTheory.Sieve.functor_obj
@[simps]
def functor (S : Sieve X) : Cᵒᵖ ⥤ Type v₁ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} (S : CategoryTheory.Sieve X) (Y : Cᵒᵖ)
Goal: S.functor.obj Y = { g // S.arrows g }
-- CategoryTheory.Sieve.natTransOfLe_app_coe
@[simps]
def natTransOfLe {S T : Sieve X} (h : S ≤ T) : S.functor ⟶ T.functor 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} {S T : CategoryTheory.Sieve X} (h : S ≤ T) (Y : Cᵒᵖ) (f : S.functor.obj Y)
Goal: ↑((CategoryTheory.Sieve.natTransOfLe h).app Y f) = ↑f
-- CategoryTheory.Sieve.functorInclusion_app
@[simps]
def functorInclusion (S : Sieve X) : S.functor ⟶ yoneda.obj X 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} (S : CategoryTheory.Sieve X) (Y : Cᵒᵖ) (f : S.functor.obj Y)
Goal: S.functorInclusion.app Y f = ↑f
-- CategoryTheory.Sieve.natTransOfLe_comm
theorem natTransOfLe_comm {S T : Sieve X} (h : S ≤ T) :
    natTransOfLe h ≫ functorInclusion _ = functorInclusion _ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} {S T : CategoryTheory.Sieve X} (h : S ≤ T)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Sieve.natTransOfLe h) T.functorInclusion = S.functorInclusion
-- CategoryTheory.Sieve.sieveOfSubfunctor_apply
@[simps]
def sieveOfSubfunctor {R} (f : R ⟶ yoneda.obj X) : Sieve X 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} {R : CategoryTheory.Functor Cᵒᵖ (Type v₁)} (f : R ⟶ CategoryTheory.yoneda.obj X) (Y : C) (g : Y ⟶ X)
Goal: (CategoryTheory.Sieve.sieveOfSubfunctor f).arrows g = ∃ t, f.app (Opposite.op Y) t = g
-- CategoryTheory.Sieve.sieveOfSubfunctor_functorInclusion
theorem sieveOfSubfunctor_functorInclusion : sieveOfSubfunctor S.functorInclusion = S 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} {S : CategoryTheory.Sieve X}
Goal: CategoryTheory.Sieve.sieveOfSubfunctor S.functorInclusion = S
-- CategoryTheory.Groupoid.vertexGroup_mul
@[simps mul one inv]
instance vertexGroup (c : C) : Group (c ⟶ c) 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] (c : C) (x y : c ⟶ c)
Goal: x * y = CategoryTheory.CategoryStruct.comp x y
-- CategoryTheory.Groupoid.vertexGroup_inv
@[simps mul one inv]
instance vertexGroup (c : C) : Group (c ⟶ c) 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] (c : C)
Goal: ∀ (a : c ⟶ c), a⁻¹ = CategoryTheory.Groupoid.inv a
-- CategoryTheory.Groupoid.vertexGroup_one
@[simps mul one inv]
instance vertexGroup (c : C) : Group (c ⟶ c) 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] (c : C)
Goal: 1 = CategoryTheory.CategoryStruct.id c
-- CategoryTheory.Groupoid.vertexGroup.inv_eq_inv
theorem vertexGroup.inv_eq_inv (c : C) (γ : c ⟶ c) : γ⁻¹ = CategoryTheory.inv γ 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] (c : C) (γ : c ⟶ c)
Goal: γ⁻¹ = CategoryTheory.inv γ
-- CategoryTheory.Groupoid.vertexGroupIsomOfMap_symm_apply
@[simps]
def vertexGroupIsomOfMap {c d : C} (f : c ⟶ d) : (c ⟶ c) ≃* (d ⟶ d) 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] {c d : C} (f : c ⟶ d) (δ : d ⟶ d)
Goal: (CategoryTheory.Groupoid.vertexGroupIsomOfMap f).symm δ =
  CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp δ (CategoryTheory.Groupoid.inv f))
-- CategoryTheory.Groupoid.vertexGroupIsomOfMap_apply
@[simps]
def vertexGroupIsomOfMap {c d : C} (f : c ⟶ d) : (c ⟶ c) ≃* (d ⟶ d) 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] {c d : C} (f : c ⟶ d) (γ : c ⟶ c)
Goal: (CategoryTheory.Groupoid.vertexGroupIsomOfMap f) γ =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.Groupoid.inv f) (CategoryTheory.CategoryStruct.comp γ f)
-- CategoryTheory.Groupoid.CategoryTheory.Functor.mapVertexGroup_apply
@[simps]
def CategoryTheory.Functor.mapVertexGroup {D : Type v} [Groupoid D] (φ : C ⥤ D) (c : C) :
    (c ⟶ c) →* (φ.obj c ⟶ φ.obj c) 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] {D : Type v} [CategoryTheory.Groupoid D] (φ : CategoryTheory.Functor C D) (c : C)
Goal: ∀ (a : c ⟶ c), (CategoryTheory.Groupoid.CategoryTheory.Functor.mapVertexGroup φ c) a = φ.map a
-- CategoryTheory.Sieve.overEquiv_top
@[simp]
lemma overEquiv_top {X : C} (Y : Over X) :
    overEquiv Y ⊤ = ⊤ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} (Y : CategoryTheory.Over X)
Goal: (CategoryTheory.Sieve.overEquiv Y) ⊤ = ⊤
-- CategoryTheory.Sieve.overEquiv_symm_top
@[simp]
lemma overEquiv_symm_top {X : C} (Y : Over X) :
    (overEquiv Y).symm ⊤ = ⊤ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} (Y : CategoryTheory.Over X)
Goal: (CategoryTheory.Sieve.overEquiv Y).symm ⊤ = ⊤
-- CategoryTheory.Sieve.overEquiv_pullback
lemma overEquiv_pullback {X : C} {Y₁ Y₂ : Over X} (f : Y₁ ⟶ Y₂) (S : Sieve Y₂) :
    overEquiv _ (S.pullback f) = (overEquiv _ S).pullback f.left 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {Y₁ Y₂ : CategoryTheory.Over X} (f : Y₁ ⟶ Y₂) (S : CategoryTheory.Sieve Y₂)
Goal: (CategoryTheory.Sieve.overEquiv Y₁) (CategoryTheory.Sieve.pullback f S) =
  CategoryTheory.Sieve.pullback f.left ((CategoryTheory.Sieve.overEquiv Y₂) S)
-- CategoryTheory.Sieve.overEquiv_symm_iff
@[simp]
lemma overEquiv_symm_iff {X : C} {Y : Over X} (S : Sieve Y.left) {Z : Over X} (f : Z ⟶ Y) :
    (overEquiv Y).symm S f ↔ S f.left 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {Y : CategoryTheory.Over X} (S : CategoryTheory.Sieve Y.left) {Z : CategoryTheory.Over X} (f : Z ⟶ Y)
Goal: ((CategoryTheory.Sieve.overEquiv Y).symm S).arrows f ↔ S.arrows f.left
-- CategoryTheory.Sieve.overEquiv_iff
lemma overEquiv_iff {X : C} {Y : Over X} (S : Sieve Y) {Z : C} (f : Z ⟶ Y.left) :
    overEquiv Y S f ↔ S (Over.homMk f : Over.mk (f ≫ Y.hom) ⟶ Y) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {Y : CategoryTheory.Over X} (S : CategoryTheory.Sieve Y) {Z : C} (f : Z ⟶ Y.left)
Goal: ((CategoryTheory.Sieve.overEquiv Y) S).arrows f ↔ S.arrows (CategoryTheory.Over.homMk f ⋯)
-- CategoryTheory.Sieve.functorPushforward_over_map
@[simp]
lemma functorPushforward_over_map {X Y : C} (f : X ⟶ Y) (Z : Over X) (S : Sieve Z.left) :
    Sieve.functorPushforward (Over.map f) ((Sieve.overEquiv Z).symm S) =
      (Sieve.overEquiv ((Over.map f).obj Z)).symm S 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) (Z : CategoryTheory.Over X) (S : CategoryTheory.Sieve Z.left)
Goal: CategoryTheory.Sieve.functorPushforward (CategoryTheory.Over.map f) ((CategoryTheory.Sieve.overEquiv Z).symm S) =
  (CategoryTheory.Sieve.overEquiv ((CategoryTheory.Over.map f).obj Z)).symm S
-- CategoryTheory.GrothendieckTopology.mem_over_iff
lemma mem_over_iff {X : C} {Y : Over X} (S : Sieve Y) :
    S ∈ (J.over X) Y ↔ Sieve.overEquiv _ S ∈ J Y.left 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) {X : C} {Y : CategoryTheory.Over X} (S : CategoryTheory.Sieve Y)
Goal: S ∈ (J.over X).sieves Y ↔ (CategoryTheory.Sieve.overEquiv Y) S ∈ J.sieves Y.left
-- CategoryTheory.GrothendieckTopology.overEquiv_symm_mem_over
lemma overEquiv_symm_mem_over {X : C} (Y : Over X) (S : Sieve Y.left) (hS : S ∈ J Y.left) :
    (Sieve.overEquiv Y).symm S ∈ (J.over X) Y 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) {X : C} (Y : CategoryTheory.Over X) (S : CategoryTheory.Sieve Y.left) (hS : S ∈ J.sieves Y.left)
Goal: (CategoryTheory.Sieve.overEquiv Y).symm S ∈ (J.over X).sieves Y
-- CategoryTheory.GrothendieckTopology.over_forget_coverPreserving
lemma over_forget_coverPreserving (X : C) :
    CoverPreserving (J.over X) J (Over.forget X) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) (X : C)
Goal: CategoryTheory.CoverPreserving (J.over X) J (CategoryTheory.Over.forget X)
-- CategoryTheory.GrothendieckTopology.over_forget_compatiblePreserving
lemma over_forget_compatiblePreserving (X : C) :
    CompatiblePreserving J (Over.forget X) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) (X : C)
Goal: CategoryTheory.CompatiblePreserving J (CategoryTheory.Over.forget X)
-- CategoryTheory.GrothendieckTopology.over_map_coverPreserving
lemma over_map_coverPreserving {X Y : C} (f : X ⟶ Y) :
    CoverPreserving (J.over X) (J.over Y) (Over.map f) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) {X Y : C} (f : X ⟶ Y)
Goal: CategoryTheory.CoverPreserving (J.over X) (J.over Y) (CategoryTheory.Over.map f)
-- CategoryTheory.GrothendieckTopology.over_map_compatiblePreserving
lemma over_map_compatiblePreserving {X Y : C} (f : X ⟶ Y) :
    CompatiblePreserving (J.over Y) (Over.map f) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) {X Y : C} (f : X ⟶ Y)
Goal: CategoryTheory.CompatiblePreserving (J.over Y) (CategoryTheory.Over.map f)
-- CategoryTheory.Equalizer.FirstObj.ext
@[ext]
lemma FirstObj.ext (z₁ z₂ : FirstObj P R) (h : ∀ (Y : C) (f : Y ⟶ X)
    (hf : R f), (Pi.π _ ⟨Y, f, hf⟩ : FirstObj P R ⟶ _) z₁ =
      (Pi.π _ ⟨Y, f, hf⟩ : FirstObj P R ⟶ _) z₂) : z₁ = z₂ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {P : CategoryTheory.Functor Cᵒᵖ (Type (max v u))} {X : C} {R : CategoryTheory.Presieve X} (z₁ z₂ : CategoryTheory.Equalizer.FirstObj P R) (h :
  ∀ (Y : C) (f : Y ⟶ X) (hf : R f),
    CategoryTheory.Limits.Pi.π (fun f => P.obj (Opposite.op f.fst)) ⟨Y, ⟨f, hf⟩⟩ z₁ =
      CategoryTheory.Limits.Pi.π (fun f => P.obj (Opposite.op f.fst)) ⟨Y, ⟨f, hf⟩⟩ z₂)
Goal: z₁ = z₂
-- CategoryTheory.Equalizer.firstObjEqFamily_hom
@[simps]
def firstObjEqFamily : FirstObj P R ≅ R.FamilyOfElements P 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (P : CategoryTheory.Functor Cᵒᵖ (Type (max v u))) {X : C} (R : CategoryTheory.Presieve X) (t : CategoryTheory.Equalizer.FirstObj P R) (Y : C) (f : Y ⟶ X) (hf : R f)
Goal: (CategoryTheory.Equalizer.firstObjEqFamily P R).hom t f hf =
  CategoryTheory.Limits.Pi.π (fun f => P.obj (Opposite.op f.fst)) ⟨Y, ⟨f, hf⟩⟩ t
-- CategoryTheory.Equalizer.firstObjEqFamily_inv
@[simps]
def firstObjEqFamily : FirstObj P R ≅ R.FamilyOfElements P 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (P : CategoryTheory.Functor Cᵒᵖ (Type (max v u))) {X : C} (R : CategoryTheory.Presieve X)
Goal: ∀ (a : CategoryTheory.Presieve.FamilyOfElements P R),
  (CategoryTheory.Equalizer.firstObjEqFamily P R).inv a = CategoryTheory.Limits.Pi.lift (fun f x => x ↑f.snd ⋯) a
-- CategoryTheory.Equalizer.Sieve.SecondObj.ext
@[ext]
lemma SecondObj.ext (z₁ z₂ : SecondObj P S) (h : ∀ (Y Z : C) (g : Z ⟶ Y) (f : Y ⟶ X)
    (hf : S.arrows f), (Pi.π _ ⟨Y, Z, g, f, hf⟩ : SecondObj P S ⟶ _) z₁ =
      (Pi.π _ ⟨Y, Z, g, f, hf⟩ : SecondObj P S ⟶ _) z₂) : z₁ = z₂ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {P : CategoryTheory.Functor Cᵒᵖ (Type (max v u))} {X : C} {S : CategoryTheory.Sieve X} (z₁ z₂ : CategoryTheory.Equalizer.Sieve.SecondObj P S) (h :
  ∀ (Y Z : C) (g : Z ⟶ Y) (f : Y ⟶ X) (hf : S.arrows f),
    CategoryTheory.Limits.Pi.π (fun f => P.obj (Opposite.op f.snd.fst)) ⟨Y, ⟨Z, ⟨g, ⟨f, hf⟩⟩⟩⟩ z₁ =
      CategoryTheory.Limits.Pi.π (fun f => P.obj (Opposite.op f.snd.fst)) ⟨Y, ⟨Z, ⟨g, ⟨f, hf⟩⟩⟩⟩ z₂)
Goal: z₁ = z₂