ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Iso.symm_self_conj
@[simp]
theorem symm_self_conj (f : End X) : α.symm.conj (α.conj f) = f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (α : X ≅ Y) (f : CategoryTheory.End X)
Goal: α.symm.conj (α.conj f) = f
-- CategoryTheory.Iso.self_symm_conj
@[simp]
theorem self_symm_conj (f : End Y) : α.conj (α.symm.conj f) = f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (α : X ≅ Y) (f : CategoryTheory.End Y)
Goal: α.conj (α.symm.conj f) = f
-- CategoryTheory.Iso.conj_pow
theorem conj_pow (f : End X) (n : ℕ) : α.conj (f ^ n) = α.conj f ^ n 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (α : X ≅ Y) (f : CategoryTheory.End X) (n : ℕ)
Goal: α.conj (f ^ n) = α.conj f ^ n
-- CategoryTheory.Iso.conjAut_apply
theorem conjAut_apply (f : Aut X) : α.conjAut f = α.symm ≪≫ f ≪≫ α 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (α : X ≅ Y) (f : CategoryTheory.Aut X)
Goal: α.conjAut f = α.symm ≪≫ f ≪≫ α
-- CategoryTheory.Iso.conjAut_hom
@[simp]
theorem conjAut_hom (f : Aut X) : (α.conjAut f).hom = α.conj f.hom 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (α : X ≅ Y) (f : CategoryTheory.Aut X)
Goal: (α.conjAut f).hom = α.conj f.hom
-- CategoryTheory.Iso.trans_conjAut
@[simp]
theorem trans_conjAut {Z : C} (β : Y ≅ Z) (f : Aut X) :
    (α ≪≫ β).conjAut f = β.conjAut (α.conjAut f) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (α : X ≅ Y) {Z : C} (β : Y ≅ Z) (f : CategoryTheory.Aut X)
Goal: (α ≪≫ β).conjAut f = β.conjAut (α.conjAut f)
-- CategoryTheory.Iso.conjAut_mul
theorem conjAut_mul (f g : Aut X) : α.conjAut (f * g) = α.conjAut f * α.conjAut g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (α : X ≅ Y) (f g : CategoryTheory.Aut X)
Goal: α.conjAut (f * g) = α.conjAut f * α.conjAut g
-- CategoryTheory.Iso.conjAut_trans
@[simp]
theorem conjAut_trans (f g : Aut X) : α.conjAut (f ≪≫ g) = α.conjAut f ≪≫ α.conjAut g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (α : X ≅ Y) (f g : CategoryTheory.Aut X)
Goal: α.conjAut (f ≪≫ g) = α.conjAut f ≪≫ α.conjAut g
-- CategoryTheory.Iso.conjAut_pow
theorem conjAut_pow (f : Aut X) (n : ℕ) : α.conjAut (f ^ n) = α.conjAut f ^ n 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (α : X ≅ Y) (f : CategoryTheory.Aut X) (n : ℕ)
Goal: α.conjAut (f ^ n) = α.conjAut f ^ n
-- CategoryTheory.Iso.conjAut_zpow
theorem conjAut_zpow (f : Aut X) (n : ℤ) : α.conjAut (f ^ n) = α.conjAut f ^ n 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (α : X ≅ Y) (f : CategoryTheory.Aut X) (n : ℤ)
Goal: α.conjAut (f ^ n) = α.conjAut f ^ n
-- CategoryTheory.Functor.map_conj
theorem map_conj {X Y : C} (α : X ≅ Y) (f : End X) :
    F.map (α.conj f) = (F.mapIso α).conj (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 Y : C} (α : X ≅ Y) (f : CategoryTheory.End X)
Goal: F.map (α.conj f) = (F.mapIso α).conj (F.map f)
-- CategoryTheory.Functor.map_conjAut
theorem map_conjAut (F : C ⥤ D) {X Y : C} (α : X ≅ Y) (f : Aut X) :
    F.mapIso (α.conjAut f) = (F.mapIso α).conjAut (F.mapIso f) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u₁} [CategoryTheory.Category.{v₁, u₁} D] (F : CategoryTheory.Functor C D) {X Y : C} (α : X ≅ Y) (f : CategoryTheory.Aut X)
