ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- RatFunc.denom_div_dvd
@[simp]
theorem denom_div_dvd (p q : K[X]) : denom (algebraMap _ _ p / algebraMap _ _ q) ∣ q 
Arguments: {K : Type u} [Field K] (p q : K[X])
Goal: ((algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) q).denom ∣ q
-- RatFunc.num_div_denom
@[simp]
theorem num_div_denom (x : RatFunc K) : algebraMap _ _ (num x) / algebraMap _ _ (denom x) = x 
Arguments: {K : Type u} [Field K] (x : RatFunc K)
Goal: (algebraMap K[X] (RatFunc K)) x.num / (algebraMap K[X] (RatFunc K)) x.denom = x
-- RatFunc.isCoprime_num_denom
theorem isCoprime_num_denom (x : RatFunc K) : IsCoprime x.num x.denom 
Arguments: {K : Type u} [Field K] (x : RatFunc K)
Goal: IsCoprime x.num x.denom
-- RatFunc.num_eq_zero_iff
@[simp]
theorem num_eq_zero_iff {x : RatFunc K} : num x = 0 ↔ x = 0 
Arguments: {K : Type u} [Field K] {x : RatFunc K}
Goal: x.num = 0 ↔ x = 0
-- RatFunc.num_ne_zero
theorem num_ne_zero {x : RatFunc K} (hx : x ≠ 0) : num x ≠ 0 
Arguments: {K : Type u} [Field K] {x : RatFunc K} (hx : x ≠ 0)
Goal: x.num ≠ 0
-- RatFunc.num_mul_eq_mul_denom_iff
theorem num_mul_eq_mul_denom_iff {x : RatFunc K} {p q : K[X]} (hq : q ≠ 0) :
    x.num * q = p * x.denom ↔ x = algebraMap _ _ p / algebraMap _ _ q 
Arguments: {K : Type u} [Field K] {x : RatFunc K} {p q : K[X]} (hq : q ≠ 0)
Goal: x.num * q = p * x.denom ↔ x = (algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) q
-- RatFunc.num_denom_add
theorem num_denom_add (x y : RatFunc K) :
    (x + y).num * (x.denom * y.denom) = (x.num * y.denom + x.denom * y.num) * (x + y).denom 
Arguments: {K : Type u} [Field K] (x y : RatFunc K)
Goal: (x + y).num * (x.denom * y.denom) = (x.num * y.denom + x.denom * y.num) * (x + y).denom
-- RatFunc.num_denom_neg
theorem num_denom_neg (x : RatFunc K) : (-x).num * x.denom = -x.num * (-x).denom 
Arguments: {K : Type u} [Field K] (x : RatFunc K)
Goal: (-x).num * x.denom = -x.num * (-x).denom
-- RatFunc.num_denom_mul
theorem num_denom_mul (x y : RatFunc K) :
    (x * y).num * (x.denom * y.denom) = x.num * y.num * (x * y).denom 
Arguments: {K : Type u} [Field K] (x y : RatFunc K)
Goal: (x * y).num * (x.denom * y.denom) = x.num * y.num * (x * y).denom
-- RatFunc.num_dvd
theorem num_dvd {x : RatFunc K} {p : K[X]} (hp : p ≠ 0) :
    num x ∣ p ↔ ∃ q : K[X], q ≠ 0 ∧ x = algebraMap _ _ p / algebraMap _ _ q 
Arguments: {K : Type u} [Field K] {x : RatFunc K} {p : K[X]} (hp : p ≠ 0)
Goal: x.num ∣ p ↔ ∃ q, q ≠ 0 ∧ x = (algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) q
-- RatFunc.denom_dvd
theorem denom_dvd {x : RatFunc K} {q : K[X]} (hq : q ≠ 0) :
    denom x ∣ q ↔ ∃ p : K[X], x = algebraMap _ _ p / algebraMap _ _ q 
