File: Mathlib/Topology/Sheaves/Skyscraper.lean

full_name: skyscraperPresheaf_map
code: /-- A skyscraper presheaf is a presheaf supported at a single point: if `p₀ ∈ X` is a specified
point, then the skyscraper presheaf `𝓕` with value `A` is defined by `U ↦ A` if `p₀ ∈ U` and
`U ↦ *` if `p₀ ∉ A` where `*` is some terminal object.
-/
@[simps]
def skyscraperPresheaf : Presheaf C X 
goal: (skyscraperPresheaf p₀ A).map i =
  if h : p₀ ∈ Opposite.unop V then CategoryTheory.eqToHom ⋯
  else (⋯ ▸ CategoryTheory.Limits.terminalIsTerminal).from ((fun U => if p₀ ∈ Opposite.unop U then A else ⊤_ C) U)

full_name: skyscraperPresheaf
code: /-- A skyscraper presheaf is a presheaf supported at a single point: if `p₀ ∈ X` is a specified
point, then the skyscraper presheaf `𝓕` with value `A` is defined by `U ↦ A` if `p₀ ∈ U` and
`U ↦ *` if `p₀ ∉ A` where `*` is some terminal object.
-/
@[simps]
def skyscraperPresheaf : Presheaf C X 
goal: TopCat.Presheaf C X

full_name: skyscraperPresheaf_obj
code: /-- A skyscraper presheaf is a presheaf supported at a single point: if `p₀ ∈ X` is a specified
point, then the skyscraper presheaf `𝓕` with value `A` is defined by `U ↦ A` if `p₀ ∈ U` and
`U ↦ *` if `p₀ ∉ A` where `*` is some terminal object.
-/
@[simps]
def skyscraperPresheaf : Presheaf C X 
goal: (skyscraperPresheaf p₀ A).obj U = if p₀ ∈ Opposite.unop U then A else ⊤_ C

full_name: skyscraperPresheaf_eq_pushforward
code: theorem skyscraperPresheaf_eq_pushforward
    [hd : ∀ U : Opens (TopCat.of PUnit.{u + 1}), Decidable (PUnit.unit ∈ U)] :
    skyscraperPresheaf p₀ A =
      ContinuousMap.const (TopCat.of PUnit) p₀ _*
        skyscraperPresheaf (X := TopCat.of PUnit) PUnit.unit A 
goal: skyscraperPresheaf p₀ A =
  (TopCat.Presheaf.pushforward C (ContinuousMap.const (↑(TopCat.of PUnit.{u + 1})) p₀)).obj
    (skyscraperPresheaf PUnit.unit A)

full_name: SkyscraperPresheafFunctor.map'
code: /-- Taking skyscraper presheaf at a point is functorial: `c ↦ skyscraper p₀ c` defines a functor by
sending every `f : a ⟶ b` to the natural transformation `α` defined as: `α(U) = f : a ⟶ b` if
`p₀ ∈ U` and the unique morphism to a terminal object in `C` if `p₀ ∉ U`.
-/
@[simps]
def SkyscraperPresheafFunctor.map' {a b : C} (f : a ⟶ b) :
    skyscraperPresheaf p₀ a ⟶ skyscraperPresheaf p₀ b 
goal: skyscraperPresheaf p₀ a ⟶ skyscraperPresheaf p₀ b

full_name: SkyscraperPresheafFunctor.map'_app
code: /-- Taking skyscraper presheaf at a point is functorial: `c ↦ skyscraper p₀ c` defines a functor by
sending every `f : a ⟶ b` to the natural transformation `α` defined as: `α(U) = f : a ⟶ b` if
`p₀ ∈ U` and the unique morphism to a terminal object in `C` if `p₀ ∉ U`.
-/
@[simps]
def SkyscraperPresheafFunctor.map' {a b : C} (f : a ⟶ b) :
    skyscraperPresheaf p₀ a ⟶ skyscraperPresheaf p₀ b 