Goal: F.mapIso (α.conjAut f) = (F.mapIso α).conjAut (F.mapIso f)
-- CategoryTheory.Presieve.bind_comp
@[simp]
theorem bind_comp {S : Presieve X} {R : ∀ ⦃Y : C⦄ ⦃f : Y ⟶ X⦄, S f → Presieve Y} {g : Z ⟶ Y}
    (h₁ : S f) (h₂ : R h₁ g) : bind S R (g ≫ f) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} (f : Y ⟶ X) {S : CategoryTheory.Presieve X} {R : ⦃Y : C⦄ → ⦃f : Y ⟶ X⦄ → S f → CategoryTheory.Presieve Y} {g : Z ⟶ Y} (h₁ : S f) (h₂ : R h₁ g)
Goal: S.bind R (CategoryTheory.CategoryStruct.comp g f)
-- CategoryTheory.Presieve.singleton.mk
lemma singleton.mk {f : Y ⟶ X} : singleton f f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} {f : Y ⟶ X}
Goal: CategoryTheory.Presieve.singleton f f
-- CategoryTheory.Presieve.singleton_eq_iff_domain
@[simp]
theorem singleton_eq_iff_domain (f g : Y ⟶ X) : singleton f g ↔ f = g 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f g : Y ⟶ X)
Goal: CategoryTheory.Presieve.singleton f g ↔ f = g
-- CategoryTheory.Presieve.singleton_self
theorem singleton_self : singleton f f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : Y ⟶ X)
Goal: CategoryTheory.Presieve.singleton f f
-- CategoryTheory.Presieve.pullback_singleton
theorem pullback_singleton [HasPullbacks C] (g : Z ⟶ X) :
    pullbackArrows f (singleton g) = singleton (pullback.snd g f) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} (f : Y ⟶ X) [CategoryTheory.Limits.HasPullbacks C] (g : Z ⟶ X)
Goal: CategoryTheory.Presieve.pullbackArrows f (CategoryTheory.Presieve.singleton g) =
  CategoryTheory.Presieve.singleton (CategoryTheory.Limits.pullback.snd g f)
-- CategoryTheory.Presieve.ofArrows_pUnit
theorem ofArrows_pUnit : (ofArrows _ fun _ : PUnit => f) = singleton f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : Y ⟶ X)
Goal: (CategoryTheory.Presieve.ofArrows (fun x => Y) fun x => f) = CategoryTheory.Presieve.singleton f
-- CategoryTheory.Presieve.ofArrows_pullback
theorem ofArrows_pullback [HasPullbacks C] {ι : Type*} (Z : ι → C) (g : ∀ i : ι, Z i ⟶ X) :
    (ofArrows (fun i => pullback (g i) f) fun i => pullback.snd _ _) =
      pullbackArrows f (ofArrows Z g) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : Y ⟶ X) [CategoryTheory.Limits.HasPullbacks C] {ι : Type u_1} (Z : ι → C) (g : (i : ι) → Z i ⟶ X)
Goal: (CategoryTheory.Presieve.ofArrows (fun i => CategoryTheory.Limits.pullback (g i) f) fun i =>
    CategoryTheory.Limits.pullback.snd (g i) f) =
  CategoryTheory.Presieve.pullbackArrows f (CategoryTheory.Presieve.ofArrows Z g)
-- CategoryTheory.Presieve.ofArrows_bind
theorem ofArrows_bind {ι : Type*} (Z : ι → C) (g : ∀ i : ι, Z i ⟶ X)
    (j : ∀ ⦃Y⦄ (f : Y ⟶ X), ofArrows Z g f → Type*) (W : ∀ ⦃Y⦄ (f : Y ⟶ X) (H), j f H → C)
    (k : ∀ ⦃Y⦄ (f : Y ⟶ X) (H i), W f H i ⟶ Y) :
    ((ofArrows Z g).bind fun Y f H => ofArrows (W f H) (k f H)) =
      ofArrows (fun i : Σi, j _ (ofArrows.mk i) => W (g i.1) _ i.2) fun ij =>
        k (g ij.1) _ ij.2 ≫ g ij.1 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} {ι : Type u_1} (Z : ι → C) (g : (i : ι) → Z i ⟶ X) (j : ⦃Y : C⦄ → (f : Y ⟶ X) → CategoryTheory.Presieve.ofArrows Z g f → Type u_2) (W : ⦃Y : C⦄ → (f : Y ⟶ X) → (H : CategoryTheory.Presieve.ofArrows Z g f) → j f H → C) (k : ⦃Y : C⦄ → (f : Y ⟶ X) → (H : CategoryTheory.Presieve.ofArrows Z g f) → (i : j f H) → W f H i ⟶ Y)