Arguments: {K : Type u} [Field K] {x : RatFunc K} {q : K[X]} (hq : q ≠ 0)
Goal: x.denom ∣ q ↔ ∃ p, x = (algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) q
-- RatFunc.num_mul_dvd
theorem num_mul_dvd (x y : RatFunc K) : num (x * y) ∣ num x * num y 
Arguments: {K : Type u} [Field K] (x y : RatFunc K)
Goal: (x * y).num ∣ x.num * y.num
-- RatFunc.denom_mul_dvd
theorem denom_mul_dvd (x y : RatFunc K) : denom (x * y) ∣ denom x * denom y 
Arguments: {K : Type u} [Field K] (x y : RatFunc K)
Goal: (x * y).denom ∣ x.denom * y.denom
-- RatFunc.denom_add_dvd
theorem denom_add_dvd (x y : RatFunc K) : denom (x + y) ∣ denom x * denom y 
Arguments: {K : Type u} [Field K] (x y : RatFunc K)
Goal: (x + y).denom ∣ x.denom * y.denom
-- RatFunc.map_denom_ne_zero
theorem map_denom_ne_zero {L F : Type*} [Zero L] [FunLike F K[X] L] [ZeroHomClass F K[X] L]
    (φ : F) (hφ : Function.Injective φ) (f : RatFunc K) : φ f.denom ≠ 0 
Arguments: {K : Type u} [Field K] {L : Type u_1} {F : Type u_2} [Zero L] [FunLike F K[X] L] [ZeroHomClass F K[X] L] (φ : F) (hφ : Function.Injective ⇑φ) (f : RatFunc K)
Goal: φ f.denom ≠ 0
-- RatFunc.map_apply
theorem map_apply {R F : Type*} [CommRing R] [IsDomain R]
    [FunLike F K[X] R[X]] [MonoidHomClass F K[X] R[X]] (φ : F)
    (hφ : K[X]⁰ ≤ R[X]⁰.comap φ) (f : RatFunc K) :
    map φ hφ f = algebraMap _ _ (φ f.num) / algebraMap _ _ (φ f.denom) 
Arguments: {K : Type u} [Field K] {R : Type u_1} {F : Type u_2} [CommRing R] [IsDomain R] [FunLike F K[X] R[X]] [MonoidHomClass F K[X] R[X]] (φ : F) (hφ : K[X]⁰ ≤ Submonoid.comap φ R[X]⁰) (f : RatFunc K)
Goal: (RatFunc.map φ hφ) f = (algebraMap R[X] (RatFunc R)) (φ f.num) / (algebraMap R[X] (RatFunc R)) (φ f.denom)
-- RatFunc.liftMonoidWithZeroHom_apply
theorem liftMonoidWithZeroHom_apply {L : Type*} [CommGroupWithZero L] (φ : K[X] →*₀ L)
    (hφ : K[X]⁰ ≤ L⁰.comap φ) (f : RatFunc K) :
    liftMonoidWithZeroHom φ hφ f = φ f.num / φ f.denom 
Arguments: {K : Type u} [Field K] {L : Type u_1} [CommGroupWithZero L] (φ : K[X] →*₀ L) (hφ : K[X]⁰ ≤ Submonoid.comap φ L⁰) (f : RatFunc K)
Goal: (RatFunc.liftMonoidWithZeroHom φ hφ) f = φ f.num / φ f.denom
-- RatFunc.liftRingHom_apply
theorem liftRingHom_apply {L : Type*} [Field L] (φ : K[X] →+* L) (hφ : K[X]⁰ ≤ L⁰.comap φ)
    (f : RatFunc K) : liftRingHom φ hφ f = φ f.num / φ f.denom 
Arguments: {K : Type u} [Field K] {L : Type u_1} [Field L] (φ : K[X] →+* L) (hφ : K[X]⁰ ≤ Submonoid.comap φ L⁰) (f : RatFunc K)
Goal: (RatFunc.liftRingHom φ hφ) f = φ f.num / φ f.denom
-- RatFunc.liftAlgHom_apply
theorem liftAlgHom_apply {L S : Type*} [Field L] [CommSemiring S] [Algebra S K[X]] [Algebra S L]
    (φ : K[X] →ₐ[S] L) (hφ : K[X]⁰ ≤ L⁰.comap φ) (f : RatFunc K) :
    liftAlgHom φ hφ f = φ f.num / φ f.denom 
