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 ⌀ |
|---|---|---|---|---|---|---|
stalkFunctor_map_germ_apply' [ConcreteCategory C FC]
{F G : X.Presheaf C} (U : Opens X) (x : X) (hx : x ∈ U) (f : F ⟶ G) (s) :
DFunLike.coe (F := ToHom (F.stalk x) (G.stalk x))
(ConcreteCategory.hom ((stalkFunctor C x).map f)) (F.germ U x hx s) =
G.germ U x hx (f.app (op U) s) :=
stalkFunctor_map_germ_apply U x hx f s
variable (C) | theorem | Topology | [
"Mathlib.Topology.Category.TopCat.OpenNhds",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/Stalks.lean | stalkFunctor_map_germ_apply' | null |
stalkPushforward (f : X ⟶ Y) (F : X.Presheaf C) (x : X) : (f _* F).stalk (f x) ⟶ F.stalk x := by
refine ?_ ≫ colimit.pre _ (OpenNhds.map f x).op
exact colim.map (whiskerRight (NatTrans.op (OpenNhds.inclusionMapIso f x).inv) F)
@[reassoc (attr := simp), elementwise (attr := simp)] | def | Topology | [
"Mathlib.Topology.Category.TopCat.OpenNhds",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/Stalks.lean | stalkPushforward | For a presheaf `F` on a space `X`, a continuous map `f : X ⟶ Y` induces a morphisms between the
stalk of `f _ * F` at `f x` and the stalk of `F` at `x`. |
stalkPushforward_germ (f : X ⟶ Y) (F : X.Presheaf C) (U : Opens Y)
(x : X) (hx : f x ∈ U) :
(f _* F).germ U (f x) hx ≫ F.stalkPushforward C f x = F.germ ((Opens.map f).obj U) x hx := by
simp [germ, stalkPushforward] | theorem | Topology | [
"Mathlib.Topology.Category.TopCat.OpenNhds",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/Stalks.lean | stalkPushforward_germ | null |
@[simp]
id (ℱ : X.Presheaf C) (x : X) :
ℱ.stalkPushforward C (𝟙 X) x = (stalkFunctor C x).map (Pushforward.id ℱ).hom := by
ext
simp only [stalkPushforward, germ, colim_map, ι_colimMap_assoc, whiskerRight_app]
erw [CategoryTheory.Functor.map_id]
simp [stalkFunctor]
@[simp] | theorem | Topology | [
"Mathlib.Topology.Category.TopCat.OpenNhds",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/Stalks.lean | id | null |
comp (ℱ : X.Presheaf C) (f : X ⟶ Y) (g : Y ⟶ Z) (x : X) :
ℱ.stalkPushforward C (f ≫ g) x =
(f _* ℱ).stalkPushforward C g (f x) ≫ ℱ.stalkPushforward C f x := by
ext
simp [germ, stalkPushforward] | theorem | Topology | [
"Mathlib.Topology.Category.TopCat.OpenNhds",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/Stalks.lean | comp | null |
stalkPushforward_iso_of_isInducing {f : X ⟶ Y} (hf : IsInducing f)
(F : X.Presheaf C) (x : X) : IsIso (F.stalkPushforward _ f x) := by
haveI := Functor.initial_of_adjunction (hf.adjunctionNhds x)
convert (Functor.Final.colimitIso (OpenNhds.map f x).op ((OpenNhds.inclusion x).op ⋙ F)).isIso_hom
refine stalk_hom_ext _ fun U hU ↦ (stalkPushforward_germ _ f F _ x hU).trans ?_
symm
exact colimit.ι_pre ((OpenNhds.inclusion x).op ⋙ F) (OpenNhds.map f x).op _ | theorem | Topology | [
"Mathlib.Topology.Category.TopCat.OpenNhds",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/Stalks.lean | stalkPushforward_iso_of_isInducing | null |
stalkPullbackHom (f : X ⟶ Y) (F : Y.Presheaf C) (x : X) :
F.stalk (f x) ⟶ ((pullback C f).obj F).stalk x :=
(stalkFunctor _ (f x)).map ((pushforwardPullbackAdjunction C f).unit.app F) ≫
stalkPushforward _ _ _ x
@[reassoc (attr := simp)] | def | Topology | [
"Mathlib.Topology.Category.TopCat.OpenNhds",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/Stalks.lean | stalkPullbackHom | The morphism `ℱ_{f x} ⟶ (f⁻¹ℱ)ₓ` that factors through `(f_*f⁻¹ℱ)_{f x}`. |
germ_stalkPullbackHom
(f : X ⟶ Y) (F : Y.Presheaf C) (x : X) (U : Opens Y) (hU : f x ∈ U) :
F.germ U (f x) hU ≫ stalkPullbackHom C f F x =
((pushforwardPullbackAdjunction C f).unit.app F).app _ ≫
((pullback C f).obj F).germ ((Opens.map f).obj U) x hU := by
simp [stalkPullbackHom, germ, stalkFunctor, stalkPushforward] | lemma | Topology | [
"Mathlib.Topology.Category.TopCat.OpenNhds",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/Stalks.lean | germ_stalkPullbackHom | null |
germToPullbackStalk (f : X ⟶ Y) (F : Y.Presheaf C) (U : Opens X) (x : X) (hx : x ∈ U) :
((pullback C f).obj F).obj (op U) ⟶ F.stalk (f x) :=
((Opens.map f).op.isPointwiseLeftKanExtensionLeftKanExtensionUnit F (op U)).desc
{ pt := F.stalk ((f : X → Y) (x : X))
ι :=
{ app := fun V => F.germ _ (f x) (V.hom.unop.le hx)
naturality := fun _ _ i => by simp } }
variable {C} in
@[ext] | def | Topology | [
"Mathlib.Topology.Category.TopCat.OpenNhds",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/Stalks.lean | germToPullbackStalk | The morphism `(f⁻¹ℱ)(U) ⟶ ℱ_{f(x)}` for some `U ∋ x`. |
pullback_obj_obj_ext {Z : C} {f : X ⟶ Y} {F : Y.Presheaf C} (U : (Opens X)ᵒᵖ)
{φ ψ : ((pullback C f).obj F).obj U ⟶ Z}
(h : ∀ (V : Opens Y) (hV : U.unop ≤ (Opens.map f).obj V),
((pushforwardPullbackAdjunction C f).unit.app F).app (op V) ≫
((pullback C f).obj F).map (homOfLE hV).op ≫ φ =
((pushforwardPullbackAdjunction C f).unit.app F).app (op V) ≫
((pullback C f).obj F).map (homOfLE hV).op ≫ ψ) : φ = ψ := by
obtain ⟨U⟩ := U
apply ((Opens.map f).op.isPointwiseLeftKanExtensionLeftKanExtensionUnit F _).hom_ext
rintro ⟨⟨V⟩, ⟨⟩, ⟨b⟩⟩
simpa [pushforwardPullbackAdjunction, Functor.lanAdjunction_unit]
using h V (leOfHom b)
@[reassoc (attr := simp)] | lemma | Topology | [
"Mathlib.Topology.Category.TopCat.OpenNhds",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/Stalks.lean | pullback_obj_obj_ext | null |
pushforwardPullbackAdjunction_unit_pullback_map_germToPullbackStalk
(f : X ⟶ Y) (F : Y.Presheaf C) (U : Opens X) (x : X) (hx : x ∈ U) (V : Opens Y)
(hV : U ≤ (Opens.map f).obj V) :
((pushforwardPullbackAdjunction C f).unit.app F).app (op V) ≫
((pullback C f).obj F).map (homOfLE hV).op ≫ germToPullbackStalk C f F U x hx =
F.germ _ (f x) (hV hx) := by
simpa [pushforwardPullbackAdjunction] using
((Opens.map f).op.isPointwiseLeftKanExtensionLeftKanExtensionUnit F (op U)).fac _
(CostructuredArrow.mk (homOfLE hV).op)
@[reassoc (attr := simp)] | lemma | Topology | [
"Mathlib.Topology.Category.TopCat.OpenNhds",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/Stalks.lean | pushforwardPullbackAdjunction_unit_pullback_map_germToPullbackStalk | null |
germToPullbackStalk_stalkPullbackHom
(f : X ⟶ Y) (F : Y.Presheaf C) (U : Opens X) (x : X) (hx : x ∈ U) :
germToPullbackStalk C f F U x hx ≫ stalkPullbackHom C f F x =
((pullback C f).obj F).germ _ x hx := by
ext V hV
dsimp
simp only [pushforwardPullbackAdjunction_unit_pullback_map_germToPullbackStalk_assoc,
germ_stalkPullbackHom, germ_res]
@[reassoc (attr := simp)] | lemma | Topology | [
"Mathlib.Topology.Category.TopCat.OpenNhds",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/Stalks.lean | germToPullbackStalk_stalkPullbackHom | null |
pushforwardPullbackAdjunction_unit_app_app_germToPullbackStalk
(f : X ⟶ Y) (F : Y.Presheaf C) (V : (Opens Y)ᵒᵖ) (x : X) (hx : f x ∈ V.unop) :
((pushforwardPullbackAdjunction C f).unit.app F).app V ≫ germToPullbackStalk C f F _ x hx =
F.germ _ (f x) hx := by
simpa using pushforwardPullbackAdjunction_unit_pullback_map_germToPullbackStalk
C f F ((Opens.map f).obj V.unop) x hx V.unop (by rfl) | lemma | Topology | [
"Mathlib.Topology.Category.TopCat.OpenNhds",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/Stalks.lean | pushforwardPullbackAdjunction_unit_app_app_germToPullbackStalk | null |
stalkPullbackInv (f : X ⟶ Y) (F : Y.Presheaf C) (x : X) :
((pullback C f).obj F).stalk x ⟶ F.stalk (f x) :=
colimit.desc ((OpenNhds.inclusion x).op ⋙ (Presheaf.pullback C f).obj F)
{ pt := F.stalk (f x)
ι :=
{ app := fun U => F.germToPullbackStalk _ f (unop U).1 x (unop U).2
naturality := fun U V i => by
dsimp
ext W hW
dsimp [OpenNhds.inclusion]
rw [Category.comp_id, ← Functor.map_comp_assoc,
pushforwardPullbackAdjunction_unit_pullback_map_germToPullbackStalk]
erw [pushforwardPullbackAdjunction_unit_pullback_map_germToPullbackStalk] } }
@[reassoc (attr := simp)] | def | Topology | [
"Mathlib.Topology.Category.TopCat.OpenNhds",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/Stalks.lean | stalkPullbackInv | The morphism `(f⁻¹ℱ)ₓ ⟶ ℱ_{f(x)}`. |
germ_stalkPullbackInv (f : X ⟶ Y) (F : Y.Presheaf C) (x : X) (V : Opens X) (hV : x ∈ V) :
((pullback C f).obj F).germ _ x hV ≫ stalkPullbackInv C f F x =
F.germToPullbackStalk _ f V x hV := by
apply colimit.ι_desc | lemma | Topology | [
"Mathlib.Topology.Category.TopCat.OpenNhds",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/Stalks.lean | germ_stalkPullbackInv | null |
stalkPullbackIso (f : X ⟶ Y) (F : Y.Presheaf C) (x : X) :
F.stalk (f x) ≅ ((pullback C f).obj F).stalk x where
hom := stalkPullbackHom _ _ _ _
inv := stalkPullbackInv _ _ _ _
hom_inv_id := by
ext U hU
dsimp
rw [germ_stalkPullbackHom_assoc, germ_stalkPullbackInv, Category.comp_id,
pushforwardPullbackAdjunction_unit_app_app_germToPullbackStalk]
inv_hom_id := by
ext V hV
dsimp
rw [germ_stalkPullbackInv_assoc, Category.comp_id, germToPullbackStalk_stalkPullbackHom] | def | Topology | [
"Mathlib.Topology.Category.TopCat.OpenNhds",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/Stalks.lean | stalkPullbackIso | The isomorphism `ℱ_{f(x)} ≅ (f⁻¹ℱ)ₓ`. |
noncomputable stalkSpecializes (F : X.Presheaf C) {x y : X} (h : x ⤳ y) :
F.stalk y ⟶ F.stalk x := by
refine colimit.desc _ ⟨_, fun U => ?_, ?_⟩
· exact
colimit.ι ((OpenNhds.inclusion x).op ⋙ F)
(op ⟨(unop U).1, (specializes_iff_forall_open.mp h _ (unop U).1.2 (unop U).2 :)⟩)
· intro U V i
dsimp
rw [Category.comp_id]
let U' : OpenNhds x := ⟨_, (specializes_iff_forall_open.mp h _ (unop U).1.2 (unop U).2 :)⟩
let V' : OpenNhds x := ⟨_, (specializes_iff_forall_open.mp h _ (unop V).1.2 (unop V).2 :)⟩
exact colimit.w ((OpenNhds.inclusion x).op ⋙ F) (show V' ⟶ U' from i.unop).op
@[reassoc (attr := simp), elementwise nosimp] | def | Topology | [
"Mathlib.Topology.Category.TopCat.OpenNhds",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/Stalks.lean | stalkSpecializes | If `x` specializes to `y`, then there is a natural map `F.stalk y ⟶ F.stalk x`. |
germ_stalkSpecializes (F : X.Presheaf C)
{U : Opens X} {y : X} (hy : y ∈ U) {x : X} (h : x ⤳ y) :
F.germ U y hy ≫ F.stalkSpecializes h = F.germ U x (h.mem_open U.isOpen hy) :=
colimit.ι_desc _ _
@[simp] | theorem | Topology | [
"Mathlib.Topology.Category.TopCat.OpenNhds",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/Stalks.lean | germ_stalkSpecializes | null |
stalkSpecializes_refl {C : Type*} [Category C] [Limits.HasColimits C] {X : TopCat}
(F : X.Presheaf C) (x : X) : F.stalkSpecializes (specializes_refl x) = 𝟙 _ := by
ext
simp
@[reassoc (attr := simp), elementwise (attr := simp)] | theorem | Topology | [
"Mathlib.Topology.Category.TopCat.OpenNhds",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/Stalks.lean | stalkSpecializes_refl | null |
stalkSpecializes_comp {C : Type*} [Category C] [Limits.HasColimits C] {X : TopCat}
(F : X.Presheaf C) {x y z : X} (h : x ⤳ y) (h' : y ⤳ z) :
F.stalkSpecializes h' ≫ F.stalkSpecializes h = F.stalkSpecializes (h.trans h') := by
ext
simp
@[reassoc (attr := simp), elementwise (attr := simp)] | theorem | Topology | [
"Mathlib.Topology.Category.TopCat.OpenNhds",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/Stalks.lean | stalkSpecializes_comp | null |
stalkSpecializes_stalkFunctor_map {F G : X.Presheaf C} (f : F ⟶ G) {x y : X} (h : x ⤳ y) :
F.stalkSpecializes h ≫ (stalkFunctor C x).map f =
(stalkFunctor C y).map f ≫ G.stalkSpecializes h := by
change (_ : colimit _ ⟶ _) = (_ : colimit _ ⟶ _)
ext; delta stalkFunctor; simpa [stalkSpecializes] using by rfl
@[reassoc (attr := simp), elementwise (attr := simp)] | theorem | Topology | [
"Mathlib.Topology.Category.TopCat.OpenNhds",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/Stalks.lean | stalkSpecializes_stalkFunctor_map | null |
stalkSpecializes_stalkPushforward (f : X ⟶ Y) (F : X.Presheaf C) {x y : X} (h : x ⤳ y) :
(f _* F).stalkSpecializes (f.hom.map_specializes h) ≫ F.stalkPushforward _ f x =
F.stalkPushforward _ f y ≫ F.stalkSpecializes h := by
change (_ : colimit _ ⟶ _) = (_ : colimit _ ⟶ _)
ext; delta stalkPushforward
simp only [stalkSpecializes, colimit.ι_desc_assoc, colimit.ι_map_assoc, colimit.ι_pre,
Category.assoc, colimit.pre_desc, colimit.ι_desc]
rfl | theorem | Topology | [
"Mathlib.Topology.Category.TopCat.OpenNhds",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/Stalks.lean | stalkSpecializes_stalkPushforward | null |
@[simps]
stalkCongr {X : TopCat} {C : Type*} [Category C] [HasColimits C] (F : X.Presheaf C) {x y : X}
(e : Inseparable x y) : F.stalk x ≅ F.stalk y :=
⟨F.stalkSpecializes e.ge, F.stalkSpecializes e.le, by simp, by simp⟩ | def | Topology | [
"Mathlib.Topology.Category.TopCat.OpenNhds",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/Stalks.lean | stalkCongr | The stalks are isomorphic on inseparable points |
germ_ext (F : X.Presheaf C) {U V : Opens X} {x : X} {hxU : x ∈ U} {hxV : x ∈ V}
(W : Opens X) (hxW : x ∈ W) (iWU : W ⟶ U) (iWV : W ⟶ V)
{sU : ToType (F.obj (op U))} {sV : ToType (F.obj (op V))}
(ih : F.map iWU.op sU = F.map iWV.op sV) :
F.germ _ x hxU sU = F.germ _ x hxV sV := by
rw [← F.germ_res iWU x hxW, ← F.germ_res iWV x hxW, ConcreteCategory.comp_apply,
ConcreteCategory.comp_apply, ih]
variable [PreservesFilteredColimits (forget C)] | theorem | Topology | [
"Mathlib.Topology.Category.TopCat.OpenNhds",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/Stalks.lean | germ_ext | null |
germ_exist (F : X.Presheaf C) (x : X) (t : ToType (stalk.{v, u} F x)) :
∃ (U : Opens X) (m : x ∈ U) (s : ToType (F.obj (op U))), F.germ _ x m s = t := by
obtain ⟨U, s, e⟩ :=
Types.jointly_surjective.{v, v} _ (isColimitOfPreserves (forget C) (colimit.isColimit _)) t
revert s e
induction U with | op U => ?_
obtain ⟨V, m⟩ := U
intro s e
exact ⟨V, m, s, e⟩ | theorem | Topology | [
"Mathlib.Topology.Category.TopCat.OpenNhds",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/Stalks.lean | germ_exist | For presheaves valued in a concrete category whose forgetful functor preserves filtered colimits,
every element of the stalk is the germ of a section. |
germ_eq (F : X.Presheaf C) {U V : Opens X} (x : X) (mU : x ∈ U) (mV : x ∈ V)
(s : ToType (F.obj (op U))) (t : ToType (F.obj (op V)))
(h : F.germ U x mU s = F.germ V x mV t) :
∃ (W : Opens X) (_m : x ∈ W) (iU : W ⟶ U) (iV : W ⟶ V), F.map iU.op s = F.map iV.op t := by
obtain ⟨W, iU, iV, e⟩ :=
(Types.FilteredColimit.isColimit_eq_iff.{v, v} _
(isColimitOfPreserves (forget C) (colimit.isColimit ((OpenNhds.inclusion x).op ⋙ F)))).mp
h
exact ⟨(unop W).1, (unop W).2, iU.unop, iV.unop, e⟩ | theorem | Topology | [
"Mathlib.Topology.Category.TopCat.OpenNhds",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/Stalks.lean | germ_eq | null |
stalkFunctor_map_injective_of_app_injective {F G : Presheaf C X} {f : F ⟶ G}
(h : ∀ U : Opens X, Function.Injective (f.app (op U))) (x : X) :
Function.Injective ((stalkFunctor C x).map f) := fun s t hst => by
rcases germ_exist F x s with ⟨U₁, hxU₁, s, rfl⟩
rcases germ_exist F x t with ⟨U₂, hxU₂, t, rfl⟩
rw [stalkFunctor_map_germ_apply, stalkFunctor_map_germ_apply] at hst
obtain ⟨W, hxW, iWU₁, iWU₂, heq⟩ := G.germ_eq x hxU₁ hxU₂ _ _ hst
rw [← ConcreteCategory.comp_apply, ← ConcreteCategory.comp_apply, ← f.naturality, ← f.naturality,
ConcreteCategory.comp_apply, ConcreteCategory.comp_apply] at heq
replace heq := h W heq
convert congr_arg (F.germ _ x hxW) heq using 1
exacts [(F.germ_res_apply iWU₁ x hxW s).symm, (F.germ_res_apply iWU₂ x hxW t).symm] | theorem | Topology | [
"Mathlib.Topology.Category.TopCat.OpenNhds",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/Stalks.lean | stalkFunctor_map_injective_of_app_injective | null |
germ_exist_of_isBasis (F : X.Presheaf C) (x : X) (t : ToType (F.stalk x)) :
∃ (U : Opens X) (m : x ∈ U) (_ : U ∈ B) (s : ToType (F.obj (op U))), F.germ _ x m s = t := by
obtain ⟨U, hxU, s, rfl⟩ := F.germ_exist x t
obtain ⟨_, ⟨V, hV, rfl⟩, hxV, hVU⟩ := hB.exists_subset_of_mem_open hxU U.2
exact ⟨V, hxV, hV, F.map (homOfLE hVU).op s, by rw [← ConcreteCategory.comp_apply, F.germ_res']⟩ | lemma | Topology | [
"Mathlib.Topology.Category.TopCat.OpenNhds",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/Stalks.lean | germ_exist_of_isBasis | null |
germ_eq_of_isBasis (F : X.Presheaf C) {U V : Opens X} (x : X) (mU : x ∈ U) (mV : x ∈ V)
{s : ToType (F.obj (op U))} {t : ToType (F.obj (op V))}
(h : F.germ U x mU s = F.germ V x mV t) :
∃ (W : Opens X) (_ : x ∈ W) (_ : W ∈ B) (hWU : W ≤ U) (hWV : W ≤ V),
F.map (homOfLE hWU).op s = F.map (homOfLE hWV).op t := by
obtain ⟨W, hxW, hWU, hWV, e⟩ := F.germ_eq x mU mV _ _ h
obtain ⟨_, ⟨W', hW', rfl⟩, hxW', hW'W⟩ := hB.exists_subset_of_mem_open hxW W.2
refine ⟨W', hxW', hW', hW'W.trans hWU.le, hW'W.trans hWV.le, ?_⟩
simpa only [← ConcreteCategory.comp_apply, ← F.map_comp] using
DFunLike.congr_arg (ConcreteCategory.hom (F.map (homOfLE hW'W).op)) e | lemma | Topology | [
"Mathlib.Topology.Category.TopCat.OpenNhds",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/Stalks.lean | germ_eq_of_isBasis | null |
stalkFunctor_map_injective_of_isBasis
{F G : X.Presheaf C} {α : F ⟶ G} (hα : ∀ U ∈ B, Function.Injective (α.app (op U))) (x : X) :
Function.Injective ((stalkFunctor _ x).map α) := by
intro s t hst
obtain ⟨U₁, hxU₁, hU₁, s, rfl⟩ := germ_exist_of_isBasis hB _ x s
obtain ⟨U₂, hxU₂, hU₂, t, rfl⟩ := germ_exist_of_isBasis hB _ x t
rw [stalkFunctor_map_germ_apply, stalkFunctor_map_germ_apply] at hst
obtain ⟨W, hxW, hW, iWU₁, iWU₂, heq⟩ := germ_eq_of_isBasis hB _ _ hxU₁ hxU₂ hst
simp only [← α.naturality_apply, (hα W hW).eq_iff] at heq
simpa [germ_res_apply'] using congr(F.germ W x hxW $heq) | lemma | Topology | [
"Mathlib.Topology.Category.TopCat.OpenNhds",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/Stalks.lean | stalkFunctor_map_injective_of_isBasis | null |
section_ext (F : Sheaf C X) (U : Opens X) (s t : ToType (F.1.obj (op U)))
(h : ∀ (x : X) (hx : x ∈ U), F.presheaf.germ U x hx s = F.presheaf.germ U x hx t) : s = t := by
choose V m i₁ i₂ heq using fun x : U => F.presheaf.germ_eq x.1 x.2 x.2 s t (h x.1 x.2)
apply F.eq_of_locally_eq' V U i₁
· intro x hxU
simp only [Opens.coe_iSup, Set.mem_iUnion, SetLike.mem_coe]
exact ⟨⟨x, hxU⟩, m ⟨x, hxU⟩⟩
· intro x
rw [heq, Subsingleton.elim (i₁ x) (i₂ x)]
/-
Note that the analogous statement for surjectivity is false: Surjectivity on stalks does not
imply surjectivity of the components of a sheaf morphism. However it does imply that the morphism
is an epi, but this fact is not yet formalized.
-/ | theorem | Topology | [
"Mathlib.Topology.Category.TopCat.OpenNhds",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/Stalks.lean | section_ext | Let `F` be a sheaf valued in a concrete category, whose forgetful functor reflects isomorphisms,
preserves limits and filtered colimits. Then two sections who agree on every stalk must be equal. |
app_injective_of_stalkFunctor_map_injective {F : Sheaf C X} {G : Presheaf C X} (f : F.1 ⟶ G)
(U : Opens X) (h : ∀ x ∈ U, Function.Injective ((stalkFunctor C x).map f)) :
Function.Injective (f.app (op U)) := fun s t hst =>
section_ext F _ _ _ fun x hx =>
h x hx <| by rw [stalkFunctor_map_germ_apply, stalkFunctor_map_germ_apply, hst] | theorem | Topology | [
"Mathlib.Topology.Category.TopCat.OpenNhds",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/Stalks.lean | app_injective_of_stalkFunctor_map_injective | null |
app_injective_iff_stalkFunctor_map_injective {F : Sheaf C X} {G : Presheaf C X}
(f : F.1 ⟶ G) :
(∀ x : X, Function.Injective ((stalkFunctor C x).map f)) ↔
∀ U : Opens X, Function.Injective (f.app (op U)) :=
⟨fun h U => app_injective_of_stalkFunctor_map_injective f U fun x _ => h x,
stalkFunctor_map_injective_of_app_injective⟩ | theorem | Topology | [
"Mathlib.Topology.Category.TopCat.OpenNhds",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/Stalks.lean | app_injective_iff_stalkFunctor_map_injective | null |
stalkFunctor_preserves_mono (x : X) :
Functor.PreservesMonomorphisms (Sheaf.forget.{v} C X ⋙ stalkFunctor C x) :=
⟨@fun _𝓐 _𝓑 f _ =>
ConcreteCategory.mono_of_injective _ <|
(app_injective_iff_stalkFunctor_map_injective f.1).mpr
(fun c =>
(ConcreteCategory.mono_iff_injective_of_preservesPullback (f.1.app (op c))).mp
((NatTrans.mono_iff_mono_app f.1).mp
(CategoryTheory.presheaf_mono_of_mono ..) <|
op c))
x⟩
include instCC in | instance | Topology | [
"Mathlib.Topology.Category.TopCat.OpenNhds",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/Stalks.lean | stalkFunctor_preserves_mono | null |
stalk_mono_of_mono {F G : Sheaf C X} (f : F ⟶ G) [Mono f] :
∀ x, Mono <| (stalkFunctor C x).map f.1 :=
fun x => Functor.map_mono (Sheaf.forget.{v} C X ⋙ stalkFunctor C x) f
include instCC in | theorem | Topology | [
"Mathlib.Topology.Category.TopCat.OpenNhds",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/Stalks.lean | stalk_mono_of_mono | null |
mono_of_stalk_mono {F G : Sheaf C X} (f : F ⟶ G) [∀ x, Mono <| (stalkFunctor C x).map f.1] :
Mono f :=
(Sheaf.Hom.mono_iff_presheaf_mono _ _ _).mpr <|
(NatTrans.mono_iff_mono_app _).mpr fun U =>
(ConcreteCategory.mono_iff_injective_of_preservesPullback _).mpr <|
app_injective_of_stalkFunctor_map_injective f.1 U.unop fun _x _hx =>
(ConcreteCategory.mono_iff_injective_of_preservesPullback
((stalkFunctor C _).map f.val)).mp <| inferInstance
include instCC in | theorem | Topology | [
"Mathlib.Topology.Category.TopCat.OpenNhds",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/Stalks.lean | mono_of_stalk_mono | null |
mono_iff_stalk_mono {F G : Sheaf C X} (f : F ⟶ G) :
Mono f ↔ ∀ x, Mono ((stalkFunctor C x).map f.1) :=
⟨fun _ => stalk_mono_of_mono _, fun _ => mono_of_stalk_mono _⟩ | theorem | Topology | [
"Mathlib.Topology.Category.TopCat.OpenNhds",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/Stalks.lean | mono_iff_stalk_mono | null |
app_surjective_of_injective_of_locally_surjective {F G : Sheaf C X} (f : F ⟶ G)
(U : Opens X) (hinj : ∀ x ∈ U, Function.Injective ((stalkFunctor C x).map f.1))
(hsurj : ∀ (t x) (_ : x ∈ U), ∃ (V : Opens X) (_ : x ∈ V) (iVU : V ⟶ U)
(s : ToType (F.1.obj (op V))), f.1.app (op V) s = G.1.map iVU.op t) :
Function.Surjective (f.1.app (op U)) := by
conv at hsurj =>
enter [t]
rw [Subtype.forall' (p := (· ∈ U))]
intro t
choose V mV iVU sf heq using hsurj t
have V_cover : U ≤ iSup V := by
intro x hxU
simp only [Opens.coe_iSup, Set.mem_iUnion, SetLike.mem_coe]
exact ⟨⟨x, hxU⟩, mV ⟨x, hxU⟩⟩
suffices IsCompatible F.val V sf by
obtain ⟨s, s_spec, -⟩ := F.existsUnique_gluing' V U iVU V_cover sf this
· use s
apply G.eq_of_locally_eq' V U iVU V_cover
intro x
rw [← ConcreteCategory.comp_apply, ← f.1.naturality, ConcreteCategory.comp_apply, s_spec, heq]
intro x y
apply section_ext
intro z hz
apply hinj z ((iVU x).le ((inf_le_left : V x ⊓ V y ≤ V x) hz))
dsimp only
rw [stalkFunctor_map_germ_apply, stalkFunctor_map_germ_apply]
simp_rw [← ConcreteCategory.comp_apply, f.1.naturality, ConcreteCategory.comp_apply, heq,
← ConcreteCategory.comp_apply, ← G.1.map_comp]
rfl | theorem | Topology | [
"Mathlib.Topology.Category.TopCat.OpenNhds",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/Stalks.lean | app_surjective_of_injective_of_locally_surjective | For surjectivity, we are given an arbitrary section `t` and need to find a preimage for it.
We claim that it suffices to find preimages *locally*. That is, for each `x : U` we construct
a neighborhood `V ≤ U` and a section `s : F.obj (op V))` such that `f.app (op V) s` and `t`
agree on `V`. |
app_surjective_of_stalkFunctor_map_bijective {F G : Sheaf C X} (f : F ⟶ G) (U : Opens X)
(h : ∀ x ∈ U, Function.Bijective ((stalkFunctor C x).map f.1)) :
Function.Surjective (f.1.app (op U)) := by
refine app_surjective_of_injective_of_locally_surjective f U (And.left <| h · ·) fun t x hx => ?_
obtain ⟨s₀, hs₀⟩ := (h x hx).2 (G.presheaf.germ U x hx t)
obtain ⟨V₁, hxV₁, s₁, hs₁⟩ := F.presheaf.germ_exist x s₀
subst hs₁; rename' hs₀ => hs₁
rw [stalkFunctor_map_germ_apply V₁ x hxV₁ f.1 s₁] at hs₁
obtain ⟨V₂, hxV₂, iV₂V₁, iV₂U, heq⟩ := G.presheaf.germ_eq x hxV₁ hx _ _ hs₁
use V₂, hxV₂, iV₂U, F.1.map iV₂V₁.op s₁
rw [← ConcreteCategory.comp_apply, f.1.naturality, ConcreteCategory.comp_apply, heq] | theorem | Topology | [
"Mathlib.Topology.Category.TopCat.OpenNhds",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/Stalks.lean | app_surjective_of_stalkFunctor_map_bijective | null |
app_bijective_of_stalkFunctor_map_bijective {F G : Sheaf C X} (f : F ⟶ G) (U : Opens X)
(h : ∀ x ∈ U, Function.Bijective ((stalkFunctor C x).map f.1)) :
Function.Bijective (f.1.app (op U)) :=
⟨app_injective_of_stalkFunctor_map_injective f.1 U fun x hx => (h x hx).1,
app_surjective_of_stalkFunctor_map_bijective f U h⟩
include instCC in | theorem | Topology | [
"Mathlib.Topology.Category.TopCat.OpenNhds",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/Stalks.lean | app_bijective_of_stalkFunctor_map_bijective | null |
app_isIso_of_stalkFunctor_map_iso {F G : Sheaf C X} (f : F ⟶ G) (U : Opens X)
[∀ x : U, IsIso ((stalkFunctor C x.val).map f.1)] : IsIso (f.1.app (op U)) := by
suffices IsIso ((forget C).map (f.1.app (op U))) by
exact isIso_of_reflects_iso (f.1.app (op U)) (forget C)
rw [isIso_iff_bijective]
apply app_bijective_of_stalkFunctor_map_bijective
intro x hx
apply (isIso_iff_bijective _).mp
exact Functor.map_isIso (forget C) ((stalkFunctor C (⟨x, hx⟩ : U).1).map f.1)
include instCC in | theorem | Topology | [
"Mathlib.Topology.Category.TopCat.OpenNhds",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/Stalks.lean | app_isIso_of_stalkFunctor_map_iso | null |
isIso_of_stalkFunctor_map_iso {F G : Sheaf C X} (f : F ⟶ G)
[∀ x : X, IsIso ((stalkFunctor C x).map f.1)] : IsIso f := by
suffices IsIso ((Sheaf.forget C X).map f) by exact isIso_of_fully_faithful (Sheaf.forget C X) f
suffices ∀ U : (Opens X)ᵒᵖ, IsIso (f.1.app U) by
exact @NatIso.isIso_of_isIso_app _ _ _ _ F.1 G.1 f.1 this
intro U; induction U
apply app_isIso_of_stalkFunctor_map_iso
include instCC in | theorem | Topology | [
"Mathlib.Topology.Category.TopCat.OpenNhds",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/Stalks.lean | isIso_of_stalkFunctor_map_iso | Let `F` and `G` be sheaves valued in a concrete category, whose forgetful functor reflects
isomorphisms, preserves limits and filtered colimits. Then if the stalk maps of a morphism
`f : F ⟶ G` are all isomorphisms, `f` must be an isomorphism. |
isIso_iff_stalkFunctor_map_iso {F G : Sheaf C X} (f : F ⟶ G) :
IsIso f ↔ ∀ x : X, IsIso ((stalkFunctor C x).map f.1) :=
⟨fun _ x =>
@Functor.map_isIso _ _ _ _ _ _ (stalkFunctor C x) f.1 ((Sheaf.forget C X).map_isIso f),
fun _ => isIso_of_stalkFunctor_map_iso f⟩ | theorem | Topology | [
"Mathlib.Topology.Category.TopCat.OpenNhds",
"Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing"
] | Mathlib/Topology/Sheaves/Stalks.lean | isIso_iff_stalkFunctor_map_iso | Let `F` and `G` be sheaves valued in a concrete category, whose forgetful functor reflects
isomorphisms, preserves limits and filtered colimits. Then a morphism `f : F ⟶ G` is an
isomorphism if and only if all of its stalk maps are isomorphisms. |
@[stacks 08YG]
SpectralSpace : Prop extends
T0Space α, CompactSpace α, QuasiSober α, QuasiSeparatedSpace α, PrespectralSpace α | class | Topology | [
"Mathlib.Topology.Sober",
"Mathlib.Topology.Spectral.Prespectral"
] | Mathlib/Topology/Spectral/Basic.lean | SpectralSpace | A topological space is spectral if it is T0, compact, sober, quasi-separated, and its compact open
subsets form an open basis. |
@[stacks 005A, stacks 08YG]
IsSpectralMap (f : α → β) : Prop extends Continuous f where
/-- A function between topological spaces is spectral if it is continuous and the preimage of
every compact open set is compact open. -/
isCompact_preimage_of_isOpen ⦃s : Set β⦄ : IsOpen s → IsCompact s → IsCompact (f ⁻¹' s) | structure | Topology | [
"Mathlib.Tactic.StacksAttribute",
"Mathlib.Topology.ContinuousMap.Basic",
"Mathlib.Topology.Maps.Proper.Basic"
] | Mathlib/Topology/Spectral/Hom.lean | IsSpectralMap | A function between topological spaces is spectral if it is continuous and the preimage of every
compact open set is compact open. |
IsCompact.preimage_of_isOpen (hf : IsSpectralMap f) (h₀ : IsCompact s) (h₁ : IsOpen s) :
IsCompact (f ⁻¹' s) :=
hf.isCompact_preimage_of_isOpen h₁ h₀ | theorem | Topology | [
"Mathlib.Tactic.StacksAttribute",
"Mathlib.Topology.ContinuousMap.Basic",
"Mathlib.Topology.Maps.Proper.Basic"
] | Mathlib/Topology/Spectral/Hom.lean | IsCompact.preimage_of_isOpen | null |
IsSpectralMap.continuous {f : α → β} (hf : IsSpectralMap f) : Continuous f :=
hf.toContinuous | theorem | Topology | [
"Mathlib.Tactic.StacksAttribute",
"Mathlib.Topology.ContinuousMap.Basic",
"Mathlib.Topology.Maps.Proper.Basic"
] | Mathlib/Topology/Spectral/Hom.lean | IsSpectralMap.continuous | null |
isSpectralMap_id : IsSpectralMap (@id α) :=
⟨continuous_id, fun _s _ => id⟩
@[stacks 005B] | theorem | Topology | [
"Mathlib.Tactic.StacksAttribute",
"Mathlib.Topology.ContinuousMap.Basic",
"Mathlib.Topology.Maps.Proper.Basic"
] | Mathlib/Topology/Spectral/Hom.lean | isSpectralMap_id | null |
IsSpectralMap.comp {f : β → γ} {g : α → β} (hf : IsSpectralMap f) (hg : IsSpectralMap g) :
IsSpectralMap (f ∘ g) :=
⟨hf.continuous.comp hg.continuous, fun _s hs₀ hs₁ =>
((hs₁.preimage_of_isOpen hf hs₀).preimage_of_isOpen hg) (hs₀.preimage hf.continuous)⟩ | theorem | Topology | [
"Mathlib.Tactic.StacksAttribute",
"Mathlib.Topology.ContinuousMap.Basic",
"Mathlib.Topology.Maps.Proper.Basic"
] | Mathlib/Topology/Spectral/Hom.lean | IsSpectralMap.comp | null |
IsProperMap.isSpectralMap {f : α → β} (hf : IsProperMap f) : IsSpectralMap f :=
⟨hf.toContinuous, fun _ _ ↦ hf.isCompact_preimage⟩ | theorem | Topology | [
"Mathlib.Tactic.StacksAttribute",
"Mathlib.Topology.ContinuousMap.Basic",
"Mathlib.Topology.Maps.Proper.Basic"
] | Mathlib/Topology/Spectral/Hom.lean | IsProperMap.isSpectralMap | null |
SpectralMap (α β : Type*) [TopologicalSpace α] [TopologicalSpace β] where
/-- function between topological spaces -/
toFun : α → β
/-- proof that `toFun` is a spectral map -/
spectral' : IsSpectralMap toFun | structure | Topology | [
"Mathlib.Tactic.StacksAttribute",
"Mathlib.Topology.ContinuousMap.Basic",
"Mathlib.Topology.Maps.Proper.Basic"
] | Mathlib/Topology/Spectral/Hom.lean | SpectralMap | The type of spectral maps from `α` to `β`. |
SpectralMapClass (F α β : Type*) [TopologicalSpace α] [TopologicalSpace β]
[FunLike F α β] : Prop where
/-- statement that `F` is a type of spectral maps -/
map_spectral (f : F) : IsSpectralMap f | class | Topology | [
"Mathlib.Tactic.StacksAttribute",
"Mathlib.Topology.ContinuousMap.Basic",
"Mathlib.Topology.Maps.Proper.Basic"
] | Mathlib/Topology/Spectral/Hom.lean | SpectralMapClass | `SpectralMapClass F α β` states that `F` is a type of spectral maps.
You should extend this class when you extend `SpectralMap`. |
toContinuousMap (f : SpectralMap α β) : ContinuousMap α β :=
⟨_, f.spectral'.continuous⟩ | def | Topology | [
"Mathlib.Tactic.StacksAttribute",
"Mathlib.Topology.ContinuousMap.Basic",
"Mathlib.Topology.Maps.Proper.Basic"
] | Mathlib/Topology/Spectral/Hom.lean | toContinuousMap | Reinterpret a `SpectralMap` as a `ContinuousMap`. |
instFunLike : FunLike (SpectralMap α β) α β where
coe := SpectralMap.toFun
coe_injective' f g h := by cases f; cases g; congr | instance | Topology | [
"Mathlib.Tactic.StacksAttribute",
"Mathlib.Topology.ContinuousMap.Basic",
"Mathlib.Topology.Maps.Proper.Basic"
] | Mathlib/Topology/Spectral/Hom.lean | instFunLike | null |
@[simp]
toFun_eq_coe {f : SpectralMap α β} : f.toFun = (f : α → β) :=
rfl
@[ext] | theorem | Topology | [
"Mathlib.Tactic.StacksAttribute",
"Mathlib.Topology.ContinuousMap.Basic",
"Mathlib.Topology.Maps.Proper.Basic"
] | Mathlib/Topology/Spectral/Hom.lean | toFun_eq_coe | null |
ext {f g : SpectralMap α β} (h : ∀ a, f a = g a) : f = g :=
DFunLike.ext f g h | theorem | Topology | [
"Mathlib.Tactic.StacksAttribute",
"Mathlib.Topology.ContinuousMap.Basic",
"Mathlib.Topology.Maps.Proper.Basic"
] | Mathlib/Topology/Spectral/Hom.lean | ext | null |
protected copy (f : SpectralMap α β) (f' : α → β) (h : f' = f) : SpectralMap α β :=
⟨f', h.symm.subst f.spectral'⟩
@[simp] | def | Topology | [
"Mathlib.Tactic.StacksAttribute",
"Mathlib.Topology.ContinuousMap.Basic",
"Mathlib.Topology.Maps.Proper.Basic"
] | Mathlib/Topology/Spectral/Hom.lean | copy | Copy of a `SpectralMap` with a new `toFun` equal to the old one. Useful to fix definitional
equalities. |
coe_copy (f : SpectralMap α β) (f' : α → β) (h : f' = f) : ⇑(f.copy f' h) = f' :=
rfl | theorem | Topology | [
"Mathlib.Tactic.StacksAttribute",
"Mathlib.Topology.ContinuousMap.Basic",
"Mathlib.Topology.Maps.Proper.Basic"
] | Mathlib/Topology/Spectral/Hom.lean | coe_copy | null |
copy_eq (f : SpectralMap α β) (f' : α → β) (h : f' = f) : f.copy f' h = f :=
DFunLike.ext' h
variable (α) | theorem | Topology | [
"Mathlib.Tactic.StacksAttribute",
"Mathlib.Topology.ContinuousMap.Basic",
"Mathlib.Topology.Maps.Proper.Basic"
] | Mathlib/Topology/Spectral/Hom.lean | copy_eq | null |
protected id : SpectralMap α α :=
⟨id, isSpectralMap_id⟩ | def | Topology | [
"Mathlib.Tactic.StacksAttribute",
"Mathlib.Topology.ContinuousMap.Basic",
"Mathlib.Topology.Maps.Proper.Basic"
] | Mathlib/Topology/Spectral/Hom.lean | id | `id` as a `SpectralMap`. |
@[simp, norm_cast]
coe_id : ⇑(SpectralMap.id α) = id :=
rfl
variable {α}
@[simp] | theorem | Topology | [
"Mathlib.Tactic.StacksAttribute",
"Mathlib.Topology.ContinuousMap.Basic",
"Mathlib.Topology.Maps.Proper.Basic"
] | Mathlib/Topology/Spectral/Hom.lean | coe_id | null |
id_apply (a : α) : SpectralMap.id α a = a :=
rfl | theorem | Topology | [
"Mathlib.Tactic.StacksAttribute",
"Mathlib.Topology.ContinuousMap.Basic",
"Mathlib.Topology.Maps.Proper.Basic"
] | Mathlib/Topology/Spectral/Hom.lean | id_apply | null |
comp (f : SpectralMap β γ) (g : SpectralMap α β) : SpectralMap α γ :=
⟨f.toContinuousMap.comp g.toContinuousMap, f.spectral'.comp g.spectral'⟩
@[simp] | def | Topology | [
"Mathlib.Tactic.StacksAttribute",
"Mathlib.Topology.ContinuousMap.Basic",
"Mathlib.Topology.Maps.Proper.Basic"
] | Mathlib/Topology/Spectral/Hom.lean | comp | Composition of `SpectralMap`s as a `SpectralMap`. |
coe_comp (f : SpectralMap β γ) (g : SpectralMap α β) : (f.comp g : α → γ) = f ∘ g :=
rfl
@[simp] | theorem | Topology | [
"Mathlib.Tactic.StacksAttribute",
"Mathlib.Topology.ContinuousMap.Basic",
"Mathlib.Topology.Maps.Proper.Basic"
] | Mathlib/Topology/Spectral/Hom.lean | coe_comp | null |
comp_apply (f : SpectralMap β γ) (g : SpectralMap α β) (a : α) : (f.comp g) a = f (g a) :=
rfl | theorem | Topology | [
"Mathlib.Tactic.StacksAttribute",
"Mathlib.Topology.ContinuousMap.Basic",
"Mathlib.Topology.Maps.Proper.Basic"
] | Mathlib/Topology/Spectral/Hom.lean | comp_apply | null |
coe_comp_continuousMap (f : SpectralMap β γ) (g : SpectralMap α β) :
f ∘ g = (f : ContinuousMap β γ) ∘ (g : ContinuousMap α β) :=
rfl
@[simp] | theorem | Topology | [
"Mathlib.Tactic.StacksAttribute",
"Mathlib.Topology.ContinuousMap.Basic",
"Mathlib.Topology.Maps.Proper.Basic"
] | Mathlib/Topology/Spectral/Hom.lean | coe_comp_continuousMap | null |
coe_comp_continuousMap' (f : SpectralMap β γ) (g : SpectralMap α β) :
(f.comp g : ContinuousMap α γ) = (f : ContinuousMap β γ).comp g :=
rfl
@[simp] | theorem | Topology | [
"Mathlib.Tactic.StacksAttribute",
"Mathlib.Topology.ContinuousMap.Basic",
"Mathlib.Topology.Maps.Proper.Basic"
] | Mathlib/Topology/Spectral/Hom.lean | coe_comp_continuousMap' | null |
comp_assoc (f : SpectralMap γ δ) (g : SpectralMap β γ) (h : SpectralMap α β) :
(f.comp g).comp h = f.comp (g.comp h) :=
rfl
@[simp] | theorem | Topology | [
"Mathlib.Tactic.StacksAttribute",
"Mathlib.Topology.ContinuousMap.Basic",
"Mathlib.Topology.Maps.Proper.Basic"
] | Mathlib/Topology/Spectral/Hom.lean | comp_assoc | null |
comp_id (f : SpectralMap α β) : f.comp (SpectralMap.id α) = f :=
ext fun _a => rfl
@[simp] | theorem | Topology | [
"Mathlib.Tactic.StacksAttribute",
"Mathlib.Topology.ContinuousMap.Basic",
"Mathlib.Topology.Maps.Proper.Basic"
] | Mathlib/Topology/Spectral/Hom.lean | comp_id | null |
id_comp (f : SpectralMap α β) : (SpectralMap.id β).comp f = f :=
ext fun _a => rfl
@[simp] | theorem | Topology | [
"Mathlib.Tactic.StacksAttribute",
"Mathlib.Topology.ContinuousMap.Basic",
"Mathlib.Topology.Maps.Proper.Basic"
] | Mathlib/Topology/Spectral/Hom.lean | id_comp | null |
cancel_right {g₁ g₂ : SpectralMap β γ} {f : SpectralMap α β} (hf : Surjective f) :
g₁.comp f = g₂.comp f ↔ g₁ = g₂ :=
⟨fun h => ext <| hf.forall.2 <| DFunLike.ext_iff.1 h,
fun a => of_eq (congrFun (congrArg comp a) f)⟩
@[simp] | theorem | Topology | [
"Mathlib.Tactic.StacksAttribute",
"Mathlib.Topology.ContinuousMap.Basic",
"Mathlib.Topology.Maps.Proper.Basic"
] | Mathlib/Topology/Spectral/Hom.lean | cancel_right | null |
cancel_left {g : SpectralMap β γ} {f₁ f₂ : SpectralMap α β} (hg : Injective g) :
g.comp f₁ = g.comp f₂ ↔ f₁ = f₂ :=
⟨fun h => ext fun a => hg <| by rw [← comp_apply, h, comp_apply], congr_arg _⟩ | theorem | Topology | [
"Mathlib.Tactic.StacksAttribute",
"Mathlib.Topology.ContinuousMap.Basic",
"Mathlib.Topology.Maps.Proper.Basic"
] | Mathlib/Topology/Spectral/Hom.lean | cancel_left | null |
@[stacks 08YG "The last condition for spectral spaces", mk_iff]
PrespectralSpace (X : Type*) [TopologicalSpace X] : Prop where
isTopologicalBasis : IsTopologicalBasis { U : Set X | IsOpen U ∧ IsCompact U } | class | Topology | [
"Mathlib.Order.Ideal",
"Mathlib.Topology.Sets.Compacts",
"Mathlib.Topology.Sets.OpenCover",
"Mathlib.Topology.Spectral.Hom"
] | Mathlib/Topology/Spectral/Prespectral.lean | PrespectralSpace | A space is prespectral if the lattice of compact opens forms a basis. |
PrespectralSpace.of_isTopologicalBasis {B : Set (Set X)}
(basis : IsTopologicalBasis B) (isCompact_basis : ∀ U ∈ B, IsCompact U) :
PrespectralSpace X where
isTopologicalBasis := basis.of_isOpen_of_subset (fun _ h ↦ h.1)
fun s hs ↦ ⟨basis.isOpen hs, isCompact_basis s hs⟩ | lemma | Topology | [
"Mathlib.Order.Ideal",
"Mathlib.Topology.Sets.Compacts",
"Mathlib.Topology.Sets.OpenCover",
"Mathlib.Topology.Spectral.Hom"
] | Mathlib/Topology/Spectral/Prespectral.lean | PrespectralSpace.of_isTopologicalBasis | A space is prespectral if it has a basis consisting of compact opens. |
PrespectralSpace.of_isTopologicalBasis' {ι : Type*} {b : ι → Set X}
(basis : IsTopologicalBasis (Set.range b)) (isCompact_basis : ∀ i, IsCompact (b i)) :
PrespectralSpace X :=
.of_isTopologicalBasis basis (by simp_all) | lemma | Topology | [
"Mathlib.Order.Ideal",
"Mathlib.Topology.Sets.Compacts",
"Mathlib.Topology.Sets.OpenCover",
"Mathlib.Topology.Spectral.Hom"
] | Mathlib/Topology/Spectral/Prespectral.lean | PrespectralSpace.of_isTopologicalBasis' | A space is prespectral if it has a basis consisting of compact opens.
This is the variant with an indexed basis instead. |
PrespectralSpace.of_isOpenCover
{ι : Type*} {U : ι → Opens X} (hU : IsOpenCover U) [∀ i, PrespectralSpace (U i)] :
PrespectralSpace X := by
refine .of_isTopologicalBasis (hU.isTopologicalBasis fun i ↦ isTopologicalBasis) ?_
simp only [Set.mem_iUnion, Set.mem_image, Set.mem_setOf_eq, forall_exists_index, and_imp,
forall_comm (α := Set _), forall_apply_eq_imp_iff₂]
exact fun i V hV hV' ↦ hV'.image continuous_subtype_val | lemma | Topology | [
"Mathlib.Order.Ideal",
"Mathlib.Topology.Sets.Compacts",
"Mathlib.Topology.Sets.OpenCover",
"Mathlib.Topology.Spectral.Hom"
] | Mathlib/Topology/Spectral/Prespectral.lean | PrespectralSpace.of_isOpenCover | null |
PrespectralSpace.of_isInducing [PrespectralSpace Y]
(f : X → Y) (hf : IsInducing f) (hf' : IsSpectralMap f) : PrespectralSpace X :=
.of_isTopologicalBasis (PrespectralSpace.isTopologicalBasis.isInducing hf) (by
simp only [Set.mem_image, Set.mem_setOf_eq, forall_exists_index, and_imp]
rintro _ U h₁ h₂ rfl
exact hf'.isCompact_preimage_of_isOpen h₁ h₂) | lemma | Topology | [
"Mathlib.Order.Ideal",
"Mathlib.Topology.Sets.Compacts",
"Mathlib.Topology.Sets.OpenCover",
"Mathlib.Topology.Spectral.Hom"
] | Mathlib/Topology/Spectral/Prespectral.lean | PrespectralSpace.of_isInducing | null |
PrespectralSpace.of_isClosedEmbedding [PrespectralSpace Y]
(f : X → Y) (hf : IsClosedEmbedding f) : PrespectralSpace X :=
.of_isInducing f hf.isInducing hf.isProperMap.isSpectralMap | lemma | Topology | [
"Mathlib.Order.Ideal",
"Mathlib.Topology.Sets.Compacts",
"Mathlib.Topology.Sets.OpenCover",
"Mathlib.Topology.Spectral.Hom"
] | Mathlib/Topology/Spectral/Prespectral.lean | PrespectralSpace.of_isClosedEmbedding | null |
PrespectralSpace.sigma {ι : Type*} (X : ι → Type*) [∀ i, TopologicalSpace (X i)]
[∀ i, PrespectralSpace (X i)] : PrespectralSpace (Σ i, X i) :=
.of_isTopologicalBasis (IsTopologicalBasis.sigma fun i ↦ isTopologicalBasis) fun U hU ↦ by
simp_rw [Set.mem_iUnion] at hU
obtain ⟨i, V, hV, rfl⟩ := hU
exact hV.2.image continuous_sigmaMk
variable (X) in | instance | Topology | [
"Mathlib.Order.Ideal",
"Mathlib.Topology.Sets.Compacts",
"Mathlib.Topology.Sets.OpenCover",
"Mathlib.Topology.Spectral.Hom"
] | Mathlib/Topology/Spectral/Prespectral.lean | PrespectralSpace.sigma | null |
PrespectralSpace.isBasis_opens [PrespectralSpace X] :
TopologicalSpace.Opens.IsBasis { U : Opens X | IsCompact (U : Set X) } := by
dsimp only [TopologicalSpace.Opens.IsBasis]
convert isTopologicalBasis (X := X)
ext s
exact ⟨fun ⟨V, hV, heq⟩ ↦ heq ▸ ⟨V.2, hV⟩, fun h ↦ ⟨⟨s, h.1⟩, h.2, rfl⟩⟩ | lemma | Topology | [
"Mathlib.Order.Ideal",
"Mathlib.Topology.Sets.Compacts",
"Mathlib.Topology.Sets.OpenCover",
"Mathlib.Topology.Spectral.Hom"
] | Mathlib/Topology/Spectral/Prespectral.lean | PrespectralSpace.isBasis_opens | null |
PrespectralSpace.opensEquiv [PrespectralSpace X] :
Opens X ≃o Order.Ideal (CompactOpens X) where
toFun U := ⟨⟨{ V | (V : Set X) ⊆ U }, fun U₁ U₂ h₁ h₂ ↦ subset_trans (α := Set X) h₁ h₂⟩,
⟨⊥, by simp⟩, fun U₁ h₁ U₂ h₂ ↦ ⟨U₁ ⊔ U₂, by aesop, le_sup_left, le_sup_right⟩⟩
invFun I := ⨆ U ∈ I, U.toOpens
left_inv U := by
apply le_antisymm
· simp only [iSup_le_iff]
exact fun _ ↦ id
· intro x hxU
obtain ⟨V, ⟨h₁, h₂⟩, hxV, hVU⟩ := isTopologicalBasis.exists_subset_of_mem_open hxU U.2
simp only [Opens.mem_iSup, SetLike.mem_coe]
exact ⟨⟨⟨_, h₂⟩, h₁⟩, hVU, hxV⟩
right_inv I := by
ext U
dsimp
change U.toOpens ≤ _ ↔ _
refine ⟨fun H ↦ ?_, fun h ↦ le_iSup₂ (f := fun U (h : U ∈ I) ↦ U.toOpens) U h⟩
simp only [← SetLike.coe_subset_coe, Opens.iSup_mk, Opens.carrier_eq_coe, Opens.coe_mk] at H
obtain ⟨s, hsI, hs, hU⟩ := U.isCompact.elim_finite_subcover_image (fun U _ ↦ U.2) H
exact I.lower (a := hs.toFinset.sup fun i ↦ i) (by simpa [← SetLike.coe_subset_coe]) (by simpa)
map_rel_iff' {U V} := by
change (∀ (W : CompactOpens X), (W : Set X) ⊆ U → (W : Set X) ⊆ V) ↔ U ≤ V
refine ⟨?_, fun H W ↦ (le_trans · H)⟩
intro H x hxU
obtain ⟨W, ⟨h₁, h₂⟩, hxW, hWU⟩ := isTopologicalBasis.exists_subset_of_mem_open hxU U.2
exact H ⟨⟨W, h₂⟩, h₁⟩ hWU hxW
open TopologicalSpace Opens in | def | Topology | [
"Mathlib.Order.Ideal",
"Mathlib.Topology.Sets.Compacts",
"Mathlib.Topology.Sets.OpenCover",
"Mathlib.Topology.Spectral.Hom"
] | Mathlib/Topology/Spectral/Prespectral.lean | PrespectralSpace.opensEquiv | In a prespectral space, the lattice of opens is determined by its lattice of compact opens. |
IsOpenMap.exists_opens_image_eq_of_prespectralSpace [PrespectralSpace X] {f : X → Y}
(hfc : Continuous f) (h : IsOpenMap f) {U : Set Y} (hs : U ⊆ Set.range f) (hU : IsOpen U)
(hc : IsCompact U) : ∃ (V : Opens X), IsCompact V.1 ∧ f '' V = U := by
obtain ⟨Us, hUs, heq⟩ := TopologicalSpace.Opens.isBasis_iff_cover.mp
(PrespectralSpace.isBasis_opens X) ⟨f ⁻¹' U, hU.preimage hfc⟩
obtain ⟨t, ht⟩ := by
refine hc.elim_finite_subcover (fun s : Us ↦ f '' s.1) (fun s ↦ h _ s.1.2) (fun x hx ↦ ?_)
obtain ⟨x, rfl⟩ := hs hx
obtain ⟨i, hi, hx⟩ := mem_sSup.mp <| by rwa [← heq]
exact Set.mem_iUnion.mpr ⟨⟨i, hi⟩, x, hx, rfl⟩
refine ⟨⨆ s ∈ t, s.1, ?_, ?_⟩
· simp only [iSup_mk, carrier_eq_coe, coe_mk]
exact t.finite_toSet.isCompact_biUnion fun i _ ↦ hUs i.2
· simp only [iSup_mk, carrier_eq_coe, Set.iUnion_coe_set, coe_mk, Set.image_iUnion]
convert_to ⋃ i ∈ t, f '' i.1 = U
· simp
· refine subset_antisymm (fun x ↦ ?_) ht
simp_rw [Set.mem_iUnion]
rintro ⟨i, hi, x, hx, rfl⟩
have := heq ▸ mem_sSup.mpr ⟨i.1, i.2, hx⟩
exact this | lemma | Topology | [
"Mathlib.Order.Ideal",
"Mathlib.Topology.Sets.Compacts",
"Mathlib.Topology.Sets.OpenCover",
"Mathlib.Topology.Spectral.Hom"
] | Mathlib/Topology/Spectral/Prespectral.lean | IsOpenMap.exists_opens_image_eq_of_prespectralSpace | If `X` has a basis of compact opens and `f : X → S` is open, every
compact open of `S` is the image of a compact open of `X`. |
uniformSpace : UniformSpace R :=
.ofFun (fun x y => abv (y - x)) (by simp) (fun x y => abv.map_sub y x)
(fun _ _ _ => (abv.sub_le _ _ _).trans_eq (add_comm _ _))
fun ε ε0 => ⟨ε / 2, half_pos ε0, fun _ h₁ _ h₂ => (add_lt_add h₁ h₂).trans_eq (add_halves ε)⟩ | def | Topology | [
"Mathlib.Algebra.Order.AbsoluteValue.Basic",
"Mathlib.Algebra.Order.Field.Basic",
"Mathlib.Topology.UniformSpace.OfFun"
] | Mathlib/Topology/UniformSpace/AbsoluteValue.lean | uniformSpace | The uniform structure coming from an absolute value. |
hasBasis_uniformity :
𝓤[abv.uniformSpace].HasBasis ((0 : 𝕜) < ·) fun ε => { p : R × R | abv (p.2 - p.1) < ε } :=
UniformSpace.hasBasis_ofFun (exists_gt _) _ _ _ _ _ | theorem | Topology | [
"Mathlib.Algebra.Order.AbsoluteValue.Basic",
"Mathlib.Algebra.Order.Field.Basic",
"Mathlib.Topology.UniformSpace.OfFun"
] | Mathlib/Topology/UniformSpace/AbsoluteValue.lean | hasBasis_uniformity | null |
@[pp_with_univ]
AbstractCompletion.{v, u} (α : Type u) [UniformSpace α] where
/-- The underlying space of the completion. -/
space : Type v
/-- A map from a space to its completion. -/
coe : α → space
/-- The completion carries a uniform structure. -/
uniformStruct : UniformSpace space
/-- The completion is complete. -/
complete : CompleteSpace space
/-- The completion is a T₀ space. -/
separation : T0Space space
/-- The map into the completion is uniform-inducing. -/
isUniformInducing : IsUniformInducing coe
/-- The map into the completion has dense range. -/
dense : DenseRange coe
attribute [local instance]
AbstractCompletion.uniformStruct AbstractCompletion.complete AbstractCompletion.separation | structure | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.Topology.UniformSpace.Equiv"
] | Mathlib/Topology/UniformSpace/AbstractCompletion.lean | AbstractCompletion. | A completion of `α` is the data of a complete separated uniform space
and a map from `α` with dense range and inducing the original uniform structure on `α`. |
ofComplete [T0Space α] [CompleteSpace α] : AbstractCompletion α :=
mk α id inferInstance inferInstance inferInstance .id denseRange_id | def | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.Topology.UniformSpace.Equiv"
] | Mathlib/Topology/UniformSpace/AbstractCompletion.lean | ofComplete | If `α` is complete, then it is an abstract completion of itself. |
closure_range : closure (range ι) = univ :=
pkg.dense.closure_range | theorem | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.Topology.UniformSpace.Equiv"
] | Mathlib/Topology/UniformSpace/AbstractCompletion.lean | closure_range | null |
isDenseInducing : IsDenseInducing ι :=
⟨pkg.isUniformInducing.isInducing, pkg.dense⟩ | theorem | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.Topology.UniformSpace.Equiv"
] | Mathlib/Topology/UniformSpace/AbstractCompletion.lean | isDenseInducing | null |
uniformContinuous_coe : UniformContinuous ι :=
IsUniformInducing.uniformContinuous pkg.isUniformInducing | theorem | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.Topology.UniformSpace.Equiv"
] | Mathlib/Topology/UniformSpace/AbstractCompletion.lean | uniformContinuous_coe | null |
continuous_coe : Continuous ι :=
pkg.uniformContinuous_coe.continuous
@[elab_as_elim] | theorem | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.Topology.UniformSpace.Equiv"
] | Mathlib/Topology/UniformSpace/AbstractCompletion.lean | continuous_coe | null |
induction_on {p : hatα → Prop} (a : hatα) (hp : IsClosed { a | p a }) (ih : ∀ a, p (ι a)) :
p a :=
isClosed_property pkg.dense hp ih a
variable {β : Type uβ} | theorem | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.Topology.UniformSpace.Equiv"
] | Mathlib/Topology/UniformSpace/AbstractCompletion.lean | induction_on | null |
protected funext [TopologicalSpace β] [T2Space β] {f g : hatα → β} (hf : Continuous f)
(hg : Continuous g) (h : ∀ a, f (ι a) = g (ι a)) : f = g :=
funext fun a => pkg.induction_on a (isClosed_eq hf hg) h
variable [UniformSpace β] | theorem | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.Topology.UniformSpace.Equiv"
] | Mathlib/Topology/UniformSpace/AbstractCompletion.lean | funext | null |
protected extend (f : α → β) : hatα → β :=
open scoped Classical in
if UniformContinuous f then pkg.isDenseInducing.extend f else fun x => f (pkg.dense.some x)
variable {f : α → β} | def | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.Topology.UniformSpace.Equiv"
] | Mathlib/Topology/UniformSpace/AbstractCompletion.lean | extend | Extension of maps to completions |
extend_def (hf : UniformContinuous f) : pkg.extend f = pkg.isDenseInducing.extend f :=
if_pos hf | theorem | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.Topology.UniformSpace.Equiv"
] | Mathlib/Topology/UniformSpace/AbstractCompletion.lean | extend_def | null |
inseparable_extend_coe (hf : UniformContinuous f) (x : α) :
Inseparable (pkg.extend f (ι x)) (f x) := by
rw [extend_def _ hf]
exact pkg.isDenseInducing.inseparable_extend hf.continuous.continuousAt | theorem | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.Topology.UniformSpace.Equiv"
] | Mathlib/Topology/UniformSpace/AbstractCompletion.lean | inseparable_extend_coe | null |
extend_coe [T2Space β] (hf : UniformContinuous f) (a : α) : (pkg.extend f) (ι a) = f a := by
rw [pkg.extend_def hf]
exact pkg.isDenseInducing.extend_eq hf.continuous a
variable [CompleteSpace β] | theorem | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.Topology.UniformSpace.Equiv"
] | Mathlib/Topology/UniformSpace/AbstractCompletion.lean | extend_coe | null |
uniformContinuous_extend : UniformContinuous (pkg.extend f) := by
by_cases hf : UniformContinuous f
· rw [pkg.extend_def hf]
exact uniformContinuous_uniformly_extend pkg.isUniformInducing pkg.dense hf
· unfold AbstractCompletion.extend
rw [if_neg hf]
exact uniformContinuous_of_const fun a b => by congr 1 | theorem | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.Topology.UniformSpace.Equiv"
] | Mathlib/Topology/UniformSpace/AbstractCompletion.lean | uniformContinuous_extend | null |
continuous_extend : Continuous (pkg.extend f) :=
pkg.uniformContinuous_extend.continuous | theorem | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.Topology.UniformSpace.Equiv"
] | Mathlib/Topology/UniformSpace/AbstractCompletion.lean | continuous_extend | null |
isUniformInducing_extend (h : IsUniformInducing f) :
IsUniformInducing (pkg.extend f) := by
rw [extend_def _ h.uniformContinuous]
exact pkg.isDenseInducing.isUniformInducing_extend pkg.isUniformInducing h
variable [T0Space β] | lemma | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.Topology.UniformSpace.Equiv"
] | Mathlib/Topology/UniformSpace/AbstractCompletion.lean | isUniformInducing_extend | null |
extend_unique (hf : UniformContinuous f) {g : hatα → β} (hg : UniformContinuous g)
(h : ∀ a : α, f a = g (ι a)) : pkg.extend f = g := by
apply pkg.funext pkg.continuous_extend hg.continuous
simpa only [pkg.extend_coe hf] using h
@[simp] | theorem | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.Topology.UniformSpace.Equiv"
] | Mathlib/Topology/UniformSpace/AbstractCompletion.lean | extend_unique | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.