Goal: ((CategoryTheory.Presieve.ofArrows Z g).bind fun Y f H => CategoryTheory.Presieve.ofArrows (W f H) (k f H)) =
  CategoryTheory.Presieve.ofArrows (fun i => W (g i.fst) ⋯ i.snd) fun ij =>
    CategoryTheory.CategoryStruct.comp (k (g ij.fst) ⋯ ij.snd) (g ij.fst)
-- CategoryTheory.Presieve.ofArrows_surj
theorem ofArrows_surj {ι : Type*} {Y : ι → C} (f : ∀ i, Y i ⟶ X) {Z : C} (g : Z ⟶ X)
    (hg : ofArrows Y f g) : ∃ (i : ι) (h : Y i = Z),
    g = eqToHom h.symm ≫ f i 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} {ι : Type u_1} {Y : ι → C} (f : (i : ι) → Y i ⟶ X) {Z : C} (g : Z ⟶ X) (hg : CategoryTheory.Presieve.ofArrows Y f g)
Goal: ∃ i, ∃ (h : Y i = Z), g = CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯) (f i)
-- CategoryTheory.Presieve.functorPullback_mem
@[simp]
theorem functorPullback_mem (R : Presieve (F.obj X)) {Y} (f : Y ⟶ X) :
    R.functorPullback F f ↔ R (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.Presieve (F.obj X)) {Y : C} (f : Y ⟶ X)
Goal: CategoryTheory.Presieve.functorPullback F R f ↔ R (F.map f)
-- CategoryTheory.Presieve.functorPullback_id
@[simp]
theorem functorPullback_id (R : Presieve X) : R.functorPullback (𝟭 _) = R 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} (R : CategoryTheory.Presieve X)
Goal: CategoryTheory.Presieve.functorPullback (CategoryTheory.Functor.id C) R = R
-- CategoryTheory.Presieve.hasPullbacks.has_pullbacks
class hasPullbacks (R : Presieve X) : Prop where
    has_pullbacks : ∀ {Y Z} {f : Y ⟶ X} (_ : R f) {g : Z ⟶ X} (_ : R g), HasPullback f g
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} {R : CategoryTheory.Presieve X} [self : R.hasPullbacks] {Y Z : C} {f : Y ⟶ X}
Goal: R f → ∀ {g : Z ⟶ X}, R g → CategoryTheory.Limits.HasPullback f g
-- CategoryTheory.Presieve.FunctorPushforwardStructure.cover
structure FunctorPushforwardStructure (S : Presieve X) {Y} (f : Y ⟶ F.obj X) where
    preobj : C
    premap : preobj ⟶ X
    lift : Y ⟶ F.obj preobj
    cover : S premap
    fac : f = lift ≫ F.map premap
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 : CategoryTheory.Presieve X} {Y : D} {f : Y ⟶ F.obj X} (self : CategoryTheory.Presieve.FunctorPushforwardStructure F S f)
Goal: S self.premap
-- CategoryTheory.Presieve.FunctorPushforwardStructure.fac
structure FunctorPushforwardStructure (S : Presieve X) {Y} (f : Y ⟶ F.obj X) where
    preobj : C
    premap : preobj ⟶ X
    lift : Y ⟶ F.obj preobj
    cover : S premap
    fac : f = lift ≫ F.map premap
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 : CategoryTheory.Presieve X} {Y : D} {f : Y ⟶ F.obj X} (self : CategoryTheory.Presieve.FunctorPushforwardStructure F S f)
Goal: f = CategoryTheory.CategoryStruct.comp self.lift (F.map self.premap)
-- CategoryTheory.Presieve.functorPushforward_comp
theorem functorPushforward_comp (R : Presieve 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.Presieve X)
Goal: CategoryTheory.Presieve.functorPushforward (F.comp G) R =
  CategoryTheory.Presieve.functorPushforward G (CategoryTheory.Presieve.functorPushforward F R)