Arguments: {K : Type u} [Field K] {L : Type u_1} {S : Type u_2} [Field L] [CommSemiring S] [Algebra S K[X]] [Algebra S L] (φ : K[X] →ₐ[S] L) (hφ : K[X]⁰ ≤ Submonoid.comap φ L⁰) (f : RatFunc K)
Goal: (RatFunc.liftAlgHom φ hφ) f = φ f.num / φ f.denom
-- RatFunc.num_mul_denom_add_denom_mul_num_ne_zero
theorem num_mul_denom_add_denom_mul_num_ne_zero {x y : RatFunc K} (hxy : x + y ≠ 0) :
    x.num * y.denom + x.denom * y.num ≠ 0 
Arguments: {K : Type u} [Field K] {x y : RatFunc K} (hxy : x + y ≠ 0)
Goal: x.num * y.denom + x.denom * y.num ≠ 0
-- CategoryTheory.Presieve.Extensive.arrows_nonempty_isColimit
class Presieve.Extensive {X : C} (R : Presieve X) : Prop where
    arrows_nonempty_isColimit : ∃ (α : Type) (_ : Finite α) (Z : α → C) (π : (a : α) → (Z a ⟶ X)),
    R = Presieve.ofArrows Z π ∧ Nonempty (IsColimit (Cofan.mk X π))
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] {X : C} {R : CategoryTheory.Presieve X} [self : R.Extensive]
Goal: ∃ α,
  ∃ (_ : Finite α),
    ∃ Z π,
      R = CategoryTheory.Presieve.ofArrows Z π ∧
        Nonempty (CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.Cofan.mk X π))
-- CategoryTheory.isSheafFor_extensive_of_preservesFiniteProducts
theorem isSheafFor_extensive_of_preservesFiniteProducts {X : C} (S : Presieve X) [S.Extensive]
    (F : Cᵒᵖ ⥤ Type w) [PreservesFiniteProducts F] : S.IsSheafFor F  
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.FinitaryPreExtensive C] {X : C} (S : CategoryTheory.Presieve X) [S.Extensive] (F : CategoryTheory.Functor Cᵒᵖ (Type w)) [CategoryTheory.Limits.PreservesFiniteProducts F]
Goal: CategoryTheory.Presieve.IsSheafFor F S
-- CategoryTheory.extensiveTopology.isSheaf_yoneda_obj
theorem extensiveTopology.isSheaf_yoneda_obj (W : C) : Presieve.IsSheaf (extensiveTopology C)
    (yoneda.obj W) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.FinitaryPreExtensive C] (W : C)
Goal: CategoryTheory.Presieve.IsSheaf (CategoryTheory.extensiveTopology C) (CategoryTheory.yoneda.obj W)
-- CategoryTheory.extensiveTopology.subcanonical
theorem extensiveTopology.subcanonical : Sheaf.Subcanonical (extensiveTopology C) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.FinitaryPreExtensive C]
Goal: CategoryTheory.Sheaf.Subcanonical (CategoryTheory.extensiveTopology C)
-- CategoryTheory.Presieve.isSheaf_iff_preservesFiniteProducts
theorem Presieve.isSheaf_iff_preservesFiniteProducts (F : Cᵒᵖ ⥤ Type w) :
    Presieve.IsSheaf (extensiveTopology C) F ↔
    Nonempty (PreservesFiniteProducts F) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.FinitaryPreExtensive C] [CategoryTheory.FinitaryExtensive C] (F : CategoryTheory.Functor Cᵒᵖ (Type w))
Goal: CategoryTheory.Presieve.IsSheaf (CategoryTheory.extensiveTopology C) F ↔
  Nonempty (CategoryTheory.Limits.PreservesFiniteProducts F)
