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
⌀ |
|---|---|---|---|---|---|---|
prodBinaryFanIsLimit (X Y : TopCat.{u}) : IsLimit (prodBinaryFan X Y) where
lift := fun S : BinaryFan X Y => ofHom {
toFun := fun s => (S.fst s, S.snd s)
continuous_toFun := by continuity }
fac := by
rintro S (_ | _) <;> {dsimp; ext; rfl}
uniq := by
intro S m h
ext x
refine Prod.ext ?_ ?_
· specialize h ⟨WalkingPair.left⟩
apply_fun fun e => e x at h
exact h
· specialize h ⟨WalkingPair.right⟩
apply_fun fun e => e x at h
exact h
|
def
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.EpiMono",
"Mathlib.Topology.Category.TopCat.Limits.Basic",
"Mathlib.CategoryTheory.Limits.Shapes.Products",
"Mathlib.CategoryTheory.Limits.ConcreteCategory.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Tactic.CategoryTheory.Elementwise",
"Mathlib.Topology.Homeomorph.Lemmas"
] |
Mathlib/Topology/Category/TopCat/Limits/Products.lean
|
prodBinaryFanIsLimit
|
The constructed binary fan is indeed a limit
|
prodIsoProd (X Y : TopCat.{u}) : X ⨯ Y ≅ TopCat.of (X × Y) :=
(limit.isLimit _).conePointUniqueUpToIso (prodBinaryFanIsLimit X Y)
@[reassoc (attr := simp)]
|
def
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.EpiMono",
"Mathlib.Topology.Category.TopCat.Limits.Basic",
"Mathlib.CategoryTheory.Limits.Shapes.Products",
"Mathlib.CategoryTheory.Limits.ConcreteCategory.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Tactic.CategoryTheory.Elementwise",
"Mathlib.Topology.Homeomorph.Lemmas"
] |
Mathlib/Topology/Category/TopCat/Limits/Products.lean
|
prodIsoProd
|
The homeomorphism between `X ⨯ Y` and the set-theoretic product of `X` and `Y`,
equipped with the product topology.
|
prodIsoProd_hom_fst (X Y : TopCat.{u}) :
(prodIsoProd X Y).hom ≫ prodFst = Limits.prod.fst := by
simp [← Iso.eq_inv_comp, prodIsoProd]
rfl
@[reassoc (attr := simp)]
|
theorem
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.EpiMono",
"Mathlib.Topology.Category.TopCat.Limits.Basic",
"Mathlib.CategoryTheory.Limits.Shapes.Products",
"Mathlib.CategoryTheory.Limits.ConcreteCategory.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Tactic.CategoryTheory.Elementwise",
"Mathlib.Topology.Homeomorph.Lemmas"
] |
Mathlib/Topology/Category/TopCat/Limits/Products.lean
|
prodIsoProd_hom_fst
| null |
prodIsoProd_hom_snd (X Y : TopCat.{u}) :
(prodIsoProd X Y).hom ≫ prodSnd = Limits.prod.snd := by
simp [← Iso.eq_inv_comp, prodIsoProd]
rfl
|
theorem
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.EpiMono",
"Mathlib.Topology.Category.TopCat.Limits.Basic",
"Mathlib.CategoryTheory.Limits.Shapes.Products",
"Mathlib.CategoryTheory.Limits.ConcreteCategory.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Tactic.CategoryTheory.Elementwise",
"Mathlib.Topology.Homeomorph.Lemmas"
] |
Mathlib/Topology/Category/TopCat/Limits/Products.lean
|
prodIsoProd_hom_snd
| null |
prodIsoProd_hom_apply {X Y : TopCat.{u}} (x : ↑(X ⨯ Y)) :
(prodIsoProd X Y).hom x = ((Limits.prod.fst : X ⨯ Y ⟶ _) x,
(Limits.prod.snd : X ⨯ Y ⟶ _) x) := by
ext
· exact ConcreteCategory.congr_hom (prodIsoProd_hom_fst X Y) x
· exact ConcreteCategory.congr_hom (prodIsoProd_hom_snd X Y) x
@[reassoc (attr := simp), elementwise]
|
theorem
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.EpiMono",
"Mathlib.Topology.Category.TopCat.Limits.Basic",
"Mathlib.CategoryTheory.Limits.Shapes.Products",
"Mathlib.CategoryTheory.Limits.ConcreteCategory.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Tactic.CategoryTheory.Elementwise",
"Mathlib.Topology.Homeomorph.Lemmas"
] |
Mathlib/Topology/Category/TopCat/Limits/Products.lean
|
prodIsoProd_hom_apply
| null |
prodIsoProd_inv_fst (X Y : TopCat.{u}) :
(prodIsoProd X Y).inv ≫ Limits.prod.fst = prodFst := by simp [Iso.inv_comp_eq]
@[reassoc (attr := simp), elementwise]
|
theorem
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.EpiMono",
"Mathlib.Topology.Category.TopCat.Limits.Basic",
"Mathlib.CategoryTheory.Limits.Shapes.Products",
"Mathlib.CategoryTheory.Limits.ConcreteCategory.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Tactic.CategoryTheory.Elementwise",
"Mathlib.Topology.Homeomorph.Lemmas"
] |
Mathlib/Topology/Category/TopCat/Limits/Products.lean
|
prodIsoProd_inv_fst
| null |
prodIsoProd_inv_snd (X Y : TopCat.{u}) :
(prodIsoProd X Y).inv ≫ Limits.prod.snd = prodSnd := by simp [Iso.inv_comp_eq]
|
theorem
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.EpiMono",
"Mathlib.Topology.Category.TopCat.Limits.Basic",
"Mathlib.CategoryTheory.Limits.Shapes.Products",
"Mathlib.CategoryTheory.Limits.ConcreteCategory.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Tactic.CategoryTheory.Elementwise",
"Mathlib.Topology.Homeomorph.Lemmas"
] |
Mathlib/Topology/Category/TopCat/Limits/Products.lean
|
prodIsoProd_inv_snd
| null |
prod_topology {X Y : TopCat.{u}} :
(X ⨯ Y).str =
induced (Limits.prod.fst : X ⨯ Y ⟶ _) X.str ⊓
induced (Limits.prod.snd : X ⨯ Y ⟶ _) Y.str := by
let homeo := homeoOfIso (prodIsoProd X Y)
refine homeo.isInducing.eq_induced.trans ?_
change induced homeo (_ ⊓ _) = _
simp [induced_compose]
rfl
|
theorem
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.EpiMono",
"Mathlib.Topology.Category.TopCat.Limits.Basic",
"Mathlib.CategoryTheory.Limits.Shapes.Products",
"Mathlib.CategoryTheory.Limits.ConcreteCategory.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Tactic.CategoryTheory.Elementwise",
"Mathlib.Topology.Homeomorph.Lemmas"
] |
Mathlib/Topology/Category/TopCat/Limits/Products.lean
|
prod_topology
| null |
range_prod_map {W X Y Z : TopCat.{u}} (f : W ⟶ Y) (g : X ⟶ Z) :
Set.range (Limits.prod.map f g) =
(Limits.prod.fst : Y ⨯ Z ⟶ _) ⁻¹' Set.range f ∩
(Limits.prod.snd : Y ⨯ Z ⟶ _) ⁻¹' Set.range g := by
ext x
constructor
· rintro ⟨y, rfl⟩
simp_rw [Set.mem_inter_iff, Set.mem_preimage, Set.mem_range, ← ConcreteCategory.comp_apply,
Limits.prod.map_fst, Limits.prod.map_snd, ConcreteCategory.comp_apply, exists_apply_eq_apply,
and_self_iff]
· rintro ⟨⟨x₁, hx₁⟩, ⟨x₂, hx₂⟩⟩
use (prodIsoProd W X).inv (x₁, x₂)
apply Concrete.limit_ext
rintro ⟨⟨⟩⟩
· rw [← ConcreteCategory.comp_apply]
erw [Limits.prod.map_fst]
rw [ConcreteCategory.comp_apply, TopCat.prodIsoProd_inv_fst_apply]
exact hx₁
· rw [← ConcreteCategory.comp_apply]
erw [Limits.prod.map_snd]
rw [ConcreteCategory.comp_apply, TopCat.prodIsoProd_inv_snd_apply]
exact hx₂
|
theorem
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.EpiMono",
"Mathlib.Topology.Category.TopCat.Limits.Basic",
"Mathlib.CategoryTheory.Limits.Shapes.Products",
"Mathlib.CategoryTheory.Limits.ConcreteCategory.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Tactic.CategoryTheory.Elementwise",
"Mathlib.Topology.Homeomorph.Lemmas"
] |
Mathlib/Topology/Category/TopCat/Limits/Products.lean
|
range_prod_map
| null |
isInducing_prodMap {W X Y Z : TopCat.{u}} {f : W ⟶ X} {g : Y ⟶ Z} (hf : IsInducing f)
(hg : IsInducing g) : IsInducing (Limits.prod.map f g) := by
constructor
simp_rw [prod_topology, induced_inf, induced_compose, ← coe_comp,
prod.map_fst, prod.map_snd, coe_comp, ← induced_compose (g := f), ← induced_compose (g := g)]
rw [← hf.eq_induced, ← hg.eq_induced]
|
theorem
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.EpiMono",
"Mathlib.Topology.Category.TopCat.Limits.Basic",
"Mathlib.CategoryTheory.Limits.Shapes.Products",
"Mathlib.CategoryTheory.Limits.ConcreteCategory.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Tactic.CategoryTheory.Elementwise",
"Mathlib.Topology.Homeomorph.Lemmas"
] |
Mathlib/Topology/Category/TopCat/Limits/Products.lean
|
isInducing_prodMap
| null |
isEmbedding_prodMap {W X Y Z : TopCat.{u}} {f : W ⟶ X} {g : Y ⟶ Z} (hf : IsEmbedding f)
(hg : IsEmbedding g) : IsEmbedding (Limits.prod.map f g) :=
⟨isInducing_prodMap hf.isInducing hg.isInducing, by
haveI := (TopCat.mono_iff_injective _).mpr hf.injective
haveI := (TopCat.mono_iff_injective _).mpr hg.injective
exact (TopCat.mono_iff_injective _).mp inferInstance⟩
|
theorem
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.EpiMono",
"Mathlib.Topology.Category.TopCat.Limits.Basic",
"Mathlib.CategoryTheory.Limits.Shapes.Products",
"Mathlib.CategoryTheory.Limits.ConcreteCategory.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Tactic.CategoryTheory.Elementwise",
"Mathlib.Topology.Homeomorph.Lemmas"
] |
Mathlib/Topology/Category/TopCat/Limits/Products.lean
|
isEmbedding_prodMap
| null |
protected binaryCofan (X Y : TopCat.{u}) : BinaryCofan X Y :=
BinaryCofan.mk (ofHom ⟨Sum.inl, by continuity⟩) (ofHom ⟨Sum.inr, by continuity⟩)
|
def
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.EpiMono",
"Mathlib.Topology.Category.TopCat.Limits.Basic",
"Mathlib.CategoryTheory.Limits.Shapes.Products",
"Mathlib.CategoryTheory.Limits.ConcreteCategory.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Tactic.CategoryTheory.Elementwise",
"Mathlib.Topology.Homeomorph.Lemmas"
] |
Mathlib/Topology/Category/TopCat/Limits/Products.lean
|
binaryCofan
|
The binary coproduct cofan in `TopCat`.
|
binaryCofanIsColimit (X Y : TopCat.{u}) : IsColimit (TopCat.binaryCofan X Y) := by
refine Limits.BinaryCofan.isColimitMk (fun s => ofHom
{ toFun := Sum.elim s.inl s.inr, continuous_toFun := ?_ }) ?_ ?_ ?_
· continuity
· intro s
ext
rfl
· intro s
ext
rfl
· intro s m h₁ h₂
ext (x | x)
exacts [ConcreteCategory.congr_hom h₁ x, ConcreteCategory.congr_hom h₂ x]
|
def
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.EpiMono",
"Mathlib.Topology.Category.TopCat.Limits.Basic",
"Mathlib.CategoryTheory.Limits.Shapes.Products",
"Mathlib.CategoryTheory.Limits.ConcreteCategory.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Tactic.CategoryTheory.Elementwise",
"Mathlib.Topology.Homeomorph.Lemmas"
] |
Mathlib/Topology/Category/TopCat/Limits/Products.lean
|
binaryCofanIsColimit
|
The constructed binary coproduct cofan in `TopCat` is the coproduct.
|
binaryCofan_isColimit_iff {X Y : TopCat} (c : BinaryCofan X Y) :
Nonempty (IsColimit c) ↔
IsOpenEmbedding c.inl ∧ IsOpenEmbedding c.inr ∧ IsCompl (range c.inl) (range c.inr) := by
classical
constructor
· rintro ⟨h⟩
rw [← show _ = c.inl from
h.comp_coconePointUniqueUpToIso_inv (binaryCofanIsColimit X Y) ⟨WalkingPair.left⟩,
← show _ = c.inr from
h.comp_coconePointUniqueUpToIso_inv (binaryCofanIsColimit X Y) ⟨WalkingPair.right⟩]
dsimp
refine ⟨(homeoOfIso <| h.coconePointUniqueUpToIso
(binaryCofanIsColimit X Y)).symm.isOpenEmbedding.comp .inl,
(homeoOfIso <| h.coconePointUniqueUpToIso
(binaryCofanIsColimit X Y)).symm.isOpenEmbedding.comp .inr, ?_⟩
rw [Set.range_comp, ← eq_compl_iff_isCompl]
conv_rhs => rw [Set.range_comp]
erw [← Set.image_compl_eq (homeoOfIso <| h.coconePointUniqueUpToIso
(binaryCofanIsColimit X Y)).symm.bijective, Set.compl_range_inr, Set.image_comp]
· rintro ⟨h₁, h₂, h₃⟩
have : ∀ x, x ∈ Set.range c.inl ∨ x ∈ Set.range c.inr := by
rw [eq_compl_iff_isCompl.mpr h₃.symm]
exact fun _ => or_not
refine ⟨BinaryCofan.IsColimit.mk _ ?_ ?_ ?_ ?_⟩
· intro T f g
refine ofHom (ContinuousMap.mk ?_ ?_)
· exact fun x =>
if h : x ∈ Set.range c.inl then f ((Equiv.ofInjective _ h₁.injective).symm ⟨x, h⟩)
else g ((Equiv.ofInjective _ h₂.injective).symm ⟨x, (this x).resolve_left h⟩)
rw [continuous_iff_continuousAt]
intro x
by_cases h : x ∈ Set.range c.inl
· revert h x
apply (IsOpen.continuousOn_iff _).mp
· rw [continuousOn_iff_continuous_restrict]
convert_to Continuous (f ∘ h₁.isEmbedding.toHomeomorph.symm)
· ext ⟨x, hx⟩
exact dif_pos hx
continuity
· exact h₁.isOpen_range
· revert h x
apply (IsOpen.continuousOn_iff _).mp
· rw [continuousOn_iff_continuous_restrict]
have : ∀ a, a ∉ Set.range c.inl → a ∈ Set.range c.inr := by
rintro a (h : a ∈ (Set.range c.inl)ᶜ)
rwa [eq_compl_iff_isCompl.mpr h₃.symm]
convert_to Continuous
(g ∘ h₂.isEmbedding.toHomeomorph.symm ∘ Subtype.map _ this)
· ext ⟨x, hx⟩
exact dif_neg hx
apply Continuous.comp
...
|
theorem
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.EpiMono",
"Mathlib.Topology.Category.TopCat.Limits.Basic",
"Mathlib.CategoryTheory.Limits.Shapes.Products",
"Mathlib.CategoryTheory.Limits.ConcreteCategory.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Tactic.CategoryTheory.Elementwise",
"Mathlib.Topology.Homeomorph.Lemmas"
] |
Mathlib/Topology/Category/TopCat/Limits/Products.lean
|
binaryCofan_isColimit_iff
| null |
pullbackFst (f : X ⟶ Z) (g : Y ⟶ Z) : TopCat.of { p : X × Y // f p.1 = g p.2 } ⟶ X :=
ofHom ⟨Prod.fst ∘ Subtype.val, by fun_prop⟩
|
abbrev
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Limits.Products"
] |
Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean
|
pullbackFst
|
The first projection from the pullback.
|
pullbackFst_apply (f : X ⟶ Z) (g : Y ⟶ Z) (x) : pullbackFst f g x = x.1.1 := rfl
|
lemma
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Limits.Products"
] |
Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean
|
pullbackFst_apply
| null |
pullbackSnd (f : X ⟶ Z) (g : Y ⟶ Z) : TopCat.of { p : X × Y // f p.1 = g p.2 } ⟶ Y :=
ofHom ⟨Prod.snd ∘ Subtype.val, by fun_prop⟩
|
abbrev
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Limits.Products"
] |
Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean
|
pullbackSnd
|
The second projection from the pullback.
|
pullbackSnd_apply (f : X ⟶ Z) (g : Y ⟶ Z) (x) : pullbackSnd f g x = x.1.2 := rfl
|
lemma
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Limits.Products"
] |
Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean
|
pullbackSnd_apply
| null |
pullbackCone (f : X ⟶ Z) (g : Y ⟶ Z) : PullbackCone f g :=
PullbackCone.mk (pullbackFst f g) (pullbackSnd f g)
(by
dsimp [pullbackFst, pullbackSnd, Function.comp_def]
ext ⟨x, h⟩
simpa)
|
def
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Limits.Products"
] |
Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean
|
pullbackCone
|
The explicit pullback cone of `X, Y` given by `{ p : X × Y // f p.1 = g p.2 }`.
|
pullbackConeIsLimit (f : X ⟶ Z) (g : Y ⟶ Z) : IsLimit (pullbackCone f g) :=
PullbackCone.isLimitAux' _
(by
intro S
constructor; swap
· exact ofHom
{ toFun := fun x =>
⟨⟨S.fst x, S.snd x⟩, by simpa using ConcreteCategory.congr_hom S.condition x⟩
continuous_toFun := by fun_prop }
refine ⟨?_, ?_, ?_⟩
· delta pullbackCone
ext a
dsimp
· delta pullbackCone
ext a
dsimp
· intro m h₁ h₂
ext x
apply Subtype.ext
apply Prod.ext
· simpa using ConcreteCategory.congr_hom h₁ x
· simpa using ConcreteCategory.congr_hom h₂ x)
|
def
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Limits.Products"
] |
Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean
|
pullbackConeIsLimit
|
The constructed cone is a limit.
|
pullbackIsoProdSubtype (f : X ⟶ Z) (g : Y ⟶ Z) :
pullback f g ≅ TopCat.of { p : X × Y // f p.1 = g p.2 } :=
(limit.isLimit _).conePointUniqueUpToIso (pullbackConeIsLimit f g)
@[reassoc (attr := simp)]
|
def
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Limits.Products"
] |
Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean
|
pullbackIsoProdSubtype
|
The pullback of two maps can be identified as a subspace of `X × Y`.
|
pullbackIsoProdSubtype_inv_fst (f : X ⟶ Z) (g : Y ⟶ Z) :
(pullbackIsoProdSubtype f g).inv ≫ pullback.fst _ _ = pullbackFst f g := by
simp [pullbackCone, pullbackIsoProdSubtype]
|
theorem
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Limits.Products"
] |
Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean
|
pullbackIsoProdSubtype_inv_fst
| null |
pullbackIsoProdSubtype_inv_fst_apply (f : X ⟶ Z) (g : Y ⟶ Z)
(x : { p : X × Y // f p.1 = g p.2 }) :
pullback.fst f g ((pullbackIsoProdSubtype f g).inv x) = (x : X × Y).fst :=
ConcreteCategory.congr_hom (pullbackIsoProdSubtype_inv_fst f g) x
@[reassoc (attr := simp)]
|
theorem
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Limits.Products"
] |
Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean
|
pullbackIsoProdSubtype_inv_fst_apply
| null |
pullbackIsoProdSubtype_inv_snd (f : X ⟶ Z) (g : Y ⟶ Z) :
(pullbackIsoProdSubtype f g).inv ≫ pullback.snd _ _ = pullbackSnd f g := by
simp [pullbackCone, pullbackIsoProdSubtype]
|
theorem
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Limits.Products"
] |
Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean
|
pullbackIsoProdSubtype_inv_snd
| null |
pullbackIsoProdSubtype_inv_snd_apply (f : X ⟶ Z) (g : Y ⟶ Z)
(x : { p : X × Y // f p.1 = g p.2 }) :
pullback.snd f g ((pullbackIsoProdSubtype f g).inv x) = (x : X × Y).snd :=
ConcreteCategory.congr_hom (pullbackIsoProdSubtype_inv_snd f g) x
|
theorem
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Limits.Products"
] |
Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean
|
pullbackIsoProdSubtype_inv_snd_apply
| null |
pullbackIsoProdSubtype_hom_fst (f : X ⟶ Z) (g : Y ⟶ Z) :
(pullbackIsoProdSubtype f g).hom ≫ pullbackFst f g = pullback.fst _ _ := by
rw [← Iso.eq_inv_comp, pullbackIsoProdSubtype_inv_fst]
|
theorem
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Limits.Products"
] |
Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean
|
pullbackIsoProdSubtype_hom_fst
| null |
pullbackIsoProdSubtype_hom_snd (f : X ⟶ Z) (g : Y ⟶ Z) :
(pullbackIsoProdSubtype f g).hom ≫ pullbackSnd f g = pullback.snd _ _ := by
rw [← Iso.eq_inv_comp, pullbackIsoProdSubtype_inv_snd]
|
theorem
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Limits.Products"
] |
Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean
|
pullbackIsoProdSubtype_hom_snd
| null |
pullbackIsoProdSubtype_hom_apply {f : X ⟶ Z} {g : Y ⟶ Z}
(x : ↑(pullback f g)) :
(pullbackIsoProdSubtype f g).hom x =
⟨⟨pullback.fst f g x, pullback.snd f g x⟩, by
simpa using CategoryTheory.congr_fun pullback.condition x⟩ := by
apply Subtype.ext; apply Prod.ext
exacts [ConcreteCategory.congr_hom (pullbackIsoProdSubtype_hom_fst f g) x,
ConcreteCategory.congr_hom (pullbackIsoProdSubtype_hom_snd f g) x]
|
theorem
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Limits.Products"
] |
Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean
|
pullbackIsoProdSubtype_hom_apply
| null |
pullback_topology {X Y Z : TopCat.{u}} (f : X ⟶ Z) (g : Y ⟶ Z) :
(pullback f g).str =
induced (pullback.fst f g) X.str ⊓
induced (pullback.snd f g) Y.str := by
let homeo := homeoOfIso (pullbackIsoProdSubtype f g)
refine homeo.isInducing.eq_induced.trans ?_
change induced homeo (induced _ ( (induced Prod.fst X.str) ⊓ (induced Prod.snd Y.str))) = _
simp only [induced_compose, induced_inf]
rfl
|
theorem
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Limits.Products"
] |
Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean
|
pullback_topology
| null |
range_pullback_to_prod {X Y Z : TopCat} (f : X ⟶ Z) (g : Y ⟶ Z) :
Set.range (prod.lift (pullback.fst f g) (pullback.snd f g)) =
{ x | (Limits.prod.fst ≫ f) x = (Limits.prod.snd ≫ g) x } := by
ext x
constructor
· rintro ⟨y, rfl⟩
simp only [← ConcreteCategory.comp_apply, Set.mem_setOf_eq]
simp [pullback.condition]
· rintro (h : f (_, _).1 = g (_, _).2)
use (pullbackIsoProdSubtype f g).inv ⟨⟨_, _⟩, h⟩
apply Concrete.limit_ext
rintro ⟨⟨⟩⟩ <;>
rw [← ConcreteCategory.comp_apply, ← ConcreteCategory.comp_apply, limit.lift_π] <;>
cat_disch
|
theorem
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Limits.Products"
] |
Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean
|
range_pullback_to_prod
| null |
noncomputable
pullbackHomeoPreimage
{X Y Z : Type*} [TopologicalSpace X] [TopologicalSpace Y] [TopologicalSpace Z]
(f : X → Z) (hf : Continuous f) (g : Y → Z) (hg : IsEmbedding g) :
{ p : X × Y // f p.1 = g p.2 } ≃ₜ f ⁻¹' Set.range g where
toFun := fun x ↦ ⟨x.1.1, _, x.2.symm⟩
invFun := fun x ↦ ⟨⟨x.1, Exists.choose x.2⟩, (Exists.choose_spec x.2).symm⟩
left_inv := by
intro x
ext <;> dsimp
apply hg.injective
convert x.prop
exact Exists.choose_spec (p := fun y ↦ g y = f (↑x : X × Y).1) _
continuous_toFun := by fun_prop
continuous_invFun := by
apply Continuous.subtype_mk
refine continuous_subtype_val.prodMk <| hg.isInducing.continuous_iff.mpr ?_
convert hf.comp continuous_subtype_val
ext x
exact Exists.choose_spec x.2
|
def
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Limits.Products"
] |
Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean
|
pullbackHomeoPreimage
|
The pullback along an embedding is (isomorphic to) the preimage.
|
isInducing_pullback_to_prod {X Y Z : TopCat.{u}} (f : X ⟶ Z) (g : Y ⟶ Z) :
IsInducing <| ⇑(prod.lift (pullback.fst f g) (pullback.snd f g)) :=
⟨by simp [prod_topology, pullback_topology, induced_compose, ← coe_comp]⟩
|
theorem
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Limits.Products"
] |
Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean
|
isInducing_pullback_to_prod
| null |
isEmbedding_pullback_to_prod {X Y Z : TopCat.{u}} (f : X ⟶ Z) (g : Y ⟶ Z) :
IsEmbedding <| ⇑(prod.lift (pullback.fst f g) (pullback.snd f g)) :=
⟨isInducing_pullback_to_prod f g, (TopCat.mono_iff_injective _).mp inferInstance⟩
|
theorem
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Limits.Products"
] |
Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean
|
isEmbedding_pullback_to_prod
| null |
range_pullback_map {W X Y Z S T : TopCat} (f₁ : W ⟶ S) (f₂ : X ⟶ S) (g₁ : Y ⟶ T)
(g₂ : Z ⟶ T) (i₁ : W ⟶ Y) (i₂ : X ⟶ Z) (i₃ : S ⟶ T) [H₃ : Mono i₃] (eq₁ : f₁ ≫ i₃ = i₁ ≫ g₁)
(eq₂ : f₂ ≫ i₃ = i₂ ≫ g₂) :
Set.range (pullback.map f₁ f₂ g₁ g₂ i₁ i₂ i₃ eq₁ eq₂) =
(pullback.fst g₁ g₂) ⁻¹' Set.range i₁ ∩ (pullback.snd g₁ g₂) ⁻¹' Set.range i₂ := by
ext
constructor
· rintro ⟨y, rfl⟩
simp only [Set.mem_inter_iff, Set.mem_preimage, Set.mem_range]
rw [← ConcreteCategory.comp_apply, ← ConcreteCategory.comp_apply]
simp only [limit.lift_π, PullbackCone.mk_pt, PullbackCone.mk_π_app]
exact ⟨exists_apply_eq_apply _ _, exists_apply_eq_apply _ _⟩
rintro ⟨⟨x₁, hx₁⟩, ⟨x₂, hx₂⟩⟩
have : f₁ x₁ = f₂ x₂ := by
apply (TopCat.mono_iff_injective _).mp H₃
rw [← ConcreteCategory.comp_apply, eq₁, ← ConcreteCategory.comp_apply, eq₂,
ConcreteCategory.comp_apply, ConcreteCategory.comp_apply, hx₁, hx₂,
← ConcreteCategory.comp_apply, pullback.condition, ConcreteCategory.comp_apply]
use (pullbackIsoProdSubtype f₁ f₂).inv ⟨⟨x₁, x₂⟩, this⟩
apply Concrete.limit_ext
rintro (_ | _ | _) <;>
rw [← ConcreteCategory.comp_apply, ← ConcreteCategory.comp_apply]
· simp [hx₁, ← limit.w _ WalkingCospan.Hom.inl]
· simp [hx₁]
· simp [hx₂]
|
theorem
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Limits.Products"
] |
Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean
|
range_pullback_map
|
If the map `S ⟶ T` is mono, then there is a description of the image of `W ×ₛ X ⟶ Y ×ₜ Z`.
|
pullback_fst_range {X Y S : TopCat} (f : X ⟶ S) (g : Y ⟶ S) :
Set.range (pullback.fst f g) = { x : X | ∃ y : Y, f x = g y } := by
ext x
constructor
· rintro ⟨y, rfl⟩
use pullback.snd f g y
exact CategoryTheory.congr_fun pullback.condition y
· rintro ⟨y, eq⟩
use (TopCat.pullbackIsoProdSubtype f g).inv ⟨⟨x, y⟩, eq⟩
rw [pullbackIsoProdSubtype_inv_fst_apply]
|
theorem
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Limits.Products"
] |
Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean
|
pullback_fst_range
| null |
pullback_snd_range {X Y S : TopCat} (f : X ⟶ S) (g : Y ⟶ S) :
Set.range (pullback.snd f g) = { y : Y | ∃ x : X, f x = g y } := by
ext y
constructor
· rintro ⟨x, rfl⟩
use pullback.fst f g x
exact CategoryTheory.congr_fun pullback.condition x
· rintro ⟨x, eq⟩
use (TopCat.pullbackIsoProdSubtype f g).inv ⟨⟨x, y⟩, eq⟩
rw [pullbackIsoProdSubtype_inv_snd_apply]
|
theorem
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Limits.Products"
] |
Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean
|
pullback_snd_range
| null |
pullback_map_isEmbedding {W X Y Z S T : TopCat.{u}} (f₁ : W ⟶ S) (f₂ : X ⟶ S)
(g₁ : Y ⟶ T) (g₂ : Z ⟶ T) {i₁ : W ⟶ Y} {i₂ : X ⟶ Z} (H₁ : IsEmbedding i₁)
(H₂ : IsEmbedding i₂) (i₃ : S ⟶ T) (eq₁ : f₁ ≫ i₃ = i₁ ≫ g₁) (eq₂ : f₂ ≫ i₃ = i₂ ≫ g₂) :
IsEmbedding (pullback.map f₁ f₂ g₁ g₂ i₁ i₂ i₃ eq₁ eq₂) := by
refine .of_comp (ContinuousMap.continuous_toFun _)
(show Continuous (prod.lift (pullback.fst g₁ g₂) (pullback.snd g₁ g₂)) from
ContinuousMap.continuous_toFun _)
?_
suffices
IsEmbedding (prod.lift (pullback.fst f₁ f₂) (pullback.snd f₁ f₂) ≫ Limits.prod.map i₁ i₂) by
simpa [← coe_comp] using this
rw [coe_comp]
exact (isEmbedding_prodMap H₁ H₂).comp (isEmbedding_pullback_to_prod _ _)
|
theorem
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Limits.Products"
] |
Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean
|
pullback_map_isEmbedding
|
If there is a diagram where the morphisms `W ⟶ Y` and `X ⟶ Z` are embeddings,
then the induced morphism `W ×ₛ X ⟶ Y ×ₜ Z` is also an embedding.
```
W ⟶ Y
↘ ↘
S ⟶ T
↗ ↗
X ⟶ Z
```
|
pullback_map_isOpenEmbedding {W X Y Z S T : TopCat.{u}} (f₁ : W ⟶ S)
(f₂ : X ⟶ S) (g₁ : Y ⟶ T) (g₂ : Z ⟶ T) {i₁ : W ⟶ Y} {i₂ : X ⟶ Z} (H₁ : IsOpenEmbedding i₁)
(H₂ : IsOpenEmbedding i₂) (i₃ : S ⟶ T) [H₃ : Mono i₃] (eq₁ : f₁ ≫ i₃ = i₁ ≫ g₁)
(eq₂ : f₂ ≫ i₃ = i₂ ≫ g₂) : IsOpenEmbedding (pullback.map f₁ f₂ g₁ g₂ i₁ i₂ i₃ eq₁ eq₂) := by
constructor
· apply
pullback_map_isEmbedding f₁ f₂ g₁ g₂ H₁.isEmbedding H₂.isEmbedding i₃ eq₁ eq₂
· rw [range_pullback_map]
apply IsOpen.inter <;> apply Continuous.isOpen_preimage
· apply ContinuousMap.continuous_toFun
· exact H₁.isOpen_range
· apply ContinuousMap.continuous_toFun
· exact H₂.isOpen_range
|
theorem
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Limits.Products"
] |
Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean
|
pullback_map_isOpenEmbedding
|
If there is a diagram where the morphisms `W ⟶ Y` and `X ⟶ Z` are open embeddings, and `S ⟶ T`
is mono, then the induced morphism `W ×ₛ X ⟶ Y ×ₜ Z` is also an open embedding.
```
W ⟶ Y
↘ ↘
S ⟶ T
↗ ↗
X ⟶ Z
```
|
snd_isEmbedding_of_left {X Y S : TopCat} {f : X ⟶ S} (H : IsEmbedding f) (g : Y ⟶ S) :
IsEmbedding <| ⇑(pullback.snd f g) := by
convert (homeoOfIso (asIso (pullback.snd (𝟙 S) g))).isEmbedding.comp
(pullback_map_isEmbedding (i₂ := 𝟙 Y)
f g (𝟙 S) g H (homeoOfIso (Iso.refl _)).isEmbedding (𝟙 _) rfl (by simp))
simp [homeoOfIso, ← coe_comp]
|
lemma
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Limits.Products"
] |
Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean
|
snd_isEmbedding_of_left
| null |
fst_isEmbedding_of_right {X Y S : TopCat} (f : X ⟶ S) {g : Y ⟶ S}
(H : IsEmbedding g) : IsEmbedding <| ⇑(pullback.fst f g) := by
convert (homeoOfIso (asIso (pullback.fst f (𝟙 S)))).isEmbedding.comp
(pullback_map_isEmbedding (i₁ := 𝟙 X)
f g f (𝟙 _) (homeoOfIso (Iso.refl _)).isEmbedding H (𝟙 _) rfl (by simp))
simp [homeoOfIso, ← coe_comp]
|
theorem
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Limits.Products"
] |
Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean
|
fst_isEmbedding_of_right
| null |
isEmbedding_of_pullback {X Y S : TopCat} {f : X ⟶ S} {g : Y ⟶ S} (H₁ : IsEmbedding f)
(H₂ : IsEmbedding g) : IsEmbedding (limit.π (cospan f g) WalkingCospan.one) := by
convert H₂.comp (snd_isEmbedding_of_left H₁ g)
rw [← coe_comp, ← limit.w _ WalkingCospan.Hom.inr]
rfl
|
theorem
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Limits.Products"
] |
Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean
|
isEmbedding_of_pullback
| null |
snd_isOpenEmbedding_of_left {X Y S : TopCat} {f : X ⟶ S} (H : IsOpenEmbedding f)
(g : Y ⟶ S) : IsOpenEmbedding <| ⇑(pullback.snd f g) := by
convert (homeoOfIso (asIso (pullback.snd (𝟙 S) g))).isOpenEmbedding.comp
(pullback_map_isOpenEmbedding (i₂ := 𝟙 Y) f g (𝟙 _) g H
(homeoOfIso (Iso.refl _)).isOpenEmbedding (𝟙 _) rfl (by simp))
simp [homeoOfIso, ← coe_comp]
|
theorem
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Limits.Products"
] |
Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean
|
snd_isOpenEmbedding_of_left
| null |
fst_isOpenEmbedding_of_right {X Y S : TopCat} (f : X ⟶ S) {g : Y ⟶ S}
(H : IsOpenEmbedding g) : IsOpenEmbedding <| ⇑(pullback.fst f g) := by
convert (homeoOfIso (asIso (pullback.fst f (𝟙 S)))).isOpenEmbedding.comp
(pullback_map_isOpenEmbedding (i₁ := 𝟙 X) f g f (𝟙 _)
(homeoOfIso (Iso.refl _)).isOpenEmbedding H (𝟙 _) rfl (by simp))
simp [homeoOfIso, ← coe_comp]
|
theorem
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Limits.Products"
] |
Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean
|
fst_isOpenEmbedding_of_right
| null |
isOpenEmbedding_of_pullback {X Y S : TopCat} {f : X ⟶ S} {g : Y ⟶ S}
(H₁ : IsOpenEmbedding f) (H₂ : IsOpenEmbedding g) :
IsOpenEmbedding (limit.π (cospan f g) WalkingCospan.one) := by
convert H₂.comp (snd_isOpenEmbedding_of_left H₁ g)
rw [← coe_comp, ← limit.w _ WalkingCospan.Hom.inr]
rfl
|
theorem
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Limits.Products"
] |
Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean
|
isOpenEmbedding_of_pullback
|
If `X ⟶ S`, `Y ⟶ S` are open embeddings, then so is `X ×ₛ Y ⟶ S`.
|
fst_iso_of_right_embedding_range_subset {X Y S : TopCat} (f : X ⟶ S) {g : Y ⟶ S}
(hg : IsEmbedding g) (H : Set.range f ⊆ Set.range g) :
IsIso (pullback.fst f g) := by
let esto : (pullback f g : TopCat) ≃ₜ X :=
(fst_isEmbedding_of_right f hg).toHomeomorph.trans
{ toFun := Subtype.val
invFun := fun x =>
⟨x, by
rw [pullback_fst_range]
exact ⟨_, (H (Set.mem_range_self x)).choose_spec.symm⟩⟩ }
convert (isoOfHomeo esto).isIso_hom
|
theorem
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Limits.Products"
] |
Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean
|
fst_iso_of_right_embedding_range_subset
| null |
snd_iso_of_left_embedding_range_subset {X Y S : TopCat} {f : X ⟶ S} (hf : IsEmbedding f)
(g : Y ⟶ S) (H : Set.range g ⊆ Set.range f) : IsIso (pullback.snd f g) := by
let esto : (pullback f g : TopCat) ≃ₜ Y :=
(snd_isEmbedding_of_left hf g).toHomeomorph.trans
{ toFun := Subtype.val
invFun := fun x =>
⟨x, by
rw [pullback_snd_range]
exact ⟨_, (H (Set.mem_range_self x)).choose_spec⟩⟩ }
convert (isoOfHomeo esto).isIso_hom
|
theorem
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Limits.Products"
] |
Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean
|
snd_iso_of_left_embedding_range_subset
| null |
pullback_snd_image_fst_preimage (f : X ⟶ Z) (g : Y ⟶ Z) (U : Set X) :
(pullback.snd f g) '' ((pullback.fst f g) ⁻¹' U) =
g ⁻¹' (f '' U) := by
ext x
constructor
· rintro ⟨y, hy, rfl⟩
exact
⟨(pullback.fst f g) y, hy, CategoryTheory.congr_fun pullback.condition y⟩
· rintro ⟨y, hy, eq⟩
refine ⟨(TopCat.pullbackIsoProdSubtype f g).inv ⟨⟨_, _⟩, eq⟩, ?_, ?_⟩
· simp only [coe_of, Set.mem_preimage]
convert hy
rw [pullbackIsoProdSubtype_inv_fst_apply]
· rw [pullbackIsoProdSubtype_inv_snd_apply]
|
theorem
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Limits.Products"
] |
Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean
|
pullback_snd_image_fst_preimage
| null |
pullback_fst_image_snd_preimage (f : X ⟶ Z) (g : Y ⟶ Z) (U : Set Y) :
(pullback.fst f g) '' ((pullback.snd f g) ⁻¹' U) =
f ⁻¹' (g '' U) := by
ext x
constructor
· rintro ⟨y, hy, rfl⟩
exact
⟨(pullback.snd f g) y, hy,
(CategoryTheory.congr_fun pullback.condition y).symm⟩
· rintro ⟨y, hy, eq⟩
refine ⟨(TopCat.pullbackIsoProdSubtype f g).inv ⟨⟨_, _⟩, eq.symm⟩, ?_, ?_⟩
· simp only [coe_of, Set.mem_preimage]
convert hy
rw [pullbackIsoProdSubtype_inv_snd_apply]
· rw [pullbackIsoProdSubtype_inv_fst_apply]
|
theorem
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Limits.Products"
] |
Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean
|
pullback_fst_image_snd_preimage
| null |
isOpen_iff_of_isColimit_cofork (c : Cofork f g) (hc : IsColimit c) (U : Set c.pt) :
IsOpen U ↔ IsOpen (c.π ⁻¹' U) := by
rw [isOpen_iff_of_isColimit _ hc]
constructor
· intro h
exact h .one
· rintro h (_ | _)
· rw [← c.w .left]
exact Continuous.isOpen_preimage f.hom.continuous (c.π ⁻¹' U) h
· exact h
|
lemma
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Limits.Products"
] |
Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean
|
isOpen_iff_of_isColimit_cofork
| null |
isQuotientMap_of_isColimit_cofork (c : Cofork f g) (hc : IsColimit c) :
IsQuotientMap c.π := by
rw [isQuotientMap_iff]
constructor
· simpa only [← epi_iff_surjective] using epi_of_isColimit_cofork hc
· exact isOpen_iff_of_isColimit_cofork c hc
|
lemma
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Limits.Products"
] |
Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean
|
isQuotientMap_of_isColimit_cofork
| null |
coequalizer_isOpen_iff (U : Set ((coequalizer f g :) : Type u)) :
IsOpen U ↔ IsOpen (coequalizer.π f g ⁻¹' U) :=
isOpen_iff_of_isColimit_cofork _ (coequalizerIsCoequalizer f g) _
|
theorem
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Limits.Products"
] |
Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean
|
coequalizer_isOpen_iff
| null |
OnePoint (X : Type*) :=
Option X
|
def
|
Topology
|
[
"Mathlib.Data.Fintype.Option",
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.Topology.Sets.Opens"
] |
Mathlib/Topology/Compactification/OnePoint/Basic.lean
|
OnePoint
|
The OnePoint extension of an arbitrary topological space `X`
|
@[match_pattern] infty : OnePoint X := none
@[inherit_doc]
scoped notation "∞" => OnePoint.infty
|
def
|
Topology
|
[
"Mathlib.Data.Fintype.Option",
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.Topology.Sets.Opens"
] |
Mathlib/Topology/Compactification/OnePoint/Basic.lean
|
infty
|
The repr uses the notation from the `OnePoint` locale. -/
instance [Repr X] : Repr (OnePoint X) :=
⟨fun o _ =>
match o with
| none => "∞"
| some a => "↑" ++ repr a⟩
namespace OnePoint
/-- The point at infinity
|
@[coe, match_pattern] some : X → OnePoint X := Option.some
@[simp]
|
def
|
Topology
|
[
"Mathlib.Data.Fintype.Option",
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.Topology.Sets.Opens"
] |
Mathlib/Topology/Compactification/OnePoint/Basic.lean
|
some
|
Coercion from `X` to `OnePoint X`.
|
some_eq_iff (x₁ x₂ : X) : (some x₁ = some x₂) ↔ (x₁ = x₂) := by
rw [iff_eq_eq]
exact Option.some.injEq x₁ x₂
|
lemma
|
Topology
|
[
"Mathlib.Data.Fintype.Option",
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.Topology.Sets.Opens"
] |
Mathlib/Topology/Compactification/OnePoint/Basic.lean
|
some_eq_iff
| null |
infinite [Infinite X] : Infinite (OnePoint X) :=
inferInstanceAs (Infinite (Option X))
|
instance
|
Topology
|
[
"Mathlib.Data.Fintype.Option",
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.Topology.Sets.Opens"
] |
Mathlib/Topology/Compactification/OnePoint/Basic.lean
|
infinite
| null |
coe_injective : Function.Injective ((↑) : X → OnePoint X) :=
Option.some_injective X
@[norm_cast]
|
theorem
|
Topology
|
[
"Mathlib.Data.Fintype.Option",
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.Topology.Sets.Opens"
] |
Mathlib/Topology/Compactification/OnePoint/Basic.lean
|
coe_injective
| null |
coe_eq_coe {x y : X} : (x : OnePoint X) = y ↔ x = y :=
coe_injective.eq_iff
@[simp]
|
theorem
|
Topology
|
[
"Mathlib.Data.Fintype.Option",
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.Topology.Sets.Opens"
] |
Mathlib/Topology/Compactification/OnePoint/Basic.lean
|
coe_eq_coe
| null |
coe_ne_infty (x : X) : (x : OnePoint X) ≠ ∞ :=
nofun
@[simp]
|
theorem
|
Topology
|
[
"Mathlib.Data.Fintype.Option",
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.Topology.Sets.Opens"
] |
Mathlib/Topology/Compactification/OnePoint/Basic.lean
|
coe_ne_infty
| null |
infty_ne_coe (x : X) : ∞ ≠ (x : OnePoint X) :=
nofun
|
theorem
|
Topology
|
[
"Mathlib.Data.Fintype.Option",
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.Topology.Sets.Opens"
] |
Mathlib/Topology/Compactification/OnePoint/Basic.lean
|
infty_ne_coe
| null |
@[elab_as_elim, induction_eliminator, cases_eliminator]
protected rec {C : OnePoint X → Sort*} (infty : C ∞) (coe : ∀ x : X, C x) :
∀ z : OnePoint X, C z
| ∞ => infty
| (x : X) => coe x
|
def
|
Topology
|
[
"Mathlib.Data.Fintype.Option",
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.Topology.Sets.Opens"
] |
Mathlib/Topology/Compactification/OnePoint/Basic.lean
|
rec
|
Recursor for `OnePoint` using the preferred forms `∞` and `↑x`.
|
@[inline] protected elim : OnePoint X → Y → (X → Y) → Y := Option.elim
@[simp] theorem elim_infty (y : Y) (f : X → Y) : ∞.elim y f = y := rfl
@[simp] theorem elim_some (y : Y) (f : X → Y) (x : X) : (some x).elim y f = f x := rfl
|
def
|
Topology
|
[
"Mathlib.Data.Fintype.Option",
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.Topology.Sets.Opens"
] |
Mathlib/Topology/Compactification/OnePoint/Basic.lean
|
elim
|
An elimination principle for `OnePoint`.
|
isCompl_range_coe_infty : IsCompl (range ((↑) : X → OnePoint X)) {∞} :=
isCompl_range_some_none X
|
theorem
|
Topology
|
[
"Mathlib.Data.Fintype.Option",
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.Topology.Sets.Opens"
] |
Mathlib/Topology/Compactification/OnePoint/Basic.lean
|
isCompl_range_coe_infty
| null |
range_coe_union_infty : range ((↑) : X → OnePoint X) ∪ {∞} = univ :=
range_some_union_none X
@[simp]
|
theorem
|
Topology
|
[
"Mathlib.Data.Fintype.Option",
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.Topology.Sets.Opens"
] |
Mathlib/Topology/Compactification/OnePoint/Basic.lean
|
range_coe_union_infty
| null |
insert_infty_range_coe : insert ∞ (range (@some X)) = univ :=
insert_none_range_some _
@[simp]
|
theorem
|
Topology
|
[
"Mathlib.Data.Fintype.Option",
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.Topology.Sets.Opens"
] |
Mathlib/Topology/Compactification/OnePoint/Basic.lean
|
insert_infty_range_coe
| null |
range_coe_inter_infty : range ((↑) : X → OnePoint X) ∩ {∞} = ∅ :=
range_some_inter_none X
@[simp]
|
theorem
|
Topology
|
[
"Mathlib.Data.Fintype.Option",
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.Topology.Sets.Opens"
] |
Mathlib/Topology/Compactification/OnePoint/Basic.lean
|
range_coe_inter_infty
| null |
compl_range_coe : (range ((↑) : X → OnePoint X))ᶜ = {∞} :=
compl_range_some X
|
theorem
|
Topology
|
[
"Mathlib.Data.Fintype.Option",
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.Topology.Sets.Opens"
] |
Mathlib/Topology/Compactification/OnePoint/Basic.lean
|
compl_range_coe
| null |
compl_infty : ({∞}ᶜ : Set (OnePoint X)) = range ((↑) : X → OnePoint X) :=
(@isCompl_range_coe_infty X).symm.compl_eq
|
theorem
|
Topology
|
[
"Mathlib.Data.Fintype.Option",
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.Topology.Sets.Opens"
] |
Mathlib/Topology/Compactification/OnePoint/Basic.lean
|
compl_infty
| null |
compl_image_coe (s : Set X) : ((↑) '' s : Set (OnePoint X))ᶜ = (↑) '' sᶜ ∪ {∞} := by
rw [coe_injective.compl_image_eq, compl_range_coe]
|
theorem
|
Topology
|
[
"Mathlib.Data.Fintype.Option",
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.Topology.Sets.Opens"
] |
Mathlib/Topology/Compactification/OnePoint/Basic.lean
|
compl_image_coe
| null |
ne_infty_iff_exists {x : OnePoint X} : x ≠ ∞ ↔ ∃ y : X, (y : OnePoint X) = x := by
induction x using OnePoint.rec <;> simp
|
theorem
|
Topology
|
[
"Mathlib.Data.Fintype.Option",
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.Topology.Sets.Opens"
] |
Mathlib/Topology/Compactification/OnePoint/Basic.lean
|
ne_infty_iff_exists
| null |
canLift : CanLift (OnePoint X) X (↑) fun x => x ≠ ∞ :=
WithTop.canLift
|
instance
|
Topology
|
[
"Mathlib.Data.Fintype.Option",
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.Topology.Sets.Opens"
] |
Mathlib/Topology/Compactification/OnePoint/Basic.lean
|
canLift
| null |
notMem_range_coe_iff {x : OnePoint X} : x ∉ range some ↔ x = ∞ := by
rw [← mem_compl_iff, compl_range_coe, mem_singleton_iff]
@[deprecated (since := "2025-05-23")] alias not_mem_range_coe_iff := notMem_range_coe_iff
|
theorem
|
Topology
|
[
"Mathlib.Data.Fintype.Option",
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.Topology.Sets.Opens"
] |
Mathlib/Topology/Compactification/OnePoint/Basic.lean
|
notMem_range_coe_iff
| null |
infty_notMem_range_coe : ∞ ∉ range ((↑) : X → OnePoint X) :=
notMem_range_coe_iff.2 rfl
@[deprecated (since := "2025-05-23")] alias infty_not_mem_range_coe := infty_notMem_range_coe
|
theorem
|
Topology
|
[
"Mathlib.Data.Fintype.Option",
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.Topology.Sets.Opens"
] |
Mathlib/Topology/Compactification/OnePoint/Basic.lean
|
infty_notMem_range_coe
| null |
infty_notMem_image_coe {s : Set X} : ∞ ∉ ((↑) : X → OnePoint X) '' s :=
notMem_subset (image_subset_range _ _) infty_notMem_range_coe
@[deprecated (since := "2025-05-23")] alias infty_not_mem_image_coe := infty_notMem_image_coe
@[simp]
|
theorem
|
Topology
|
[
"Mathlib.Data.Fintype.Option",
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.Topology.Sets.Opens"
] |
Mathlib/Topology/Compactification/OnePoint/Basic.lean
|
infty_notMem_image_coe
| null |
coe_preimage_infty : ((↑) : X → OnePoint X) ⁻¹' {∞} = ∅ := by
ext
simp
|
theorem
|
Topology
|
[
"Mathlib.Data.Fintype.Option",
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.Topology.Sets.Opens"
] |
Mathlib/Topology/Compactification/OnePoint/Basic.lean
|
coe_preimage_infty
| null |
protected map (f : X → Y) : OnePoint X → OnePoint Y :=
Option.map f
@[simp] theorem map_infty (f : X → Y) : OnePoint.map f ∞ = ∞ := rfl
@[simp] theorem map_some (f : X → Y) (x : X) : (x : OnePoint X).map f = f x := rfl
@[simp] theorem map_id : OnePoint.map (id : X → X) = id := Option.map_id
|
def
|
Topology
|
[
"Mathlib.Data.Fintype.Option",
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.Topology.Sets.Opens"
] |
Mathlib/Topology/Compactification/OnePoint/Basic.lean
|
map
|
Extend a map `f : X → Y` to a map `OnePoint X → OnePoint Y`
by sending infinity to infinity.
|
map_comp {Z : Type*} (f : Y → Z) (g : X → Y) :
OnePoint.map (f ∘ g) = OnePoint.map f ∘ OnePoint.map g :=
(Option.map_comp_map _ _).symm
/-!
|
theorem
|
Topology
|
[
"Mathlib.Data.Fintype.Option",
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.Topology.Sets.Opens"
] |
Mathlib/Topology/Compactification/OnePoint/Basic.lean
|
map_comp
| null |
isOpen_def :
IsOpen s ↔ (∞ ∈ s → IsCompact ((↑) ⁻¹' s : Set X)ᶜ) ∧ IsOpen ((↑) ⁻¹' s : Set X) :=
Iff.rfl
|
theorem
|
Topology
|
[
"Mathlib.Data.Fintype.Option",
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.Topology.Sets.Opens"
] |
Mathlib/Topology/Compactification/OnePoint/Basic.lean
|
isOpen_def
| null |
isOpen_iff_of_mem' (h : ∞ ∈ s) :
IsOpen s ↔ IsCompact ((↑) ⁻¹' s : Set X)ᶜ ∧ IsOpen ((↑) ⁻¹' s : Set X) := by
simp [isOpen_def, h]
|
theorem
|
Topology
|
[
"Mathlib.Data.Fintype.Option",
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.Topology.Sets.Opens"
] |
Mathlib/Topology/Compactification/OnePoint/Basic.lean
|
isOpen_iff_of_mem'
| null |
isOpen_iff_of_mem (h : ∞ ∈ s) :
IsOpen s ↔ IsClosed ((↑) ⁻¹' s : Set X)ᶜ ∧ IsCompact ((↑) ⁻¹' s : Set X)ᶜ := by
simp only [isOpen_iff_of_mem' h, isClosed_compl_iff, and_comm]
|
theorem
|
Topology
|
[
"Mathlib.Data.Fintype.Option",
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.Topology.Sets.Opens"
] |
Mathlib/Topology/Compactification/OnePoint/Basic.lean
|
isOpen_iff_of_mem
| null |
isOpen_iff_of_notMem (h : ∞ ∉ s) : IsOpen s ↔ IsOpen ((↑) ⁻¹' s : Set X) := by
simp [isOpen_def, h]
@[deprecated (since := "2025-05-23")] alias isOpen_iff_of_not_mem := isOpen_iff_of_notMem
|
theorem
|
Topology
|
[
"Mathlib.Data.Fintype.Option",
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.Topology.Sets.Opens"
] |
Mathlib/Topology/Compactification/OnePoint/Basic.lean
|
isOpen_iff_of_notMem
| null |
isClosed_iff_of_mem (h : ∞ ∈ s) : IsClosed s ↔ IsClosed ((↑) ⁻¹' s : Set X) := by
have : ∞ ∉ sᶜ := fun H => H h
rw [← isOpen_compl_iff, isOpen_iff_of_notMem this, ← isOpen_compl_iff, preimage_compl]
|
theorem
|
Topology
|
[
"Mathlib.Data.Fintype.Option",
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.Topology.Sets.Opens"
] |
Mathlib/Topology/Compactification/OnePoint/Basic.lean
|
isClosed_iff_of_mem
| null |
isClosed_iff_of_notMem (h : ∞ ∉ s) :
IsClosed s ↔ IsClosed ((↑) ⁻¹' s : Set X) ∧ IsCompact ((↑) ⁻¹' s : Set X) := by
rw [← isOpen_compl_iff, isOpen_iff_of_mem (mem_compl h), ← preimage_compl, compl_compl]
@[deprecated (since := "2025-05-23")] alias isClosed_iff_of_not_mem := isClosed_iff_of_notMem
@[simp]
|
theorem
|
Topology
|
[
"Mathlib.Data.Fintype.Option",
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.Topology.Sets.Opens"
] |
Mathlib/Topology/Compactification/OnePoint/Basic.lean
|
isClosed_iff_of_notMem
| null |
isOpen_image_coe {s : Set X} : IsOpen ((↑) '' s : Set (OnePoint X)) ↔ IsOpen s := by
rw [isOpen_iff_of_notMem infty_notMem_image_coe, preimage_image_eq _ coe_injective]
|
theorem
|
Topology
|
[
"Mathlib.Data.Fintype.Option",
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.Topology.Sets.Opens"
] |
Mathlib/Topology/Compactification/OnePoint/Basic.lean
|
isOpen_image_coe
| null |
isOpen_compl_image_coe {s : Set X} :
IsOpen ((↑) '' s : Set (OnePoint X))ᶜ ↔ IsClosed s ∧ IsCompact s := by
rw [isOpen_iff_of_mem, ← preimage_compl, compl_compl, preimage_image_eq _ coe_injective]
exact infty_notMem_image_coe
@[simp]
|
theorem
|
Topology
|
[
"Mathlib.Data.Fintype.Option",
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.Topology.Sets.Opens"
] |
Mathlib/Topology/Compactification/OnePoint/Basic.lean
|
isOpen_compl_image_coe
| null |
isClosed_image_coe {s : Set X} :
IsClosed ((↑) '' s : Set (OnePoint X)) ↔ IsClosed s ∧ IsCompact s := by
rw [← isOpen_compl_iff, isOpen_compl_image_coe]
|
theorem
|
Topology
|
[
"Mathlib.Data.Fintype.Option",
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.Topology.Sets.Opens"
] |
Mathlib/Topology/Compactification/OnePoint/Basic.lean
|
isClosed_image_coe
| null |
opensOfCompl (s : Set X) (h₁ : IsClosed s) (h₂ : IsCompact s) :
TopologicalSpace.Opens (OnePoint X) :=
⟨((↑) '' s)ᶜ, isOpen_compl_image_coe.2 ⟨h₁, h₂⟩⟩
|
def
|
Topology
|
[
"Mathlib.Data.Fintype.Option",
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.Topology.Sets.Opens"
] |
Mathlib/Topology/Compactification/OnePoint/Basic.lean
|
opensOfCompl
|
An open set in `OnePoint X` constructed from a closed compact set in `X`
|
infty_mem_opensOfCompl {s : Set X} (h₁ : IsClosed s) (h₂ : IsCompact s) :
∞ ∈ opensOfCompl s h₁ h₂ :=
mem_compl infty_notMem_image_coe
@[continuity]
|
theorem
|
Topology
|
[
"Mathlib.Data.Fintype.Option",
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.Topology.Sets.Opens"
] |
Mathlib/Topology/Compactification/OnePoint/Basic.lean
|
infty_mem_opensOfCompl
| null |
continuous_coe : Continuous ((↑) : X → OnePoint X) :=
continuous_def.mpr fun _s hs => hs.right
|
theorem
|
Topology
|
[
"Mathlib.Data.Fintype.Option",
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.Topology.Sets.Opens"
] |
Mathlib/Topology/Compactification/OnePoint/Basic.lean
|
continuous_coe
| null |
isOpenMap_coe : IsOpenMap ((↑) : X → OnePoint X) := fun _ => isOpen_image_coe.2
|
theorem
|
Topology
|
[
"Mathlib.Data.Fintype.Option",
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.Topology.Sets.Opens"
] |
Mathlib/Topology/Compactification/OnePoint/Basic.lean
|
isOpenMap_coe
| null |
isOpenEmbedding_coe : IsOpenEmbedding ((↑) : X → OnePoint X) :=
.of_continuous_injective_isOpenMap continuous_coe coe_injective isOpenMap_coe
|
theorem
|
Topology
|
[
"Mathlib.Data.Fintype.Option",
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.Topology.Sets.Opens"
] |
Mathlib/Topology/Compactification/OnePoint/Basic.lean
|
isOpenEmbedding_coe
| null |
isOpen_range_coe : IsOpen (range ((↑) : X → OnePoint X)) :=
isOpenEmbedding_coe.isOpen_range
|
theorem
|
Topology
|
[
"Mathlib.Data.Fintype.Option",
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.Topology.Sets.Opens"
] |
Mathlib/Topology/Compactification/OnePoint/Basic.lean
|
isOpen_range_coe
| null |
isClosed_infty : IsClosed ({∞} : Set (OnePoint X)) := by
rw [← compl_range_coe, isClosed_compl_iff]
exact isOpen_range_coe
|
theorem
|
Topology
|
[
"Mathlib.Data.Fintype.Option",
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.Topology.Sets.Opens"
] |
Mathlib/Topology/Compactification/OnePoint/Basic.lean
|
isClosed_infty
| null |
nhds_coe_eq (x : X) : 𝓝 ↑x = map ((↑) : X → OnePoint X) (𝓝 x) :=
(isOpenEmbedding_coe.map_nhds_eq x).symm
|
theorem
|
Topology
|
[
"Mathlib.Data.Fintype.Option",
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.Topology.Sets.Opens"
] |
Mathlib/Topology/Compactification/OnePoint/Basic.lean
|
nhds_coe_eq
| null |
nhdsWithin_coe_image (s : Set X) (x : X) :
𝓝[(↑) '' s] (x : OnePoint X) = map (↑) (𝓝[s] x) :=
(isOpenEmbedding_coe.isEmbedding.map_nhdsWithin_eq _ _).symm
|
theorem
|
Topology
|
[
"Mathlib.Data.Fintype.Option",
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.Topology.Sets.Opens"
] |
Mathlib/Topology/Compactification/OnePoint/Basic.lean
|
nhdsWithin_coe_image
| null |
nhdsWithin_coe (s : Set (OnePoint X)) (x : X) : 𝓝[s] ↑x = map (↑) (𝓝[(↑) ⁻¹' s] x) :=
(isOpenEmbedding_coe.map_nhdsWithin_preimage_eq _ _).symm
|
theorem
|
Topology
|
[
"Mathlib.Data.Fintype.Option",
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.Topology.Sets.Opens"
] |
Mathlib/Topology/Compactification/OnePoint/Basic.lean
|
nhdsWithin_coe
| null |
comap_coe_nhds (x : X) : comap ((↑) : X → OnePoint X) (𝓝 x) = 𝓝 x :=
(isOpenEmbedding_coe.isInducing.nhds_eq_comap x).symm
|
theorem
|
Topology
|
[
"Mathlib.Data.Fintype.Option",
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.Topology.Sets.Opens"
] |
Mathlib/Topology/Compactification/OnePoint/Basic.lean
|
comap_coe_nhds
| null |
nhdsNE_coe_neBot (x : X) [h : NeBot (𝓝[≠] x)] : NeBot (𝓝[≠] (x : OnePoint X)) := by
simpa [nhdsWithin_coe, preimage, coe_eq_coe] using h.map some
@[deprecated (since := "2025-03-02")]
alias nhdsWithin_compl_coe_neBot := nhdsNE_coe_neBot
|
instance
|
Topology
|
[
"Mathlib.Data.Fintype.Option",
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.Topology.Sets.Opens"
] |
Mathlib/Topology/Compactification/OnePoint/Basic.lean
|
nhdsNE_coe_neBot
|
If `x` is not an isolated point of `X`, then `x : OnePoint X` is not an isolated point
of `OnePoint X`.
|
nhdsNE_infty_eq : 𝓝[≠] (∞ : OnePoint X) = map (↑) (coclosedCompact X) := by
refine (nhdsWithin_basis_open ∞ _).ext (hasBasis_coclosedCompact.map _) ?_ ?_
· rintro s ⟨hs, hso⟩
refine ⟨_, (isOpen_iff_of_mem hs).mp hso, ?_⟩
simp
· rintro s ⟨h₁, h₂⟩
refine ⟨_, ⟨mem_compl infty_notMem_image_coe, isOpen_compl_image_coe.2 ⟨h₁, h₂⟩⟩, ?_⟩
simp [compl_image_coe, ← diff_eq]
@[deprecated (since := "2025-03-02")]
alias nhdsWithin_compl_infty_eq := nhdsNE_infty_eq
|
theorem
|
Topology
|
[
"Mathlib.Data.Fintype.Option",
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.Topology.Sets.Opens"
] |
Mathlib/Topology/Compactification/OnePoint/Basic.lean
|
nhdsNE_infty_eq
| null |
nhdsNE_infty_neBot [NoncompactSpace X] : NeBot (𝓝[≠] (∞ : OnePoint X)) := by
rw [nhdsNE_infty_eq]
infer_instance
@[deprecated (since := "2025-03-02")]
alias nhdsWithin_compl_infty_neBot := nhdsNE_infty_neBot
|
instance
|
Topology
|
[
"Mathlib.Data.Fintype.Option",
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.Topology.Sets.Opens"
] |
Mathlib/Topology/Compactification/OnePoint/Basic.lean
|
nhdsNE_infty_neBot
|
If `X` is a non-compact space, then `∞` is not an isolated point of `OnePoint X`.
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.