-- CategoryTheory.Presieve.image_mem_functorPushforward
theorem image_mem_functorPushforward (R : Presieve X) {f : Y ⟶ 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 Y : C} (R : CategoryTheory.Presieve X) {f : Y ⟶ X} (h : R f)
Goal: CategoryTheory.Presieve.functorPushforward F R (F.map f)
-- CategoryTheory.Sieve.downward_closed
structure Sieve {C : Type u₁} [Category.{v₁} C] (X : C) where
    arrows : Presieve X
    downward_closed : ∀ {Y Z f} (_ : arrows f) (g : Z ⟶ Y), arrows (g ≫ f)
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} (self : CategoryTheory.Sieve X) {Y Z : C} {f : Y ⟶ X}
Goal: self.arrows f → ∀ (g : Z ⟶ Y), self.arrows (CategoryTheory.CategoryStruct.comp g f)
-- CategoryTheory.Sieve.arrows_ext
theorem arrows_ext : ∀ {R S : Sieve X}, R.arrows = S.arrows → R = S 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} {R S : CategoryTheory.Sieve X}
Goal: R.arrows = S.arrows → R = S
-- CategoryTheory.Sieve.ext
@[ext]
protected theorem ext {R S : Sieve X} (h : ∀ ⦃Y⦄ (f : Y ⟶ X), R f ↔ S f) : R = S 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} {R S : CategoryTheory.Sieve X} (h : ∀ ⦃Y : C⦄ (f : Y ⟶ X), R.arrows f ↔ S.arrows f)
Goal: R = S
-- CategoryTheory.Sieve.ext_iff
protected theorem ext_iff {R S : Sieve X} : R = S ↔ ∀ ⦃Y⦄ (f : Y ⟶ X), R f ↔ S f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} {R S : CategoryTheory.Sieve X}
Goal: R = S ↔ ∀ ⦃Y : C⦄ (f : Y ⟶ X), R.arrows f ↔ S.arrows f
-- CategoryTheory.Sieve.sInf_apply
@[simp]
theorem sInf_apply {Ss : Set (Sieve X)} {Y} (f : Y ⟶ X) :
    sInf Ss f ↔ ∀ (S : Sieve X) (_ : S ∈ Ss), S f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} {Ss : Set (CategoryTheory.Sieve X)} {Y : C} (f : Y ⟶ X)
Goal: (sInf Ss).arrows f ↔ ∀ S ∈ Ss, S.arrows f
-- CategoryTheory.Sieve.sSup_apply
@[simp]
theorem sSup_apply {Ss : Set (Sieve X)} {Y} (f : Y ⟶ X) :
    sSup Ss f ↔ ∃ (S : Sieve X) (_ : S ∈ Ss), S f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} {Ss : Set (CategoryTheory.Sieve X)} {Y : C} (f : Y ⟶ X)