-- CategoryTheory.Presheaf.isSheaf_iff_preservesFiniteProducts
theorem Presheaf.isSheaf_iff_preservesFiniteProducts (F : Cᵒᵖ ⥤ D) :
    IsSheaf (extensiveTopology C) F ↔ Nonempty (PreservesFiniteProducts F) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] {D : Type u_2} [CategoryTheory.Category.{u_4, u_2} D] [CategoryTheory.FinitaryPreExtensive C] [CategoryTheory.FinitaryExtensive C] (F : CategoryTheory.Functor Cᵒᵖ D)
Goal: CategoryTheory.Presheaf.IsSheaf (CategoryTheory.extensiveTopology C) F ↔
  Nonempty (CategoryTheory.Limits.PreservesFiniteProducts F)
-- CategoryTheory.MonoOver.mk'_obj
@[simps]
def mk' {X A : C} (f : A ⟶ X) [hf : Mono f] : MonoOver X 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X A : C} (f : A ⟶ X) [hf : CategoryTheory.Mono f]
Goal: (CategoryTheory.MonoOver.mk' f).obj = CategoryTheory.Over.mk f
-- CategoryTheory.MonoOver.forget_obj_left
@[simp]
theorem forget_obj_left {f} : ((forget X).obj f).left = (f : C) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} {f : CategoryTheory.MonoOver X}
Goal: ((CategoryTheory.MonoOver.forget X).obj f).left = f.obj.left
-- CategoryTheory.MonoOver.mk'_coe'
@[simp]
theorem mk'_coe' {X A : C} (f : A ⟶ X) [Mono f] : (mk' f : C) = A 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X A : C} (f : A ⟶ X) [CategoryTheory.Mono f]
Goal: (CategoryTheory.MonoOver.mk' f).obj.left = A
-- CategoryTheory.MonoOver.mk'_arrow
@[simp]
theorem mk'_arrow {X A : C} (f : A ⟶ X) [Mono f] : (mk' f).arrow = f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X A : C} (f : A ⟶ X) [CategoryTheory.Mono f]
Goal: (CategoryTheory.MonoOver.mk' f).arrow = f
-- CategoryTheory.MonoOver.forget_obj_hom
@[simp]
theorem forget_obj_hom {f} : ((forget X).obj f).hom = f.arrow 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} {f : CategoryTheory.MonoOver X}
Goal: ((CategoryTheory.MonoOver.forget X).obj f).hom = f.arrow
-- CategoryTheory.MonoOver.w
@[reassoc]
theorem w {f g : MonoOver X} (k : f ⟶ g) : k.left ≫ g.arrow = f.arrow 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} {f g : CategoryTheory.MonoOver X} (k : f ⟶ g)
Goal: CategoryTheory.CategoryStruct.comp k.left g.arrow = f.arrow
-- CategoryTheory.MonoOver.isoMk_hom
@[simps]
def isoMk {f g : MonoOver X} (h : f.obj.left ≅ g.obj.left)
    (w : h.hom ≫ g.arrow = f.arrow := by aesop_cat) : f ≅ g 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} {f g : CategoryTheory.MonoOver X} (h : f.obj.left ≅ g.obj.left) (w : CategoryTheory.CategoryStruct.comp h.hom g.arrow = f.arrow := by aesop_cat)
Goal: (CategoryTheory.MonoOver.isoMk h w).hom = CategoryTheory.MonoOver.homMk h.hom w
-- CategoryTheory.MonoOver.isoMk_inv
@[simps]
def isoMk {f g : MonoOver X} (h : f.obj.left ≅ g.obj.left)
    (w : h.hom ≫ g.arrow = f.arrow := by aesop_cat) : f ≅ g 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} {f g : CategoryTheory.MonoOver X} (h : f.obj.left ≅ g.obj.left) (w : CategoryTheory.CategoryStruct.comp h.hom g.arrow = f.arrow := by aesop_cat)
