File: Mathlib/CategoryTheory/Sites/Over.lean

full_name: CategoryTheory.Sieve.overEquiv
code: /-- The equivalence `Sieve Y ≃ Sieve Y.left` for all `Y : Over X`. -/
def overEquiv {X : C} (Y : Over X) :
    Sieve Y ≃ Sieve Y.left 
goal: CategoryTheory.Sieve Y ≃ CategoryTheory.Sieve Y.left

full_name: CategoryTheory.Sieve.overEquiv_top
code: @[simp]
lemma overEquiv_top {X : C} (Y : Over X) :
    overEquiv Y ⊤ = ⊤ 
goal: (CategoryTheory.Sieve.overEquiv Y) ⊤ = ⊤

full_name: CategoryTheory.Sieve.overEquiv_symm_top
code: @[simp]
lemma overEquiv_symm_top {X : C} (Y : Over X) :
    (overEquiv Y).symm ⊤ = ⊤ 
goal: (CategoryTheory.Sieve.overEquiv Y).symm ⊤ = ⊤

full_name: CategoryTheory.Sieve.overEquiv_pullback
code: lemma overEquiv_pullback {X : C} {Y₁ Y₂ : Over X} (f : Y₁ ⟶ Y₂) (S : Sieve Y₂) :
    overEquiv _ (S.pullback f) = (overEquiv _ S).pullback f.left 
goal: (CategoryTheory.Sieve.overEquiv Y₁) (CategoryTheory.Sieve.pullback f S) =
  CategoryTheory.Sieve.pullback f.left ((CategoryTheory.Sieve.overEquiv Y₂) S)

full_name: CategoryTheory.Sieve.overEquiv_symm_iff
code: @[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 
goal: ((CategoryTheory.Sieve.overEquiv Y).symm S).arrows f ↔ S.arrows f.left

full_name: CategoryTheory.Sieve.overEquiv_iff
code: 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) 
goal: ((CategoryTheory.Sieve.overEquiv Y) S).arrows f ↔ S.arrows (CategoryTheory.Over.homMk f ⋯)

full_name: CategoryTheory.Sieve.functorPushforward_over_map
code: @[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 
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

full_name: CategoryTheory.GrothendieckTopology.over
code: /-- The Grothendieck topology on the category `Over X` for any `X : C` that is
induced by a Grothendieck topology on `C`. -/
def over (X : C) : GrothendieckTopology (Over X) 
goal: CategoryTheory.GrothendieckTopology (CategoryTheory.Over X)

full_name: CategoryTheory.GrothendieckTopology.mem_over_iff
code: lemma mem_over_iff {X : C} {Y : Over X} (S : Sieve Y) :
    S ∈ (J.over X) Y ↔ Sieve.overEquiv _ S ∈ J Y.left 
goal: S ∈ (J.over X).sieves Y ↔ (CategoryTheory.Sieve.overEquiv Y) S ∈ J.sieves Y.left

full_name: CategoryTheory.GrothendieckTopology.overEquiv_symm_mem_over
code: 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 
goal: (CategoryTheory.Sieve.overEquiv Y).symm S ∈ (J.over X).sieves Y

full_name: CategoryTheory.GrothendieckTopology.over_forget_coverPreserving
code: lemma over_forget_coverPreserving (X : C) :
    CoverPreserving (J.over X) J (Over.forget X) 
goal: CategoryTheory.CoverPreserving (J.over X) J (CategoryTheory.Over.forget X)

full_name: CategoryTheory.GrothendieckTopology.over_forget_compatiblePreserving
code: lemma over_forget_compatiblePreserving (X : C) :
    CompatiblePreserving J (Over.forget X) 
goal: CategoryTheory.CompatiblePreserving J (CategoryTheory.Over.forget X)

full_name: CategoryTheory.GrothendieckTopology.instIsCocontinuousOverForgetOver
code: instance (X : C) : (Over.forget X).IsCocontinuous (J.over X) J 
goal: (CategoryTheory.Over.forget X).IsCocontinuous (J.over X) J

full_name: CategoryTheory.GrothendieckTopology.instIsContinuousOverForgetOver
code: instance (X : C) : (Over.forget X).IsContinuous (J.over X) J 
goal: (CategoryTheory.Over.forget X).IsContinuous (J.over X) J

full_name: CategoryTheory.GrothendieckTopology.overPullback
code: /-- The pullback functor `Sheaf J A ⥤ Sheaf (J.over X) A` -/
abbrev overPullback (A : Type u') [Category.{v'} A] (X : C) :
    Sheaf J A ⥤ Sheaf (J.over X) A 
goal: CategoryTheory.Functor (CategoryTheory.Sheaf J A) (CategoryTheory.Sheaf (J.over X) A)

full_name: CategoryTheory.GrothendieckTopology.over_map_coverPreserving
code: lemma over_map_coverPreserving {X Y : C} (f : X ⟶ Y) :
    CoverPreserving (J.over X) (J.over Y) (Over.map f) 
goal: CategoryTheory.CoverPreserving (J.over X) (J.over Y) (CategoryTheory.Over.map f)

full_name: CategoryTheory.GrothendieckTopology.over_map_compatiblePreserving
code: lemma over_map_compatiblePreserving {X Y : C} (f : X ⟶ Y) :
    CompatiblePreserving (J.over Y) (Over.map f) 
goal: CategoryTheory.CompatiblePreserving (J.over Y) (CategoryTheory.Over.map f)

full_name: CategoryTheory.GrothendieckTopology.instIsContinuousOverMapOver
code: instance {X Y : C} (f : X ⟶ Y) : (Over.map f).IsContinuous (J.over X) (J.over Y) 
goal: (CategoryTheory.Over.map f).IsContinuous (J.over X) (J.over Y)

full_name: CategoryTheory.GrothendieckTopology.overMapPullback
code: /-- The pullback functor `Sheaf (J.over Y) A ⥤ Sheaf (J.over X) A` induced
by a morphism `f : X ⟶ Y`. -/
abbrev overMapPullback (A : Type u') [Category.{v'} A] {X Y : C} (f : X ⟶ Y) :
    Sheaf (J.over Y) A ⥤ Sheaf (J.over X) A 
goal: CategoryTheory.Functor (CategoryTheory.Sheaf (J.over Y) A) (CategoryTheory.Sheaf (J.over X) A)

full_name: CategoryTheory.Sheaf.over
code: /-- Given `F : Sheaf J A` and `X : C`, this is the pullback of `F` on `J.over X`. -/
abbrev Sheaf.over {A : Type u'} [Category.{v'} A] (F : Sheaf J A) (X : C) :
    Sheaf (J.over X) A 
goal: CategoryTheory.Sheaf (J.over X) A