Goal: (sSup Ss).arrows f ↔ ∃ S, ∃ (_ : S ∈ Ss), S.arrows f
-- CategoryTheory.Sieve.inter_apply
@[simp]
theorem inter_apply {R S : Sieve X} {Y} (f : Y ⟶ X) : (R ⊓ S) f ↔ R f ∧ S f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} {R S : CategoryTheory.Sieve X} {Y : C} (f : Y ⟶ X)
Goal: (R ⊓ S).arrows f ↔ R.arrows f ∧ S.arrows f
-- CategoryTheory.Sieve.union_apply
@[simp]
theorem union_apply {R S : Sieve X} {Y} (f : Y ⟶ X) : (R ⊔ S) f ↔ R f ∨ S f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} {R S : CategoryTheory.Sieve X} {Y : C} (f : Y ⟶ X)
Goal: (R ⊔ S).arrows f ↔ R.arrows f ∨ S.arrows f
-- CategoryTheory.Sieve.top_apply
@[simp]
theorem top_apply (f : Y ⟶ X) : (⊤ : Sieve X) f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : Y ⟶ X)
Goal: ⊤.arrows f
-- CategoryTheory.Sieve.generate_apply
@[simps]
def generate (R : Presieve X) : Sieve X 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} (R : CategoryTheory.Presieve X) (Z : C) (f : Z ⟶ X)
Goal: (CategoryTheory.Sieve.generate R).arrows f = ∃ Y h g, R g ∧ CategoryTheory.CategoryStruct.comp h g = f
-- CategoryTheory.Sieve.bind_apply
@[simps]
def bind (S : Presieve X) (R : ∀ ⦃Y⦄ ⦃f : Y ⟶ X⦄, S f → Sieve Y) : Sieve X 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} (S : CategoryTheory.Presieve X) (R : ⦃Y : C⦄ → ⦃f : Y ⟶ X⦄ → S f → CategoryTheory.Sieve Y)
Goal: (CategoryTheory.Sieve.bind S R).arrows = S.bind fun Y f h => (R h).arrows
-- CategoryTheory.Sieve.generate_le_iff
theorem generate_le_iff (R : Presieve X) (S : Sieve X) : generate R ≤ S ↔ R ≤ S 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} (R : CategoryTheory.Presieve X) (S : CategoryTheory.Sieve X)
Goal: CategoryTheory.Sieve.generate R ≤ S ↔ R ≤ S.arrows
-- CategoryTheory.Sieve.le_generate
theorem le_generate (R : Presieve X) : R ≤ generate R 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} (R : CategoryTheory.Presieve X)
Goal: R ≤ (CategoryTheory.Sieve.generate R).arrows
-- CategoryTheory.Sieve.generate_sieve
@[simp]
theorem generate_sieve (S : Sieve X) : generate S = S 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} (S : CategoryTheory.Sieve X)
Goal: CategoryTheory.Sieve.generate S.arrows = S
-- CategoryTheory.Sieve.id_mem_iff_eq_top
theorem id_mem_iff_eq_top : S (𝟙 X) ↔ S = ⊤ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} {S : CategoryTheory.Sieve X}
Goal: S.arrows (CategoryTheory.CategoryStruct.id X) ↔ S = ⊤
-- CategoryTheory.Sieve.generate_of_contains_isSplitEpi
theorem generate_of_contains_isSplitEpi {R : Presieve X} (f : Y ⟶ X) [IsSplitEpi f] (hf : R f) :
    generate R = ⊤ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} {R : CategoryTheory.Presieve X} (f : Y ⟶ X) [CategoryTheory.IsSplitEpi f] (hf : R f)
Goal: CategoryTheory.Sieve.generate R = ⊤
-- CategoryTheory.Sieve.generate_of_singleton_isSplitEpi
@[simp]
theorem generate_of_singleton_isSplitEpi (f : Y ⟶ X) [IsSplitEpi f] :
    generate (Presieve.singleton f) = ⊤ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : Y ⟶ X) [CategoryTheory.IsSplitEpi f]
Goal: CategoryTheory.Sieve.generate (CategoryTheory.Presieve.singleton f) = ⊤
-- CategoryTheory.Sieve.generate_top
@[simp]
theorem generate_top : generate (⊤ : Presieve X) = ⊤ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C}
Goal: CategoryTheory.Sieve.generate ⊤ = ⊤
-- CategoryTheory.Sieve.comp_mem_iff
@[simp]
lemma comp_mem_iff (i : X ⟶ Y) (f : Y ⟶ Z) [IsIso i] (S : Sieve Z) :
    S (i ≫ f) ↔ S f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} (i : X ⟶ Y) (f : Y ⟶ Z) [CategoryTheory.IsIso i] (S : CategoryTheory.Sieve Z)
Goal: S.arrows (CategoryTheory.CategoryStruct.comp i f) ↔ S.arrows f
-- CategoryTheory.Sieve.ofArrows_mk
lemma ofArrows_mk {I : Type*} {X : C} (Y : I → C) (f : ∀ i, Y i ⟶ X) (i : I) :
    ofArrows Y f (f i) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {I : Type u_1} {X : C} (Y : I → C) (f : (i : I) → Y i ⟶ X) (i : I)
Goal: (CategoryTheory.Sieve.ofArrows Y f).arrows (f i)
-- CategoryTheory.Sieve.mem_ofArrows_iff
lemma mem_ofArrows_iff {I : Type*} {X : C} (Y : I → C) (f : ∀ i, Y i ⟶ X)
    {W : C} (g : W ⟶ X) :
    ofArrows Y f g ↔ ∃ (i : I) (a : W ⟶ Y i), g = a ≫ f i 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {I : Type u_1} {X : C} (Y : I → C) (f : (i : I) → Y i ⟶ X) {W : C} (g : W ⟶ X)