Goal: (CategoryTheory.MonoOver.isoMk h w).inv = CategoryTheory.MonoOver.homMk h.inv ⋯
-- CategoryTheory.MonoOver.lift_map
@[simps]
def lift {Y : D} (F : Over Y ⥤ Over X)
    (h : ∀ f : MonoOver Y, Mono (F.obj ((MonoOver.forget Y).obj f)).hom) :
    MonoOver Y ⥤ MonoOver X 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {Y : D} (F : CategoryTheory.Functor (CategoryTheory.Over Y) (CategoryTheory.Over X)) (h : ∀ (f : CategoryTheory.MonoOver Y), CategoryTheory.Mono (F.obj ((CategoryTheory.MonoOver.forget Y).obj f)).hom)
Goal: ∀ {X_1 Y_1 : CategoryTheory.MonoOver Y} (k : X_1 ⟶ Y_1),
  (CategoryTheory.MonoOver.lift F h).map k = ((CategoryTheory.MonoOver.forget Y).comp F).map k
-- CategoryTheory.MonoOver.lift_obj_obj
@[simps]
def lift {Y : D} (F : Over Y ⥤ Over X)
    (h : ∀ f : MonoOver Y, Mono (F.obj ((MonoOver.forget Y).obj f)).hom) :
    MonoOver Y ⥤ MonoOver X 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {Y : D} (F : CategoryTheory.Functor (CategoryTheory.Over Y) (CategoryTheory.Over X)) (h : ∀ (f : CategoryTheory.MonoOver Y), CategoryTheory.Mono (F.obj ((CategoryTheory.MonoOver.forget Y).obj f)).hom) (f : CategoryTheory.MonoOver Y)
Goal: ((CategoryTheory.MonoOver.lift F h).obj f).obj = F.obj ((CategoryTheory.MonoOver.forget Y).obj f)
-- CategoryTheory.MonoOver.lift_comm
@[simp]
theorem lift_comm (F : Over Y ⥤ Over X)
    (h : ∀ f : MonoOver Y, Mono (F.obj ((MonoOver.forget Y).obj f)).hom) :
    lift F h ⋙ MonoOver.forget X = MonoOver.forget Y ⋙ F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (F : CategoryTheory.Functor (CategoryTheory.Over Y) (CategoryTheory.Over X)) (h : ∀ (f : CategoryTheory.MonoOver Y), CategoryTheory.Mono (F.obj ((CategoryTheory.MonoOver.forget Y).obj f)).hom)
Goal: (CategoryTheory.MonoOver.lift F h).comp (CategoryTheory.MonoOver.forget X) = (CategoryTheory.MonoOver.forget Y).comp F
-- CategoryTheory.MonoOver.lift_obj_arrow
@[simp]
theorem lift_obj_arrow {Y : D} (F : Over Y ⥤ Over X)
    (h : ∀ f : MonoOver Y, Mono (F.obj ((MonoOver.forget Y).obj f)).hom) (f : MonoOver Y) :
    ((lift F h).obj f).arrow = (F.obj ((forget Y).obj f)).hom 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {Y : D} (F : CategoryTheory.Functor (CategoryTheory.Over Y) (CategoryTheory.Over X)) (h : ∀ (f : CategoryTheory.MonoOver Y), CategoryTheory.Mono (F.obj ((CategoryTheory.MonoOver.forget Y).obj f)).hom) (f : CategoryTheory.MonoOver Y)
Goal: ((CategoryTheory.MonoOver.lift F h).obj f).arrow = (F.obj ((CategoryTheory.MonoOver.forget Y).obj f)).hom
-- CategoryTheory.MonoOver.pullback_obj_left
@[simp]
theorem pullback_obj_left (f : X ⟶ Y) (g : MonoOver Y) :
    ((pullback f).obj g : C) = Limits.pullback g.arrow f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} [CategoryTheory.Limits.HasPullbacks C] (f : X ⟶ Y) (g : CategoryTheory.MonoOver Y)
