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 ⌀ |
|---|---|---|---|---|---|---|
protected comap_comp (g : C(β, γ)) (f : C(α, β)) :
comap (g.comp f) = (comap f).comp (comap g) :=
rfl | theorem | Topology | [
"Mathlib.Order.Hom.CompleteLattice",
"Mathlib.Topology.Compactness.Bases",
"Mathlib.Topology.ContinuousMap.Basic",
"Mathlib.Order.CompactlyGenerated.Basic",
"Mathlib.Order.Copy"
] | Mathlib/Topology/Sets/Opens.lean | comap_comp | null |
protected comap_comap (g : C(β, γ)) (f : C(α, β)) (U : Opens γ) :
comap f (comap g U) = comap (g.comp f) U :=
rfl | theorem | Topology | [
"Mathlib.Order.Hom.CompleteLattice",
"Mathlib.Topology.Compactness.Bases",
"Mathlib.Topology.ContinuousMap.Basic",
"Mathlib.Order.CompactlyGenerated.Basic",
"Mathlib.Order.Copy"
] | Mathlib/Topology/Sets/Opens.lean | comap_comap | null |
comap_injective [T0Space β] : Injective (comap : C(α, β) → FrameHom (Opens β) (Opens α)) :=
fun f g h =>
ContinuousMap.ext fun a =>
Inseparable.eq <|
inseparable_iff_forall_isOpen.2 fun s hs =>
have : comap f ⟨s, hs⟩ = comap g ⟨s, hs⟩ := DFunLike.congr_fun h ⟨_, hs⟩
show a ∈ f ⁻¹' s ↔ a ∈ g ⁻¹' s from Set.ext_iff.1 (coe_inj.2 this) a | theorem | Topology | [
"Mathlib.Order.Hom.CompleteLattice",
"Mathlib.Topology.Compactness.Bases",
"Mathlib.Topology.ContinuousMap.Basic",
"Mathlib.Order.CompactlyGenerated.Basic",
"Mathlib.Order.Copy"
] | Mathlib/Topology/Sets/Opens.lean | comap_injective | null |
@[simps -fullyApplied apply]
_root_.Homeomorph.opensCongr (f : α ≃ₜ β) : Opens α ≃o Opens β where
toFun := Opens.comap (f.symm : C(β, α))
invFun := Opens.comap (f : C(α, β))
left_inv _ := ext <| f.toEquiv.preimage_symm_preimage _
right_inv _ := ext <| f.toEquiv.symm_preimage_preimage _
map_rel_iff' := by
simp only [← SetLike.coe_subset_coe]; exact f.symm.surjective.preimage_subset_preimage_iff
@[simp] | def | Topology | [
"Mathlib.Order.Hom.CompleteLattice",
"Mathlib.Topology.Compactness.Bases",
"Mathlib.Topology.ContinuousMap.Basic",
"Mathlib.Order.CompactlyGenerated.Basic",
"Mathlib.Order.Copy"
] | Mathlib/Topology/Sets/Opens.lean | _root_.Homeomorph.opensCongr | A homeomorphism induces an order-preserving equivalence on open sets, by taking comaps. |
_root_.Homeomorph.opensCongr_symm (f : α ≃ₜ β) : f.opensCongr.symm = f.symm.opensCongr :=
rfl | theorem | Topology | [
"Mathlib.Order.Hom.CompleteLattice",
"Mathlib.Topology.Compactness.Bases",
"Mathlib.Topology.ContinuousMap.Basic",
"Mathlib.Order.CompactlyGenerated.Basic",
"Mathlib.Order.Copy"
] | Mathlib/Topology/Sets/Opens.lean | _root_.Homeomorph.opensCongr_symm | null |
OpenNhdsOf (x : α) extends Opens α where
/-- The point `x` belongs to every `U : TopologicalSpace.OpenNhdsOf x`. -/
mem' : x ∈ carrier | structure | Topology | [
"Mathlib.Order.Hom.CompleteLattice",
"Mathlib.Topology.Compactness.Bases",
"Mathlib.Topology.ContinuousMap.Basic",
"Mathlib.Order.CompactlyGenerated.Basic",
"Mathlib.Order.Copy"
] | Mathlib/Topology/Sets/Opens.lean | OpenNhdsOf | The open neighborhoods of a point. See also `Opens` or `nhds`. |
toOpens_injective : Injective (toOpens : OpenNhdsOf x → Opens α)
| ⟨_, _⟩, ⟨_, _⟩, rfl => rfl | theorem | Topology | [
"Mathlib.Order.Hom.CompleteLattice",
"Mathlib.Topology.Compactness.Bases",
"Mathlib.Topology.ContinuousMap.Basic",
"Mathlib.Order.CompactlyGenerated.Basic",
"Mathlib.Order.Copy"
] | Mathlib/Topology/Sets/Opens.lean | toOpens_injective | null |
canLiftSet : CanLift (Set α) (OpenNhdsOf x) (↑) fun s => IsOpen s ∧ x ∈ s :=
⟨fun s hs => ⟨⟨⟨s, hs.1⟩, hs.2⟩, rfl⟩⟩ | instance | Topology | [
"Mathlib.Order.Hom.CompleteLattice",
"Mathlib.Topology.Compactness.Bases",
"Mathlib.Topology.ContinuousMap.Basic",
"Mathlib.Order.CompactlyGenerated.Basic",
"Mathlib.Order.Copy"
] | Mathlib/Topology/Sets/Opens.lean | canLiftSet | null |
protected mem (U : OpenNhdsOf x) : x ∈ U :=
U.mem' | theorem | Topology | [
"Mathlib.Order.Hom.CompleteLattice",
"Mathlib.Topology.Compactness.Bases",
"Mathlib.Topology.ContinuousMap.Basic",
"Mathlib.Order.CompactlyGenerated.Basic",
"Mathlib.Order.Copy"
] | Mathlib/Topology/Sets/Opens.lean | mem | null |
protected isOpen (U : OpenNhdsOf x) : IsOpen (U : Set α) :=
U.is_open' | theorem | Topology | [
"Mathlib.Order.Hom.CompleteLattice",
"Mathlib.Topology.Compactness.Bases",
"Mathlib.Topology.ContinuousMap.Basic",
"Mathlib.Order.CompactlyGenerated.Basic",
"Mathlib.Order.Copy"
] | Mathlib/Topology/Sets/Opens.lean | isOpen | null |
basis_nhds : (𝓝 x).HasBasis (fun _ : OpenNhdsOf x => True) (↑) :=
(nhds_basis_opens x).to_hasBasis (fun U hU => ⟨⟨⟨U, hU.2⟩, hU.1⟩, trivial, Subset.rfl⟩) fun U _ =>
⟨U, ⟨⟨U.mem, U.isOpen⟩, Subset.rfl⟩⟩ | theorem | Topology | [
"Mathlib.Order.Hom.CompleteLattice",
"Mathlib.Topology.Compactness.Bases",
"Mathlib.Topology.ContinuousMap.Basic",
"Mathlib.Order.CompactlyGenerated.Basic",
"Mathlib.Order.Copy"
] | Mathlib/Topology/Sets/Opens.lean | basis_nhds | null |
comap (f : C(α, β)) (x : α) : LatticeHom (OpenNhdsOf (f x)) (OpenNhdsOf x) where
toFun U := ⟨Opens.comap f U.1, U.mem⟩
map_sup' _ _ := rfl
map_inf' _ _ := rfl | def | Topology | [
"Mathlib.Order.Hom.CompleteLattice",
"Mathlib.Topology.Compactness.Bases",
"Mathlib.Topology.ContinuousMap.Basic",
"Mathlib.Order.CompactlyGenerated.Basic",
"Mathlib.Order.Copy"
] | Mathlib/Topology/Sets/Opens.lean | comap | Preimage of an open neighborhood of `f x` under a continuous map `f` as a `LatticeHom`. |
ClopenUpperSet (α : Type*) [TopologicalSpace α] [LE α] extends Clopens α where
upper' : IsUpperSet carrier | structure | Topology | [
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/Sets/Order.lean | ClopenUpperSet | The type of clopen upper sets of a topological space. |
Simps.coe (s : ClopenUpperSet α) : Set α := s
initialize_simps_projections ClopenUpperSet (carrier → coe, as_prefix coe) | def | Topology | [
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/Sets/Order.lean | Simps.coe | See Note [custom simps projection]. |
upper (s : ClopenUpperSet α) : IsUpperSet (s : Set α) :=
s.upper' | theorem | Topology | [
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/Sets/Order.lean | upper | null |
isClopen (s : ClopenUpperSet α) : IsClopen (s : Set α) :=
s.isClopen' | theorem | Topology | [
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/Sets/Order.lean | isClopen | null |
@[simps]
toUpperSet (s : ClopenUpperSet α) : UpperSet α :=
⟨s, s.upper⟩
@[ext] | def | Topology | [
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/Sets/Order.lean | toUpperSet | Reinterpret an upper clopen as an upper set. |
protected ext {s t : ClopenUpperSet α} (h : (s : Set α) = t) : s = t :=
SetLike.ext' h
@[simp] | theorem | Topology | [
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/Sets/Order.lean | ext | null |
coe_mk (s : Clopens α) (h) : (mk s h : Set α) = s :=
rfl | theorem | Topology | [
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/Sets/Order.lean | coe_mk | null |
@[simp]
coe_sup (s t : ClopenUpperSet α) : (↑(s ⊔ t) : Set α) = ↑s ∪ ↑t :=
rfl
@[simp] | theorem | Topology | [
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/Sets/Order.lean | coe_sup | null |
coe_inf (s t : ClopenUpperSet α) : (↑(s ⊓ t) : Set α) = ↑s ∩ ↑t :=
rfl
@[simp] | theorem | Topology | [
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/Sets/Order.lean | coe_inf | null |
coe_top : (↑(⊤ : ClopenUpperSet α) : Set α) = univ :=
rfl
@[simp] | theorem | Topology | [
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/Sets/Order.lean | coe_top | null |
coe_bot : (↑(⊥ : ClopenUpperSet α) : Set α) = ∅ :=
rfl | theorem | Topology | [
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/Sets/Order.lean | coe_bot | null |
principalOpen (x : X) : Opens X := .mk { y | x ≤ y } <| by
rw [IsUpperSet.isOpen_iff_isUpperSet]
intro y z h1 h2
exact le_trans h2 h1 | def | Topology | [
"Mathlib.Combinatorics.Quiver.ReflQuiver",
"Mathlib.Order.CompletePartialOrder",
"Mathlib.Topology.Order.UpperLowerSetTopology",
"Mathlib.Topology.Sheaves.SheafCondition.OpensLeCover"
] | Mathlib/Topology/Sheaves/Alexandrov.lean | principalOpen | Given `x : X`, this is the principal open subset of `X` generated by `x`. |
self_mem_principalOpen (x : X) : x ∈ principalOpen x := le_refl _
@[simp] | lemma | Topology | [
"Mathlib.Combinatorics.Quiver.ReflQuiver",
"Mathlib.Order.CompletePartialOrder",
"Mathlib.Topology.Order.UpperLowerSetTopology",
"Mathlib.Topology.Sheaves.SheafCondition.OpensLeCover"
] | Mathlib/Topology/Sheaves/Alexandrov.lean | self_mem_principalOpen | null |
principalOpen_le_iff {x : X} (U : Opens X) :
principalOpen x ≤ U ↔ x ∈ U := by
refine ⟨fun h => h <| self_mem_principalOpen _, fun hx y hy => ?_⟩
· have := U.isOpen
rw [IsUpperSet.isOpen_iff_isUpperSet] at this
exact this hy hx | lemma | Topology | [
"Mathlib.Combinatorics.Quiver.ReflQuiver",
"Mathlib.Order.CompletePartialOrder",
"Mathlib.Topology.Order.UpperLowerSetTopology",
"Mathlib.Topology.Sheaves.SheafCondition.OpensLeCover"
] | Mathlib/Topology/Sheaves/Alexandrov.lean | principalOpen_le_iff | null |
principalOpen_le {x y : X} (h : x ≤ y) :
principalOpen y ≤ principalOpen x :=
fun _ hc => le_trans h hc
variable (X) in | lemma | Topology | [
"Mathlib.Combinatorics.Quiver.ReflQuiver",
"Mathlib.Order.CompletePartialOrder",
"Mathlib.Topology.Order.UpperLowerSetTopology",
"Mathlib.Topology.Sheaves.SheafCondition.OpensLeCover"
] | Mathlib/Topology/Sheaves/Alexandrov.lean | principalOpen_le | null |
@[simps]
principals : X ⥤ (Opens X)ᵒᵖ where
obj x := .op <| principalOpen x
map {x y} f := .op <| principalOpen_le f.le |>.hom | def | Topology | [
"Mathlib.Combinatorics.Quiver.ReflQuiver",
"Mathlib.Order.CompletePartialOrder",
"Mathlib.Topology.Order.UpperLowerSetTopology",
"Mathlib.Topology.Sheaves.SheafCondition.OpensLeCover"
] | Mathlib/Topology/Sheaves/Alexandrov.lean | principals | The functor sending `x : X` to the principal open associated with `x`. |
exists_le_of_le_sup {ι : Type v} {x : X}
(Us : ι → Opens X) (h : principalOpen x ≤ iSup Us) :
∃ i : ι, principalOpen x ≤ Us i := by
grind [principalOpen_le_iff, Opens.mem_iSup] | lemma | Topology | [
"Mathlib.Combinatorics.Quiver.ReflQuiver",
"Mathlib.Order.CompletePartialOrder",
"Mathlib.Topology.Order.UpperLowerSetTopology",
"Mathlib.Topology.Sheaves.SheafCondition.OpensLeCover"
] | Mathlib/Topology/Sheaves/Alexandrov.lean | exists_le_of_le_sup | null |
principalsKanExtension : (Opens X)ᵒᵖ ⥤ C :=
(principals X).pointwiseRightKanExtension F | abbrev | Topology | [
"Mathlib.Combinatorics.Quiver.ReflQuiver",
"Mathlib.Order.CompletePartialOrder",
"Mathlib.Topology.Order.UpperLowerSetTopology",
"Mathlib.Topology.Sheaves.SheafCondition.OpensLeCover"
] | Mathlib/Topology/Sheaves/Alexandrov.lean | principalsKanExtension | The right kan extension of `F` along `X ⥤ (Opens X)ᵒᵖ`. |
generator (U : Opens X) :
StructuredArrow (.op U) (principals X) ⥤ X :=
StructuredArrow.proj (.op U) (principals X) | abbrev | Topology | [
"Mathlib.Combinatorics.Quiver.ReflQuiver",
"Mathlib.Order.CompletePartialOrder",
"Mathlib.Topology.Order.UpperLowerSetTopology",
"Mathlib.Topology.Sheaves.SheafCondition.OpensLeCover"
] | Mathlib/Topology/Sheaves/Alexandrov.lean | generator | Given a structured arrow `f` with domain `U : Opens X` over `principals X`,
this functor sends `f` to its "generator", an element of `X`. |
@[simps]
projSup {ι : Type v} (Us : ι → Opens X) :
StructuredArrow (.op <| iSup Us) (principals X) ⥤
(ObjectProperty.FullSubcategory fun V => ∃ i, V ≤ Us i)ᵒᵖ where
obj f := .op <| .mk (principalOpen f.right) <| exists_le_of_le_sup Us f.hom.unop.le
map e := .op <| LE.le.hom <| principalOpen_le <| e.right.le
variable {F} in | def | Topology | [
"Mathlib.Combinatorics.Quiver.ReflQuiver",
"Mathlib.Order.CompletePartialOrder",
"Mathlib.Topology.Order.UpperLowerSetTopology",
"Mathlib.Topology.Sheaves.SheafCondition.OpensLeCover"
] | Mathlib/Topology/Sheaves/Alexandrov.lean | projSup | Given a structured arrow `f` with domain `iSup Us` over `principals X`,
where `Us` is a family of `Opens X`, this functor sends `f` to the principal open
associated with it, considered as an object in the full subcategory of all `V : Opens X`
such that `V ≤ Us i` for some `i`.
This definition is primarily meant to be used in `lowerCone`, and `isLimit` below. |
@[simps]
lowerCone
{α : Type v} (Us : α → Opens X)
(S : Cone ((ObjectProperty.ι fun V => ∃ i, V ≤ Us i).op ⋙ principalsKanExtension F)) :
Cone (generator (iSup Us) ⋙ F) where
pt := S.pt
π := {
app := fun f =>
S.π.app ((projSup Us).obj f) ≫ limit.π (generator (principalOpen f.right) ⋙ F)
⟨.mk .unit, f.right, 𝟙 _⟩
naturality := by
rintro x y e
simp only [Functor.const_obj_obj, Functor.comp_obj, Functor.const_obj_map,
Functor.op_obj, ObjectProperty.ι_obj, Functor.pointwiseRightKanExtension_obj,
Category.id_comp, Functor.comp_map, Category.assoc]
rw [← S.w ((projSup Us).map e), Category.assoc]
congr 1
simp only [projSup_obj, Functor.comp_obj, Functor.op_obj, ObjectProperty.ι_obj,
Functor.pointwiseRightKanExtension_obj, projSup_map, homOfLE_leOfHom, Functor.comp_map,
Functor.op_map, Quiver.Hom.unop_op,
Functor.pointwiseRightKanExtension_map, limit.lift_π]
let xx : StructuredArrow (Opposite.op (principalOpen x.right)) (principals X) :=
⟨.mk .unit, x.right, 𝟙 _⟩
let yy : StructuredArrow (Opposite.op (principalOpen x.right)) (principals X) :=
⟨.mk .unit, y.right, .op <| LE.le.hom <| principalOpen_le e.right.le⟩
let ee : xx ⟶ yy := { left := 𝟙 _, right := e.right }
exact limit.w
(StructuredArrow.proj (Opposite.op (principalOpen x.right)) (principals X) ⋙ F) ee
|>.symm
} | def | Topology | [
"Mathlib.Combinatorics.Quiver.ReflQuiver",
"Mathlib.Order.CompletePartialOrder",
"Mathlib.Topology.Order.UpperLowerSetTopology",
"Mathlib.Topology.Sheaves.SheafCondition.OpensLeCover"
] | Mathlib/Topology/Sheaves/Alexandrov.lean | lowerCone | This is an auxiliary definition which is only meant to be used in `isLimit` below. |
isLimit {X : TopCat.{v}} [Preorder X] [Topology.IsUpperSet X]
(F : X ⥤ C)
(α : Type v) (Us : α → Opens X) :
IsLimit (mapCone (principalsKanExtension F) (opensLeCoverCocone Us).op) where
lift S := limit.lift _ (lowerCone Us S)
fac := by
rintro S ⟨V, i, hV⟩
dsimp [forget, opensLeCoverCocone]
ext ⟨_, x, f⟩
simp only [comp_obj, StructuredArrow.proj_obj, Category.assoc, limit.lift_π, lowerCone_pt,
lowerCone_π_app, const_obj_obj, projSup_obj, StructuredArrow.map_obj_right, op_obj,
ObjectProperty.ι_obj, pointwiseRightKanExtension_obj]
have e : principalOpen x ≤ V := f.unop.le
let VV : (ObjectProperty.FullSubcategory fun V => ∃ i, V ≤ Us i) := ⟨V, i, hV⟩
let xx : (ObjectProperty.FullSubcategory fun V => ∃ i, V ≤ Us i) :=
⟨principalOpen x, i, le_trans e hV⟩
let ee : xx ⟶ VV := e.hom
rw [← S.w ee.op, Category.assoc]
congr 1
simp only [comp_obj, op_obj, ObjectProperty.ι_obj, pointwiseRightKanExtension_obj,
Functor.comp_map, op_map, Quiver.Hom.unop_op,
pointwiseRightKanExtension_map, limit.lift_π, xx, VV]
congr
uniq := by
intro S m hm
dsimp
symm
ext ⟨_, x, f⟩
simp only [lowerCone_pt, comp_obj, limit.lift_π, lowerCone_π_app, const_obj_obj, projSup_obj,
op_obj, ObjectProperty.ι_obj, pointwiseRightKanExtension_obj]
specialize hm ⟨principalOpen x, ?_⟩
· apply exists_le_of_le_sup
exact f.unop.le
· rw [← hm]
simp only [mapCone_pt, Cocone.op_pt, pointwiseRightKanExtension_obj,
const_obj_obj, comp_obj, op_obj, ObjectProperty.ι_obj, mapCone_π_app, Cocone.op_π,
NatTrans.op_app, pointwiseRightKanExtension_map, Category.assoc, limit.lift_π]
congr | def | Topology | [
"Mathlib.Combinatorics.Quiver.ReflQuiver",
"Mathlib.Order.CompletePartialOrder",
"Mathlib.Topology.Order.UpperLowerSetTopology",
"Mathlib.Topology.Sheaves.SheafCondition.OpensLeCover"
] | Mathlib/Topology/Sheaves/Alexandrov.lean | isLimit | This is the main construction in this file showing that the right Kan extension
of `F : X ⥤ C` along `principals : X ⥤ (Opens X)ᵒᵖ` is a sheaf, by showing that a certain
cone is a limit cone.
See `isSheaf_principalsKanExtension` for the main application. |
isSheaf_principalsKanExtension
{X : TopCat.{v}} [Preorder X] [Topology.IsUpperSet X] (F : X ⥤ C) :
Presheaf.IsSheaf (principalsKanExtension F) := by
rw [isSheaf_iff_isSheafOpensLeCover]
intro ι Us
constructor
apply isLimit | theorem | Topology | [
"Mathlib.Combinatorics.Quiver.ReflQuiver",
"Mathlib.Order.CompletePartialOrder",
"Mathlib.Topology.Order.UpperLowerSetTopology",
"Mathlib.Topology.Sheaves.SheafCondition.OpensLeCover"
] | Mathlib/Topology/Sheaves/Alexandrov.lean | isSheaf_principalsKanExtension | null |
Topology.IsUpperSet.isSheaf_of_isRightKanExtension
(P : (Opens X)ᵒᵖ ⥤ C)
(η : Alexandrov.principals X ⋙ P ⟶ F)
[P.IsRightKanExtension η] :
Presheaf.IsSheaf (Opens.grothendieckTopology X) P := by
let γ : principals X ⋙ principalsKanExtension F ⟶ F :=
(principals X).pointwiseRightKanExtensionCounit F
let _ : (principalsKanExtension F).IsRightKanExtension γ := inferInstance
have : P ≅ principalsKanExtension F :=
@rightKanExtensionUnique _ _ _ _ _ _ _ _ _ _ (by assumption) _ _ (by assumption)
change TopCat.Presheaf.IsSheaf (X := TopCat.of X) P
rw [isSheaf_iso_iff this]
let _ : Preorder (TopCat.of X) := inferInstanceAs <| Preorder X
have _ : Topology.IsUpperSet (TopCat.of X) := inferInstanceAs <| Topology.IsUpperSet X
exact isSheaf_principalsKanExtension (X := TopCat.of X) F | theorem | Topology | [
"Mathlib.Combinatorics.Quiver.ReflQuiver",
"Mathlib.Order.CompletePartialOrder",
"Mathlib.Topology.Order.UpperLowerSetTopology",
"Mathlib.Topology.Sheaves.SheafCondition.OpensLeCover"
] | Mathlib/Topology/Sheaves/Alexandrov.lean | Topology.IsUpperSet.isSheaf_of_isRightKanExtension | The main theorem of this file.
If `X` is a topological space and preorder whose topology is the `UpperSet` topology associated
with the preorder, `F : X ⥤ C` is a functor into a complete category from the preorder category,
and `P : (Opens X)ᵒᵖ ⥤ C` denotes the right Kan extension of `F` along the
functor `X ⥤ (Open X)ᵒᵖ` which sends `x : X` to `{y | x ≤ y}`, then `P` is a sheaf. |
restrictOpenCommRingCat_apply {X : TopCat}
{F : Presheaf CommRingCat X} {V : Opens ↑X} (f : CommRingCat.carrier (F.obj (op V)))
(U : Opens ↑X) (e : U ≤ V := by restrict_tac) :
f |_ U = F.map (homOfLE e).op f :=
rfl | lemma | Topology | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.Algebra.Category.Ring.FilteredColimits",
"Mathlib.Topology.Category.TopCommRingCat",
"Mathlib.Topology.ContinuousMap.Algebra",
"Mathlib.Topology.Sheaves.Stalks"
] | Mathlib/Topology/Sheaves/CommRingCat.lean | restrictOpenCommRingCat_apply | Unfold `restrictOpen` in the category of commutative rings (with the correct carrier type).
Although unification hints help with applying `TopCat.Presheaf.restrictOpenCommRingCat`,
so it can be safely de-specialized, this lemma needs to be kept to ensure rewrites go right. |
SubmonoidPresheaf (F : X.Presheaf CommRingCat) where
/-- The submonoid structure for each component -/
obj : ∀ U, Submonoid (F.obj U)
map : ∀ {U V : (Opens X)ᵒᵖ} (i : U ⟶ V), obj U ≤ (obj V).comap (F.map i).hom
variable {F : X.Presheaf CommRingCat.{w}} (G : F.SubmonoidPresheaf) | structure | Topology | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.Algebra.Category.Ring.FilteredColimits",
"Mathlib.Topology.Category.TopCommRingCat",
"Mathlib.Topology.ContinuousMap.Algebra",
"Mathlib.Topology.Sheaves.Stalks"
] | Mathlib/Topology/Sheaves/CommRingCat.lean | SubmonoidPresheaf | A subpresheaf with a submonoid structure on each of the components. |
protected noncomputable SubmonoidPresheaf.localizationPresheaf : X.Presheaf CommRingCat where
obj U := CommRingCat.of <| Localization (G.obj U)
map {_ _} i := CommRingCat.ofHom <| IsLocalization.map _ (F.map i).hom (G.map i)
map_id U := by
simp_rw [F.map_id]
ext x
exact IsLocalization.map_id x
map_comp {U V W} i j := by
delta CommRingCat.ofHom CommRingCat.of Bundled.of
simp_rw [F.map_comp]
ext : 1
dsimp
rw [IsLocalization.map_comp_map] | def | Topology | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.Algebra.Category.Ring.FilteredColimits",
"Mathlib.Topology.Category.TopCommRingCat",
"Mathlib.Topology.ContinuousMap.Algebra",
"Mathlib.Topology.Sheaves.Stalks"
] | Mathlib/Topology/Sheaves/CommRingCat.lean | SubmonoidPresheaf.localizationPresheaf | The localization of a presheaf of `CommRing`s with respect to a `SubmonoidPresheaf`. |
@[simps app]
SubmonoidPresheaf.toLocalizationPresheaf : F ⟶ G.localizationPresheaf where
app U := CommRingCat.ofHom <| algebraMap (F.obj U) (Localization <| G.obj U)
naturality {_ _} i := CommRingCat.hom_ext <| (IsLocalization.map_comp (G.map i)).symm | def | Topology | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.Algebra.Category.Ring.FilteredColimits",
"Mathlib.Topology.Category.TopCommRingCat",
"Mathlib.Topology.ContinuousMap.Algebra",
"Mathlib.Topology.Sheaves.Stalks"
] | Mathlib/Topology/Sheaves/CommRingCat.lean | SubmonoidPresheaf.toLocalizationPresheaf | The map into the localization presheaf. |
epi_toLocalizationPresheaf : Epi G.toLocalizationPresheaf :=
@NatTrans.epi_of_epi_app _ _ _ _ _ _ G.toLocalizationPresheaf fun U => Localization.epi' (G.obj U)
variable (F) | instance | Topology | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.Algebra.Category.Ring.FilteredColimits",
"Mathlib.Topology.Category.TopCommRingCat",
"Mathlib.Topology.ContinuousMap.Algebra",
"Mathlib.Topology.Sheaves.Stalks"
] | Mathlib/Topology/Sheaves/CommRingCat.lean | epi_toLocalizationPresheaf | null |
@[simps]
noncomputable submonoidPresheafOfStalk (S : ∀ x : X, Submonoid (F.stalk x)) :
F.SubmonoidPresheaf where
obj U := ⨅ x : U.unop, Submonoid.comap (F.germ U.unop x.1 x.2).hom (S x)
map {U V} i := by
intro s hs
simp only [Submonoid.mem_comap, Submonoid.mem_iInf] at hs ⊢
intro x
change (F.map i.unop.op ≫ F.germ V.unop x.1 x.2) s ∈ _
rw [F.germ_res]
exact hs ⟨_, i.unop.le x.2⟩ | def | Topology | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.Algebra.Category.Ring.FilteredColimits",
"Mathlib.Topology.Category.TopCommRingCat",
"Mathlib.Topology.ContinuousMap.Algebra",
"Mathlib.Topology.Sheaves.Stalks"
] | Mathlib/Topology/Sheaves/CommRingCat.lean | submonoidPresheafOfStalk | Given a submonoid at each of the stalks, we may define a submonoid presheaf consisting of
sections whose restriction onto each stalk falls in the given submonoid. |
noncomputable totalQuotientPresheaf : X.Presheaf CommRingCat.{w} :=
(F.submonoidPresheafOfStalk fun x => (F.stalk x)⁰).localizationPresheaf | def | Topology | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.Algebra.Category.Ring.FilteredColimits",
"Mathlib.Topology.Category.TopCommRingCat",
"Mathlib.Topology.ContinuousMap.Algebra",
"Mathlib.Topology.Sheaves.Stalks"
] | Mathlib/Topology/Sheaves/CommRingCat.lean | totalQuotientPresheaf | The localization of a presheaf of `CommRing`s at locally non-zero-divisor sections. |
noncomputable toTotalQuotientPresheaf : F ⟶ F.totalQuotientPresheaf :=
SubmonoidPresheaf.toLocalizationPresheaf _
deriving Epi | def | Topology | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.Algebra.Category.Ring.FilteredColimits",
"Mathlib.Topology.Category.TopCommRingCat",
"Mathlib.Topology.ContinuousMap.Algebra",
"Mathlib.Topology.Sheaves.Stalks"
] | Mathlib/Topology/Sheaves/CommRingCat.lean | toTotalQuotientPresheaf | The map into the presheaf of total quotient rings |
continuousFunctions (X : TopCat.{v}ᵒᵖ) (R : TopCommRingCat.{v}) : CommRingCat.{v} :=
CommRingCat.of (X.unop ⟶ (forget₂ TopCommRingCat TopCat).obj R) | def | Topology | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.Algebra.Category.Ring.FilteredColimits",
"Mathlib.Topology.Category.TopCommRingCat",
"Mathlib.Topology.ContinuousMap.Algebra",
"Mathlib.Topology.Sheaves.Stalks"
] | Mathlib/Topology/Sheaves/CommRingCat.lean | continuousFunctions | The (bundled) commutative ring of continuous functions from a topological space
to a topological commutative ring, with pointwise multiplication. |
pullback {X Y : TopCatᵒᵖ} (f : X ⟶ Y) (R : TopCommRingCat) :
continuousFunctions X R ⟶ continuousFunctions Y R := CommRingCat.ofHom
{ toFun g := f.unop ≫ g
map_one' := rfl
map_zero' := rfl
map_add' := by cat_disch
map_mul' := by cat_disch } | def | Topology | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.Algebra.Category.Ring.FilteredColimits",
"Mathlib.Topology.Category.TopCommRingCat",
"Mathlib.Topology.ContinuousMap.Algebra",
"Mathlib.Topology.Sheaves.Stalks"
] | Mathlib/Topology/Sheaves/CommRingCat.lean | pullback | Pulling back functions into a topological ring along a continuous map is a ring homomorphism. |
map (X : TopCat.{u}ᵒᵖ) {R S : TopCommRingCat.{u}} (φ : R ⟶ S) :
continuousFunctions X R ⟶ continuousFunctions X S := CommRingCat.ofHom
{ toFun g := g ≫ (forget₂ TopCommRingCat TopCat).map φ
map_one' := by ext; exact φ.1.map_one
map_zero' := by ext; exact φ.1.map_zero
map_add' _ _ := by ext; exact φ.1.map_add _ _
map_mul' _ _ := by ext; exact φ.1.map_mul _ _ } | def | Topology | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.Algebra.Category.Ring.FilteredColimits",
"Mathlib.Topology.Category.TopCommRingCat",
"Mathlib.Topology.ContinuousMap.Algebra",
"Mathlib.Topology.Sheaves.Stalks"
] | Mathlib/Topology/Sheaves/CommRingCat.lean | map | A homomorphism of topological rings can be postcomposed with functions from a source space `X`;
this is a ring homomorphism (with respect to the pointwise ring operations on functions). |
commRingYoneda : TopCommRingCat.{u} ⥤ TopCat.{u}ᵒᵖ ⥤ CommRingCat.{u} where
obj R :=
{ obj := fun X => continuousFunctions X R
map := fun {_ _} f => continuousFunctions.pullback f R
map_id := fun X => by
ext
rfl
map_comp := fun {_ _ _} _ _ => rfl }
map {_ _} φ :=
{ app := fun X => continuousFunctions.map X φ
naturality := fun _ _ _ => rfl }
map_id X := by
ext
rfl
map_comp {_ _ _} _ _ := rfl | def | Topology | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.Algebra.Category.Ring.FilteredColimits",
"Mathlib.Topology.Category.TopCommRingCat",
"Mathlib.Topology.ContinuousMap.Algebra",
"Mathlib.Topology.Sheaves.Stalks"
] | Mathlib/Topology/Sheaves/CommRingCat.lean | commRingYoneda | An upgraded version of the Yoneda embedding, observing that the continuous maps
from `X : TopCat` to `R : TopCommRingCat` form a commutative ring, functorial in both `X` and
`R`. |
presheafToTopCommRing (T : TopCommRingCat.{v}) : X.Presheaf CommRingCat.{v} :=
(Opens.toTopCat X).op ⋙ commRingYoneda.obj T | def | Topology | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.Algebra.Category.Ring.FilteredColimits",
"Mathlib.Topology.Category.TopCommRingCat",
"Mathlib.Topology.ContinuousMap.Algebra",
"Mathlib.Topology.Sheaves.Stalks"
] | Mathlib/Topology/Sheaves/CommRingCat.lean | presheafToTopCommRing | The presheaf (of commutative rings), consisting of functions on an open set `U ⊆ X` with
values in some topological commutative ring `T`.
For example, we could construct the presheaf of continuous complex-valued functions of `X` as
```
presheafToTopCommRing X (TopCommRingCat.of ℂ)
```
(this requires `import Topology.Instances.Complex`). |
algebra_section_stalk (F : X.Presheaf CommRingCat) {U : Opens X} (x : U) :
Algebra (F.obj <| op U) (F.stalk x) :=
(F.germ U x.1 x.2).hom.toAlgebra
@[simp] | instance | Topology | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.Algebra.Category.Ring.FilteredColimits",
"Mathlib.Topology.Category.TopCommRingCat",
"Mathlib.Topology.ContinuousMap.Algebra",
"Mathlib.Topology.Sheaves.Stalks"
] | Mathlib/Topology/Sheaves/CommRingCat.lean | algebra_section_stalk | null |
stalk_open_algebraMap {X : TopCat} (F : X.Presheaf CommRingCat) {U : Opens X} (x : U) :
algebraMap (F.obj <| op U) (F.stalk x) = (F.germ U x.1 x.2).hom :=
rfl | theorem | Topology | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.Algebra.Category.Ring.FilteredColimits",
"Mathlib.Topology.Category.TopCommRingCat",
"Mathlib.Topology.ContinuousMap.Algebra",
"Mathlib.Topology.Sheaves.Stalks"
] | Mathlib/Topology/Sheaves/CommRingCat.lean | stalk_open_algebraMap | null |
objSupIsoProdEqLocus {X : TopCat} (F : X.Sheaf CommRingCat) (U V : Opens X) :
F.1.obj (op <| U ⊔ V) ≅ CommRingCat.of <|
RingHom.eqLocus
(RingHom.comp (F.val.map (homOfLE inf_le_left : U ⊓ V ⟶ U).op).hom
(RingHom.fst (F.val.obj <| op U) (F.val.obj <| op V)))
(RingHom.comp (F.val.map (homOfLE inf_le_right : U ⊓ V ⟶ V).op).hom
(RingHom.snd (F.val.obj <| op U) (F.val.obj <| op V))) :=
(F.isLimitPullbackCone U V).conePointUniqueUpToIso (CommRingCat.pullbackConeIsLimit _ _) | def | Topology | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.Algebra.Category.Ring.FilteredColimits",
"Mathlib.Topology.Category.TopCommRingCat",
"Mathlib.Topology.ContinuousMap.Algebra",
"Mathlib.Topology.Sheaves.Stalks"
] | Mathlib/Topology/Sheaves/CommRingCat.lean | objSupIsoProdEqLocus | `F(U ⊔ V)` is isomorphic to the `eq_locus` of the two maps `F(U) × F(V) ⟶ F(U ⊓ V)`. |
objSupIsoProdEqLocus_hom_fst {X : TopCat} (F : X.Sheaf CommRingCat) (U V : Opens X) (x) :
((F.objSupIsoProdEqLocus U V).hom x).1.fst = F.1.map (homOfLE le_sup_left).op x :=
ConcreteCategory.congr_hom
((F.isLimitPullbackCone U V).conePointUniqueUpToIso_hom_comp
(CommRingCat.pullbackConeIsLimit _ _) WalkingCospan.left)
x | theorem | Topology | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.Algebra.Category.Ring.FilteredColimits",
"Mathlib.Topology.Category.TopCommRingCat",
"Mathlib.Topology.ContinuousMap.Algebra",
"Mathlib.Topology.Sheaves.Stalks"
] | Mathlib/Topology/Sheaves/CommRingCat.lean | objSupIsoProdEqLocus_hom_fst | null |
objSupIsoProdEqLocus_hom_snd {X : TopCat} (F : X.Sheaf CommRingCat) (U V : Opens X) (x) :
((F.objSupIsoProdEqLocus U V).hom x).1.snd = F.1.map (homOfLE le_sup_right).op x :=
ConcreteCategory.congr_hom
((F.isLimitPullbackCone U V).conePointUniqueUpToIso_hom_comp
(CommRingCat.pullbackConeIsLimit _ _) WalkingCospan.right)
x | theorem | Topology | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.Algebra.Category.Ring.FilteredColimits",
"Mathlib.Topology.Category.TopCommRingCat",
"Mathlib.Topology.ContinuousMap.Algebra",
"Mathlib.Topology.Sheaves.Stalks"
] | Mathlib/Topology/Sheaves/CommRingCat.lean | objSupIsoProdEqLocus_hom_snd | null |
objSupIsoProdEqLocus_inv_fst {X : TopCat} (F : X.Sheaf CommRingCat) (U V : Opens X) (x) :
F.1.map (homOfLE le_sup_left).op ((F.objSupIsoProdEqLocus U V).inv x) = x.1.1 :=
ConcreteCategory.congr_hom
((F.isLimitPullbackCone U V).conePointUniqueUpToIso_inv_comp
(CommRingCat.pullbackConeIsLimit _ _) WalkingCospan.left)
x | theorem | Topology | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.Algebra.Category.Ring.FilteredColimits",
"Mathlib.Topology.Category.TopCommRingCat",
"Mathlib.Topology.ContinuousMap.Algebra",
"Mathlib.Topology.Sheaves.Stalks"
] | Mathlib/Topology/Sheaves/CommRingCat.lean | objSupIsoProdEqLocus_inv_fst | null |
objSupIsoProdEqLocus_inv_snd {X : TopCat} (F : X.Sheaf CommRingCat) (U V : Opens X) (x) :
F.1.map (homOfLE le_sup_right).op ((F.objSupIsoProdEqLocus U V).inv x) = x.1.2 :=
ConcreteCategory.congr_hom
((F.isLimitPullbackCone U V).conePointUniqueUpToIso_inv_comp
(CommRingCat.pullbackConeIsLimit _ _) WalkingCospan.right)
x | theorem | Topology | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.Algebra.Category.Ring.FilteredColimits",
"Mathlib.Topology.Category.TopCommRingCat",
"Mathlib.Topology.ContinuousMap.Algebra",
"Mathlib.Topology.Sheaves.Stalks"
] | Mathlib/Topology/Sheaves/CommRingCat.lean | objSupIsoProdEqLocus_inv_snd | null |
objSupIsoProdEqLocus_inv_eq_iff {X : TopCat.{u}} (F : X.Sheaf CommRingCat.{u})
{U V W UW VW : Opens X} (e : W ≤ U ⊔ V) (x) (y : F.1.obj (op W))
(h₁ : UW = U ⊓ W) (h₂ : VW = V ⊓ W) :
F.1.map (homOfLE e).op ((F.objSupIsoProdEqLocus U V).inv x) = y ↔
F.1.map (homOfLE (h₁ ▸ inf_le_left : UW ≤ U)).op x.1.1 =
F.1.map (homOfLE <| h₁ ▸ inf_le_right).op y ∧
F.1.map (homOfLE (h₂ ▸ inf_le_left : VW ≤ V)).op x.1.2 =
F.1.map (homOfLE <| h₂ ▸ inf_le_right).op y := by
subst h₁ h₂
constructor
· rintro rfl
rw [← TopCat.Sheaf.objSupIsoProdEqLocus_inv_fst, ← TopCat.Sheaf.objSupIsoProdEqLocus_inv_snd]
simp only [← CommRingCat.comp_apply, ← Functor.map_comp, ← op_comp,
homOfLE_comp, and_self]
· rintro ⟨e₁, e₂⟩
refine F.eq_of_locally_eq₂
(homOfLE (inf_le_right : U ⊓ W ≤ W)) (homOfLE (inf_le_right : V ⊓ W ≤ W)) ?_ _ _ ?_ ?_
· rw [← inf_sup_right]
exact le_inf e le_rfl
· rw [← e₁, ← TopCat.Sheaf.objSupIsoProdEqLocus_inv_fst]
simp only [← CommRingCat.comp_apply, ← Functor.map_comp, ← op_comp,
homOfLE_comp]
· rw [← e₂, ← TopCat.Sheaf.objSupIsoProdEqLocus_inv_snd]
simp only [← CommRingCat.comp_apply, ← Functor.map_comp, ← op_comp,
homOfLE_comp] | theorem | Topology | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.Algebra.Category.Ring.FilteredColimits",
"Mathlib.Topology.Category.TopCommRingCat",
"Mathlib.Topology.ContinuousMap.Algebra",
"Mathlib.Topology.Sheaves.Stalks"
] | Mathlib/Topology/Sheaves/CommRingCat.lean | objSupIsoProdEqLocus_inv_eq_iff | null |
@[stacks 0073 "In fact we prove a stronger version with arbitrary target category."]
isSheaf_iff_isSheaf_comp' {C : Type u₁} [Category.{v₁} C] {D : Type u₂} [Category.{v₂} D]
(G : C ⥤ D) [G.ReflectsIsomorphisms] [HasLimitsOfSize.{v, v} C] [PreservesLimitsOfSize.{v, v} G]
{X : TopCat.{v}} (F : Presheaf C X) : Presheaf.IsSheaf F ↔ Presheaf.IsSheaf (F ⋙ G) :=
Presheaf.isSheaf_iff_isSheaf_comp _ F G | theorem | Topology | [
"Mathlib.Topology.Sheaves.Sheaf"
] | Mathlib/Topology/Sheaves/Forget.lean | isSheaf_iff_isSheaf_comp' | If `G : C ⥤ D` is a functor which reflects isomorphisms and preserves limits
(we assume all limits exist in `C`),
then checking the sheaf condition for a presheaf `F : Presheaf C X`
is equivalent to checking the sheaf condition for `F ⋙ G`.
The important special case is when
`C` is a concrete category with a forgetful functor
that preserves limits and reflects isomorphisms.
Then to check the sheaf condition it suffices to check it on the underlying sheaf of types.
Another useful example is the forgetful functor `TopCommRingCat ⥤ TopCat`. |
isSheaf_iff_isSheaf_comp {C : Type u₁} [Category.{v} C] {D : Type u₂} [Category.{v} D]
(G : C ⥤ D) [G.ReflectsIsomorphisms] [HasLimits C] [PreservesLimits G]
{X : TopCat.{v}} (F : Presheaf C X) : Presheaf.IsSheaf F ↔ Presheaf.IsSheaf (F ⋙ G) :=
isSheaf_iff_isSheaf_comp' G F | theorem | Topology | [
"Mathlib.Topology.Sheaves.Sheaf"
] | Mathlib/Topology/Sheaves/Forget.lean | isSheaf_iff_isSheaf_comp | null |
pushforward_sheaf_of_sheaf {F : X.Presheaf C} (h : F.IsSheaf) : (f _* F).IsSheaf :=
(Opens.map f).op_comp_isSheaf _ _ ⟨_, h⟩
variable (C) | theorem | Topology | [
"Mathlib.Topology.Sheaves.SheafCondition.Sites",
"Mathlib.CategoryTheory.Sites.Pullback"
] | Mathlib/Topology/Sheaves/Functors.lean | pushforward_sheaf_of_sheaf | The pushforward of a sheaf (by a continuous map) is a sheaf. |
pushforward (f : X ⟶ Y) : X.Sheaf C ⥤ Y.Sheaf C :=
(Opens.map f).sheafPushforwardContinuous _ _ _ | def | Topology | [
"Mathlib.Topology.Sheaves.SheafCondition.Sites",
"Mathlib.CategoryTheory.Sites.Pullback"
] | Mathlib/Topology/Sheaves/Functors.lean | pushforward | The pushforward functor. |
pushforward_forget (f : X ⟶ Y) :
pushforward C f ⋙ forget C Y = forget C X ⋙ Presheaf.pushforward C f := rfl | lemma | Topology | [
"Mathlib.Topology.Sheaves.SheafCondition.Sites",
"Mathlib.CategoryTheory.Sites.Pullback"
] | Mathlib/Topology/Sheaves/Functors.lean | pushforward_forget | null |
pushforwardForgetIso (f : X ⟶ Y) :
pushforward C f ⋙ forget C Y ≅ forget C X ⋙ Presheaf.pushforward C f := Iso.refl _
variable {C}
@[simp] lemma pushforward_obj_val (f : X ⟶ Y) (F : X.Sheaf C) :
((pushforward C f).obj F).1 = f _* F.1 := rfl
@[simp] lemma pushforward_map (f : X ⟶ Y) {F F' : X.Sheaf C} (α : F ⟶ F') :
((pushforward C f).map α).1 = (Presheaf.pushforward C f).map α.1 := rfl
variable (A : Type*) [Category.{w} A] {FA : A → A → Type*} {CA : A → Type w}
variable [∀ X Y, FunLike (FA X Y) (CA X) (CA Y)] [ConcreteCategory.{w} A FA] [HasColimits A]
variable [HasLimits A] [PreservesLimits (CategoryTheory.forget A)]
variable [PreservesFilteredColimits (CategoryTheory.forget A)]
variable [(CategoryTheory.forget A).ReflectsIsomorphisms] | def | Topology | [
"Mathlib.Topology.Sheaves.SheafCondition.Sites",
"Mathlib.CategoryTheory.Sites.Pullback"
] | Mathlib/Topology/Sheaves/Functors.lean | pushforwardForgetIso | Pushforward of sheaves is isomorphic (actually definitionally equal) to pushforward of presheaves. |
pullback (f : X ⟶ Y) : Y.Sheaf A ⥤ X.Sheaf A :=
(Opens.map f).sheafPullback _ _ _ | def | Topology | [
"Mathlib.Topology.Sheaves.SheafCondition.Sites",
"Mathlib.CategoryTheory.Sites.Pullback"
] | Mathlib/Topology/Sheaves/Functors.lean | pullback | The pullback functor. |
pullbackIso (f : X ⟶ Y) :
pullback A f ≅ forget A Y ⋙ Presheaf.pullback A f ⋙ presheafToSheaf _ _ :=
Functor.sheafPullbackConstruction.sheafPullbackIso _ _ _ _ | def | Topology | [
"Mathlib.Topology.Sheaves.SheafCondition.Sites",
"Mathlib.CategoryTheory.Sites.Pullback"
] | Mathlib/Topology/Sheaves/Functors.lean | pullbackIso | The pullback of a sheaf is isomorphic (actually definitionally equal) to the sheafification
of the pullback as a presheaf. |
pullbackPushforwardAdjunction (f : X ⟶ Y) :
pullback A f ⊣ pushforward A f :=
(Opens.map f).sheafAdjunctionContinuous _ _ _ | def | Topology | [
"Mathlib.Topology.Sheaves.SheafCondition.Sites",
"Mathlib.CategoryTheory.Sites.Pullback"
] | Mathlib/Topology/Sheaves/Functors.lean | pullbackPushforwardAdjunction | The adjunction between pullback and pushforward for sheaves on topological spaces. |
isSheaf_of_isLimit [HasLimitsOfShape J C] {X : TopCat} (F : J ⥤ Presheaf.{v} C X)
(H : ∀ j, (F.obj j).IsSheaf) {c : Cone F} (hc : IsLimit c) : c.pt.IsSheaf := by
let F' : J ⥤ Sheaf C X :=
{ obj := fun j => ⟨F.obj j, H j⟩
map := fun f => ⟨F.map f⟩ }
let e : F' ⋙ Sheaf.forget C X ≅ F := NatIso.ofComponents fun _ => Iso.refl _
exact Presheaf.isSheaf_of_iso
((isLimitOfPreserves (Sheaf.forget C X) (limit.isLimit F')).conePointsIsoOfNatIso hc e)
(limit F').2 | theorem | Topology | [
"Mathlib.Topology.Sheaves.Sheaf",
"Mathlib.CategoryTheory.Sites.Limits",
"Mathlib.CategoryTheory.Limits.FunctorCategory.Basic"
] | Mathlib/Topology/Sheaves/Limits.lean | isSheaf_of_isLimit | null |
limit_isSheaf [HasLimitsOfShape J C] {X : TopCat} (F : J ⥤ Presheaf.{v} C X)
(H : ∀ j, (F.obj j).IsSheaf) : (limit F).IsSheaf :=
isSheaf_of_isLimit F H (limit.isLimit F) | theorem | Topology | [
"Mathlib.Topology.Sheaves.Sheaf",
"Mathlib.CategoryTheory.Sites.Limits",
"Mathlib.CategoryTheory.Limits.FunctorCategory.Basic"
] | Mathlib/Topology/Sheaves/Limits.lean | limit_isSheaf | null |
IsLocallySurjective (T : ℱ ⟶ 𝒢) :=
CategoryTheory.Presheaf.IsLocallySurjective (Opens.grothendieckTopology X) T | def | Topology | [
"Mathlib.Topology.Sheaves.Presheaf",
"Mathlib.Topology.Sheaves.Stalks",
"Mathlib.CategoryTheory.Limits.Preserves.Filtered",
"Mathlib.CategoryTheory.Sites.LocallySurjective"
] | Mathlib/Topology/Sheaves/LocallySurjective.lean | IsLocallySurjective | A map of presheaves `T : ℱ ⟶ 𝒢` is **locally surjective** if for any open set `U`,
section `t` over `U`, and `x ∈ U`, there exists an open set `x ∈ V ⊆ U` and a section `s` over `V`
such that `$T_*(s_V) = t|_V$`.
See `TopCat.Presheaf.isLocallySurjective_iff` below. |
isLocallySurjective_iff (T : ℱ ⟶ 𝒢) :
IsLocallySurjective T ↔
∀ (U t), ∀ x ∈ U, ∃ (V : _) (ι : V ⟶ U), (∃ s, (T.app _) s = t |_ₕ ι) ∧ x ∈ V :=
⟨fun h _ => h.imageSieve_mem, fun h => ⟨h _⟩⟩ | theorem | Topology | [
"Mathlib.Topology.Sheaves.Presheaf",
"Mathlib.Topology.Sheaves.Stalks",
"Mathlib.CategoryTheory.Limits.Preserves.Filtered",
"Mathlib.CategoryTheory.Sites.LocallySurjective"
] | Mathlib/Topology/Sheaves/LocallySurjective.lean | isLocallySurjective_iff | null |
locally_surjective_iff_surjective_on_stalks (T : ℱ ⟶ 𝒢) :
IsLocallySurjective T ↔ ∀ x : X, Function.Surjective ((stalkFunctor C x).map T) := by
constructor <;> intro hT
· /- human proof:
Let g ∈ Γₛₜ 𝒢 x be a germ. Represent it on an open set U ⊆ X
as ⟨t, U⟩. By local surjectivity, pass to a smaller open set V
on which there exists s ∈ Γ_ ℱ V mapping to t |_ V.
Then the germ of s maps to g -/
intro x g
obtain ⟨U, hxU, t, rfl⟩ := 𝒢.germ_exist x g
rcases hT.imageSieve_mem t x hxU with ⟨V, ι, ⟨s, h_eq⟩, hxV⟩
use ℱ.germ _ x hxV s
simp [h_eq, germ_res_apply]
· /- human proof:
Let U be an open set, t ∈ Γ ℱ U a section, x ∈ U a point.
By surjectivity on stalks, the germ of t is the image of
some germ f ∈ Γₛₜ ℱ x. Represent f on some open set V ⊆ X as ⟨s, V⟩.
Then there is some possibly smaller open set x ∈ W ⊆ V ∩ U on which
we have T(s) |_ W = t |_ W. -/
constructor
intro U t x hxU
set t_x := 𝒢.germ _ x hxU t with ht_x
obtain ⟨s_x, hs_x : ((stalkFunctor C x).map T) s_x = t_x⟩ := hT x t_x
obtain ⟨V, hxV, s, rfl⟩ := ℱ.germ_exist x s_x
have key_W := 𝒢.germ_eq x hxV hxU (T.app _ s) t <| by
convert hs_x using 1
symm
convert stalkFunctor_map_germ_apply _ _ _ _ s
obtain ⟨W, hxW, hWV, hWU, h_eq⟩ := key_W
refine ⟨W, hWU, ⟨ℱ.map hWV.op s, ?_⟩, hxW⟩
convert h_eq using 1
simp only [← ConcreteCategory.comp_apply, T.naturality] | theorem | Topology | [
"Mathlib.Topology.Sheaves.Presheaf",
"Mathlib.Topology.Sheaves.Stalks",
"Mathlib.CategoryTheory.Limits.Preserves.Filtered",
"Mathlib.CategoryTheory.Sites.LocallySurjective"
] | Mathlib/Topology/Sheaves/LocallySurjective.lean | locally_surjective_iff_surjective_on_stalks | An equivalent condition for a map of presheaves to be locally surjective
is for all the induced maps on stalks to be surjective. |
PrelocalPredicate where
/-- The underlying predicate of a prelocal predicate -/
pred : ∀ {U : Opens X}, (∀ x : U, T x) → Prop
/-- The underlying predicate should be invariant under restriction -/
res : ∀ {U V : Opens X} (i : U ⟶ V) (f : ∀ x : V, T x) (_ : pred f), pred fun x : U ↦ f (i x)
variable (X) | structure | Topology | [
"Mathlib.Topology.Sheaves.SheafOfFunctions",
"Mathlib.Topology.Sheaves.Stalks",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/LocalPredicate.lean | PrelocalPredicate | Given a topological space `X : TopCat` and a type family `T : X → Type`,
a `P : PrelocalPredicate T` consists of:
* a family of predicates `P.pred`, one for each `U : Opens X`, of the form `(Π x : U, T x) → Prop`
* a proof that if `f : Π x : V, T x` satisfies the predicate on `V : Opens X`, then
the restriction of `f` to any open subset `U` also satisfies the predicate. |
@[simps!]
continuousPrelocal (T) [TopologicalSpace T] : PrelocalPredicate fun _ : X ↦ T where
pred {_} f := Continuous f
res {_ _} i _ h := Continuous.comp h (Opens.isOpenEmbedding_of_le i.le).continuous | def | Topology | [
"Mathlib.Topology.Sheaves.SheafOfFunctions",
"Mathlib.Topology.Sheaves.Stalks",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/LocalPredicate.lean | continuousPrelocal | Continuity is a "prelocal" predicate on functions to a fixed topological space `T`. |
inhabitedPrelocalPredicate (T) [TopologicalSpace T] :
Inhabited (PrelocalPredicate fun _ : X ↦ T) :=
⟨continuousPrelocal X T⟩
variable {X} in | instance | Topology | [
"Mathlib.Topology.Sheaves.SheafOfFunctions",
"Mathlib.Topology.Sheaves.Stalks",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/LocalPredicate.lean | inhabitedPrelocalPredicate | Satisfying the inhabited linter. |
LocalPredicate extends PrelocalPredicate T where
/-- A local predicate must be local --- provided that it is locally satisfied, it is also globally
satisfied -/
locality :
∀ {U : Opens X} (f : ∀ x : U, T x)
(_ : ∀ x : U, ∃ (V : Opens X) (_ : x.1 ∈ V) (i : V ⟶ U),
pred fun x : V ↦ f (i x : U)), pred f | structure | Topology | [
"Mathlib.Topology.Sheaves.SheafOfFunctions",
"Mathlib.Topology.Sheaves.Stalks",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/LocalPredicate.lean | LocalPredicate | Given a topological space `X : TopCat` and a type family `T : X → Type`,
a `P : LocalPredicate T` consists of:
* a family of predicates `P.pred`, one for each `U : Opens X`, of the form `(Π x : U, T x) → Prop`
* a proof that if `f : Π x : V, T x` satisfies the predicate on `V : Opens X`, then
the restriction of `f` to any open subset `U` also satisfies the predicate, and
* a proof that given some `f : Π x : U, T x`,
if for every `x : U` we can find an open set `x ∈ V ≤ U`
so that the restriction of `f` to `V` satisfies the predicate,
then `f` itself satisfies the predicate. |
continuousLocal (T) [TopologicalSpace T] : LocalPredicate fun _ : X ↦ T :=
{ continuousPrelocal X T with
locality := fun {U} f w ↦ by
apply continuous_iff_continuousAt.2
intro x
specialize w x
rcases w with ⟨V, m, i, w⟩
dsimp at w
rw [continuous_iff_continuousAt] at w
specialize w ⟨x, m⟩
simpa using (Opens.isOpenEmbedding_of_le i.le).continuousAt_iff.1 w } | def | Topology | [
"Mathlib.Topology.Sheaves.SheafOfFunctions",
"Mathlib.Topology.Sheaves.Stalks",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/LocalPredicate.lean | continuousLocal | Continuity is a "local" predicate on functions to a fixed topological space `T`. |
inhabitedLocalPredicate (T) [TopologicalSpace T] :
Inhabited (LocalPredicate fun _ : X ↦ T) :=
⟨continuousLocal X T⟩
variable {X T} | instance | Topology | [
"Mathlib.Topology.Sheaves.SheafOfFunctions",
"Mathlib.Topology.Sheaves.Stalks",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/LocalPredicate.lean | inhabitedLocalPredicate | Satisfying the inhabited linter. |
PrelocalPredicate.and (P Q : PrelocalPredicate T) : PrelocalPredicate T where
pred f := P.pred f ∧ Q.pred f
res i f h := ⟨P.res i f h.1, Q.res i f h.2⟩ | def | Topology | [
"Mathlib.Topology.Sheaves.SheafOfFunctions",
"Mathlib.Topology.Sheaves.Stalks",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/LocalPredicate.lean | PrelocalPredicate.and | The conjunction of two prelocal predicates is prelocal. |
LocalPredicate.and (P Q : LocalPredicate T) : LocalPredicate T where
__ := P.1.and Q.1
locality f w := by
refine ⟨P.locality f ?_, Q.locality f ?_⟩ <;>
(intro x; have ⟨V, hV, i, h⟩ := w x; use V, hV, i)
exacts [h.1, h.2] | def | Topology | [
"Mathlib.Topology.Sheaves.SheafOfFunctions",
"Mathlib.Topology.Sheaves.Stalks",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/LocalPredicate.lean | LocalPredicate.and | The conjunction of two prelocal predicates is prelocal. |
isSection {T} (p : T → X) : LocalPredicate fun _ : X ↦ T where
pred f := p ∘ f = (↑)
res _ _ h := funext fun _ ↦ congr_fun h _
locality _ w := funext fun x ↦ have ⟨_, hV, _, h⟩ := w x; congr_fun h ⟨x, hV⟩ | def | Topology | [
"Mathlib.Topology.Sheaves.SheafOfFunctions",
"Mathlib.Topology.Sheaves.Stalks",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/LocalPredicate.lean | isSection | The local predicate of being a partial section of a function. |
PrelocalPredicate.sheafify {T : X → Type*} (P : PrelocalPredicate T) : LocalPredicate T where
pred {U} f := ∀ x : U, ∃ (V : Opens X) (_ : x.1 ∈ V) (i : V ⟶ U), P.pred fun x : V ↦ f (i x : U)
res {V U} i f w x := by
specialize w (i x)
rcases w with ⟨V', m', i', p⟩
exact ⟨V ⊓ V', ⟨x.2, m'⟩, V.infLELeft _, P.res (V.infLERight V') _ p⟩
locality {U} f w x := by
specialize w x
rcases w with ⟨V, m, i, p⟩
specialize p ⟨x.1, m⟩
rcases p with ⟨V', m', i', p'⟩
exact ⟨V', m', i' ≫ i, p'⟩ | def | Topology | [
"Mathlib.Topology.Sheaves.SheafOfFunctions",
"Mathlib.Topology.Sheaves.Stalks",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/LocalPredicate.lean | PrelocalPredicate.sheafify | Given a `P : PrelocalPredicate`, we can always construct a `LocalPredicate`
by asking that the condition from `P` holds locally near every point. |
sheafifyOf {T : X → Type*} {P : PrelocalPredicate T} {U : Opens X}
{f : ∀ x : U, T x} (h : P.pred f) : P.sheafify.pred f := fun x ↦
⟨U, x.2, 𝟙 _, by convert h⟩ | theorem | Topology | [
"Mathlib.Topology.Sheaves.SheafOfFunctions",
"Mathlib.Topology.Sheaves.Stalks",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/LocalPredicate.lean | sheafifyOf | null |
sheafify_inductionOn {X : TopCat} {T : X → Type*} (P : PrelocalPredicate T)
(op : {x : X} → T x → T x)
(hop : ∀ {U : Opens X} {a : (x : U) → T x}, P.pred a →
∀ (p : U), ∃ (W : Opens X) (i : W ⟶ U), p.1 ∈ W ∧ P.pred fun x : W ↦ op (a (i x)))
{U : Opens X} {a : (x : U) → T x} (ha : P.sheafify.pred a) :
P.sheafify.pred (fun x : U ↦ op (a x)) := by
intro x
rcases ha x with ⟨Va, ma, ia, ha⟩
rcases hop ha ⟨x, ma⟩ with ⟨W, sa, hx, hw⟩
exact ⟨W, hx, sa ≫ ia, hw⟩ | theorem | Topology | [
"Mathlib.Topology.Sheaves.SheafOfFunctions",
"Mathlib.Topology.Sheaves.Stalks",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/LocalPredicate.lean | sheafify_inductionOn | For a unary operation (e.g. `x ↦ -x`) defined at each stalk, if a prelocal predicate is closed
under the operation on each open set (possibly by refinement), then the sheafified predicate is
also closed under the operation. See `sheafify_inductionOn'` for the version without refinement. |
sheafify_inductionOn' {X : TopCat} {T : X → Type*} (P : PrelocalPredicate T)
(op : {x : X} → T x → T x)
(hop : ∀ {U : Opens X} {a : (x : U) → T x}, P.pred a → P.pred fun x : U ↦ op (a x))
{U : Opens X} {a : (x : U) → T x} (ha : P.sheafify.pred a) :
P.sheafify.pred (fun x : U ↦ op (a x)) :=
P.sheafify_inductionOn op (fun ha p ↦ ⟨_, 𝟙 _, p.2, hop ha⟩) ha | theorem | Topology | [
"Mathlib.Topology.Sheaves.SheafOfFunctions",
"Mathlib.Topology.Sheaves.Stalks",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/LocalPredicate.lean | sheafify_inductionOn' | For a unary operation (e.g. `x ↦ -x`) defined at each stalk, if a prelocal predicate is closed
under the operation on each open set, then the sheafified predicate is also closed under the
operation. See `sheafify_inductionOn` for the version with refinement. |
sheafify_inductionOn₂ {X : TopCat} {T₁ T₂ T₃ : X → Type*}
(P₁ : PrelocalPredicate T₁) (P₂ : PrelocalPredicate T₂) (P₃ : PrelocalPredicate T₃)
(op : {x : X} → T₁ x → T₂ x → T₃ x)
(hop : ∀ {U V : Opens X} {a : (x : U) → T₁ x} {b : (x : V) → T₂ x}, P₁.pred a → P₂.pred b →
∀ (p : (U ⊓ V : Opens X)), ∃ (W : Opens X) (ia : W ⟶ U) (ib : W ⟶ V),
p.1 ∈ W ∧ P₃.pred fun x : W ↦ op (a (ia x)) (b (ib x)))
{U : Opens X} {a : (x : U) → T₁ x} {b : (x : U) → T₂ x}
(ha : P₁.sheafify.pred a) (hb : P₂.sheafify.pred b) :
P₃.sheafify.pred (fun x : U ↦ op (a x) (b x)) := by
intro x
rcases ha x with ⟨Va, ma, ia, ha⟩
rcases hb x with ⟨Vb, mb, ib, hb⟩
rcases hop ha hb ⟨x, ma, mb⟩ with ⟨W, sa, sb, hx, hw⟩
exact ⟨W, hx, sa ≫ ia, hw⟩ | theorem | Topology | [
"Mathlib.Topology.Sheaves.SheafOfFunctions",
"Mathlib.Topology.Sheaves.Stalks",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/LocalPredicate.lean | sheafify_inductionOn₂ | For a binary operation (e.g. `x ↦ y ↦ x + y`) defined at each stalk, if a prelocal predicate is
closed under the operation on each open set (possibly by refinement), then the sheafified predicate
is also closed under the operation. See `sheafify_inductionOn₂'` for the version without
refinement. |
sheafify_inductionOn₂' {X : TopCat} {T₁ T₂ T₃ : X → Type*}
(P₁ : PrelocalPredicate T₁) (P₂ : PrelocalPredicate T₂) (P₃ : PrelocalPredicate T₃)
(op : {x : X} → T₁ x → T₂ x → T₃ x)
(hop : ∀ {U V : Opens X} {a : (x : U) → T₁ x} {b : (x : V) → T₂ x}, P₁.pred a → P₂.pred b →
P₃.pred fun x : (U ⊓ V : Opens X) ↦ op (a ⟨x, x.2.1⟩) (b ⟨x, x.2.2⟩))
{U : Opens X} {a : (x : U) → T₁ x} {b : (x : U) → T₂ x}
(ha : P₁.sheafify.pred a) (hb : P₂.sheafify.pred b) :
P₃.sheafify.pred (fun x : U ↦ op (a x) (b x)) :=
P₁.sheafify_inductionOn₂ P₂ P₃ op
(fun ha hb p ↦ ⟨_, Opens.infLELeft _ _, Opens.infLERight _ _, p.2, hop ha hb⟩) ha hb | theorem | Topology | [
"Mathlib.Topology.Sheaves.SheafOfFunctions",
"Mathlib.Topology.Sheaves.Stalks",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/LocalPredicate.lean | sheafify_inductionOn₂' | For a binary operation (e.g. `x ↦ y ↦ x + y`) defined at each stalk, if a prelocal predicate is
closed under the operation on each open set, then the sheafified predicate is also closed under the
operation. See `sheafify_inductionOn₂` for the version with refinement. |
@[simps!]
subpresheafToTypes (P : PrelocalPredicate T) : Presheaf (Type _) X where
obj U := { f : ∀ x : U.unop, T x // P.pred f }
map {_ _} i f := ⟨fun x ↦ f.1 (i.unop x), P.res i.unop f.1 f.2⟩ | def | Topology | [
"Mathlib.Topology.Sheaves.SheafOfFunctions",
"Mathlib.Topology.Sheaves.Stalks",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/LocalPredicate.lean | subpresheafToTypes | The subpresheaf of dependent functions on `X` satisfying the "pre-local" predicate `P`. |
subtype : subpresheafToTypes P ⟶ presheafToTypes X T where app _ f := f.1
open TopCat.Presheaf
attribute [local instance] Types.instFunLike Types.instConcreteCategory in | def | Topology | [
"Mathlib.Topology.Sheaves.SheafOfFunctions",
"Mathlib.Topology.Sheaves.Stalks",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/LocalPredicate.lean | subtype | The natural transformation including the subpresheaf of functions satisfying a local predicate
into the presheaf of all functions. |
isSheaf (P : LocalPredicate T) : (subpresheafToTypes P.toPrelocalPredicate).IsSheaf :=
Presheaf.isSheaf_of_isSheafUniqueGluing_types _ fun ι U sf sf_comp ↦ by
let sf' (i : ι) : (presheafToTypes X T).obj (op (U i)) := (sf i).val
have sf'_comp : (presheafToTypes X T).IsCompatible U sf' := fun i j ↦
congr_arg Subtype.val (sf_comp i j)
obtain ⟨gl, gl_spec, gl_uniq⟩ := (sheafToTypes X T).existsUnique_gluing U sf'
(by exact sf'_comp)
refine ⟨⟨gl, ?_⟩, ?_, ?_⟩
· -- Our first goal is to show that this chosen gluing satisfies the
apply P.locality
rintro ⟨x, mem⟩
choose i hi using Opens.mem_iSup.mp mem
use U i, hi, Opens.leSupr U i
convert (sf i).property using 1
exact gl_spec i
· exact fun i ↦ Subtype.ext (gl_spec i)
· intro gl' hgl'
refine Subtype.ext ?_
exact gl_uniq gl'.1 fun i ↦ congr_arg Subtype.val (hgl' i) | theorem | Topology | [
"Mathlib.Topology.Sheaves.SheafOfFunctions",
"Mathlib.Topology.Sheaves.Stalks",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/LocalPredicate.lean | isSheaf | The functions satisfying a local predicate satisfy the sheaf condition. |
@[simps]
subsheafToTypes (P : LocalPredicate T) : Sheaf (Type _) X :=
⟨subpresheafToTypes P.toPrelocalPredicate, subpresheafToTypes.isSheaf P⟩ | def | Topology | [
"Mathlib.Topology.Sheaves.SheafOfFunctions",
"Mathlib.Topology.Sheaves.Stalks",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/LocalPredicate.lean | subsheafToTypes | The subsheaf of the sheaf of all dependently typed functions satisfying the local predicate `P`. |
stalkToFiber (P : LocalPredicate T) (x : X) : (subsheafToTypes P).presheaf.stalk x ⟶ T x := by
refine
colimit.desc _
{ pt := T x
ι :=
{ app := fun U f ↦ ?_
naturality := ?_ } }
· exact f.1 ⟨x, (unop U).2⟩
· aesop | def | Topology | [
"Mathlib.Topology.Sheaves.SheafOfFunctions",
"Mathlib.Topology.Sheaves.Stalks",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/LocalPredicate.lean | stalkToFiber | There is a canonical map from the stalk to the original fiber, given by evaluating sections. |
stalkToFiber_germ (P : LocalPredicate T) (U : Opens X) (x : X) (hx : x ∈ U) (f) :
stalkToFiber P x ((subsheafToTypes P).presheaf.germ U x hx f) = f.1 ⟨x, hx⟩ := by
simp [Presheaf.germ, stalkToFiber] | theorem | Topology | [
"Mathlib.Topology.Sheaves.SheafOfFunctions",
"Mathlib.Topology.Sheaves.Stalks",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/LocalPredicate.lean | stalkToFiber_germ | null |
stalkToFiber_surjective (P : LocalPredicate T) (x : X)
(w : ∀ t : T x, ∃ (U : OpenNhds x) (f : ∀ y : U.1, T y) (_ : P.pred f), f ⟨x, U.2⟩ = t) :
Function.Surjective (stalkToFiber P x) := fun t ↦ by
rcases w t with ⟨U, f, h, rfl⟩
fconstructor
· exact (subsheafToTypes P).presheaf.germ _ x U.2 ⟨f, h⟩
· exact stalkToFiber_germ P U.1 x U.2 ⟨f, h⟩ | theorem | Topology | [
"Mathlib.Topology.Sheaves.SheafOfFunctions",
"Mathlib.Topology.Sheaves.Stalks",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/LocalPredicate.lean | stalkToFiber_surjective | The `stalkToFiber` map is surjective at `x` if
every point in the fiber `T x` has an allowed section passing through it. |
stalkToFiber_injective (P : LocalPredicate T) (x : X)
(w :
∀ (U V : OpenNhds x) (fU : ∀ y : U.1, T y) (_ : P.pred fU) (fV : ∀ y : V.1, T y)
(_ : P.pred fV) (_ : fU ⟨x, U.2⟩ = fV ⟨x, V.2⟩),
∃ (W : OpenNhds x) (iU : W ⟶ U) (iV : W ⟶ V), ∀ w : W.1,
fU (iU w : U.1) = fV (iV w : V.1)) :
Function.Injective (stalkToFiber P x) := fun tU tV h ↦ by
let Q :
∃ (W : (OpenNhds x)ᵒᵖ) (s : ∀ w : (unop W).1, T w) (hW : P.pred s),
tU = (subsheafToTypes P).presheaf.germ _ x (unop W).2 ⟨s, hW⟩ ∧
tV = (subsheafToTypes P).presheaf.germ _ x (unop W).2 ⟨s, hW⟩ :=
?_
· choose W s hW e using Q
exact e.1.trans e.2.symm
obtain ⟨U, ⟨fU, hU⟩, rfl⟩ := jointly_surjective' tU
obtain ⟨V, ⟨fV, hV⟩, rfl⟩ := jointly_surjective' tV
dsimp
simp only [stalkToFiber, Types.Colimit.ι_desc_apply] at h
specialize w (unop U) (unop V) fU hU fV hV h
rcases w with ⟨W, iU, iV, w⟩
refine ⟨op W, fun w ↦ fU (iU w : (unop U).1), P.res ?_ _ hU, ?_⟩
· rcases W with ⟨W, m⟩
exact iU
· exact ⟨colimit_sound iU.op (Subtype.eq rfl), colimit_sound iV.op (Subtype.eq (funext w).symm)⟩
universe u | theorem | Topology | [
"Mathlib.Topology.Sheaves.SheafOfFunctions",
"Mathlib.Topology.Sheaves.Stalks",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/LocalPredicate.lean | stalkToFiber_injective | The `stalkToFiber` map is injective at `x` if any two allowed sections which agree at `x`
agree on some neighborhood of `x`. |
subpresheafContinuousPrelocalIsoPresheafToTop {X : TopCat.{u}} (T : TopCat.{u}) :
subpresheafToTypes (continuousPrelocal X T) ≅ presheafToTop X T :=
NatIso.ofComponents fun X ↦
{ hom := by rintro ⟨f, c⟩; exact ofHom ⟨f, c⟩
inv := by rintro ⟨f, c⟩; exact ⟨f, c⟩ } | def | Topology | [
"Mathlib.Topology.Sheaves.SheafOfFunctions",
"Mathlib.Topology.Sheaves.Stalks",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/LocalPredicate.lean | subpresheafContinuousPrelocalIsoPresheafToTop | Some repackaging:
the presheaf of functions satisfying `continuousPrelocal` is just the same thing as
the presheaf of continuous functions. |
sheafToTop (T : TopCat) : Sheaf (Type _) X :=
⟨presheafToTop X T,
Presheaf.isSheaf_of_iso (subpresheafContinuousPrelocalIsoPresheafToTop T)
(subpresheafToTypes.isSheaf (continuousLocal X T))⟩ | def | Topology | [
"Mathlib.Topology.Sheaves.SheafOfFunctions",
"Mathlib.Topology.Sheaves.Stalks",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/LocalPredicate.lean | sheafToTop | The sheaf of continuous functions on `X` with values in a space `T`. |
@[simps! toSquare]
noncomputable mayerVietorisSquare' (sq : Square (Opens T))
(h₄ : sq.X₄ = sq.X₂ ⊔ sq.X₃) (h₁ : sq.X₁ = sq.X₂ ⊓ sq.X₃) :
(Opens.grothendieckTopology T).MayerVietorisSquare :=
GrothendieckTopology.MayerVietorisSquare.mk_of_isPullback
(J := (Opens.grothendieckTopology T)) sq
(Square.IsPullback.mk _ (by
refine PullbackCone.IsLimit.mk _ ?_ ?_ ?_ ?_
· intro s
apply homOfLE
rw [h₁, le_inf_iff]
exact ⟨leOfHom s.fst, leOfHom s.snd⟩
all_goals intros; apply Subsingleton.elim))
(fun x hx ↦ by
rw [h₄] at hx
obtain (hx | hx) := hx
· exact ⟨_, _, ⟨Sieve.ofArrows_mk _ _ WalkingPair.left, hx⟩⟩
· exact ⟨_, _, ⟨Sieve.ofArrows_mk _ _ WalkingPair.right, hx⟩⟩) | def | Topology | [
"Mathlib.CategoryTheory.Sites.MayerVietorisSquare",
"Mathlib.CategoryTheory.Sites.Spaces",
"Mathlib.CategoryTheory.Functor.ReflectsIso.Balanced"
] | Mathlib/Topology/Sheaves/MayerVietoris.lean | mayerVietorisSquare' | A square consisting of opens `X₂ ⊓ X₃`, `X₂`, `X₃` and `X₂ ⊔ X₃` is
a Mayer-Vietoris square. |
@[simps!]
noncomputable mayerVietorisSquare (U V : Opens T) :
(Opens.grothendieckTopology T).MayerVietorisSquare :=
mayerVietorisSquare'
{ X₁ := U ⊓ V
X₂ := U
X₃ := V
X₄ := U ⊔ V
f₁₂ := homOfLE inf_le_left
f₁₃ := homOfLE inf_le_right
f₂₄ := homOfLE le_sup_left
f₃₄ := homOfLE le_sup_right
fac := Subsingleton.elim _ _ } rfl rfl | def | Topology | [
"Mathlib.CategoryTheory.Sites.MayerVietorisSquare",
"Mathlib.CategoryTheory.Sites.Spaces",
"Mathlib.CategoryTheory.Functor.ReflectsIso.Balanced"
] | Mathlib/Topology/Sheaves/MayerVietoris.lean | mayerVietorisSquare | The Mayer-Vietoris square attached to two open subsets
of a topological space. |
Presheaf (X : TopCat.{w}) : Type max u v w :=
(Opens X)ᵒᵖ ⥤ 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 | Presheaf | The category of `C`-valued presheaves on a (bundled) topological space `X`. |
@[simp] comp_app {X : TopCat} {U : (Opens X)ᵒᵖ} {P Q R : Presheaf C X}
(f : P ⟶ Q) (g : Q ⟶ R) :
(f ≫ g).app U = f.app U ≫ g.app U := rfl
@[ext] | 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_app | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.