goal: (SkyscraperPresheafFunctor.map' p₀ f).app U =
  if h : p₀ ∈ Opposite.unop U then CategoryTheory.eqToHom ⋯ ≫ f ≫ CategoryTheory.eqToHom ⋯
  else (⋯ ▸ CategoryTheory.Limits.terminalIsTerminal).from ((skyscraperPresheaf p₀ a).obj U)

full_name: SkyscraperPresheafFunctor.map'_id
code: theorem SkyscraperPresheafFunctor.map'_id {a : C} :
    SkyscraperPresheafFunctor.map' p₀ (𝟙 a) = 𝟙 _ 
goal: SkyscraperPresheafFunctor.map' p₀ (𝟙 a) = 𝟙 (skyscraperPresheaf p₀ a)

full_name: SkyscraperPresheafFunctor.map'_comp
code: theorem SkyscraperPresheafFunctor.map'_comp {a b c : C} (f : a ⟶ b) (g : b ⟶ c) :
    SkyscraperPresheafFunctor.map' p₀ (f ≫ g) =
      SkyscraperPresheafFunctor.map' p₀ f ≫ SkyscraperPresheafFunctor.map' p₀ g 
goal: SkyscraperPresheafFunctor.map' p₀ (f ≫ g) = SkyscraperPresheafFunctor.map' p₀ f ≫ SkyscraperPresheafFunctor.map' p₀ g

full_name: skyscraperPresheafFunctor_obj
code: /-- Taking skyscraper presheaf at a point is functorial: `c ↦ skyscraper p₀ c` defines a functor by
sending every `f : a ⟶ b` to the natural transformation `α` defined as: `α(U) = f : a ⟶ b` if
`p₀ ∈ U` and the unique morphism to a terminal object in `C` if `p₀ ∉ U`.
-/
@[simps]
def skyscraperPresheafFunctor : C ⥤ Presheaf C X 
goal: (skyscraperPresheafFunctor p₀).obj A = skyscraperPresheaf p₀ A

full_name: skyscraperPresheafFunctor
code: /-- Taking skyscraper presheaf at a point is functorial: `c ↦ skyscraper p₀ c` defines a functor by
sending every `f : a ⟶ b` to the natural transformation `α` defined as: `α(U) = f : a ⟶ b` if
`p₀ ∈ U` and the unique morphism to a terminal object in `C` if `p₀ ∉ U`.
-/
@[simps]
def skyscraperPresheafFunctor : C ⥤ Presheaf C X 
goal: C ⥤ TopCat.Presheaf C X

full_name: skyscraperPresheafFunctor_map
code: /-- Taking skyscraper presheaf at a point is functorial: `c ↦ skyscraper p₀ c` defines a functor by
sending every `f : a ⟶ b` to the natural transformation `α` defined as: `α(U) = f : a ⟶ b` if
`p₀ ∈ U` and the unique morphism to a terminal object in `C` if `p₀ ∉ U`.
-/
@[simps]
def skyscraperPresheafFunctor : C ⥤ Presheaf C X 
goal: ∀ {X_1 Y : C} (f : X_1 ⟶ Y), (skyscraperPresheafFunctor p₀).map f = SkyscraperPresheafFunctor.map' p₀ f

full_name: skyscraperPresheafCoconeOfSpecializes_ι_app
code: /-- The cocone at `A` for the stalk functor of `skyscraperPresheaf p₀ A` when `y ∈ closure {p₀}`
-/
@[simps]
def skyscraperPresheafCoconeOfSpecializes {y : X} (h : p₀ ⤳ y) :
    Cocone ((OpenNhds.inclusion y).op ⋙ skyscraperPresheaf p₀ A) 
goal: (skyscraperPresheafCoconeOfSpecializes p₀ A h).ι.app U = CategoryTheory.eqToHom ⋯

full_name: skyscraperPresheafCoconeOfSpecializes
code: /-- The cocone at `A` for the stalk functor of `skyscraperPresheaf p₀ A` when `y ∈ closure {p₀}`
-/
@[simps]
def skyscraperPresheafCoconeOfSpecializes {y : X} (h : p₀ ⤳ y) :
    Cocone ((OpenNhds.inclusion y).op ⋙ skyscraperPresheaf p₀ A) 
goal: CategoryTheory.Limits.Cocone ((TopologicalSpace.OpenNhds.inclusion y).op ⋙ skyscraperPresheaf p₀ A)

full_name: skyscraperPresheafCoconeOfSpecializes_pt
code: /-- The cocone at `A` for the stalk functor of `skyscraperPresheaf p₀ A` when `y ∈ closure {p₀}`
-/
@[simps]
def skyscraperPresheafCoconeOfSpecializes {y : X} (h : p₀ ⤳ y) :
    Cocone ((OpenNhds.inclusion y).op ⋙ skyscraperPresheaf p₀ A) 
goal: (skyscraperPresheafCoconeOfSpecializes p₀ A h).pt = A

full_name: skyscraperPresheafCoconeIsColimitOfSpecializes
code: /--
The cocone at `A` for the stalk functor of `skyscraperPresheaf p₀ A` when `y ∈ closure {p₀}` is a
colimit
-/
noncomputable def skyscraperPresheafCoconeIsColimitOfSpecializes {y : X} (h : p₀ ⤳ y) :
    IsColimit (skyscraperPresheafCoconeOfSpecializes p₀ A h) 
goal: CategoryTheory.Limits.IsColimit (skyscraperPresheafCoconeOfSpecializes p₀ A h)

full_name: skyscraperPresheafStalkOfSpecializes
code: /-- If `y ∈ closure {p₀}`, then the stalk of `skyscraperPresheaf p₀ A` at `y` is `A`.
-/
noncomputable def skyscraperPresheafStalkOfSpecializes [HasColimits C] {y : X} (h : p₀ ⤳ y) :
    (skyscraperPresheaf p₀ A).stalk y ≅ A 
goal: (skyscraperPresheaf p₀ A).stalk y ≅ A

full_name: skyscraperPresheafCocone
code: /-- The cocone at `*` for the stalk functor of `skyscraperPresheaf p₀ A` when `y ∉ closure {p₀}`
-/
@[simps]
def skyscraperPresheafCocone (y : X) :
    Cocone ((OpenNhds.inclusion y).op ⋙ skyscraperPresheaf p₀ A) 
goal: CategoryTheory.Limits.Cocone ((TopologicalSpace.OpenNhds.inclusion y).op ⋙ skyscraperPresheaf p₀ A)

full_name: skyscraperPresheafCocone_ι_app
code: /-- The cocone at `*` for the stalk functor of `skyscraperPresheaf p₀ A` when `y ∉ closure {p₀}`
-/
@[simps]
def skyscraperPresheafCocone (y : X) :
    Cocone ((OpenNhds.inclusion y).op ⋙ skyscraperPresheaf p₀ A) 
goal: ∀ (x : (TopologicalSpace.OpenNhds y)ᵒᵖ),
  (skyscraperPresheafCocone p₀ A y).ι.app x =
    CategoryTheory.Limits.terminal.from (((TopologicalSpace.OpenNhds.inclusion y).op ⋙ skyscraperPresheaf p₀ A).obj x)

full_name: skyscraperPresheafCocone_pt
code: /-- The cocone at `*` for the stalk functor of `skyscraperPresheaf p₀ A` when `y ∉ closure {p₀}`
-/
@[simps]
def skyscraperPresheafCocone (y : X) :
    Cocone ((OpenNhds.inclusion y).op ⋙ skyscraperPresheaf p₀ A) 
goal: (skyscraperPresheafCocone p₀ A y).pt = ⊤_ C

full_name: skyscraperPresheafCoconeIsColimitOfNotSpecializes
code: /--
The cocone at `*` for the stalk functor of `skyscraperPresheaf p₀ A` when `y ∉ closure {p₀}` is a
colimit
-/
noncomputable def skyscraperPresheafCoconeIsColimitOfNotSpecializes {y : X} (h : ¬p₀ ⤳ y) :
    IsColimit (skyscraperPresheafCocone p₀ A y) 
goal: CategoryTheory.Limits.IsColimit (skyscraperPresheafCocone p₀ A y)

full_name: skyscraperPresheafStalkOfNotSpecializes
code: /-- If `y ∉ closure {p₀}`, then the stalk of `skyscraperPresheaf p₀ A` at `y` is isomorphic to a
terminal object.
-/
noncomputable def skyscraperPresheafStalkOfNotSpecializes [HasColimits C] {y : X} (h : ¬p₀ ⤳ y) :
    (skyscraperPresheaf p₀ A).stalk y ≅ terminal C 
goal: (skyscraperPresheaf p₀ A).stalk y ≅ ⊤_ C

full_name: skyscraperPresheafStalkOfNotSpecializesIsTerminal
code: /-- If `y ∉ closure {p₀}`, then the stalk of `skyscraperPresheaf p₀ A` at `y` is a terminal object
-/
def skyscraperPresheafStalkOfNotSpecializesIsTerminal [HasColimits C] {y : X} (h : ¬p₀ ⤳ y) :
    IsTerminal ((skyscraperPresheaf p₀ A).stalk y) 
goal: CategoryTheory.Limits.IsTerminal ((skyscraperPresheaf p₀ A).stalk y)

full_name: skyscraperPresheaf_isSheaf
code: theorem skyscraperPresheaf_isSheaf : (skyscraperPresheaf p₀ A).IsSheaf 
goal: (skyscraperPresheaf p₀ A).IsSheaf

full_name: skyscraperSheaf
code: /--
The skyscraper presheaf supported at `p₀` with value `A` is the sheaf that assigns `A` to all opens
`U` that contain `p₀` and assigns `*` otherwise.
-/
def skyscraperSheaf : Sheaf C X 
goal: TopCat.Sheaf C X

full_name: skyscraperSheafFunctor
code: /-- Taking skyscraper sheaf at a point is functorial: `c ↦ skyscraper p₀ c` defines a functor by
sending every `f : a ⟶ b` to the natural transformation `α` defined as: `α(U) = f : a ⟶ b` if
`p₀ ∈ U` and the unique morphism to a terminal object in `C` if `p₀ ∉ U`.
-/
def skyscraperSheafFunctor : C ⥤ Sheaf C X 
goal: C ⥤ TopCat.Sheaf C X

full_name: StalkSkyscraperPresheafAdjunctionAuxs.toSkyscraperPresheaf
code: /-- If `f : 𝓕.stalk p₀ ⟶ c`, then a natural transformation `𝓕 ⟶ skyscraperPresheaf p₀ c` can be
defined by: `𝓕.germ p₀ ≫ f : 𝓕(U) ⟶ c` if `p₀ ∈ U` and the unique morphism to a terminal object
if `p₀ ∉ U`.
-/
@[simps]
def toSkyscraperPresheaf {𝓕 : Presheaf C X} {c : C} (f : 𝓕.stalk p₀ ⟶ c) :
    𝓕 ⟶ skyscraperPresheaf p₀ c 
goal: 𝓕 ⟶ skyscraperPresheaf p₀ c

full_name: StalkSkyscraperPresheafAdjunctionAuxs.toSkyscraperPresheaf_app
code: /-- If `f : 𝓕.stalk p₀ ⟶ c`, then a natural transformation `𝓕 ⟶ skyscraperPresheaf p₀ c` can be
defined by: `𝓕.germ p₀ ≫ f : 𝓕(U) ⟶ c` if `p₀ ∈ U` and the unique morphism to a terminal object
if `p₀ ∉ U`.
-/
@[simps]
def toSkyscraperPresheaf {𝓕 : Presheaf C X} {c : C} (f : 𝓕.stalk p₀ ⟶ c) :
    𝓕 ⟶ skyscraperPresheaf p₀ c 
goal: (StalkSkyscraperPresheafAdjunctionAuxs.toSkyscraperPresheaf p₀ f).app U =
  if h : p₀ ∈ Opposite.unop U then 𝓕.germ ⟨p₀, h⟩ ≫ f ≫ CategoryTheory.eqToHom ⋯
  else (⋯ ▸ CategoryTheory.Limits.terminalIsTerminal).from (𝓕.obj U)

full_name: StalkSkyscraperPresheafAdjunctionAuxs.fromStalk
code: /-- If `f : 𝓕 ⟶ skyscraperPresheaf p₀ c` is a natural transformation, then there is a morphism
`𝓕.stalk p₀ ⟶ c` defined as the morphism from colimit to cocone at `c`.
-/
def fromStalk {𝓕 : Presheaf C X} {c : C} (f : 𝓕 ⟶ skyscraperPresheaf p₀ c) : 𝓕.stalk p₀ ⟶ c 
goal: 𝓕.stalk p₀ ⟶ c

full_name: StalkSkyscraperPresheafAdjunctionAuxs.to_skyscraper_fromStalk
code: theorem to_skyscraper_fromStalk {𝓕 : Presheaf C X} {c : C} (f : 𝓕 ⟶ skyscraperPresheaf p₀ c) :
    toSkyscraperPresheaf p₀ (fromStalk _ f) = f 
goal: StalkSkyscraperPresheafAdjunctionAuxs.toSkyscraperPresheaf p₀ (StalkSkyscraperPresheafAdjunctionAuxs.fromStalk p₀ f) = f

full_name: StalkSkyscraperPresheafAdjunctionAuxs.fromStalk_to_skyscraper
code: theorem fromStalk_to_skyscraper {𝓕 : Presheaf C X} {c : C} (f : 𝓕.stalk p₀ ⟶ c) :
    fromStalk p₀ (toSkyscraperPresheaf _ f) = f 
goal: StalkSkyscraperPresheafAdjunctionAuxs.fromStalk p₀ (StalkSkyscraperPresheafAdjunctionAuxs.toSkyscraperPresheaf p₀ f) = f

full_name: StalkSkyscraperPresheafAdjunctionAuxs.unit_app
code: /-- The unit in `Presheaf.stalkFunctor ⊣ skyscraperPresheafFunctor`
-/
@[simps]
protected def unit :
    𝟭 (Presheaf C X) ⟶ Presheaf.stalkFunctor C p₀ ⋙ skyscraperPresheafFunctor p₀ 
goal: (StalkSkyscraperPresheafAdjunctionAuxs.unit p₀).app 𝓕 =
  StalkSkyscraperPresheafAdjunctionAuxs.toSkyscraperPresheaf p₀ (𝟙 (((𝟭 (TopCat.Presheaf C X)).obj 𝓕).stalk p₀))

full_name: StalkSkyscraperPresheafAdjunctionAuxs.unit
code: /-- The unit in `Presheaf.stalkFunctor ⊣ skyscraperPresheafFunctor`
-/
@[simps]
protected def unit :
    𝟭 (Presheaf C X) ⟶ Presheaf.stalkFunctor C p₀ ⋙ skyscraperPresheafFunctor p₀ 
goal: 𝟭 (TopCat.Presheaf C X) ⟶ TopCat.Presheaf.stalkFunctor C p₀ ⋙ skyscraperPresheafFunctor p₀

full_name: StalkSkyscraperPresheafAdjunctionAuxs.counit_app
code: /-- The counit in `Presheaf.stalkFunctor ⊣ skyscraperPresheafFunctor`
-/
@[simps]
protected def counit :
    skyscraperPresheafFunctor p₀ ⋙ (Presheaf.stalkFunctor C p₀ : Presheaf C X ⥤ C) ⟶ 𝟭 C 
goal: (StalkSkyscraperPresheafAdjunctionAuxs.counit p₀).app c = (skyscraperPresheafStalkOfSpecializes p₀ c ⋯).hom

full_name: StalkSkyscraperPresheafAdjunctionAuxs.counit
code: /-- The counit in `Presheaf.stalkFunctor ⊣ skyscraperPresheafFunctor`
-/
@[simps]
protected def counit :
    skyscraperPresheafFunctor p₀ ⋙ (Presheaf.stalkFunctor C p₀ : Presheaf C X ⥤ C) ⟶ 𝟭 C 
goal: skyscraperPresheafFunctor p₀ ⋙ TopCat.Presheaf.stalkFunctor C p₀ ⟶ 𝟭 C

full_name: skyscraperPresheafStalkAdjunction
code: /-- `skyscraperPresheafFunctor` is the right adjoint of `Presheaf.stalkFunctor`
-/
def skyscraperPresheafStalkAdjunction [HasColimits C] :
    (Presheaf.stalkFunctor C p₀ : Presheaf C X ⥤ C) ⊣ skyscraperPresheafFunctor p₀ 
goal: TopCat.Presheaf.stalkFunctor C p₀ ⊣ skyscraperPresheafFunctor p₀

full_name: instIsRightAdjointPresheafSkyscraperPresheafFunctorOfHasColimits
code: instance [HasColimits C] : (skyscraperPresheafFunctor p₀ : C ⥤ Presheaf C X).IsRightAdjoint  
goal: (skyscraperPresheafFunctor p₀).IsRightAdjoint

full_name: instIsLeftAdjointPresheafStalkFunctor
code: instance [HasColimits C] : (Presheaf.stalkFunctor C p₀).IsLeftAdjoint  
goal: (TopCat.Presheaf.stalkFunctor C p₀).IsLeftAdjoint

full_name: stalkSkyscraperSheafAdjunction
code: /-- Taking stalks of a sheaf is the left adjoint functor to `skyscraperSheafFunctor`
-/
def stalkSkyscraperSheafAdjunction [HasColimits C] :
    Sheaf.forget C X ⋙ Presheaf.stalkFunctor _ p₀ ⊣ skyscraperSheafFunctor p₀ 
goal: TopCat.Sheaf.forget C X ⋙ TopCat.Presheaf.stalkFunctor C p₀ ⊣ skyscraperSheafFunctor p₀

full_name: instIsRightAdjointSheafSkyscraperSheafFunctorOfHasColimits
code: instance [HasColimits C] : (skyscraperSheafFunctor p₀ : C ⥤ Sheaf C X).IsRightAdjoint  
goal: (skyscraperSheafFunctor p₀).IsRightAdjoint