Goal: ((CategoryTheory.MonoOver.pullback f).obj g).obj.left = CategoryTheory.Limits.pullback g.arrow f
-- CategoryTheory.MonoOver.pullback_obj_arrow
@[simp]
theorem pullback_obj_arrow (f : X ⟶ Y) (g : MonoOver Y) :
    ((pullback f).obj g).arrow = pullback.snd _ _ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} [CategoryTheory.Limits.HasPullbacks C] (f : X ⟶ Y) (g : CategoryTheory.MonoOver Y)
Goal: ((CategoryTheory.MonoOver.pullback f).obj g).arrow =
  CategoryTheory.Limits.pullback.snd ((CategoryTheory.MonoOver.forget Y).obj g).hom f
-- CategoryTheory.MonoOver.map_obj_left
@[simp]
theorem map_obj_left (f : X ⟶ Y) [Mono f] (g : MonoOver X) : ((map f).obj g : C) = g.obj.left 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Mono f] (g : CategoryTheory.MonoOver X)
Goal: ((CategoryTheory.MonoOver.map f).obj g).obj.left = g.obj.left
-- CategoryTheory.MonoOver.map_obj_arrow
@[simp]
theorem map_obj_arrow (f : X ⟶ Y) [Mono f] (g : MonoOver X) : ((map f).obj g).arrow = g.arrow ≫ f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Mono f] (g : CategoryTheory.MonoOver X)
Goal: ((CategoryTheory.MonoOver.map f).obj g).arrow = CategoryTheory.CategoryStruct.comp g.arrow f
-- CategoryTheory.MonoOver.mapIso_unitIso
@[simps]
def mapIso {A B : C} (e : A ≅ B) : MonoOver A ≌ MonoOver B 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A B : C} (e : A ≅ B)
Goal: (CategoryTheory.MonoOver.mapIso e).unitIso =
  ((CategoryTheory.MonoOver.mapComp e.hom e.inv).symm ≪≫
      CategoryTheory.eqToIso ⋯ ≪≫ CategoryTheory.MonoOver.mapId A).symm
-- CategoryTheory.MonoOver.mapIso_counitIso
@[simps]
def mapIso {A B : C} (e : A ≅ B) : MonoOver A ≌ MonoOver B 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A B : C} (e : A ≅ B)
Goal: (CategoryTheory.MonoOver.mapIso e).counitIso =
  (CategoryTheory.MonoOver.mapComp e.inv e.hom).symm ≪≫ CategoryTheory.eqToIso ⋯ ≪≫ CategoryTheory.MonoOver.mapId B
