fact stringlengths 6 3.84k | type stringclasses 11
values | library stringclasses 32
values | imports listlengths 1 14 | filename stringlengths 20 95 | symbolic_name stringlengths 1 90 | docstring stringlengths 7 20k ⌀ |
|---|---|---|---|---|---|---|
ext {X : TopCat} {P Q : Presheaf C X} {f g : P ⟶ Q}
(w : ∀ U : Opens X, f.app (op U) = g.app (op U)) :
f = g := by
apply NatTrans.ext
ext U
induction U with | _ U => ?_
apply w | lemma | Topology | [
"Mathlib.Topology.Category.TopCat.Opens",
"Mathlib.CategoryTheory.Adjunction.Unique",
"Mathlib.CategoryTheory.Functor.KanExtension.Adjunction",
"Mathlib.Topology.Sheaves.Init",
"Mathlib.Data.Set.Subsingleton"
] | Mathlib/Topology/Sheaves/Presheaf.lean | ext | null |
restrict {F : X.Presheaf C}
{V : Opens X} (x : ToType (F.obj (op V))) {U : Opens X} (h : U ⟶ V) : ToType (F.obj (op U)) :=
F.map h.op x | def | Topology | [
"Mathlib.Topology.Category.TopCat.Opens",
"Mathlib.CategoryTheory.Adjunction.Unique",
"Mathlib.CategoryTheory.Functor.KanExtension.Adjunction",
"Mathlib.Topology.Sheaves.Init",
"Mathlib.Data.Set.Subsingleton"
] | Mathlib/Topology/Sheaves/Presheaf.lean | restrict | attribute `sheaf_restrict` to mark lemmas related to restricting sheaves -/
macro "sheaf_restrict" : attr =>
`(attr|aesop safe 50 apply (rule_sets := [$(Lean.mkIdent `Restrict):ident]))
attribute [sheaf_restrict] bot_le le_top le_refl inf_le_left inf_le_right
le_sup_left le_sup_right
/-- `restrict_tac` solves rel... |
restrictOpen {F : X.Presheaf C}
{V : Opens X} (x : ToType (F.obj (op V))) (U : Opens X)
(e : U ≤ V := by restrict_tac) :
ToType (F.obj (op U)) :=
x |_ₗ U ⟪e⟫ | abbrev | Topology | [
"Mathlib.Topology.Category.TopCat.Opens",
"Mathlib.CategoryTheory.Adjunction.Unique",
"Mathlib.CategoryTheory.Functor.KanExtension.Adjunction",
"Mathlib.Topology.Sheaves.Init",
"Mathlib.Data.Set.Subsingleton"
] | Mathlib/Topology/Sheaves/Presheaf.lean | restrictOpen | restriction of a section along an inclusion -/
scoped[AlgebraicGeometry] infixl:80 " |_ₕ " => TopCat.Presheaf.restrict
/-- restriction of a section along a subset relation -/
scoped[AlgebraicGeometry] notation:80 x " |_ₗ " U " ⟪" e "⟫ " =>
@TopCat.Presheaf.restrict _ _ _ _ _ _ _ _ _ x U (@homOfLE (Opens _) _ U _ e)
... |
@[simps!]
pushforward {X Y : TopCat.{w}} (f : X ⟶ Y) : X.Presheaf C ⥤ Y.Presheaf C :=
(whiskeringLeft _ _ _).obj (Opens.map f).op | def | Topology | [
"Mathlib.Topology.Category.TopCat.Opens",
"Mathlib.CategoryTheory.Adjunction.Unique",
"Mathlib.CategoryTheory.Functor.KanExtension.Adjunction",
"Mathlib.Topology.Sheaves.Init",
"Mathlib.Data.Set.Subsingleton"
] | Mathlib/Topology/Sheaves/Presheaf.lean | pushforward | restriction of a section to open subset -/
scoped[AlgebraicGeometry] infixl:80 " |_ " => TopCat.Presheaf.restrictOpen
theorem restrict_restrict
{F : X.Presheaf C} {U V W : Opens X} (e₁ : U ≤ V) (e₂ : V ≤ W) (x : ToType (F.obj (op W))) :
x |_ V |_ U = x |_ U := by
delta restrictOpen restrict
rw [← ConcreteC... |
id {X : TopCat.{w}} (ℱ : X.Presheaf C) : 𝟙 X _* ℱ ≅ ℱ := Iso.refl _
@[simp] | def | Topology | [
"Mathlib.Topology.Category.TopCat.Opens",
"Mathlib.CategoryTheory.Adjunction.Unique",
"Mathlib.CategoryTheory.Functor.KanExtension.Adjunction",
"Mathlib.Topology.Sheaves.Init",
"Mathlib.Data.Set.Subsingleton"
] | Mathlib/Topology/Sheaves/Presheaf.lean | id | push forward of a presheaf -/
scoped[AlgebraicGeometry] notation f:80 " _* " P:81 =>
Functor.obj (TopCat.Presheaf.pushforward _ f) P
@[simp]
theorem pushforward_map_app' {X Y : TopCat.{w}} (f : X ⟶ Y) {ℱ 𝒢 : X.Presheaf C} (α : ℱ ⟶ 𝒢)
{U : (Opens Y)ᵒᵖ} : ((pushforward C f).map α).app U = α.app (op <| (Opens.map... |
id_hom_app {X : TopCat.{w}} (ℱ : X.Presheaf C) (U) : (id ℱ).hom.app U = 𝟙 _ := rfl
@[simp] | theorem | Topology | [
"Mathlib.Topology.Category.TopCat.Opens",
"Mathlib.CategoryTheory.Adjunction.Unique",
"Mathlib.CategoryTheory.Functor.KanExtension.Adjunction",
"Mathlib.Topology.Sheaves.Init",
"Mathlib.Data.Set.Subsingleton"
] | Mathlib/Topology/Sheaves/Presheaf.lean | id_hom_app | null |
id_inv_app {X : TopCat.{w}} (ℱ : X.Presheaf C) (U) :
(id ℱ).inv.app U = 𝟙 _ := rfl | theorem | Topology | [
"Mathlib.Topology.Category.TopCat.Opens",
"Mathlib.CategoryTheory.Adjunction.Unique",
"Mathlib.CategoryTheory.Functor.KanExtension.Adjunction",
"Mathlib.Topology.Sheaves.Init",
"Mathlib.Data.Set.Subsingleton"
] | Mathlib/Topology/Sheaves/Presheaf.lean | id_inv_app | null |
id_eq {X : TopCat.{w}} (ℱ : X.Presheaf C) : 𝟙 X _* ℱ = ℱ := rfl | theorem | Topology | [
"Mathlib.Topology.Category.TopCat.Opens",
"Mathlib.CategoryTheory.Adjunction.Unique",
"Mathlib.CategoryTheory.Functor.KanExtension.Adjunction",
"Mathlib.Topology.Sheaves.Init",
"Mathlib.Data.Set.Subsingleton"
] | Mathlib/Topology/Sheaves/Presheaf.lean | id_eq | null |
comp {X Y Z : TopCat.{w}} (f : X ⟶ Y) (g : Y ⟶ Z) (ℱ : X.Presheaf C) :
(f ≫ g) _* ℱ ≅ g _* (f _* ℱ) := Iso.refl _ | def | Topology | [
"Mathlib.Topology.Category.TopCat.Opens",
"Mathlib.CategoryTheory.Adjunction.Unique",
"Mathlib.CategoryTheory.Functor.KanExtension.Adjunction",
"Mathlib.Topology.Sheaves.Init",
"Mathlib.Data.Set.Subsingleton"
] | Mathlib/Topology/Sheaves/Presheaf.lean | comp | The natural isomorphism between
the pushforward of a presheaf along the composition of two continuous maps and
the corresponding pushforward of a pushforward. |
comp_eq {X Y Z : TopCat.{w}} (f : X ⟶ Y) (g : Y ⟶ Z) (ℱ : X.Presheaf C) :
(f ≫ g) _* ℱ = g _* (f _* ℱ) :=
rfl
@[simp] | theorem | Topology | [
"Mathlib.Topology.Category.TopCat.Opens",
"Mathlib.CategoryTheory.Adjunction.Unique",
"Mathlib.CategoryTheory.Functor.KanExtension.Adjunction",
"Mathlib.Topology.Sheaves.Init",
"Mathlib.Data.Set.Subsingleton"
] | Mathlib/Topology/Sheaves/Presheaf.lean | comp_eq | null |
comp_hom_app {X Y Z : TopCat.{w}} (f : X ⟶ Y) (g : Y ⟶ Z) (ℱ : X.Presheaf C) (U) :
(comp f g ℱ).hom.app U = 𝟙 _ := rfl
@[simp] | theorem | Topology | [
"Mathlib.Topology.Category.TopCat.Opens",
"Mathlib.CategoryTheory.Adjunction.Unique",
"Mathlib.CategoryTheory.Functor.KanExtension.Adjunction",
"Mathlib.Topology.Sheaves.Init",
"Mathlib.Data.Set.Subsingleton"
] | Mathlib/Topology/Sheaves/Presheaf.lean | comp_hom_app | null |
comp_inv_app {X Y Z : TopCat.{w}} (f : X ⟶ Y) (g : Y ⟶ Z) (ℱ : X.Presheaf C) (U) :
(comp f g ℱ).inv.app U = 𝟙 _ := rfl | theorem | Topology | [
"Mathlib.Topology.Category.TopCat.Opens",
"Mathlib.CategoryTheory.Adjunction.Unique",
"Mathlib.CategoryTheory.Functor.KanExtension.Adjunction",
"Mathlib.Topology.Sheaves.Init",
"Mathlib.Data.Set.Subsingleton"
] | Mathlib/Topology/Sheaves/Presheaf.lean | comp_inv_app | null |
pushforwardEq {X Y : TopCat.{w}} {f g : X ⟶ Y} (h : f = g) (ℱ : X.Presheaf C) :
f _* ℱ ≅ g _* ℱ :=
isoWhiskerRight (NatIso.op (Opens.mapIso f g h).symm) ℱ | def | Topology | [
"Mathlib.Topology.Category.TopCat.Opens",
"Mathlib.CategoryTheory.Adjunction.Unique",
"Mathlib.CategoryTheory.Functor.KanExtension.Adjunction",
"Mathlib.Topology.Sheaves.Init",
"Mathlib.Data.Set.Subsingleton"
] | Mathlib/Topology/Sheaves/Presheaf.lean | pushforwardEq | An equality of continuous maps induces a natural isomorphism between the pushforwards of a presheaf
along those maps. |
pushforward_eq' {X Y : TopCat.{w}} {f g : X ⟶ Y} (h : f = g) (ℱ : X.Presheaf C) :
f _* ℱ = g _* ℱ := by rw [h]
@[simp] | theorem | Topology | [
"Mathlib.Topology.Category.TopCat.Opens",
"Mathlib.CategoryTheory.Adjunction.Unique",
"Mathlib.CategoryTheory.Functor.KanExtension.Adjunction",
"Mathlib.Topology.Sheaves.Init",
"Mathlib.Data.Set.Subsingleton"
] | Mathlib/Topology/Sheaves/Presheaf.lean | pushforward_eq' | null |
pushforwardEq_hom_app {X Y : TopCat.{w}} {f g : X ⟶ Y}
(h : f = g) (ℱ : X.Presheaf C) (U) :
(pushforwardEq h ℱ).hom.app U = ℱ.map (eqToHom (by cat_disch)) := by
simp [pushforwardEq]
variable (C) | theorem | Topology | [
"Mathlib.Topology.Category.TopCat.Opens",
"Mathlib.CategoryTheory.Adjunction.Unique",
"Mathlib.CategoryTheory.Functor.KanExtension.Adjunction",
"Mathlib.Topology.Sheaves.Init",
"Mathlib.Data.Set.Subsingleton"
] | Mathlib/Topology/Sheaves/Presheaf.lean | pushforwardEq_hom_app | null |
@[simps!]
presheafEquivOfIso {X Y : TopCat} (H : X ≅ Y) : X.Presheaf C ≌ Y.Presheaf C :=
Equivalence.congrLeft (Opens.mapMapIso H).symm.op
variable {C} | def | Topology | [
"Mathlib.Topology.Category.TopCat.Opens",
"Mathlib.CategoryTheory.Adjunction.Unique",
"Mathlib.CategoryTheory.Functor.KanExtension.Adjunction",
"Mathlib.Topology.Sheaves.Init",
"Mathlib.Data.Set.Subsingleton"
] | Mathlib/Topology/Sheaves/Presheaf.lean | presheafEquivOfIso | A homeomorphism of spaces gives an equivalence of categories of presheaves. |
toPushforwardOfIso {X Y : TopCat} (H : X ≅ Y) {ℱ : X.Presheaf C} {𝒢 : Y.Presheaf C}
(α : H.hom _* ℱ ⟶ 𝒢) : ℱ ⟶ H.inv _* 𝒢 :=
(presheafEquivOfIso _ H).toAdjunction.homEquiv ℱ 𝒢 α
@[simp] | def | Topology | [
"Mathlib.Topology.Category.TopCat.Opens",
"Mathlib.CategoryTheory.Adjunction.Unique",
"Mathlib.CategoryTheory.Functor.KanExtension.Adjunction",
"Mathlib.Topology.Sheaves.Init",
"Mathlib.Data.Set.Subsingleton"
] | Mathlib/Topology/Sheaves/Presheaf.lean | toPushforwardOfIso | If `H : X ≅ Y` is a homeomorphism,
then given an `H _* ℱ ⟶ 𝒢`, we may obtain an `ℱ ⟶ H ⁻¹ _* 𝒢`. |
toPushforwardOfIso_app {X Y : TopCat} (H₁ : X ≅ Y) {ℱ : X.Presheaf C} {𝒢 : Y.Presheaf C}
(H₂ : H₁.hom _* ℱ ⟶ 𝒢) (U : (Opens X)ᵒᵖ) :
(toPushforwardOfIso H₁ H₂).app U =
ℱ.map (eqToHom (by simp [Opens.map, Set.preimage_preimage])) ≫
H₂.app (op ((Opens.map H₁.inv).obj (unop U))) := by
simp [toPush... | theorem | Topology | [
"Mathlib.Topology.Category.TopCat.Opens",
"Mathlib.CategoryTheory.Adjunction.Unique",
"Mathlib.CategoryTheory.Functor.KanExtension.Adjunction",
"Mathlib.Topology.Sheaves.Init",
"Mathlib.Data.Set.Subsingleton"
] | Mathlib/Topology/Sheaves/Presheaf.lean | toPushforwardOfIso_app | null |
pushforwardToOfIso {X Y : TopCat} (H₁ : X ≅ Y) {ℱ : Y.Presheaf C} {𝒢 : X.Presheaf C}
(H₂ : ℱ ⟶ H₁.hom _* 𝒢) : H₁.inv _* ℱ ⟶ 𝒢 :=
((presheafEquivOfIso _ H₁.symm).toAdjunction.homEquiv ℱ 𝒢).symm H₂
@[simp] | def | Topology | [
"Mathlib.Topology.Category.TopCat.Opens",
"Mathlib.CategoryTheory.Adjunction.Unique",
"Mathlib.CategoryTheory.Functor.KanExtension.Adjunction",
"Mathlib.Topology.Sheaves.Init",
"Mathlib.Data.Set.Subsingleton"
] | Mathlib/Topology/Sheaves/Presheaf.lean | pushforwardToOfIso | If `H : X ≅ Y` is a homeomorphism,
then given an `H _* ℱ ⟶ 𝒢`, we may obtain an `ℱ ⟶ H ⁻¹ _* 𝒢`. |
pushforwardToOfIso_app {X Y : TopCat} (H₁ : X ≅ Y) {ℱ : Y.Presheaf C} {𝒢 : X.Presheaf C}
(H₂ : ℱ ⟶ H₁.hom _* 𝒢) (U : (Opens X)ᵒᵖ) :
(pushforwardToOfIso H₁ H₂).app U =
H₂.app (op ((Opens.map H₁.inv).obj (unop U))) ≫
𝒢.map (eqToHom (by simp [Opens.map, Set.preimage_preimage])) := by
simp [pushf... | theorem | Topology | [
"Mathlib.Topology.Category.TopCat.Opens",
"Mathlib.CategoryTheory.Adjunction.Unique",
"Mathlib.CategoryTheory.Functor.KanExtension.Adjunction",
"Mathlib.Topology.Sheaves.Init",
"Mathlib.Data.Set.Subsingleton"
] | Mathlib/Topology/Sheaves/Presheaf.lean | pushforwardToOfIso_app | null |
pullback {X Y : TopCat.{v}} (f : X ⟶ Y) : Y.Presheaf C ⥤ X.Presheaf C :=
(Opens.map f).op.lan | def | Topology | [
"Mathlib.Topology.Category.TopCat.Opens",
"Mathlib.CategoryTheory.Adjunction.Unique",
"Mathlib.CategoryTheory.Functor.KanExtension.Adjunction",
"Mathlib.Topology.Sheaves.Init",
"Mathlib.Data.Set.Subsingleton"
] | Mathlib/Topology/Sheaves/Presheaf.lean | pullback | Pullback a presheaf on `Y` along a continuous map `f : X ⟶ Y`, obtaining a presheaf
on `X`. |
pushforwardPullbackAdjunction {X Y : TopCat.{v}} (f : X ⟶ Y) :
pullback C f ⊣ pushforward C f :=
Functor.lanAdjunction _ _ | def | Topology | [
"Mathlib.Topology.Category.TopCat.Opens",
"Mathlib.CategoryTheory.Adjunction.Unique",
"Mathlib.CategoryTheory.Functor.KanExtension.Adjunction",
"Mathlib.Topology.Sheaves.Init",
"Mathlib.Data.Set.Subsingleton"
] | Mathlib/Topology/Sheaves/Presheaf.lean | pushforwardPullbackAdjunction | The pullback and pushforward along a continuous map are adjoint to each other. |
pullbackHomIsoPushforwardInv {X Y : TopCat.{v}} (H : X ≅ Y) :
pullback C H.hom ≅ pushforward C H.inv :=
Adjunction.leftAdjointUniq (pushforwardPullbackAdjunction C H.hom)
(presheafEquivOfIso C H.symm).toAdjunction | def | Topology | [
"Mathlib.Topology.Category.TopCat.Opens",
"Mathlib.CategoryTheory.Adjunction.Unique",
"Mathlib.CategoryTheory.Functor.KanExtension.Adjunction",
"Mathlib.Topology.Sheaves.Init",
"Mathlib.Data.Set.Subsingleton"
] | Mathlib/Topology/Sheaves/Presheaf.lean | pullbackHomIsoPushforwardInv | Pulling back along a homeomorphism is the same as pushing forward along its inverse. |
pullbackInvIsoPushforwardHom {X Y : TopCat.{v}} (H : X ≅ Y) :
pullback C H.inv ≅ pushforward C H.hom :=
Adjunction.leftAdjointUniq (pushforwardPullbackAdjunction C H.inv)
(presheafEquivOfIso C H).toAdjunction
variable {C} | def | Topology | [
"Mathlib.Topology.Category.TopCat.Opens",
"Mathlib.CategoryTheory.Adjunction.Unique",
"Mathlib.CategoryTheory.Functor.KanExtension.Adjunction",
"Mathlib.Topology.Sheaves.Init",
"Mathlib.Data.Set.Subsingleton"
] | Mathlib/Topology/Sheaves/Presheaf.lean | pullbackInvIsoPushforwardHom | Pulling back along the inverse of a homeomorphism is the same as pushing forward along it. |
pullbackObjObjOfImageOpen {X Y : TopCat.{v}} (f : X ⟶ Y) (ℱ : Y.Presheaf C) (U : Opens X)
(H : IsOpen (f '' SetLike.coe U)) : ((pullback C f).obj ℱ).obj (op U) ≅ ℱ.obj (op ⟨_, H⟩) := by
let x : CostructuredArrow (Opens.map f).op (op U) := CostructuredArrow.mk
(@homOfLE _ _ _ ((Opens.map f).obj ⟨_, H⟩) (Set.im... | def | Topology | [
"Mathlib.Topology.Category.TopCat.Opens",
"Mathlib.CategoryTheory.Adjunction.Unique",
"Mathlib.CategoryTheory.Functor.KanExtension.Adjunction",
"Mathlib.Topology.Sheaves.Init",
"Mathlib.Data.Set.Subsingleton"
] | Mathlib/Topology/Sheaves/Presheaf.lean | pullbackObjObjOfImageOpen | If `f '' U` is open, then `f⁻¹ℱ U ≅ ℱ (f '' U)`. |
presheafToTypes (T : X → Type*) : X.Presheaf (Type _) where
obj U := ∀ x : U.unop, T x
map {_ V} i g := fun x : V.unop => g (i.unop x)
map_id U := by
ext g
rfl
map_comp {_ _ _} _ _ := rfl
@[simp] | def | Topology | [
"Mathlib.Topology.Sheaves.Presheaf"
] | Mathlib/Topology/Sheaves/PresheafOfFunctions.lean | presheafToTypes | The presheaf of dependently typed functions on `X`, with fibres given by a type family `T`.
There is no requirement that the functions are continuous, here. |
presheafToTypes_obj {T : X → Type*} {U : (Opens X)ᵒᵖ} :
(presheafToTypes X T).obj U = ∀ x : U.unop, T x :=
rfl
@[simp] | theorem | Topology | [
"Mathlib.Topology.Sheaves.Presheaf"
] | Mathlib/Topology/Sheaves/PresheafOfFunctions.lean | presheafToTypes_obj | null |
presheafToTypes_map {T : X → Type*} {U V : (Opens X)ᵒᵖ} {i : U ⟶ V} {f} :
(presheafToTypes X T).map i f = fun x => f (i.unop x) :=
rfl | theorem | Topology | [
"Mathlib.Topology.Sheaves.Presheaf"
] | Mathlib/Topology/Sheaves/PresheafOfFunctions.lean | presheafToTypes_map | null |
presheafToType (T : Type*) : X.Presheaf (Type _) where
obj U := U.unop → T
map {_ _} i g := g ∘ i.unop
map_id U := by
ext g
rfl
map_comp {_ _ _} _ _ := rfl
@[simp] | def | Topology | [
"Mathlib.Topology.Sheaves.Presheaf"
] | Mathlib/Topology/Sheaves/PresheafOfFunctions.lean | presheafToType | The presheaf of functions on `X` with values in a type `T`.
There is no requirement that the functions are continuous, here. |
presheafToType_obj {T : Type*} {U : (Opens X)ᵒᵖ} :
(presheafToType X T).obj U = (U.unop → T) :=
rfl
@[simp] | theorem | Topology | [
"Mathlib.Topology.Sheaves.Presheaf"
] | Mathlib/Topology/Sheaves/PresheafOfFunctions.lean | presheafToType_obj | null |
presheafToType_map {T : Type*} {U V : (Opens X)ᵒᵖ} {i : U ⟶ V} {f} :
(presheafToType X T).map i f = f ∘ i.unop :=
rfl | theorem | Topology | [
"Mathlib.Topology.Sheaves.Presheaf"
] | Mathlib/Topology/Sheaves/PresheafOfFunctions.lean | presheafToType_map | null |
presheafToTop (T : TopCat) : X.Presheaf (Type _) :=
(Opens.toTopCat X).op ⋙ yoneda.obj T
@[simp] | def | Topology | [
"Mathlib.Topology.Sheaves.Presheaf"
] | Mathlib/Topology/Sheaves/PresheafOfFunctions.lean | presheafToTop | The presheaf of continuous functions on `X` with values in fixed target topological space
`T`. |
presheafToTop_obj (T : TopCat) (U : (Opens X)ᵒᵖ) :
(presheafToTop X T).obj U = ((Opens.toTopCat X).obj (unop U) ⟶ T) :=
rfl | theorem | Topology | [
"Mathlib.Topology.Sheaves.Presheaf"
] | Mathlib/Topology/Sheaves/PresheafOfFunctions.lean | presheafToTop_obj | null |
isSheaf_of_isTerminal_of_indiscrete {X : TopCat.{w}} (hind : X.str = ⊤) (F : Presheaf C X)
(it : IsTerminal <| F.obj <| op ⊥) : F.IsSheaf := fun c U s hs => by
obtain rfl | hne := eq_or_ne U ⊥
· intro _ _
rw [@existsUnique_iff_exists _ ⟨fun _ _ => _⟩]
· refine ⟨it.from _, fun U hU hs => IsTerminal.hom_e... | theorem | Topology | [
"Mathlib.Topology.Sheaves.SheafCondition.Sites"
] | Mathlib/Topology/Sheaves/PUnit.lean | isSheaf_of_isTerminal_of_indiscrete | null |
isSheaf_iff_isTerminal_of_indiscrete {X : TopCat.{w}} (hind : X.str = ⊤)
(F : Presheaf C X) : F.IsSheaf ↔ Nonempty (IsTerminal <| F.obj <| op ⊥) :=
⟨fun h => ⟨Sheaf.isTerminalOfEmpty ⟨F, h⟩⟩, fun ⟨it⟩ =>
isSheaf_of_isTerminal_of_indiscrete hind F it⟩ | theorem | Topology | [
"Mathlib.Topology.Sheaves.SheafCondition.Sites"
] | Mathlib/Topology/Sheaves/PUnit.lean | isSheaf_iff_isTerminal_of_indiscrete | null |
isSheaf_on_punit_of_isTerminal (F : Presheaf C (TopCat.of PUnit))
(it : IsTerminal <| F.obj <| op ⊥) : F.IsSheaf :=
isSheaf_of_isTerminal_of_indiscrete (@Subsingleton.elim (TopologicalSpace PUnit) _ _ _) F it | theorem | Topology | [
"Mathlib.Topology.Sheaves.SheafCondition.Sites"
] | Mathlib/Topology/Sheaves/PUnit.lean | isSheaf_on_punit_of_isTerminal | null |
isSheaf_on_punit_iff_isTerminal (F : Presheaf C (TopCat.of PUnit)) :
F.IsSheaf ↔ Nonempty (IsTerminal <| F.obj <| op ⊥) :=
⟨fun h => ⟨Sheaf.isTerminalOfEmpty ⟨F, h⟩⟩, fun ⟨it⟩ => isSheaf_on_punit_of_isTerminal F it⟩ | theorem | Topology | [
"Mathlib.Topology.Sheaves.SheafCondition.Sites"
] | Mathlib/Topology/Sheaves/PUnit.lean | isSheaf_on_punit_iff_isTerminal | null |
isSheaf_unit (F : Presheaf (CategoryTheory.Discrete Unit) X) : F.IsSheaf :=
fun x U S _ x _ => ⟨eqToHom (Subsingleton.elim _ _), by cat_disch, fun _ => by cat_disch⟩ | theorem | Topology | [
"Mathlib.Topology.Sheaves.Presheaf",
"Mathlib.CategoryTheory.Sites.Sheaf",
"Mathlib.CategoryTheory.Sites.Spaces"
] | Mathlib/Topology/Sheaves/Sheaf.lean | isSheaf_unit | The sheaf condition has several different equivalent formulations.
The official definition chosen here is in terms of Grothendieck topologies so that the results on
sites could be applied here easily, and this condition does not require additional constraints on
the value category.
The equivalent formulations of the sh... |
isSheaf_iso_iff {F G : Presheaf C X} (α : F ≅ G) : F.IsSheaf ↔ G.IsSheaf :=
Presheaf.isSheaf_of_iso_iff α | theorem | Topology | [
"Mathlib.Topology.Sheaves.Presheaf",
"Mathlib.CategoryTheory.Sites.Sheaf",
"Mathlib.CategoryTheory.Sites.Spaces"
] | Mathlib/Topology/Sheaves/Sheaf.lean | isSheaf_iso_iff | null |
isSheaf_of_iso {F G : Presheaf C X} (α : F ≅ G) (h : F.IsSheaf) : G.IsSheaf :=
(isSheaf_iso_iff α).1 h | theorem | Topology | [
"Mathlib.Topology.Sheaves.Presheaf",
"Mathlib.CategoryTheory.Sites.Sheaf",
"Mathlib.CategoryTheory.Sites.Spaces"
] | Mathlib/Topology/Sheaves/Sheaf.lean | isSheaf_of_iso | Transfer the sheaf condition across an isomorphism of presheaves. |
Sheaf.presheaf (F : X.Sheaf C) : TopCat.Presheaf C X :=
F.1
variable (C X) | abbrev | Topology | [
"Mathlib.Topology.Sheaves.Presheaf",
"Mathlib.CategoryTheory.Sites.Sheaf",
"Mathlib.CategoryTheory.Sites.Spaces"
] | Mathlib/Topology/Sheaves/Sheaf.lean | Sheaf.presheaf | A `TopCat.Sheaf C X` is a presheaf of objects from `C` over a (bundled) topological space `X`,
satisfying the sheaf condition.
-/
nonrec def Sheaf : Type max u v w :=
Sheaf (Opens.grothendieckTopology X) C
deriving Category
variable {C X}
/-- The underlying presheaf of a sheaf |
sheafInhabited : Inhabited (Sheaf (CategoryTheory.Discrete PUnit) X) :=
⟨⟨Functor.star _, Presheaf.isSheaf_unit _⟩⟩ | instance | Topology | [
"Mathlib.Topology.Sheaves.Presheaf",
"Mathlib.CategoryTheory.Sites.Sheaf",
"Mathlib.CategoryTheory.Sites.Spaces"
] | Mathlib/Topology/Sheaves/Sheaf.lean | sheafInhabited | null |
forget : TopCat.Sheaf C X ⥤ TopCat.Presheaf C X :=
sheafToPresheaf _ _ | def | Topology | [
"Mathlib.Topology.Sheaves.Presheaf",
"Mathlib.CategoryTheory.Sites.Sheaf",
"Mathlib.CategoryTheory.Sites.Spaces"
] | Mathlib/Topology/Sheaves/Sheaf.lean | forget | The forgetful functor from sheaves to presheaves. |
forget_full : (forget C X).Full where
map_surjective f := ⟨Sheaf.Hom.mk f, rfl⟩ | instance | Topology | [
"Mathlib.Topology.Sheaves.Presheaf",
"Mathlib.CategoryTheory.Sites.Sheaf",
"Mathlib.CategoryTheory.Sites.Spaces"
] | Mathlib/Topology/Sheaves/Sheaf.lean | forget_full | null |
forgetFaithful : (forget C X).Faithful where
map_injective := Sheaf.Hom.ext | instance | Topology | [
"Mathlib.Topology.Sheaves.Presheaf",
"Mathlib.CategoryTheory.Sites.Sheaf",
"Mathlib.CategoryTheory.Sites.Spaces"
] | Mathlib/Topology/Sheaves/Sheaf.lean | forgetFaithful | null |
id_app (F : Sheaf C X) (t) : (𝟙 F : F ⟶ F).1.app t = 𝟙 _ :=
rfl | theorem | Topology | [
"Mathlib.Topology.Sheaves.Presheaf",
"Mathlib.CategoryTheory.Sites.Sheaf",
"Mathlib.CategoryTheory.Sites.Spaces"
] | Mathlib/Topology/Sheaves/Sheaf.lean | id_app | null |
comp_app {F G H : Sheaf C X} (f : F ⟶ G) (g : G ⟶ H) (t) :
(f ≫ g).1.app t = f.1.app t ≫ g.1.app t :=
rfl | theorem | Topology | [
"Mathlib.Topology.Sheaves.Presheaf",
"Mathlib.CategoryTheory.Sites.Sheaf",
"Mathlib.CategoryTheory.Sites.Spaces"
] | Mathlib/Topology/Sheaves/Sheaf.lean | comp_app | null |
Presheaf.IsSheaf.section_ext {X : TopCat.{u}}
{A : Type*} [Category.{u} A] {FC : A → A → Type*} {CC : A → Type u}
[∀ X Y : A, FunLike (FC X Y) (CC X) (CC Y)] [ConcreteCategory.{u} A FC]
[HasLimits A] [PreservesLimits (forget A)] [(forget A).ReflectsIsomorphisms]
{F : TopCat.Presheaf A X} (hF : TopCat.Pr... | lemma | Topology | [
"Mathlib.Topology.Sheaves.Presheaf",
"Mathlib.CategoryTheory.Sites.Sheaf",
"Mathlib.CategoryTheory.Sites.Spaces"
] | Mathlib/Topology/Sheaves/Sheaf.lean | Presheaf.IsSheaf.section_ext | null |
isGerm : PrelocalPredicate fun x => F.stalk x where
pred {U} f := ∃ g : F.obj (op U), ∀ x : U, f x = F.germ U x.1 x.2 g
res := fun i _ ⟨g, p⟩ => ⟨F.map i.op g, fun x ↦ (p (i x)).trans (F.germ_res_apply i x x.2 g).symm⟩ | def | Topology | [
"Mathlib.Topology.Sheaves.LocalPredicate",
"Mathlib.Topology.Sheaves.Stalks"
] | Mathlib/Topology/Sheaves/Sheafify.lean | isGerm | The prelocal predicate on functions into the stalks, asserting that the function is equal to a germ. |
isLocallyGerm : LocalPredicate fun x => F.stalk x :=
(isGerm F).sheafify | def | Topology | [
"Mathlib.Topology.Sheaves.LocalPredicate",
"Mathlib.Topology.Sheaves.Stalks"
] | Mathlib/Topology/Sheaves/Sheafify.lean | isLocallyGerm | The local predicate on functions into the stalks,
asserting that the function is locally equal to a germ. |
sheafify : Sheaf (Type v) X :=
subsheafToTypes (Sheafify.isLocallyGerm F)
attribute [local instance] Types.instFunLike Types.instConcreteCategory in | def | Topology | [
"Mathlib.Topology.Sheaves.LocalPredicate",
"Mathlib.Topology.Sheaves.Stalks"
] | Mathlib/Topology/Sheaves/Sheafify.lean | sheafify | The sheafification of a `Type`-valued presheaf, defined as the functions into the stalks which
are locally equal to germs. |
toSheafify : F ⟶ F.sheafify.1 where
app U f := ⟨fun x => F.germ _ x x.2 f, PrelocalPredicate.sheafifyOf ⟨f, fun x => rfl⟩⟩
naturality U U' f := by
ext x
apply Subtype.ext -- Porting note (https://github.com/leanprover-community/mathlib4/issues/11041): Added `apply`
ext ⟨u, m⟩
exact germ_res_apply F ... | def | Topology | [
"Mathlib.Topology.Sheaves.LocalPredicate",
"Mathlib.Topology.Sheaves.Stalks"
] | Mathlib/Topology/Sheaves/Sheafify.lean | toSheafify | The morphism from a presheaf to its sheafification,
sending each section to its germs.
(This forms the unit of the adjunction.) |
stalkToFiber (x : X) : F.sheafify.presheaf.stalk x ⟶ F.stalk x :=
TopCat.stalkToFiber (Sheafify.isLocallyGerm F) x
attribute [local instance] Types.instFunLike Types.instConcreteCategory in | def | Topology | [
"Mathlib.Topology.Sheaves.LocalPredicate",
"Mathlib.Topology.Sheaves.Stalks"
] | Mathlib/Topology/Sheaves/Sheafify.lean | stalkToFiber | The natural morphism from the stalk of the sheafification to the original stalk.
In `sheafifyStalkIso` we show this is an isomorphism. |
stalkToFiber_surjective (x : X) : Function.Surjective (F.stalkToFiber x) := by
apply TopCat.stalkToFiber_surjective
intro t
obtain ⟨U, m, s, rfl⟩ := F.germ_exist _ t
use ⟨U, m⟩
fconstructor
· exact fun y => F.germ _ _ y.2 s
· exact ⟨PrelocalPredicate.sheafifyOf ⟨s, fun _ => rfl⟩, rfl⟩
attribute [local ins... | theorem | Topology | [
"Mathlib.Topology.Sheaves.LocalPredicate",
"Mathlib.Topology.Sheaves.Stalks"
] | Mathlib/Topology/Sheaves/Sheafify.lean | stalkToFiber_surjective | null |
stalkToFiber_injective (x : X) : Function.Injective (F.stalkToFiber x) := by
apply TopCat.stalkToFiber_injective
intro U V fU hU fV hV e
rcases hU ⟨x, U.2⟩ with ⟨U', mU, iU, gU, wU⟩
rcases hV ⟨x, V.2⟩ with ⟨V', mV, iV, gV, wV⟩
have wUx := wU ⟨x, mU⟩
dsimp at wUx; rw [wUx] at e; clear wUx
have wVx := wV ⟨x... | theorem | Topology | [
"Mathlib.Topology.Sheaves.LocalPredicate",
"Mathlib.Topology.Sheaves.Stalks"
] | Mathlib/Topology/Sheaves/Sheafify.lean | stalkToFiber_injective | null |
sheafifyStalkIso (x : X) : F.sheafify.presheaf.stalk x ≅ F.stalk x :=
(Equiv.ofBijective _ ⟨stalkToFiber_injective _ _, stalkToFiber_surjective _ _⟩).toIso | def | Topology | [
"Mathlib.Topology.Sheaves.LocalPredicate",
"Mathlib.Topology.Sheaves.Stalks"
] | Mathlib/Topology/Sheaves/Sheafify.lean | sheafifyStalkIso | The isomorphism between a stalk of the sheafification and the original stalk. |
toTypes_isSheaf (T : X → Type*) : (presheafToTypes X T).IsSheaf :=
isSheaf_of_isSheafUniqueGluing_types _ fun ι U sf hsf => by
choose index index_spec using fun x : ↑(iSup U) => Opens.mem_iSup.mp x.2
let s : ∀ x : ↑(iSup U), T x := fun x => sf (index x) ⟨x.1, index_spec x⟩
refine ⟨s, ?_, ?_⟩
· intro i... | theorem | Topology | [
"Mathlib.Topology.Sheaves.PresheafOfFunctions",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/SheafOfFunctions.lean | toTypes_isSheaf | We show that the presheaf of functions to a type `T`
(no continuity assumptions, just plain functions)
form a sheaf.
In fact, the proof is identical when we do this for dependent functions to a type family `T`,
so we do the more general case. |
toType_isSheaf (T : Type*) : (presheafToType X T).IsSheaf :=
toTypes_isSheaf X fun _ => T | theorem | Topology | [
"Mathlib.Topology.Sheaves.PresheafOfFunctions",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/SheafOfFunctions.lean | toType_isSheaf | The presheaf of not-necessarily-continuous functions to
a target type `T` satisfies the sheaf condition. |
sheafToTypes (T : X → Type*) : Sheaf (Type _) X :=
⟨presheafToTypes X T, Presheaf.toTypes_isSheaf _ _⟩ | def | Topology | [
"Mathlib.Topology.Sheaves.PresheafOfFunctions",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/SheafOfFunctions.lean | sheafToTypes | The sheaf of not-necessarily-continuous functions on `X` with values in type family
`T : X → Type u`. |
sheafToType (T : Type*) : Sheaf (Type _) X :=
⟨presheafToType X T, Presheaf.toType_isSheaf _ _⟩ | def | Topology | [
"Mathlib.Topology.Sheaves.PresheafOfFunctions",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/SheafOfFunctions.lean | sheafToType | The sheaf of not-necessarily-continuous functions on `X` with values in a type `T`. |
@[simps]
skyscraperPresheaf : Presheaf C X where
obj U := if p₀ ∈ unop U then A else terminal C
map {U V} i :=
if h : p₀ ∈ unop V then eqToHom <| by rw [if_pos h, if_pos (by simpa using i.unop.le h)]
else ((if_neg h).symm.ndrec terminalIsTerminal).from _
map_id U :=
(em (p₀ ∈ U.unop)).elim (fun h => d... | def | Topology | [
"Mathlib.Topology.Sheaves.PUnit",
"Mathlib.Topology.Sheaves.Stalks",
"Mathlib.Topology.Sheaves.Functors"
] | Mathlib/Topology/Sheaves/Skyscraper.lean | skyscraperPresheaf | 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. |
skyscraperPresheaf_eq_pushforward
[hd : ∀ U : Opens (TopCat.of PUnit.{u + 1}), Decidable (PUnit.unit ∈ U)] :
skyscraperPresheaf p₀ A =
(ofHom (ContinuousMap.const (TopCat.of PUnit) p₀)) _*
skyscraperPresheaf (X := TopCat.of PUnit) PUnit.unit A := by
convert_to @skyscraperPresheaf X p₀ (fun U => ... | theorem | Topology | [
"Mathlib.Topology.Sheaves.PUnit",
"Mathlib.Topology.Sheaves.Stalks",
"Mathlib.Topology.Sheaves.Functors"
] | Mathlib/Topology/Sheaves/Skyscraper.lean | skyscraperPresheaf_eq_pushforward | null |
@[simps]
SkyscraperPresheafFunctor.map' {a b : C} (f : a ⟶ b) :
skyscraperPresheaf p₀ a ⟶ skyscraperPresheaf p₀ b where
app U :=
if h : p₀ ∈ U.unop then eqToHom (if_pos h) ≫ f ≫ eqToHom (if_pos h).symm
else ((if_neg h).symm.ndrec terminalIsTerminal).from _
naturality U V i := by
simp only [skyscrape... | def | Topology | [
"Mathlib.Topology.Sheaves.PUnit",
"Mathlib.Topology.Sheaves.Stalks",
"Mathlib.Topology.Sheaves.Functors"
] | Mathlib/Topology/Sheaves/Skyscraper.lean | SkyscraperPresheafFunctor.map' | 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`. |
SkyscraperPresheafFunctor.map'_id {a : C} :
SkyscraperPresheafFunctor.map' p₀ (𝟙 a) = 𝟙 _ := by
ext U
simp only [SkyscraperPresheafFunctor.map'_app]; split_ifs <;> cat_disch | theorem | Topology | [
"Mathlib.Topology.Sheaves.PUnit",
"Mathlib.Topology.Sheaves.Stalks",
"Mathlib.Topology.Sheaves.Functors"
] | Mathlib/Topology/Sheaves/Skyscraper.lean | SkyscraperPresheafFunctor.map'_id | null |
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 := by
ext U
simp only [SkyscraperPresheafFunctor.map'_app]
split_ifs with h <;> cat_disch | theorem | Topology | [
"Mathlib.Topology.Sheaves.PUnit",
"Mathlib.Topology.Sheaves.Stalks",
"Mathlib.Topology.Sheaves.Functors"
] | Mathlib/Topology/Sheaves/Skyscraper.lean | SkyscraperPresheafFunctor.map'_comp | null |
@[simps]
skyscraperPresheafFunctor : C ⥤ Presheaf C X where
obj := skyscraperPresheaf p₀
map := SkyscraperPresheafFunctor.map' p₀
map_id _ := SkyscraperPresheafFunctor.map'_id p₀
map_comp := SkyscraperPresheafFunctor.map'_comp p₀ | def | Topology | [
"Mathlib.Topology.Sheaves.PUnit",
"Mathlib.Topology.Sheaves.Stalks",
"Mathlib.Topology.Sheaves.Functors"
] | Mathlib/Topology/Sheaves/Skyscraper.lean | skyscraperPresheafFunctor | 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]
skyscraperPresheafCoconeOfSpecializes {y : X} (h : p₀ ⤳ y) :
Cocone ((OpenNhds.inclusion y).op ⋙ skyscraperPresheaf p₀ A) where
pt := A
ι :=
{ app := fun U => eqToHom <| if_pos <| h.mem_open U.unop.1.2 U.unop.2
naturality := fun U V inc => by
change dite _ _ _ ≫ _ = _; rw [dif_pos]
... | def | Topology | [
"Mathlib.Topology.Sheaves.PUnit",
"Mathlib.Topology.Sheaves.Stalks",
"Mathlib.Topology.Sheaves.Functors"
] | Mathlib/Topology/Sheaves/Skyscraper.lean | skyscraperPresheafCoconeOfSpecializes | The cocone at `A` for the stalk functor of `skyscraperPresheaf p₀ A` when `y ∈ closure {p₀}` |
noncomputable skyscraperPresheafCoconeIsColimitOfSpecializes {y : X} (h : p₀ ⤳ y) :
IsColimit (skyscraperPresheafCoconeOfSpecializes p₀ A h) where
desc c := eqToHom (if_pos trivial).symm ≫ c.ι.app (op ⊤)
fac c U := by
dsimp
rw [← c.w (homOfLE <| (le_top : unop U ≤ _)).op]
change _ ≫ _ ≫ dite _ _ _ ≫... | def | Topology | [
"Mathlib.Topology.Sheaves.PUnit",
"Mathlib.Topology.Sheaves.Stalks",
"Mathlib.Topology.Sheaves.Functors"
] | Mathlib/Topology/Sheaves/Skyscraper.lean | skyscraperPresheafCoconeIsColimitOfSpecializes | The cocone at `A` for the stalk functor of `skyscraperPresheaf p₀ A` when `y ∈ closure {p₀}` is a
colimit |
noncomputable skyscraperPresheafStalkOfSpecializes [HasColimits C] {y : X} (h : p₀ ⤳ y) :
(skyscraperPresheaf p₀ A).stalk y ≅ A :=
colimit.isoColimitCocone ⟨_, skyscraperPresheafCoconeIsColimitOfSpecializes p₀ A h⟩
@[reassoc (attr := simp)] | def | Topology | [
"Mathlib.Topology.Sheaves.PUnit",
"Mathlib.Topology.Sheaves.Stalks",
"Mathlib.Topology.Sheaves.Functors"
] | Mathlib/Topology/Sheaves/Skyscraper.lean | skyscraperPresheafStalkOfSpecializes | If `y ∈ closure {p₀}`, then the stalk of `skyscraperPresheaf p₀ A` at `y` is `A`. |
germ_skyscraperPresheafStalkOfSpecializes_hom [HasColimits C] {y : X} (h : p₀ ⤳ y) (U hU) :
(skyscraperPresheaf p₀ A).germ U y hU ≫
(skyscraperPresheafStalkOfSpecializes p₀ A h).hom = eqToHom (if_pos (h.mem_open U.2 hU)) :=
colimit.isoColimitCocone_ι_hom _ _ | lemma | Topology | [
"Mathlib.Topology.Sheaves.PUnit",
"Mathlib.Topology.Sheaves.Stalks",
"Mathlib.Topology.Sheaves.Functors"
] | Mathlib/Topology/Sheaves/Skyscraper.lean | germ_skyscraperPresheafStalkOfSpecializes_hom | null |
@[simps]
skyscraperPresheafCocone (y : X) :
Cocone ((OpenNhds.inclusion y).op ⋙ skyscraperPresheaf p₀ A) where
pt := terminal C
ι :=
{ app := fun _ => terminal.from _
naturality := fun _ _ _ => terminalIsTerminal.hom_ext _ _ } | def | Topology | [
"Mathlib.Topology.Sheaves.PUnit",
"Mathlib.Topology.Sheaves.Stalks",
"Mathlib.Topology.Sheaves.Functors"
] | Mathlib/Topology/Sheaves/Skyscraper.lean | skyscraperPresheafCocone | The cocone at `*` for the stalk functor of `skyscraperPresheaf p₀ A` when `y ∉ closure {p₀}` |
noncomputable skyscraperPresheafCoconeIsColimitOfNotSpecializes {y : X} (h : ¬p₀ ⤳ y) :
IsColimit (skyscraperPresheafCocone p₀ A y) :=
let h1 : ∃ U : OpenNhds y, p₀ ∉ U.1 :=
let ⟨U, ho, h₀, hy⟩ := not_specializes_iff_exists_open.mp h
⟨⟨⟨U, ho⟩, h₀⟩, hy⟩
{ desc := fun c => eqToHom (if_neg h1.choose_spec)... | def | Topology | [
"Mathlib.Topology.Sheaves.PUnit",
"Mathlib.Topology.Sheaves.Stalks",
"Mathlib.Topology.Sheaves.Functors"
] | Mathlib/Topology/Sheaves/Skyscraper.lean | skyscraperPresheafCoconeIsColimitOfNotSpecializes | The cocone at `*` for the stalk functor of `skyscraperPresheaf p₀ A` when `y ∉ closure {p₀}` is a
colimit |
noncomputable skyscraperPresheafStalkOfNotSpecializes [HasColimits C] {y : X} (h : ¬p₀ ⤳ y) :
(skyscraperPresheaf p₀ A).stalk y ≅ terminal C :=
colimit.isoColimitCocone ⟨_, skyscraperPresheafCoconeIsColimitOfNotSpecializes _ A h⟩ | def | Topology | [
"Mathlib.Topology.Sheaves.PUnit",
"Mathlib.Topology.Sheaves.Stalks",
"Mathlib.Topology.Sheaves.Functors"
] | Mathlib/Topology/Sheaves/Skyscraper.lean | skyscraperPresheafStalkOfNotSpecializes | If `y ∉ closure {p₀}`, then the stalk of `skyscraperPresheaf p₀ A` at `y` is isomorphic to a
terminal object. |
skyscraperPresheafStalkOfNotSpecializesIsTerminal [HasColimits C] {y : X} (h : ¬p₀ ⤳ y) :
IsTerminal ((skyscraperPresheaf p₀ A).stalk y) :=
IsTerminal.ofIso terminalIsTerminal <| (skyscraperPresheafStalkOfNotSpecializes _ _ h).symm | def | Topology | [
"Mathlib.Topology.Sheaves.PUnit",
"Mathlib.Topology.Sheaves.Stalks",
"Mathlib.Topology.Sheaves.Functors"
] | Mathlib/Topology/Sheaves/Skyscraper.lean | skyscraperPresheafStalkOfNotSpecializesIsTerminal | If `y ∉ closure {p₀}`, then the stalk of `skyscraperPresheaf p₀ A` at `y` is a terminal object |
skyscraperPresheaf_isSheaf : (skyscraperPresheaf p₀ A).IsSheaf := by
classical exact
(Presheaf.isSheaf_iso_iff (eqToIso <| skyscraperPresheaf_eq_pushforward p₀ A)).mpr <|
(Sheaf.pushforward_sheaf_of_sheaf _
(Presheaf.isSheaf_on_punit_of_isTerminal _ (by
dsimp [skyscraperPresheaf]
... | theorem | Topology | [
"Mathlib.Topology.Sheaves.PUnit",
"Mathlib.Topology.Sheaves.Stalks",
"Mathlib.Topology.Sheaves.Functors"
] | Mathlib/Topology/Sheaves/Skyscraper.lean | skyscraperPresheaf_isSheaf | null |
skyscraperSheaf : Sheaf C X :=
⟨skyscraperPresheaf p₀ A, skyscraperPresheaf_isSheaf _ _⟩ | def | Topology | [
"Mathlib.Topology.Sheaves.PUnit",
"Mathlib.Topology.Sheaves.Stalks",
"Mathlib.Topology.Sheaves.Functors"
] | Mathlib/Topology/Sheaves/Skyscraper.lean | skyscraperSheaf | 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. |
skyscraperSheafFunctor : C ⥤ Sheaf C X where
obj c := skyscraperSheaf p₀ c
map f := Sheaf.Hom.mk <| (skyscraperPresheafFunctor p₀).map f
map_id _ := Sheaf.Hom.ext <| (skyscraperPresheafFunctor p₀).map_id _
map_comp _ _ := Sheaf.Hom.ext <| (skyscraperPresheafFunctor p₀).map_comp _ _ | def | Topology | [
"Mathlib.Topology.Sheaves.PUnit",
"Mathlib.Topology.Sheaves.Stalks",
"Mathlib.Topology.Sheaves.Functors"
] | Mathlib/Topology/Sheaves/Skyscraper.lean | skyscraperSheafFunctor | 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`. |
@[simps]
toSkyscraperPresheaf {𝓕 : Presheaf C X} {c : C} (f : 𝓕.stalk p₀ ⟶ c) :
𝓕 ⟶ skyscraperPresheaf p₀ c where
app U :=
if h : p₀ ∈ U.unop then 𝓕.germ _ p₀ h ≫ f ≫ eqToHom (if_pos h).symm
else ((if_neg h).symm.ndrec terminalIsTerminal).from _
naturality U V inc := by
dsimp
by_cases hV : p... | def | Topology | [
"Mathlib.Topology.Sheaves.PUnit",
"Mathlib.Topology.Sheaves.Stalks",
"Mathlib.Topology.Sheaves.Functors"
] | Mathlib/Topology/Sheaves/Skyscraper.lean | toSkyscraperPresheaf | 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`. |
fromStalk {𝓕 : Presheaf C X} {c : C} (f : 𝓕 ⟶ skyscraperPresheaf p₀ c) : 𝓕.stalk p₀ ⟶ c :=
let χ : Cocone ((OpenNhds.inclusion p₀).op ⋙ 𝓕) :=
Cocone.mk c <|
{ app := fun U => f.app ((OpenNhds.inclusion p₀).op.obj U) ≫ eqToHom (if_pos U.unop.2)
naturality := fun U V inc => by
dsimp only... | def | Topology | [
"Mathlib.Topology.Sheaves.PUnit",
"Mathlib.Topology.Sheaves.Stalks",
"Mathlib.Topology.Sheaves.Functors"
] | Mathlib/Topology/Sheaves/Skyscraper.lean | fromStalk | 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`. |
germ_fromStalk {𝓕 : Presheaf C X} {c : C} (f : 𝓕 ⟶ skyscraperPresheaf p₀ c) (U) (hU) :
𝓕.germ U p₀ hU ≫ fromStalk p₀ f = f.app (op U) ≫ eqToHom (if_pos hU) :=
colimit.ι_desc _ _ | lemma | Topology | [
"Mathlib.Topology.Sheaves.PUnit",
"Mathlib.Topology.Sheaves.Stalks",
"Mathlib.Topology.Sheaves.Functors"
] | Mathlib/Topology/Sheaves/Skyscraper.lean | germ_fromStalk | null |
to_skyscraper_fromStalk {𝓕 : Presheaf C X} {c : C} (f : 𝓕 ⟶ skyscraperPresheaf p₀ c) :
toSkyscraperPresheaf p₀ (fromStalk _ f) = f := by
apply NatTrans.ext
ext U
dsimp
split_ifs with h
· rw [← Category.assoc, germ_fromStalk, Category.assoc, eqToHom_trans, eqToHom_refl,
Category.comp_id]
· exact ... | theorem | Topology | [
"Mathlib.Topology.Sheaves.PUnit",
"Mathlib.Topology.Sheaves.Stalks",
"Mathlib.Topology.Sheaves.Functors"
] | Mathlib/Topology/Sheaves/Skyscraper.lean | to_skyscraper_fromStalk | null |
fromStalk_to_skyscraper {𝓕 : Presheaf C X} {c : C} (f : 𝓕.stalk p₀ ⟶ c) :
fromStalk p₀ (toSkyscraperPresheaf _ f) = f := by
refine 𝓕.stalk_hom_ext fun U hxU ↦ ?_
rw [germ_fromStalk, toSkyscraperPresheaf_app, dif_pos hxU, Category.assoc, Category.assoc,
eqToHom_trans, eqToHom_refl, Category.comp_id, Presh... | theorem | Topology | [
"Mathlib.Topology.Sheaves.PUnit",
"Mathlib.Topology.Sheaves.Stalks",
"Mathlib.Topology.Sheaves.Functors"
] | Mathlib/Topology/Sheaves/Skyscraper.lean | fromStalk_to_skyscraper | null |
@[simps]
protected unit :
𝟭 (Presheaf C X) ⟶ Presheaf.stalkFunctor C p₀ ⋙ skyscraperPresheafFunctor p₀ where
app _ := toSkyscraperPresheaf _ <| 𝟙 _
naturality 𝓕 𝓖 f := by
ext U; dsimp
split_ifs with h
· simp only [Category.id_comp, Category.assoc, eqToHom_trans_assoc, eqToHom_refl,
Presh... | def | Topology | [
"Mathlib.Topology.Sheaves.PUnit",
"Mathlib.Topology.Sheaves.Stalks",
"Mathlib.Topology.Sheaves.Functors"
] | Mathlib/Topology/Sheaves/Skyscraper.lean | unit | The unit in `Presheaf.stalkFunctor ⊣ skyscraperPresheafFunctor` |
@[simps]
protected counit :
skyscraperPresheafFunctor p₀ ⋙ (Presheaf.stalkFunctor C p₀ : Presheaf C X ⥤ C) ⟶ 𝟭 C where
app c := (skyscraperPresheafStalkOfSpecializes p₀ c specializes_rfl).hom
naturality x y f := TopCat.Presheaf.stalk_hom_ext _ fun U hxU ↦ by simp [hxU] | def | Topology | [
"Mathlib.Topology.Sheaves.PUnit",
"Mathlib.Topology.Sheaves.Stalks",
"Mathlib.Topology.Sheaves.Functors"
] | Mathlib/Topology/Sheaves/Skyscraper.lean | counit | The counit in `Presheaf.stalkFunctor ⊣ skyscraperPresheafFunctor` |
skyscraperPresheafStalkAdjunction [HasColimits C] :
(Presheaf.stalkFunctor C p₀ : Presheaf C X ⥤ C) ⊣ skyscraperPresheafFunctor p₀ where
unit := StalkSkyscraperPresheafAdjunctionAuxs.unit _
counit := StalkSkyscraperPresheafAdjunctionAuxs.counit _
left_triangle_components X := by
dsimp [Presheaf.stalkFunct... | def | Topology | [
"Mathlib.Topology.Sheaves.PUnit",
"Mathlib.Topology.Sheaves.Stalks",
"Mathlib.Topology.Sheaves.Functors"
] | Mathlib/Topology/Sheaves/Skyscraper.lean | skyscraperPresheafStalkAdjunction | `skyscraperPresheafFunctor` is the right adjoint of `Presheaf.stalkFunctor` |
stalkSkyscraperSheafAdjunction [HasColimits C] :
Sheaf.forget C X ⋙ Presheaf.stalkFunctor _ p₀ ⊣ skyscraperSheafFunctor p₀ where
unit :=
{ app := fun 𝓕 => ⟨(StalkSkyscraperPresheafAdjunctionAuxs.unit p₀).app 𝓕.1⟩
naturality := fun 𝓐 𝓑 f => Sheaf.Hom.ext <| by
apply (StalkSkyscraperPresheafAd... | def | Topology | [
"Mathlib.Topology.Sheaves.PUnit",
"Mathlib.Topology.Sheaves.Stalks",
"Mathlib.Topology.Sheaves.Functors"
] | Mathlib/Topology/Sheaves/Skyscraper.lean | stalkSkyscraperSheafAdjunction | Taking stalks of a sheaf is the left adjoint functor to `skyscraperSheafFunctor` |
stalkFunctor (x : X) : X.Presheaf C ⥤ C :=
(whiskeringLeft _ _ C).obj (OpenNhds.inclusion x).op ⋙ colim | def | Topology | [
"Mathlib.Topology.Category.TopCat.OpenNhds",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/Stalks.lean | stalkFunctor | Stalks are functorial with respect to morphisms of presheaves over a fixed `X`. |
stalk (ℱ : X.Presheaf C) (x : X) : C :=
(stalkFunctor C x).obj ℱ
@[simp] | def | Topology | [
"Mathlib.Topology.Category.TopCat.OpenNhds",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/Stalks.lean | stalk | The stalk of a presheaf `F` at a point `x` is calculated as the colimit of the functor
nbhds x ⥤ opens F.X ⥤ C |
stalkFunctor_obj (ℱ : X.Presheaf C) (x : X) : (stalkFunctor C x).obj ℱ = ℱ.stalk x :=
rfl | theorem | Topology | [
"Mathlib.Topology.Category.TopCat.OpenNhds",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/Stalks.lean | stalkFunctor_obj | null |
germ (F : X.Presheaf C) (U : Opens X) (x : X) (hx : x ∈ U) : F.obj (op U) ⟶ stalk F x :=
colimit.ι ((OpenNhds.inclusion x).op ⋙ F) (op ⟨U, hx⟩) | def | Topology | [
"Mathlib.Topology.Category.TopCat.OpenNhds",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/Stalks.lean | germ | The germ of a section of a presheaf over an open at a point of that open. |
Γgerm (F : X.Presheaf C) (x : X) : F.obj (op ⊤) ⟶ stalk F x :=
F.germ ⊤ x True.intro
@[reassoc] | def | Topology | [
"Mathlib.Topology.Category.TopCat.OpenNhds",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/Stalks.lean | Γgerm | The germ of a global section of a presheaf at a point. |
germ_res (F : X.Presheaf C) {U V : Opens X} (i : U ⟶ V) (x : X) (hx : x ∈ U) :
F.map i.op ≫ F.germ U x hx = F.germ V x (i.le hx) :=
let i' : (⟨U, hx⟩ : OpenNhds x) ⟶ ⟨V, i.le hx⟩ := i
colimit.w ((OpenNhds.inclusion x).op ⋙ F) i'.op | theorem | Topology | [
"Mathlib.Topology.Category.TopCat.OpenNhds",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/Stalks.lean | germ_res | null |
@[reassoc (attr := simp)]
germ_res' (F : X.Presheaf C) {U V : Opens X} (i : op V ⟶ op U) (x : X) (hx : x ∈ U) :
F.map i ≫ F.germ U x hx = F.germ V x (i.unop.le hx) :=
let i' : (⟨U, hx⟩ : OpenNhds x) ⟶ ⟨V, i.unop.le hx⟩ := i.unop
colimit.w ((OpenNhds.inclusion x).op ⋙ F) i'.op
@[reassoc] | theorem | Topology | [
"Mathlib.Topology.Category.TopCat.OpenNhds",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/Stalks.lean | germ_res' | A variant of `germ_res` with `op V ⟶ op U`
so that the LHS is more general and simp fires more easier. |
map_germ_eq_Γgerm (F : X.Presheaf C) {U : Opens X} {i : U ⟶ ⊤} (x : X) (hx : x ∈ U) :
F.map i.op ≫ F.germ U x hx = F.Γgerm x :=
germ_res F i x hx
variable {FC : C → C → Type*} {CC : C → Type*} [∀ X Y, FunLike (FC X Y) (CC X) (CC Y)] | lemma | Topology | [
"Mathlib.Topology.Category.TopCat.OpenNhds",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/Stalks.lean | map_germ_eq_Γgerm | null |
germ_res_apply (F : X.Presheaf C)
{U V : Opens X} (i : U ⟶ V) (x : X) (hx : x ∈ U) [ConcreteCategory C FC] (s) :
F.germ U x hx (F.map i.op s) = F.germ V x (i.le hx) s := by
rw [← ConcreteCategory.comp_apply, germ_res] | theorem | Topology | [
"Mathlib.Topology.Category.TopCat.OpenNhds",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/Stalks.lean | germ_res_apply | null |
germ_res_apply' (F : X.Presheaf C)
{U V : Opens X} (i : op V ⟶ op U) (x : X) (hx : x ∈ U) [ConcreteCategory C FC] (s) :
F.germ U x hx (F.map i s) = F.germ V x (i.unop.le hx) s := by
rw [← ConcreteCategory.comp_apply, germ_res'] | theorem | Topology | [
"Mathlib.Topology.Category.TopCat.OpenNhds",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/Stalks.lean | germ_res_apply' | null |
Γgerm_res_apply (F : X.Presheaf C)
{U : Opens X} {i : U ⟶ ⊤} (x : X) (hx : x ∈ U) [ConcreteCategory C FC] (s) :
F.germ U x hx (F.map i.op s) = F.Γgerm x s :=
F.germ_res_apply i x hx s | lemma | Topology | [
"Mathlib.Topology.Category.TopCat.OpenNhds",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/Stalks.lean | Γgerm_res_apply | null |
@[ext]
stalk_hom_ext (F : X.Presheaf C) {x} {Y : C} {f₁ f₂ : F.stalk x ⟶ Y}
(ih : ∀ (U : Opens X) (hxU : x ∈ U), F.germ U x hxU ≫ f₁ = F.germ U x hxU ≫ f₂) : f₁ = f₂ :=
colimit.hom_ext fun U => by
induction U with | op U => obtain ⟨U, hxU⟩ := U; exact ih U hxU
@[reassoc (attr := simp)] | theorem | Topology | [
"Mathlib.Topology.Category.TopCat.OpenNhds",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/Stalks.lean | stalk_hom_ext | A morphism from the stalk of `F` at `x` to some object `Y` is completely determined by its
composition with the `germ` morphisms. |
stalkFunctor_map_germ {F G : X.Presheaf C} (U : Opens X) (x : X) (hx : x ∈ U) (f : F ⟶ G) :
F.germ U x hx ≫ (stalkFunctor C x).map f = f.app (op U) ≫ G.germ U x hx :=
colimit.ι_map (whiskerLeft (OpenNhds.inclusion x).op f) (op ⟨U, hx⟩) | theorem | Topology | [
"Mathlib.Topology.Category.TopCat.OpenNhds",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/Stalks.lean | stalkFunctor_map_germ | null |
stalkFunctor_map_germ_apply [ConcreteCategory C FC]
{F G : X.Presheaf C} (U : Opens X) (x : X) (hx : x ∈ U) (f : F ⟶ G) (s) :
(stalkFunctor C x).map f (F.germ U x hx s) = G.germ U x hx (f.app (op U) s) := by
rw [← ConcreteCategory.comp_apply, ← stalkFunctor_map_germ, ConcreteCategory.comp_apply]
rfl
@[simp] | theorem | Topology | [
"Mathlib.Topology.Category.TopCat.OpenNhds",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/Stalks.lean | stalkFunctor_map_germ_apply | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.