Goal: (CategoryTheory.Sieve.ofArrows Y f).arrows g ↔ ∃ i a, g = CategoryTheory.CategoryStruct.comp a (f i)
-- CategoryTheory.Sieve.mem_ofObjects_iff
lemma mem_ofObjects_iff {I : Type*} (Y : I → C) {Z X : C} (g : Z ⟶ X) :
    ofObjects Y X g ↔ ∃ (i : I), Nonempty (Z ⟶ Y i) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {I : Type u_1} (Y : I → C) {Z X : C} (g : Z ⟶ X)
Goal: (CategoryTheory.Sieve.ofObjects Y X).arrows g ↔ ∃ i, Nonempty (Z ⟶ Y i)
-- CategoryTheory.Sieve.ofArrows_le_ofObjects
lemma ofArrows_le_ofObjects
    {I : Type*} (Y : I → C) {X : C} (f : ∀ i, Y i ⟶ X) :
    Sieve.ofArrows Y f ≤ Sieve.ofObjects Y X 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {I : Type u_1} (Y : I → C) {X : C} (f : (i : I) → Y i ⟶ X)
Goal: CategoryTheory.Sieve.ofArrows Y f ≤ CategoryTheory.Sieve.ofObjects Y X
-- CategoryTheory.Sieve.ofArrows_eq_ofObjects
lemma ofArrows_eq_ofObjects {X : C} (hX : IsTerminal X)
    {I : Type*} (Y : I → C) (f : ∀ i, Y i ⟶ X) :
    ofArrows Y f = ofObjects Y X 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} (hX : CategoryTheory.Limits.IsTerminal X) {I : Type u_1} (Y : I → C) (f : (i : I) → Y i ⟶ X)
Goal: CategoryTheory.Sieve.ofArrows Y f = CategoryTheory.Sieve.ofObjects Y X
-- CategoryTheory.Sieve.pullback_apply
@[simps]
def pullback (h : Y ⟶ X) (S : Sieve X) : Sieve Y 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (h : Y ⟶ X) (S : CategoryTheory.Sieve X)
Goal: ∀ (Y_1 : C) (sl : Y_1 ⟶ Y),
  (CategoryTheory.Sieve.pullback h S).arrows sl = S.arrows (CategoryTheory.CategoryStruct.comp sl h)
-- CategoryTheory.Sieve.pullback_id
@[simp]
theorem pullback_id : S.pullback (𝟙 _) = S 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} {S : CategoryTheory.Sieve X}
Goal: CategoryTheory.Sieve.pullback (CategoryTheory.CategoryStruct.id X) S = S
-- CategoryTheory.Sieve.pullback_top
@[simp]
theorem pullback_top {f : Y ⟶ X} : (⊤ : Sieve X).pullback f = ⊤ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} {f : Y ⟶ X}
Goal: CategoryTheory.Sieve.pullback f ⊤ = ⊤
-- CategoryTheory.Sieve.pullback_comp
theorem pullback_comp {f : Y ⟶ X} {g : Z ⟶ Y} (S : Sieve X) :
    S.pullback (g ≫ f) = (S.pullback f).pullback g 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} {f : Y ⟶ X} {g : Z ⟶ Y} (S : CategoryTheory.Sieve X)
Goal: CategoryTheory.Sieve.pullback (CategoryTheory.CategoryStruct.comp g f) S =
  CategoryTheory.Sieve.pullback g (CategoryTheory.Sieve.pullback f S)
-- CategoryTheory.Sieve.pullback_inter
@[simp]
theorem pullback_inter {f : Y ⟶ X} (S R : Sieve X) :
    (S ⊓ R).pullback f = S.pullback f ⊓ R.pullback f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} {f : Y ⟶ X} (S R : CategoryTheory.Sieve X)
Goal: CategoryTheory.Sieve.pullback f (S ⊓ R) = CategoryTheory.Sieve.pullback f S ⊓ CategoryTheory.Sieve.pullback f R
-- CategoryTheory.Sieve.pullback_eq_top_iff_mem
theorem pullback_eq_top_iff_mem (f : Y ⟶ X) : S f ↔ S.pullback f = ⊤ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} {S : CategoryTheory.Sieve X} (f : Y ⟶ X)
Goal: S.arrows f ↔ CategoryTheory.Sieve.pullback f S = ⊤
-- CategoryTheory.Sieve.pullback_eq_top_of_mem
theorem pullback_eq_top_of_mem (S : Sieve X) {f : Y ⟶ X} : S f → S.pullback f = ⊤ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (S : CategoryTheory.Sieve X) {f : Y ⟶ X}
Goal: S.arrows f → CategoryTheory.Sieve.pullback f S = ⊤
-- CategoryTheory.Sieve.pullback_ofObjects_eq_top
lemma pullback_ofObjects_eq_top
    {I : Type*} (Y : I → C) {X : C} {i : I} (g : X ⟶ Y i) :
    ofObjects Y X = ⊤ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {I : Type u_1} (Y : I → C) {X : C} {i : I} (g : X ⟶ Y i)