-- CategoryTheory.MonoOver.mapIso_inverse
@[simps]
def mapIso {A B : C} (e : A ≅ B) : MonoOver A ≌ MonoOver B 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A B : C} (e : A ≅ B)
Goal: (CategoryTheory.MonoOver.mapIso e).inverse = CategoryTheory.MonoOver.map e.inv
-- CategoryTheory.MonoOver.mapIso_functor
@[simps]
def mapIso {A B : C} (e : A ≅ B) : MonoOver A ≌ MonoOver B 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A B : C} (e : A ≅ B)
Goal: (CategoryTheory.MonoOver.mapIso e).functor = CategoryTheory.MonoOver.map e.hom
-- CategoryTheory.MonoOver.congr_functor
@[simps]
def congr (e : C ≌ D) : MonoOver X ≌ MonoOver (e.functor.obj X) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (X : C) {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (e : C ≌ D)
Goal: (CategoryTheory.MonoOver.congr X e).functor = CategoryTheory.MonoOver.lift (CategoryTheory.Over.post e.functor) ⋯
-- CategoryTheory.MonoOver.congr_counitIso
@[simps]
def congr (e : C ≌ D) : MonoOver X ≌ MonoOver (e.functor.obj X) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (X : C) {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (e : C ≌ D)
Goal: (CategoryTheory.MonoOver.congr X e).counitIso =
  CategoryTheory.NatIso.ofComponents (fun Y => CategoryTheory.MonoOver.isoMk (e.counitIso.app Y.obj.left) ⋯) ⋯
-- CategoryTheory.MonoOver.congr_unitIso
@[simps]
def congr (e : C ≌ D) : MonoOver X ≌ MonoOver (e.functor.obj X) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (X : C) {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (e : C ≌ D)
Goal: (CategoryTheory.MonoOver.congr X e).unitIso =
  CategoryTheory.NatIso.ofComponents (fun Y => CategoryTheory.MonoOver.isoMk (e.unitIso.app Y.obj.left) ⋯) ⋯
-- CategoryTheory.MonoOver.congr_inverse
@[simps]
def congr (e : C ≌ D) : MonoOver X ≌ MonoOver (e.functor.obj X) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (X : C) {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (e : C ≌ D)
Goal: (CategoryTheory.MonoOver.congr X e).inverse =
  (CategoryTheory.MonoOver.lift (CategoryTheory.Over.post e.inverse) ⋯).comp
    (CategoryTheory.MonoOver.mapIso (e.unitIso.symm.app X)).functor
-- CategoryTheory.MonoOver.imageMonoOver_arrow
@[simp]
theorem imageMonoOver_arrow (f : X ⟶ Y) [HasImage f] : (imageMonoOver f).arrow = image.ι f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Limits.HasImage f]
Goal: (CategoryTheory.MonoOver.imageMonoOver f).arrow = CategoryTheory.Limits.image.ι f
-- CategoryTheory.MonoOver.image_obj
@[simps]
def image : Over X ⥤ MonoOver X 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} [CategoryTheory.Limits.HasImages C] (f : CategoryTheory.Over X)
Goal: CategoryTheory.MonoOver.image.obj f = CategoryTheory.MonoOver.imageMonoOver f.hom
-- CategoryTheory.MonoOver.image_map
@[simps]
def image : Over X ⥤ MonoOver X 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} [CategoryTheory.Limits.HasImages C] {f g : CategoryTheory.Over X} (k : f ⟶ g)
Goal: CategoryTheory.MonoOver.image.map k =
  (CategoryTheory.MonoOver.forget X).preimage
    (CategoryTheory.Over.homMk
      (CategoryTheory.Limits.image.lift
        (CategoryTheory.Limits.MonoFactorisation.mk (CategoryTheory.Limits.image g.hom)
          (CategoryTheory.Limits.image.ι g.hom)
          (CategoryTheory.CategoryStruct.comp k.left (CategoryTheory.Limits.factorThruImage g.hom)) ⋯))
      ⋯)
-- CategoryTheory.extensive_regular_generate_coherent
theorem extensive_regular_generate_coherent [Preregular C] [FinitaryPreExtensive C] :
    ((extensiveCoverage C) ⊔ (regularCoverage C)).toGrothendieck =
    (coherentTopology C) 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Preregular C] [CategoryTheory.FinitaryPreExtensive C]
Goal: CategoryTheory.Coverage.toGrothendieck C (CategoryTheory.extensiveCoverage C ⊔ CategoryTheory.regularCoverage C) =
  CategoryTheory.coherentTopology C
-- CategoryTheory.regularTopology.mem_sieves_of_hasEffectiveEpi
theorem mem_sieves_of_hasEffectiveEpi (S : Sieve X) :
    (∃ (Y : C) (π : Y ⟶ X), EffectiveEpi π ∧ S.arrows π) → (S ∈ (regularTopology C).sieves X) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Preregular C] {X : C} (S : CategoryTheory.Sieve X)
Goal: (∃ Y π, CategoryTheory.EffectiveEpi π ∧ S.arrows π) → S ∈ (CategoryTheory.regularTopology C).sieves X
-- CategoryTheory.regularTopology.mem_sieves_iff_hasEffectiveEpi
theorem mem_sieves_iff_hasEffectiveEpi (S : Sieve X) :
    (S ∈ (regularTopology C).sieves  X) ↔
    ∃ (Y : C) (π : Y ⟶ X), EffectiveEpi π ∧ (S.arrows π) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Preregular C] {X : C} (S : CategoryTheory.Sieve X)
