File: Mathlib/Topology/Sheaves/SheafCondition/Sites.lean

full_name: TopCat.Presheaf.coveringOfPresieve
code: /-- Given a presieve `R` on `U`, we obtain a covering family of open sets in `X`, by taking as index
type the type of dependent pairs `(V, f)`, where `f : V ⟶ U` is in `R`.
-/
def coveringOfPresieve (U : Opens X) (R : Presieve U) : (ΣV, { f : V ⟶ U // R f }) → Opens X 
goal: (V : TopologicalSpace.Opens ↑X) × { f // R f } → TopologicalSpace.Opens ↑X

full_name: TopCat.Presheaf.coveringOfPresieve_apply
code: @[simp]
theorem coveringOfPresieve_apply (U : Opens X) (R : Presieve U) (f : ΣV, { f : V ⟶ U // R f }) :
    coveringOfPresieve U R f = f.1 
goal: TopCat.Presheaf.coveringOfPresieve U R f = f.fst

full_name: TopCat.Presheaf.coveringOfPresieve.iSup_eq_of_mem_grothendieck
code: /-- If `R` is a presieve in the grothendieck topology on `Opens X`, the covering family associated
to `R` really is _covering_, i.e. the union of all open sets equals `U`.
-/
theorem iSup_eq_of_mem_grothendieck (hR : Sieve.generate R ∈ Opens.grothendieckTopology X U) :
    iSup (coveringOfPresieve U R) = U 
goal: iSup (TopCat.Presheaf.coveringOfPresieve U R) = U

full_name: TopCat.Presheaf.presieveOfCoveringAux
code: /-- Given a family of opens `U : ι → Opens X` and any open `Y : Opens X`, we obtain a presieve
on `Y` by declaring that a morphism `f : V ⟶ Y` is a member of the presieve if and only if
there exists an index `i : ι` such that `V = U i`.
-/
def presieveOfCoveringAux {ι : Type v} (U : ι → Opens X) (Y : Opens X) : Presieve Y 
goal: CategoryTheory.Presieve Y

full_name: TopCat.Presheaf.presieveOfCovering
code: /-- Take `Y` to be `iSup U` and obtain a presieve over `iSup U`. -/
def presieveOfCovering {ι : Type v} (U : ι → Opens X) : Presieve (iSup U) 
goal: CategoryTheory.Presieve (iSup U)

full_name: TopCat.Presheaf.covering_presieve_eq_self
code: /-- Given a presieve `R` on `Y`, if we take its associated family of opens via
    `coveringOfPresieve` (which may not cover `Y` if `R` is not covering), and take
    the presieve on `Y` associated to the family of opens via `presieveOfCoveringAux`,
    then we get back the original presieve `R`. -/
@[simp]
theorem covering_presieve_eq_self {Y : Opens X} (R : Presieve Y) :
    presieveOfCoveringAux (coveringOfPresieve Y R) Y = R 
goal: TopCat.Presheaf.presieveOfCoveringAux (TopCat.Presheaf.coveringOfPresieve Y R) Y = R

full_name: TopCat.Presheaf.presieveOfCovering.mem_grothendieckTopology
code: /-- The sieve generated by `presieveOfCovering U` is a member of the grothendieck topology.
-/
theorem mem_grothendieckTopology :
    Sieve.generate (presieveOfCovering U) ∈ Opens.grothendieckTopology X (iSup U) 
goal: CategoryTheory.Sieve.generate (TopCat.Presheaf.presieveOfCovering U) ∈ (Opens.grothendieckTopology ↑X).sieves (iSup U)

full_name: TopCat.Presheaf.presieveOfCovering.homOfIndex
code: /-- An index `i : ι` can be turned into a dependent pair `(V, f)`, where `V` is an open set and
`f : V ⟶ iSup U` is a member of `presieveOfCovering U f`.
-/
def homOfIndex (i : ι) : ΣV, { f : V ⟶ iSup U // presieveOfCovering U f } 
goal: (V : TopologicalSpace.Opens ↑X) × { f // TopCat.Presheaf.presieveOfCovering U f }

full_name: TopCat.Presheaf.presieveOfCovering.indexOfHom
code: /-- By using the axiom of choice, a dependent pair `(V, f)` where `f : V ⟶ iSup U` is a member of
`presieveOfCovering U f` can be turned into an index `i : ι`, such that `V = U i`.
-/
def indexOfHom (f : ΣV, { f : V ⟶ iSup U // presieveOfCovering U f }) : ι 
goal: ι

full_name: TopCat.Presheaf.presieveOfCovering.indexOfHom_spec
code: theorem indexOfHom_spec (f : ΣV, { f : V ⟶ iSup U // presieveOfCovering U f }) :
    f.1 = U (indexOfHom U f) 
goal: f.fst = U (TopCat.Presheaf.presieveOfCovering.indexOfHom U f)

full_name: TopCat.Opens.coverDense_iff_isBasis
code: theorem coverDense_iff_isBasis [Category ι] (B : ι ⥤ Opens X) :
    B.IsCoverDense (Opens.grothendieckTopology X) ↔ Opens.IsBasis (Set.range B.obj) 
goal: B.IsCoverDense (Opens.grothendieckTopology ↑X) ↔ TopologicalSpace.Opens.IsBasis (Set.range B.obj)

full_name: TopCat.Opens.coverDense_inducedFunctor
code: theorem coverDense_inducedFunctor {B : ι → Opens X} (h : Opens.IsBasis (Set.range B)) :
    (inducedFunctor B).IsCoverDense (Opens.grothendieckTopology X)  
goal: (CategoryTheory.inducedFunctor B).IsCoverDense (Opens.grothendieckTopology ↑X)

full_name: OpenEmbedding.compatiblePreserving
code: theorem OpenEmbedding.compatiblePreserving (hf : OpenEmbedding f) :
    CompatiblePreserving (Opens.grothendieckTopology Y) hf.isOpenMap.functor 
goal: CategoryTheory.CompatiblePreserving (Opens.grothendieckTopology ↑Y) ⋯.functor

full_name: IsOpenMap.coverPreserving
code: theorem IsOpenMap.coverPreserving (hf : IsOpenMap f) :
    CoverPreserving (Opens.grothendieckTopology X) (Opens.grothendieckTopology Y) hf.functor 
goal: CategoryTheory.CoverPreserving (Opens.grothendieckTopology ↑X) (Opens.grothendieckTopology ↑Y) hf.functor

full_name: OpenEmbedding.functor_isContinuous
code: lemma OpenEmbedding.functor_isContinuous (h : OpenEmbedding f) :
    h.isOpenMap.functor.IsContinuous (Opens.grothendieckTopology X)
      (Opens.grothendieckTopology Y) 
goal: ⋯.functor.IsContinuous (Opens.grothendieckTopology ↑X) (Opens.grothendieckTopology ↑Y)

full_name: TopCat.Presheaf.isSheaf_of_openEmbedding
code: theorem TopCat.Presheaf.isSheaf_of_openEmbedding (h : OpenEmbedding f) (hF : F.IsSheaf) :
    IsSheaf (h.isOpenMap.functor.op ⋙ F) 
goal: TopCat.Presheaf.IsSheaf (⋯.functor.op ⋙ F)

full_name: instRepresentablyFlatOpensαTopologicalSpaceMap
code: instance : RepresentablyFlat (Opens.map f) 
goal: CategoryTheory.RepresentablyFlat (TopologicalSpace.Opens.map f)

full_name: compatiblePreserving_opens_map
code: theorem compatiblePreserving_opens_map :
    CompatiblePreserving (Opens.grothendieckTopology X) (Opens.map f) 
goal: CategoryTheory.CompatiblePreserving (Opens.grothendieckTopology ↑X) (TopologicalSpace.Opens.map f)

full_name: coverPreserving_opens_map
code: theorem coverPreserving_opens_map : CoverPreserving (Opens.grothendieckTopology Y)
    (Opens.grothendieckTopology X) (Opens.map f) 
goal: CategoryTheory.CoverPreserving (Opens.grothendieckTopology ↑Y) (Opens.grothendieckTopology ↑X)
  (TopologicalSpace.Opens.map f)

full_name: instIsContinuousOpensαTopologicalSpaceMapGrothendieckTopology
code: instance : (Opens.map f).IsContinuous (Opens.grothendieckTopology Y)
    (Opens.grothendieckTopology X) 
goal: (TopologicalSpace.Opens.map f).IsContinuous (Opens.grothendieckTopology ↑Y) (Opens.grothendieckTopology ↑X)

full_name: TopCat.Sheaf.isTerminalOfEmpty
code: /-- The empty component of a sheaf is terminal. -/
def isTerminalOfEmpty (F : Sheaf C X) : Limits.IsTerminal (F.val.obj (op ⊥)) 
goal: CategoryTheory.Limits.IsTerminal (F.val.obj (Opposite.op ⊥))

full_name: TopCat.Sheaf.isTerminalOfEqEmpty
code: /-- A variant of `isTerminalOfEmpty` that is easier to `apply`. -/
def isTerminalOfEqEmpty (F : X.Sheaf C) {U : Opens X} (h : U = ⊥) :
    Limits.IsTerminal (F.val.obj (op U)) 
goal: CategoryTheory.Limits.IsTerminal (F.val.obj (Opposite.op U))

full_name: TopCat.Sheaf.restrictHomEquivHom
code: /-- If a family `B` of open sets forms a basis of the topology on `X`, and if `F'`
    is a sheaf on `X`, then a homomorphism between a presheaf `F` on `X` and `F'`
    is equivalent to a homomorphism between their restrictions to the indexing type
    `ι` of `B`, with the induced category structure on `ι`. -/
def restrictHomEquivHom :
    ((inducedFunctor B).op ⋙ F ⟶ (inducedFunctor B).op ⋙ F'.1) ≃ (F ⟶ F'.1) 
goal: ((CategoryTheory.inducedFunctor B).op ⋙ F ⟶ (CategoryTheory.inducedFunctor B).op ⋙ F'.val) ≃ (F ⟶ F'.val)

full_name: TopCat.Sheaf.extend_hom_app
code: @[simp]
theorem extend_hom_app (α : (inducedFunctor B).op ⋙ F ⟶ (inducedFunctor B).op ⋙ F'.1) (i : ι) :
    (restrictHomEquivHom F F' h α).app (op (B i)) = α.app (op i) 
goal: ((TopCat.Sheaf.restrictHomEquivHom F F' h) α).app (Opposite.op (B i)) = α.app (Opposite.op i)

full_name: TopCat.Sheaf.hom_ext
code: theorem hom_ext {α β : F ⟶ F'.1} (he : ∀ i, α.app (op (B i)) = β.app (op (B i))) : α = β 
goal: α = β