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 relations among subsets (copied from `aesop cat`) -/
macro (name := restrict_tac) "restrict_tac" c:Aesop.tactic_clause* : tactic =>
`(tactic| first | assumption |
aesop $c*
(config := { terminal := true
assumptionTransparency := .reducible
enableSimp := false })
(rule_sets := [-default, -builtin, $(Lean.mkIdent `Restrict):ident]))
/-- `restrict_tac?` passes along `Try this` from `aesop` -/
macro (name := restrict_tac?) "restrict_tac?" c:Aesop.tactic_clause* : tactic =>
`(tactic|
aesop? $c*
(config := { terminal := true
assumptionTransparency := .reducible
enableSimp := false
maxRuleApplications := 300 })
(rule_sets := [-default, -builtin, $(Lean.mkIdent `Restrict):ident]))
attribute[aesop 10% (rule_sets := [Restrict])] le_trans
attribute[aesop safe destruct (rule_sets := [Restrict])] Eq.trans_le
attribute[aesop safe -50 (rule_sets := [Restrict])] Aesop.BuiltinRules.assumption
example {X} [CompleteLattice X] (v : Nat → X) (w x y z : X) (e : v 0 = v 1) (_ : v 1 = v 2)
(h₀ : v 1 ≤ x) (_ : x ≤ z ⊓ w) (h₂ : x ≤ y ⊓ z) : v 0 ≤ y := by
restrict_tac
variable {X : TopCat} {C : Type*} [Category C] {FC : C → C → Type*} {CC : C → Type*}
variable [∀ X Y, FunLike (FC X Y) (CC X) (CC Y)] [ConcreteCategory C FC]
/-- The restriction of a section along an inclusion of open sets.
For `x : F.obj (op V)`, we provide the notation `x |_ₕ i` (`h` stands for `hom`) for `i : U ⟶ V`,
and the notation `x |_ₗ U ⟪i⟫` (`l` stands for `le`) for `i : U ≤ V`. |
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)
open AlgebraicGeometry
/-- The restriction of a section along an inclusion of open sets.
For `x : F.obj (op V)`, we provide the notation `x |_ U`, where the proof `U ≤ V` is inferred by
the tactic `Top.presheaf.restrict_tac'` |
@[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 [← ConcreteCategory.comp_apply, ← Functor.map_comp]
rfl
theorem map_restrict
{F G : X.Presheaf C} (e : F ⟶ G) {U V : Opens X} (h : U ≤ V) (x : ToType (F.obj (op V))) :
e.app _ (x |_ U) = e.app _ x |_ U := by
delta restrictOpen restrict
rw [← ConcreteCategory.comp_apply, NatTrans.naturality, ConcreteCategory.comp_apply]
open CategoryTheory.Limits
variable (C)
/-- The pushforward functor. |
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 f).obj U.unop) :=
rfl
lemma id_pushforward (X : TopCat.{w}) : pushforward C (𝟙 X) = 𝟭 (X.Presheaf C) := rfl
variable {C}
namespace Pushforward
/-- The natural isomorphism between the pushforward of a presheaf along the identity continuous map
and the original presheaf. |
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 [toPushforwardOfIso, Adjunction.homEquiv_unit] | 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 [pushforwardToOfIso, Equivalence.toAdjunction, Adjunction.homEquiv_counit] | 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.image_preimage.le_u_l _)).op
have hx : IsTerminal x :=
{ lift := fun s ↦ by
fapply CostructuredArrow.homMk
· change op (unop _) ⟶ op (⟨_, H⟩ : Opens _)
refine (homOfLE ?_).op
apply (Set.image_mono s.pt.hom.unop.le).trans
exact Set.image_preimage.l_u_le (SetLike.coe s.pt.left.unop)
· simp [eq_iff_true_of_subsingleton] }
exact IsColimit.coconePointUniqueUpToIso
((Opens.map f).op.isPointwiseLeftKanExtensionLeftKanExtensionUnit ℱ (op U))
(colimitOfDiagramTerminal hx _) | 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_ext ?_ _ _⟩
rwa [le_bot_iff.1 hU.le]
· apply it.hom_ext
· convert Presieve.isSheafFor_top_sieve (F ⋙ coyoneda.obj (@op C c))
rw [← Sieve.id_mem_iff_eq_top]
have := (U.eq_bot_or_top hind).resolve_left hne
subst this
obtain he | ⟨⟨x⟩⟩ := isEmpty_or_nonempty X
· exact (hne <| SetLike.ext'_iff.2 <| Set.univ_eq_empty_iff.2 he).elim
obtain ⟨U, f, hf, hm⟩ := hs x _root_.trivial
obtain rfl | rfl := U.eq_bot_or_top hind
· cases hm
· convert hf | 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 sheaf condition on `presheaf C X` are as follows :
1. `TopCat.Presheaf.IsSheaf`: (the official definition)
It is a sheaf with respect to the Grothendieck topology on `opens X`, which is to say:
For each open cover `{ Uᵢ }` of `U`, and a family of compatible functions `A ⟶ F(Uᵢ)` for an
`A : X`, there exists a unique gluing `A ⟶ F(U)` compatible with the restriction.
2. `TopCat.Presheaf.IsSheafEqualizerProducts`: (requires `C` to have all products)
For each open cover `{ Uᵢ }` of `U`, `F(U) ⟶ ∏ᶜ F(Uᵢ)` is the equalizer of the two morphisms
`∏ᶜ F(Uᵢ) ⟶ ∏ᶜ F(Uᵢ ∩ Uⱼ)`.
See `TopCat.Presheaf.isSheaf_iff_isSheafEqualizerProducts`.
3. `TopCat.Presheaf.IsSheafOpensLeCover`:
For each open cover `{ Uᵢ }` of `U`, `F(U)` is the limit of the diagram consisting of arrows
`F(V₁) ⟶ F(V₂)` for every pair of open sets `V₁ ⊇ V₂` that are contained in some `Uᵢ`.
See `TopCat.Presheaf.isSheaf_iff_isSheafOpensLeCover`.
4. `TopCat.Presheaf.IsSheafPairwiseIntersections`:
For each open cover `{ Uᵢ }` of `U`, `F(U)` is the limit of the diagram consisting of arrows
from `F(Uᵢ)` and `F(Uⱼ)` to `F(Uᵢ ∩ Uⱼ)` for each pair `(i, j)`.
See `TopCat.Presheaf.isSheaf_iff_isSheafPairwiseIntersections`.
The following requires `C` to be concrete and complete, and `forget C` to reflect isomorphisms and
preserve limits. This applies to most "algebraic" categories, e.g. groups, abelian groups and rings.
5. `TopCat.Presheaf.IsSheafUniqueGluing`:
(requires `C` to be concrete and complete; `forget C` to reflect isomorphisms and preserve limits)
For each open cover `{ Uᵢ }` of `U`, and a compatible family of elements `x : F(Uᵢ)`, there exists
a unique gluing `x : F(U)` that restricts to the given elements.
See `TopCat.Presheaf.isSheaf_iff_isSheafUniqueGluing`.
6. The underlying sheaf of types is a sheaf.
See `TopCat.Presheaf.isSheaf_iff_isSheaf_comp` and
`CategoryTheory.Presheaf.isSheaf_iff_isSheaf_forget`.
-/
nonrec def IsSheaf (F : Presheaf.{w, v, u} C X) : Prop :=
Presheaf.IsSheaf (Opens.grothendieckTopology X) F
/-- The presheaf valued in `Unit` over any topological space is a sheaf. |
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.Presheaf.IsSheaf F)
{U : (Opens X)ᵒᵖ} {s t : ToType (F.obj U)}
(hst : ∀ x ∈ U.unop, ∃ V, ∃ hV : V ≤ U.unop, x ∈ V ∧
F.map (homOfLE hV).op s = F.map (homOfLE hV).op t) :
s = t := by
have := (isSheaf_iff_isSheaf_of_type _ _).mp
((Presheaf.isSheaf_iff_isSheaf_forget (C := Opens X) (A' := A) _ F (forget _)).mp hF)
choose V hV hxV H using fun x : U.unop ↦ hst x.1 x.2
refine (this.isSheafFor _ (.ofArrows V fun x ↦ homOfLE (hV x)) ?_).isSeparatedFor.ext ?_
· exact fun x hx ↦ ⟨V ⟨x, hx⟩, homOfLE (hV _), Sieve.le_generate _ _ (.mk _), hxV _⟩
· rintro _ _ ⟨x⟩; exact H x | 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 f.unop u m x | 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 instance] Types.instFunLike Types.instConcreteCategory in | 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, mV⟩
dsimp at wVx; rw [wVx] at e; clear wVx
rcases F.germ_eq x mU mV gU gV e with ⟨W, mW, iU', iV', (e' : F.map iU'.op gU = F.map iV'.op gV)⟩
use ⟨W ⊓ (U' ⊓ V'), ⟨mW, mU, mV⟩⟩
refine ⟨?_, ?_, ?_⟩
· change W ⊓ (U' ⊓ V') ⟶ U.obj
exact Opens.infLERight _ _ ≫ Opens.infLELeft _ _ ≫ iU
· change W ⊓ (U' ⊓ V') ⟶ V.obj
exact Opens.infLERight _ _ ≫ Opens.infLERight _ _ ≫ iV
· intro w
specialize wU ⟨w.1, w.2.2.1⟩
specialize wV ⟨w.1, w.2.2.2⟩
refine wU.trans <| .trans ?_ wV.symm
rw [← F.germ_res iU' w w.2.1, ← F.germ_res iV' w w.2.1,
CategoryTheory.types_comp_apply, CategoryTheory.types_comp_apply, e'] | 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
funext x
exact congr_fun (hsf (index ⟨x, _⟩) i) ⟨x, ⟨index_spec ⟨x.1, _⟩, x.2⟩⟩
· -- Now we just need to check that the lift we picked was the only possible one.
intro t ht
funext x
exact congr_fun (ht (index x)) ⟨x.1, index_spec x⟩ | 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 => dif_pos h) fun h =>
((if_neg h).symm.ndrec terminalIsTerminal).hom_ext _ _
map_comp {U V W} iVU iWV := by
by_cases hW : p₀ ∈ unop W
· have hV : p₀ ∈ unop V := leOfHom iWV.unop hW
simp only [dif_pos hW, dif_pos hV, eqToHom_trans]
· dsimp; rw [dif_neg hW]; apply ((if_neg hW).symm.ndrec terminalIsTerminal).hom_ext | 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 => hd <| (Opens.map <| ofHom <|
ContinuousMap.const _ p₀).obj U)
C _ _ A = _ <;> congr | 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 [skyscraperPresheaf_map]
by_cases hV : p₀ ∈ V.unop
· have hU : p₀ ∈ U.unop := leOfHom i.unop hV
simp only [skyscraperPresheaf_obj, hU, hV, ↓reduceDIte, eqToHom_trans_assoc, Category.assoc,
eqToHom_trans]
· apply ((if_neg hV).symm.ndrec terminalIsTerminal).hom_ext | 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]
swap
· exact h.mem_open V.unop.1.2 V.unop.2
· simp only [Functor.comp_obj, Functor.op_obj, skyscraperPresheaf_obj, unop_op,
Functor.const_obj_obj, eqToHom_trans, Functor.const_obj_map, Category.comp_id] } | 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 _ _ _ ≫ _ = _
rw [dif_pos]
· simp only [eqToHom_trans_assoc,
eqToHom_refl, Category.id_comp, op_unop]
· exact h.mem_open U.unop.1.2 U.unop.2
uniq c f h := by
dsimp
rw [← h, skyscraperPresheafCoconeOfSpecializes_ι_app, eqToHom_trans_assoc, eqToHom_refl,
Category.id_comp] | 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).symm ≫ c.ι.app (op h1.choose)
fac := fun c U => by
change _ = c.ι.app (op U.unop)
simp only [← c.w (homOfLE <| @inf_le_left _ _ h1.choose U.unop).op, ←
c.w (homOfLE <| @inf_le_right _ _ h1.choose U.unop).op, ← Category.assoc]
congr 1
refine ((if_neg ?_).symm.ndrec terminalIsTerminal).hom_ext _ _
exact fun h => h1.choose_spec h.1
uniq := fun c f H => by
dsimp
rw [← Category.id_comp f, ← H, ← Category.assoc]
congr 1; apply terminalIsTerminal.hom_ext } | 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]
rw [if_neg]
· exact terminalIsTerminal
· #adaptation_note /-- 2024-03-24
Previously the universe annotation was not needed here. -/
exact Set.notMem_empty PUnit.unit.{u + 1}))) | 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₀ ∈ V.unop
· have hU : p₀ ∈ U.unop := leOfHom inc.unop hV
split_ifs
rw [← Category.assoc, 𝓕.germ_res' inc, Category.assoc, Category.assoc, eqToHom_trans]
· split_ifs
exact ((if_neg hV).symm.ndrec terminalIsTerminal).hom_ext .. | 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 [Functor.const_obj_map, Functor.const_obj_obj, Functor.comp_map,
Functor.comp_obj, Functor.op_obj, skyscraperPresheaf_obj]
rw [Category.comp_id, ← Category.assoc, comp_eqToHom_iff, Category.assoc,
eqToHom_trans, f.naturality, skyscraperPresheaf_map]
have hV : p₀ ∈ (OpenNhds.inclusion p₀).obj V.unop := V.unop.2
simp only [dif_pos hV] }
colimit.desc _ χ
@[reassoc (attr := simp)] | 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 ((if_neg h).symm.ndrec terminalIsTerminal).hom_ext .. | 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, Presheaf.germ] | 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,
Presheaf.stalkFunctor_map_germ_assoc, Presheaf.stalkFunctor_obj]
· apply ((if_neg h).symm.ndrec terminalIsTerminal).hom_ext | 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.stalkFunctor, toSkyscraperPresheaf]
ext
simp only [Functor.comp_obj, Functor.op_obj, ι_colimMap_assoc, skyscraperPresheaf_obj,
Functor.whiskerLeft_app, Category.comp_id]
split_ifs with h
· simp [skyscraperPresheafStalkOfSpecializes]
rfl
· simp only [skyscraperPresheafStalkOfSpecializes, colimit.isoColimitCocone_ι_hom,
skyscraperPresheafCoconeOfSpecializes_pt, skyscraperPresheafCoconeOfSpecializes_ι_app,
Functor.comp_obj, Functor.op_obj, skyscraperPresheaf_obj, Functor.const_obj_obj]
rw [comp_eqToHom_iff]
apply ((if_neg h).symm.ndrec terminalIsTerminal).hom_ext
right_triangle_components Y := by
ext
simp only [skyscraperPresheafFunctor_obj, Functor.id_obj, skyscraperPresheaf_obj,
Functor.comp_obj, Presheaf.stalkFunctor_obj, unit_app, counit_app,
skyscraperPresheafStalkOfSpecializes, skyscraperPresheafFunctor_map, Presheaf.comp_app,
toSkyscraperPresheaf_app, Category.id_comp, SkyscraperPresheafFunctor.map'_app]
split_ifs with h
· simp [Presheaf.germ]
rfl
· simp
rfl | 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 (StalkSkyscraperPresheafAdjunctionAuxs.unit p₀).naturality }
counit := StalkSkyscraperPresheafAdjunctionAuxs.counit p₀
left_triangle_components X :=
((skyscraperPresheafStalkAdjunction p₀).left_triangle_components X.val)
right_triangle_components _ :=
Sheaf.Hom.ext ((skyscraperPresheafStalkAdjunction p₀).right_triangle_components _) | 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.