Goal: CategoryTheory.Sieve.ofObjects Y X = ⊤
-- CategoryTheory.Sieve.pushforward_apply
@[simps]
def pushforward (f : Y ⟶ X) (R : Sieve Y) : Sieve X 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : Y ⟶ X) (R : CategoryTheory.Sieve Y) (Z : C) (gf : Z ⟶ X)
Goal: (CategoryTheory.Sieve.pushforward f R).arrows gf = ∃ g, CategoryTheory.CategoryStruct.comp g f = gf ∧ R.arrows g
-- CategoryTheory.Sieve.pushforward_apply_comp
theorem pushforward_apply_comp {R : Sieve Y} {Z : C} {g : Z ⟶ Y} (hg : R g) (f : Y ⟶ X) :
    R.pushforward f (g ≫ f) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} {R : CategoryTheory.Sieve Y} {Z : C} {g : Z ⟶ Y} (hg : R.arrows g) (f : Y ⟶ X)
Goal: (CategoryTheory.Sieve.pushforward f R).arrows (CategoryTheory.CategoryStruct.comp g f)
-- CategoryTheory.Sieve.pushforward_comp
theorem pushforward_comp {f : Y ⟶ X} {g : Z ⟶ Y} (R : Sieve Z) :
    R.pushforward (g ≫ f) = (R.pushforward g).pushforward f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} {f : Y ⟶ X} {g : Z ⟶ Y} (R : CategoryTheory.Sieve Z)
Goal: CategoryTheory.Sieve.pushforward (CategoryTheory.CategoryStruct.comp g f) R =
  CategoryTheory.Sieve.pushforward f (CategoryTheory.Sieve.pushforward g R)
-- CategoryTheory.Sieve.galoisConnection
theorem galoisConnection (f : Y ⟶ X) : GaloisConnection (Sieve.pushforward f) (Sieve.pullback f) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : Y ⟶ X)
Goal: GaloisConnection (CategoryTheory.Sieve.pushforward f) (CategoryTheory.Sieve.pullback f)
-- CategoryTheory.Sieve.pullback_monotone
theorem pullback_monotone (f : Y ⟶ X) : Monotone (Sieve.pullback f) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : Y ⟶ X)
Goal: Monotone (CategoryTheory.Sieve.pullback f)
-- CategoryTheory.Sieve.pushforward_monotone
theorem pushforward_monotone (f : Y ⟶ X) : Monotone (Sieve.pushforward f) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : Y ⟶ X)
Goal: Monotone (CategoryTheory.Sieve.pushforward f)
-- CategoryTheory.Sieve.le_pushforward_pullback
theorem le_pushforward_pullback (f : Y ⟶ X) (R : Sieve Y) : R ≤ (R.pushforward f).pullback f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : Y ⟶ X) (R : CategoryTheory.Sieve Y)
Goal: R ≤ CategoryTheory.Sieve.pullback f (CategoryTheory.Sieve.pushforward f R)
-- CategoryTheory.Sieve.pullback_pushforward_le
theorem pullback_pushforward_le (f : Y ⟶ X) (R : Sieve X) : (R.pullback f).pushforward f ≤ R 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : Y ⟶ X) (R : CategoryTheory.Sieve X)
Goal: CategoryTheory.Sieve.pushforward f (CategoryTheory.Sieve.pullback f R) ≤ R
-- CategoryTheory.Sieve.pushforward_union
theorem pushforward_union {f : Y ⟶ X} (S R : Sieve Y) :
    (S ⊔ R).pushforward f = S.pushforward f ⊔ R.pushforward f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} {f : Y ⟶ X} (S R : CategoryTheory.Sieve Y)
Goal: CategoryTheory.Sieve.pushforward f (S ⊔ R) = CategoryTheory.Sieve.pushforward f S ⊔ CategoryTheory.Sieve.pushforward f R