Goal: S ∈ (CategoryTheory.regularTopology C).sieves X ↔ ∃ Y π, CategoryTheory.EffectiveEpi π ∧ S.arrows π
-- CategoryTheory.GrothendieckTopology.OneHypercoverFamily.IsGenerating.le
class IsGenerating : Prop where
  le {X : C} (S : Sieve X) (hS : S ∈ J X) :
    ∃ (E : J.OneHypercover X) (_ : H E), E.sieve₀ ≤ S
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {H : J.OneHypercoverFamily} [self : H.IsGenerating] {X : C} (S : CategoryTheory.Sieve X) (hS : S ∈ J.sieves X)
Goal: ∃ E, ∃ (_ : H E), E.sieve₀ ≤ S
-- CategoryTheory.GrothendieckTopology.OneHypercoverFamily.exists_oneHypercover
lemma exists_oneHypercover {X : C} (S : Sieve X) (hS : S ∈ J X) :
    ∃ (E : J.OneHypercover X) (_ : H E), E.sieve₀ ≤ S 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} (H : J.OneHypercoverFamily) [H.IsGenerating] {X : C} (S : CategoryTheory.Sieve X) (hS : S ∈ J.sieves X)
Goal: ∃ E, ∃ (_ : H E), E.sieve₀ ≤ S
-- CategoryTheory.GrothendieckTopology.OneHypercoverFamily.IsSheafIff.hom_ext
lemma hom_ext {X : C} (S : Sieve X) (hS : S ∈ J X) {T : A}
    {x y : T ⟶ P.obj (Opposite.op X)}
    (h : ∀ ⦃Y : C⦄ (f : Y ⟶ X) (_ : S f), x ≫ P.map f.op = y ≫ P.map f.op) :
    x = y 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {A : Type u'} [CategoryTheory.Category.{v', u'} A] (H : J.OneHypercoverFamily) [H.IsGenerating] (P : CategoryTheory.Functor Cᵒᵖ A) (hP : ∀ ⦃X : C⦄ (E : J.OneHypercover X), H E → Nonempty (CategoryTheory.Limits.IsLimit (E.multifork P))) {X : C} (S : CategoryTheory.Sieve X) (hS : S ∈ J.sieves X) {T : A} {x y : T ⟶ P.obj (Opposite.op X)} (h :
  ∀ ⦃Y : C⦄ (f : Y ⟶ X),
    S.arrows f → CategoryTheory.CategoryStruct.comp x (P.map f.op) = CategoryTheory.CategoryStruct.comp y (P.map f.op))
Goal: x = y
-- CategoryTheory.GrothendieckTopology.OneHypercoverFamily.IsSheafIff.fac'
@[reassoc]
lemma fac' (i : E.I₀) :
    lift hP hE le F ≫ P.map (E.f i).op =
      F.ι ⟨_, E.f i, le _ (Sieve.ofArrows_mk _ _ _)⟩ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {A : Type u'} [CategoryTheory.Category.{v', u'} A] {H : J.OneHypercoverFamily} {P : CategoryTheory.Functor Cᵒᵖ A} (hP : ∀ ⦃X : C⦄ (E : J.OneHypercover X), H E → Nonempty (CategoryTheory.Limits.IsLimit (E.multifork P))) {X : C} {S : CategoryTheory.Sieve X} {E : J.OneHypercover X} (hE : H E) (le : E.sieve₀ ≤ S) (F : CategoryTheory.Limits.Multifork (CategoryTheory.GrothendieckTopology.Cover.index ⟨S, ⋯⟩ P)) (i : E.I₀)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.GrothendieckTopology.OneHypercoverFamily.IsSheafIff.lift hP hE le F)
    (P.map (E.f i).op) =
  F.ι { Y := E.X i, f := E.f i, hf := ⋯ }