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 ∈ ... | 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
... | 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.... | 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 ... |
@[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)
... | 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]
e... | 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 ... | 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)... |
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_c... | 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... | 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.... | 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 := fu... | 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.I... |
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 ... | 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 _ _) Walki... | 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 _ _) Walk... | 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 _ _) Walking... | 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 _ _) Walkin... | 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 =... | 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) : Pr... | 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... |
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... | 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.ofCompone... | 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 sm... | 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... |
@[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)), p... | 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` t... |
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
spe... | 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 _,... | 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) :
... | 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_... | 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 ... | 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 ... | 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_... | 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⟩
· exa... | 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)) :
... | 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.IsP... | 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₃₄ := ... | 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.