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 ⌀ |
|---|---|---|---|---|---|---|
lipschitzOnWith_iff {f : γ → α →ᵤ β} {K : ℝ≥0} {s : Set γ} :
LipschitzOnWith K f s ↔ ∀ c, LipschitzOnWith K (fun x ↦ toFun (f x) c) s := by
simp [lipschitzOnWith_iff_restrict, lipschitzWith_iff]
rfl | lemma | Topology | [
"Mathlib.Order.CompleteLattice.Group",
"Mathlib.Topology.ContinuousMap.Bounded.Basic",
"Mathlib.Topology.ContinuousMap.Compact",
"Mathlib.Topology.MetricSpace.Lipschitz",
"Mathlib.Topology.UniformSpace.UniformConvergenceTopology"
] | Mathlib/Topology/MetricSpace/UniformConvergence.lean | lipschitzOnWith_iff | null |
lipschitzOnWith_ofFun_iff {f : γ → α → β} {K : ℝ≥0} {s : Set γ} :
LipschitzOnWith K (fun x ↦ ofFun (f x)) s ↔ ∀ c, LipschitzOnWith K (f · c) s :=
lipschitzOnWith_iff | lemma | Topology | [
"Mathlib.Order.CompleteLattice.Group",
"Mathlib.Topology.ContinuousMap.Bounded.Basic",
"Mathlib.Topology.ContinuousMap.Compact",
"Mathlib.Topology.MetricSpace.Lipschitz",
"Mathlib.Topology.UniformSpace.UniformConvergenceTopology"
] | Mathlib/Topology/MetricSpace/UniformConvergence.lean | lipschitzOnWith_ofFun_iff | null |
_root_.LipschitzOnWith.uniformEquicontinuousOn (f : α → γ → β) (K : ℝ≥0) {s : Set γ}
(h : ∀ c, LipschitzOnWith K (f c) s) : UniformEquicontinuousOn f s := by
rw [uniformEquicontinuousOn_iff_uniformContinuousOn]
rw [← lipschitzOnWith_ofFun_iff] at h
exact h.uniformContinuousOn | lemma | Topology | [
"Mathlib.Order.CompleteLattice.Group",
"Mathlib.Topology.ContinuousMap.Bounded.Basic",
"Mathlib.Topology.ContinuousMap.Compact",
"Mathlib.Topology.MetricSpace.Lipschitz",
"Mathlib.Topology.UniformSpace.UniformConvergenceTopology"
] | Mathlib/Topology/MetricSpace/UniformConvergence.lean | _root_.LipschitzOnWith.uniformEquicontinuousOn | If `f : α → γ → β` is a family of a functions, all of which are Lipschitz on `s` with the
same constant, then the family is uniformly equicontinuous on `s`. |
edist_eval_le {f g : α →ᵤ β} {x : α} :
edist (toFun f x) (toFun g x) ≤ edist f g :=
edist_le.mp le_rfl x | lemma | Topology | [
"Mathlib.Order.CompleteLattice.Group",
"Mathlib.Topology.ContinuousMap.Bounded.Basic",
"Mathlib.Topology.ContinuousMap.Compact",
"Mathlib.Topology.MetricSpace.Lipschitz",
"Mathlib.Topology.UniformSpace.UniformConvergenceTopology"
] | Mathlib/Topology/MetricSpace/UniformConvergence.lean | edist_eval_le | null |
lipschitzWith_eval (x : α) :
LipschitzWith 1 (fun f : α →ᵤ β ↦ toFun f x) := by
intro f g
simpa using edist_eval_le | lemma | Topology | [
"Mathlib.Order.CompleteLattice.Group",
"Mathlib.Topology.ContinuousMap.Bounded.Basic",
"Mathlib.Topology.ContinuousMap.Compact",
"Mathlib.Topology.MetricSpace.Lipschitz",
"Mathlib.Topology.UniformSpace.UniformConvergenceTopology"
] | Mathlib/Topology/MetricSpace/UniformConvergence.lean | lipschitzWith_eval | null |
dist_def [BoundedSpace β] (f g : α →ᵤ β) :
dist f g = ⨆ x, dist (toFun f x) (toFun g x) :=
rfl | lemma | Topology | [
"Mathlib.Order.CompleteLattice.Group",
"Mathlib.Topology.ContinuousMap.Bounded.Basic",
"Mathlib.Topology.ContinuousMap.Compact",
"Mathlib.Topology.MetricSpace.Lipschitz",
"Mathlib.Topology.UniformSpace.UniformConvergenceTopology"
] | Mathlib/Topology/MetricSpace/UniformConvergence.lean | dist_def | null |
dist_le [BoundedSpace β] {f g : α →ᵤ β} {C : ℝ} (hC : 0 ≤ C) :
dist f g ≤ C ↔ ∀ x, dist (toFun f x) (toFun g x) ≤ C := by
simp_rw [dist_edist, ← ENNReal.le_ofReal_iff_toReal_le (edist_ne_top _ _) hC, edist_le] | lemma | Topology | [
"Mathlib.Order.CompleteLattice.Group",
"Mathlib.Topology.ContinuousMap.Bounded.Basic",
"Mathlib.Topology.ContinuousMap.Compact",
"Mathlib.Topology.MetricSpace.Lipschitz",
"Mathlib.Topology.UniformSpace.UniformConvergenceTopology"
] | Mathlib/Topology/MetricSpace/UniformConvergence.lean | dist_le | null |
isometry_ofFun_boundedContinuousFunction [TopologicalSpace α] :
Isometry (ofFun ∘ DFunLike.coe : (α →ᵇ β) → α →ᵤ β) := by
simp [Isometry, edist_def, edist_eq_iSup] | lemma | Topology | [
"Mathlib.Order.CompleteLattice.Group",
"Mathlib.Topology.ContinuousMap.Bounded.Basic",
"Mathlib.Topology.ContinuousMap.Compact",
"Mathlib.Topology.MetricSpace.Lipschitz",
"Mathlib.Topology.UniformSpace.UniformConvergenceTopology"
] | Mathlib/Topology/MetricSpace/UniformConvergence.lean | isometry_ofFun_boundedContinuousFunction | null |
isometry_ofFun_continuousMap [TopologicalSpace α] [CompactSpace α] :
Isometry (ofFun ∘ DFunLike.coe : C(α, β) → α →ᵤ β) :=
isometry_ofFun_boundedContinuousFunction.comp <|
ContinuousMap.isometryEquivBoundedOfCompact α β |>.isometry | lemma | Topology | [
"Mathlib.Order.CompleteLattice.Group",
"Mathlib.Topology.ContinuousMap.Bounded.Basic",
"Mathlib.Topology.ContinuousMap.Compact",
"Mathlib.Topology.MetricSpace.Lipschitz",
"Mathlib.Topology.UniformSpace.UniformConvergenceTopology"
] | Mathlib/Topology/MetricSpace/UniformConvergence.lean | isometry_ofFun_continuousMap | null |
edist_continuousMapMk [TopologicalSpace α] [CompactSpace α]
{f g : α →ᵤ β} (hf : Continuous (toFun f)) (hg : Continuous (toFun g)) :
edist (⟨_, hf⟩ : C(α, β)) ⟨_, hg⟩ = edist f g := by
simp [← isometry_ofFun_continuousMap.edist_eq] | lemma | Topology | [
"Mathlib.Order.CompleteLattice.Group",
"Mathlib.Topology.ContinuousMap.Bounded.Basic",
"Mathlib.Topology.ContinuousMap.Compact",
"Mathlib.Topology.MetricSpace.Lipschitz",
"Mathlib.Topology.UniformSpace.UniformConvergenceTopology"
] | Mathlib/Topology/MetricSpace/UniformConvergence.lean | edist_continuousMapMk | null |
continuous_of_forall_lipschitzWith {f : γ → α →ᵤ[𝔖] β} (K : Set α → ℝ≥0)
(h : ∀ s ∈ 𝔖, ∀ c ∈ s, LipschitzWith (K s) (fun x ↦ toFun 𝔖 (f x) c)) :
Continuous f := by
rw [UniformOnFun.continuous_rng_iff]
refine fun s hs ↦ LipschitzWith.continuous (K := K s) ?_
rw [UniformFun.lipschitzWith_iff]
rintro ⟨y... | lemma | Topology | [
"Mathlib.Order.CompleteLattice.Group",
"Mathlib.Topology.ContinuousMap.Bounded.Basic",
"Mathlib.Topology.ContinuousMap.Compact",
"Mathlib.Topology.MetricSpace.Lipschitz",
"Mathlib.Topology.UniformSpace.UniformConvergenceTopology"
] | Mathlib/Topology/MetricSpace/UniformConvergence.lean | continuous_of_forall_lipschitzWith | Let `f : γ → α →ᵤ[𝔖] β`. If for every `s ∈ 𝔖` and for every `c ∈ s`, the function
`fun x ↦ f x c` is Lipschitz (with Lipschitz constant depending on `s`), then `f` is continuous. |
edist_def [Finite 𝔖] (f g : α →ᵤ[𝔖] β) :
edist f g = ⨆ x ∈ ⋃₀ 𝔖, edist (toFun 𝔖 f x) (toFun 𝔖 g x) :=
rfl | lemma | Topology | [
"Mathlib.Order.CompleteLattice.Group",
"Mathlib.Topology.ContinuousMap.Bounded.Basic",
"Mathlib.Topology.ContinuousMap.Compact",
"Mathlib.Topology.MetricSpace.Lipschitz",
"Mathlib.Topology.UniformSpace.UniformConvergenceTopology"
] | Mathlib/Topology/MetricSpace/UniformConvergence.lean | edist_def | null |
edist_def' [Finite 𝔖] (f g : α →ᵤ[𝔖] β) :
edist f g = ⨆ s ∈ 𝔖, ⨆ x ∈ s, edist (toFun 𝔖 f x) (toFun 𝔖 g x) := by
simp [edist_def, iSup_and, iSup_comm (ι := α)] | lemma | Topology | [
"Mathlib.Order.CompleteLattice.Group",
"Mathlib.Topology.ContinuousMap.Bounded.Basic",
"Mathlib.Topology.ContinuousMap.Compact",
"Mathlib.Topology.MetricSpace.Lipschitz",
"Mathlib.Topology.UniformSpace.UniformConvergenceTopology"
] | Mathlib/Topology/MetricSpace/UniformConvergence.lean | edist_def' | null |
edist_eq_restrict_sUnion [Finite 𝔖] {f g : α →ᵤ[𝔖] β} :
edist f g = edist
(UniformFun.ofFun ((⋃₀ 𝔖).restrict (toFun 𝔖 f)))
(UniformFun.ofFun ((⋃₀ 𝔖).restrict (toFun 𝔖 g))) :=
iSup_subtype' | lemma | Topology | [
"Mathlib.Order.CompleteLattice.Group",
"Mathlib.Topology.ContinuousMap.Bounded.Basic",
"Mathlib.Topology.ContinuousMap.Compact",
"Mathlib.Topology.MetricSpace.Lipschitz",
"Mathlib.Topology.UniformSpace.UniformConvergenceTopology"
] | Mathlib/Topology/MetricSpace/UniformConvergence.lean | edist_eq_restrict_sUnion | null |
edist_eq_pi_restrict [Fintype 𝔖] {f g : α →ᵤ[𝔖] β} :
edist f g = edist
(fun s : 𝔖 ↦ UniformFun.ofFun ((s : Set α).restrict (toFun 𝔖 f)))
(fun s : 𝔖 ↦ UniformFun.ofFun ((s : Set α).restrict (toFun 𝔖 g))) := by
simp_rw [edist_def', iSup_subtype', edist_pi_def, Finset.sup_univ_eq_iSup]
rfl
variab... | lemma | Topology | [
"Mathlib.Order.CompleteLattice.Group",
"Mathlib.Topology.ContinuousMap.Bounded.Basic",
"Mathlib.Topology.ContinuousMap.Compact",
"Mathlib.Topology.MetricSpace.Lipschitz",
"Mathlib.Topology.UniformSpace.UniformConvergenceTopology"
] | Mathlib/Topology/MetricSpace/UniformConvergence.lean | edist_eq_pi_restrict | null |
edist_le {f g : α →ᵤ[𝔖] β} {C : ℝ≥0∞} :
edist f g ≤ C ↔ ∀ x ∈ ⋃₀ 𝔖, edist (toFun 𝔖 f x) (toFun 𝔖 g x) ≤ C := by
simp_rw [edist_def, iSup₂_le_iff] | lemma | Topology | [
"Mathlib.Order.CompleteLattice.Group",
"Mathlib.Topology.ContinuousMap.Bounded.Basic",
"Mathlib.Topology.ContinuousMap.Compact",
"Mathlib.Topology.MetricSpace.Lipschitz",
"Mathlib.Topology.UniformSpace.UniformConvergenceTopology"
] | Mathlib/Topology/MetricSpace/UniformConvergence.lean | edist_le | null |
lipschitzWith_iff {f : γ → α →ᵤ[𝔖] β} {K : ℝ≥0} :
LipschitzWith K f ↔ ∀ c ∈ ⋃₀ 𝔖, LipschitzWith K (fun x ↦ toFun 𝔖 (f x) c) := by
simp [LipschitzWith, edist_le]
tauto | lemma | Topology | [
"Mathlib.Order.CompleteLattice.Group",
"Mathlib.Topology.ContinuousMap.Bounded.Basic",
"Mathlib.Topology.ContinuousMap.Compact",
"Mathlib.Topology.MetricSpace.Lipschitz",
"Mathlib.Topology.UniformSpace.UniformConvergenceTopology"
] | Mathlib/Topology/MetricSpace/UniformConvergence.lean | lipschitzWith_iff | null |
lipschitzOnWith_iff {f : γ → α →ᵤ[𝔖] β} {K : ℝ≥0} {s : Set γ} :
LipschitzOnWith K f s ↔ ∀ c ∈ ⋃₀ 𝔖, LipschitzOnWith K (fun x ↦ toFun 𝔖 (f x) c) s := by
simp [lipschitzOnWith_iff_restrict, lipschitzWith_iff]
rfl | lemma | Topology | [
"Mathlib.Order.CompleteLattice.Group",
"Mathlib.Topology.ContinuousMap.Bounded.Basic",
"Mathlib.Topology.ContinuousMap.Compact",
"Mathlib.Topology.MetricSpace.Lipschitz",
"Mathlib.Topology.UniformSpace.UniformConvergenceTopology"
] | Mathlib/Topology/MetricSpace/UniformConvergence.lean | lipschitzOnWith_iff | null |
edist_eval_le {f g : α →ᵤ[𝔖] β} {x : α} (hx : x ∈ ⋃₀ 𝔖) :
edist (toFun 𝔖 f x) (toFun 𝔖 g x) ≤ edist f g :=
edist_le.mp le_rfl x hx | lemma | Topology | [
"Mathlib.Order.CompleteLattice.Group",
"Mathlib.Topology.ContinuousMap.Bounded.Basic",
"Mathlib.Topology.ContinuousMap.Compact",
"Mathlib.Topology.MetricSpace.Lipschitz",
"Mathlib.Topology.UniformSpace.UniformConvergenceTopology"
] | Mathlib/Topology/MetricSpace/UniformConvergence.lean | edist_eval_le | null |
lipschitzWith_eval {x : α} (hx : x ∈ ⋃₀ 𝔖) :
LipschitzWith 1 (fun f : α →ᵤ[𝔖] β ↦ toFun 𝔖 f x) := by
intro f g
simpa only [ENNReal.coe_one, one_mul] using edist_eval_le hx | lemma | Topology | [
"Mathlib.Order.CompleteLattice.Group",
"Mathlib.Topology.ContinuousMap.Bounded.Basic",
"Mathlib.Topology.ContinuousMap.Compact",
"Mathlib.Topology.MetricSpace.Lipschitz",
"Mathlib.Topology.UniformSpace.UniformConvergenceTopology"
] | Mathlib/Topology/MetricSpace/UniformConvergence.lean | lipschitzWith_eval | null |
lipschitzWith_one_ofFun_toFun :
LipschitzWith 1 (ofFun 𝔖 ∘ UniformFun.toFun : (α →ᵤ β) → (α →ᵤ[𝔖] β)) :=
lipschitzWith_iff.mpr fun _ _ ↦ UniformFun.lipschitzWith_eval _ | lemma | Topology | [
"Mathlib.Order.CompleteLattice.Group",
"Mathlib.Topology.ContinuousMap.Bounded.Basic",
"Mathlib.Topology.ContinuousMap.Compact",
"Mathlib.Topology.MetricSpace.Lipschitz",
"Mathlib.Topology.UniformSpace.UniformConvergenceTopology"
] | Mathlib/Topology/MetricSpace/UniformConvergence.lean | lipschitzWith_one_ofFun_toFun | null |
lipschitzWith_one_ofFun_toFun' [Finite 𝔗] (h : ⋃₀ 𝔖 ⊆ ⋃₀ 𝔗) :
LipschitzWith 1 (ofFun 𝔖 ∘ toFun 𝔗 : (α →ᵤ[𝔗] β) → (α →ᵤ[𝔖] β)) :=
lipschitzWith_iff.mpr fun _x hx ↦ lipschitzWith_eval (h hx) | lemma | Topology | [
"Mathlib.Order.CompleteLattice.Group",
"Mathlib.Topology.ContinuousMap.Bounded.Basic",
"Mathlib.Topology.ContinuousMap.Compact",
"Mathlib.Topology.MetricSpace.Lipschitz",
"Mathlib.Topology.UniformSpace.UniformConvergenceTopology"
] | Mathlib/Topology/MetricSpace/UniformConvergence.lean | lipschitzWith_one_ofFun_toFun' | null |
lipschitzWith_restrict (s : Set α) (hs : s ∈ 𝔖) :
LipschitzWith 1 (UniformFun.ofFun ∘ s.restrict ∘ toFun 𝔖 : (α →ᵤ[𝔖] β) → (s →ᵤ β)) :=
UniformFun.lipschitzWith_iff.mpr fun x ↦ lipschitzWith_eval ⟨s, hs, x.2⟩ | lemma | Topology | [
"Mathlib.Order.CompleteLattice.Group",
"Mathlib.Topology.ContinuousMap.Bounded.Basic",
"Mathlib.Topology.ContinuousMap.Compact",
"Mathlib.Topology.MetricSpace.Lipschitz",
"Mathlib.Topology.UniformSpace.UniformConvergenceTopology"
] | Mathlib/Topology/MetricSpace/UniformConvergence.lean | lipschitzWith_restrict | null |
isometry_restrict (s : Set α) :
Isometry (UniformFun.ofFun ∘ s.restrict ∘ toFun {s} : (α →ᵤ[{s}] β) → (s →ᵤ β)) := by
simp [Isometry, edist_def, UniformFun.edist_def, iSup_subtype] | lemma | Topology | [
"Mathlib.Order.CompleteLattice.Group",
"Mathlib.Topology.ContinuousMap.Bounded.Basic",
"Mathlib.Topology.ContinuousMap.Compact",
"Mathlib.Topology.MetricSpace.Lipschitz",
"Mathlib.Topology.UniformSpace.UniformConvergenceTopology"
] | Mathlib/Topology/MetricSpace/UniformConvergence.lean | isometry_restrict | null |
edist_continuousRestrict [TopologicalSpace α] {f g : α →ᵤ[𝔖] β}
[CompactSpace (⋃₀ 𝔖)] (hf : ContinuousOn (toFun 𝔖 f) (⋃₀ 𝔖))
(hg : ContinuousOn (toFun 𝔖 g) (⋃₀ 𝔖)) :
edist (⟨_, hf.restrict⟩ : C(⋃₀ 𝔖, β)) ⟨_, hg.restrict⟩ = edist f g := by
simp [ContinuousMap.edist_eq_iSup, iSup_subtype, edist_def] | lemma | Topology | [
"Mathlib.Order.CompleteLattice.Group",
"Mathlib.Topology.ContinuousMap.Bounded.Basic",
"Mathlib.Topology.ContinuousMap.Compact",
"Mathlib.Topology.MetricSpace.Lipschitz",
"Mathlib.Topology.UniformSpace.UniformConvergenceTopology"
] | Mathlib/Topology/MetricSpace/UniformConvergence.lean | edist_continuousRestrict | null |
edist_continuousRestrict_of_singleton [TopologicalSpace α] {s : Set α}
{f g : α →ᵤ[{s}] β} [CompactSpace s] (hf : ContinuousOn (toFun {s} f) s)
(hg : ContinuousOn (toFun {s} g) s) :
edist (⟨_, hf.restrict⟩ : C(s, β)) ⟨_, hg.restrict⟩ = edist f g := by
simp [ContinuousMap.edist_eq_iSup, iSup_subtype, edist... | lemma | Topology | [
"Mathlib.Order.CompleteLattice.Group",
"Mathlib.Topology.ContinuousMap.Bounded.Basic",
"Mathlib.Topology.ContinuousMap.Compact",
"Mathlib.Topology.MetricSpace.Lipschitz",
"Mathlib.Topology.UniformSpace.UniformConvergenceTopology"
] | Mathlib/Topology/MetricSpace/UniformConvergence.lean | edist_continuousRestrict_of_singleton | null |
PseudoMetrizableSpace (X : Type*) [t : TopologicalSpace X] : Prop where
exists_pseudo_metric : ∃ m : PseudoMetricSpace X, m.toUniformSpace.toTopologicalSpace = t | class | Topology | [
"Mathlib.Topology.MetricSpace.Basic"
] | Mathlib/Topology/Metrizable/Basic.lean | PseudoMetrizableSpace | A topological space is *pseudo metrizable* if there exists a pseudo metric space structure
compatible with the topology. To endow such a space with a compatible distance, use
`letI : PseudoMetricSpace X := TopologicalSpace.pseudoMetrizableSpacePseudoMetric X`. |
noncomputable pseudoMetrizableSpacePseudoMetric (X : Type*) [TopologicalSpace X]
[h : PseudoMetrizableSpace X] : PseudoMetricSpace X :=
h.exists_pseudo_metric.choose.replaceTopology h.exists_pseudo_metric.choose_spec.symm | def | Topology | [
"Mathlib.Topology.MetricSpace.Basic"
] | Mathlib/Topology/Metrizable/Basic.lean | pseudoMetrizableSpacePseudoMetric | Construct on a metrizable space a metric compatible with the topology. |
pseudoMetrizableSpace_prod [PseudoMetrizableSpace X] [PseudoMetrizableSpace Y] :
PseudoMetrizableSpace (X × Y) :=
letI : PseudoMetricSpace X := pseudoMetrizableSpacePseudoMetric X
letI : PseudoMetricSpace Y := pseudoMetrizableSpacePseudoMetric Y
inferInstance | instance | Topology | [
"Mathlib.Topology.MetricSpace.Basic"
] | Mathlib/Topology/Metrizable/Basic.lean | pseudoMetrizableSpace_prod | null |
_root_.Topology.IsInducing.pseudoMetrizableSpace [PseudoMetrizableSpace Y] {f : X → Y}
(hf : IsInducing f) : PseudoMetrizableSpace X :=
letI : PseudoMetricSpace Y := pseudoMetrizableSpacePseudoMetric Y
⟨⟨hf.comapPseudoMetricSpace, rfl⟩⟩ | theorem | Topology | [
"Mathlib.Topology.MetricSpace.Basic"
] | Mathlib/Topology/Metrizable/Basic.lean | _root_.Topology.IsInducing.pseudoMetrizableSpace | Given an inducing map of a topological space into a pseudo metrizable space, the source space
is also pseudo metrizable. |
MetrizableSpace (X : Type*) [t : TopologicalSpace X] : Prop where
exists_metric : ∃ m : MetricSpace X, m.toUniformSpace.toTopologicalSpace = t | class | Topology | [
"Mathlib.Topology.MetricSpace.Basic"
] | Mathlib/Topology/Metrizable/Basic.lean | MetrizableSpace | Every pseudo-metrizable space is first countable. -/
instance (priority := 100) PseudoMetrizableSpace.firstCountableTopology
[h : PseudoMetrizableSpace X] : FirstCountableTopology X := by
rcases h with ⟨_, hm⟩
rw [← hm]
exact @UniformSpace.firstCountableTopology X PseudoMetricSpace.toUniformSpace
EMetric.... |
noncomputable metrizableSpaceMetric (X : Type*) [TopologicalSpace X] [h : MetrizableSpace X] :
MetricSpace X :=
h.exists_metric.choose.replaceTopology h.exists_metric.choose_spec.symm | def | Topology | [
"Mathlib.Topology.MetricSpace.Basic"
] | Mathlib/Topology/Metrizable/Basic.lean | metrizableSpaceMetric | Construct on a metrizable space a metric compatible with the topology. |
metrizableSpace_prod [MetrizableSpace X] [MetrizableSpace Y] : MetrizableSpace (X × Y) :=
letI : MetricSpace X := metrizableSpaceMetric X
letI : MetricSpace Y := metrizableSpaceMetric Y
inferInstance | instance | Topology | [
"Mathlib.Topology.MetricSpace.Basic"
] | Mathlib/Topology/Metrizable/Basic.lean | metrizableSpace_prod | null |
_root_.Topology.IsEmbedding.metrizableSpace [MetrizableSpace Y] {f : X → Y}
(hf : IsEmbedding f) : MetrizableSpace X :=
letI : MetricSpace Y := metrizableSpaceMetric Y
⟨⟨hf.comapMetricSpace f, rfl⟩⟩ | theorem | Topology | [
"Mathlib.Topology.MetricSpace.Basic"
] | Mathlib/Topology/Metrizable/Basic.lean | _root_.Topology.IsEmbedding.metrizableSpace | Given an embedding of a topological space into a metrizable space, the source space is also
metrizable. |
MetrizableSpace.subtype [MetrizableSpace X] (s : Set X) : MetrizableSpace s :=
IsEmbedding.subtypeVal.metrizableSpace | instance | Topology | [
"Mathlib.Topology.MetricSpace.Basic"
] | Mathlib/Topology/Metrizable/Basic.lean | MetrizableSpace.subtype | null |
metrizableSpace_pi [∀ i, MetrizableSpace (A i)] : MetrizableSpace (∀ i, A i) := by
cases nonempty_fintype ι
letI := fun i => metrizableSpaceMetric (A i)
infer_instance | instance | Topology | [
"Mathlib.Topology.MetricSpace.Basic"
] | Mathlib/Topology/Metrizable/Basic.lean | metrizableSpace_pi | null |
IsSeparable.secondCountableTopology [PseudoMetrizableSpace X] {s : Set X}
(hs : IsSeparable s) : SecondCountableTopology s := by
letI := pseudoMetrizableSpacePseudoMetric X
have := hs.separableSpace
exact UniformSpace.secondCountable_of_separable s | theorem | Topology | [
"Mathlib.Topology.MetricSpace.Basic"
] | Mathlib/Topology/Metrizable/Basic.lean | IsSeparable.secondCountableTopology | null |
IsCompletelyMetrizableSpace (X : Type*) [t : TopologicalSpace X] : Prop where
complete : ∃ m : MetricSpace X, m.toUniformSpace.toTopologicalSpace = t ∧
@CompleteSpace X m.toUniformSpace | class | Topology | [
"Mathlib.Topology.MetricSpace.Gluing",
"Mathlib.Topology.Metrizable.Uniformity"
] | Mathlib/Topology/Metrizable/CompletelyMetrizable.lean | IsCompletelyMetrizableSpace | A topological space is completely metrizable if there exists a metric space structure
compatible with the topology which makes the space complete.
To endow such a space with a compatible distance, use
`letI := upgradeIsCompletelyMetrizable X`. |
UpgradedIsCompletelyMetrizableSpace (X : Type*) extends MetricSpace X, CompleteSpace X
open scoped Uniformity in | class | Topology | [
"Mathlib.Topology.MetricSpace.Gluing",
"Mathlib.Topology.Metrizable.Uniformity"
] | Mathlib/Topology/Metrizable/CompletelyMetrizable.lean | UpgradedIsCompletelyMetrizableSpace | A convenience class, for a completely metrizable space endowed with a complete metric.
No instance of this class should be registered: It should be used as
`letI := upgradeIsCompletelyMetrizable X` to endow a completely metrizable
space with a complete metric. |
noncomputable completelyMetrizableMetric (X : Type*) [TopologicalSpace X]
[h : IsCompletelyMetrizableSpace X] : MetricSpace X :=
h.complete.choose.replaceTopology h.complete.choose_spec.1.symm | def | Topology | [
"Mathlib.Topology.MetricSpace.Gluing",
"Mathlib.Topology.Metrizable.Uniformity"
] | Mathlib/Topology/Metrizable/CompletelyMetrizable.lean | completelyMetrizableMetric | Construct on a completely metrizable space a metric (compatible with the topology)
which is complete. |
complete_completelyMetrizableMetric (X : Type*) [ht : TopologicalSpace X]
[h : IsCompletelyMetrizableSpace X] :
@CompleteSpace X (completelyMetrizableMetric X).toUniformSpace := by
convert h.complete.choose_spec.2
exact MetricSpace.replaceTopology_eq _ _ | theorem | Topology | [
"Mathlib.Topology.MetricSpace.Gluing",
"Mathlib.Topology.Metrizable.Uniformity"
] | Mathlib/Topology/Metrizable/CompletelyMetrizable.lean | complete_completelyMetrizableMetric | null |
noncomputable
upgradeIsCompletelyMetrizable (X : Type*) [TopologicalSpace X] [IsCompletelyMetrizableSpace X] :
UpgradedIsCompletelyMetrizableSpace X :=
letI := completelyMetrizableMetric X
{ complete_completelyMetrizableMetric X with } | def | Topology | [
"Mathlib.Topology.MetricSpace.Gluing",
"Mathlib.Topology.Metrizable.Uniformity"
] | Mathlib/Topology/Metrizable/CompletelyMetrizable.lean | upgradeIsCompletelyMetrizable | This definition endows a completely metrizable space with a complete metric. Use it as:
`letI := upgradeIsCompletelyMetrizable X`. |
pi_countable {ι : Type*} [Countable ι] {X : ι → Type*} [∀ i, TopologicalSpace (X i)]
[∀ i, IsCompletelyMetrizableSpace (X i)] : IsCompletelyMetrizableSpace (Π i, X i) := by
letI := fun i ↦ upgradeIsCompletelyMetrizable (X i)
infer_instance | instance | Topology | [
"Mathlib.Topology.MetricSpace.Gluing",
"Mathlib.Topology.Metrizable.Uniformity"
] | Mathlib/Topology/Metrizable/CompletelyMetrizable.lean | pi_countable | Note: the priority is set to 90 to ensure that this instance is only applied after
`EMetricSpace.metrizableSpace`. This prevents unnecessary attempts to infer completeness. -/
instance (priority := 90) MetrizableSpace [TopologicalSpace X] [IsCompletelyMetrizableSpace X] :
MetrizableSpace X := by
letI := upgradeIs... |
sigma {ι : Type*} {X : ι → Type*} [∀ n, TopologicalSpace (X n)]
[∀ n, IsCompletelyMetrizableSpace (X n)] : IsCompletelyMetrizableSpace (Σ n, X n) :=
letI := fun n ↦ upgradeIsCompletelyMetrizable (X n)
letI : MetricSpace (Σ n, X n) := Metric.Sigma.metricSpace
haveI : CompleteSpace (Σ n, X n) := Metric.Sigma.co... | instance | Topology | [
"Mathlib.Topology.MetricSpace.Gluing",
"Mathlib.Topology.Metrizable.Uniformity"
] | Mathlib/Topology/Metrizable/CompletelyMetrizable.lean | sigma | A disjoint union of completely metrizable spaces is completely metrizable. |
prod [TopologicalSpace X] [IsCompletelyMetrizableSpace X] [TopologicalSpace Y]
[IsCompletelyMetrizableSpace Y] : IsCompletelyMetrizableSpace (X × Y) :=
letI := upgradeIsCompletelyMetrizable X
letI := upgradeIsCompletelyMetrizable Y
inferInstance | instance | Topology | [
"Mathlib.Topology.MetricSpace.Gluing",
"Mathlib.Topology.Metrizable.Uniformity"
] | Mathlib/Topology/Metrizable/CompletelyMetrizable.lean | prod | The product of two completely metrizable spaces is completely metrizable. |
sum [TopologicalSpace X] [IsCompletelyMetrizableSpace X] [TopologicalSpace Y]
[IsCompletelyMetrizableSpace Y] : IsCompletelyMetrizableSpace (X ⊕ Y) :=
letI := upgradeIsCompletelyMetrizable X
letI := upgradeIsCompletelyMetrizable Y
inferInstance | instance | Topology | [
"Mathlib.Topology.MetricSpace.Gluing",
"Mathlib.Topology.Metrizable.Uniformity"
] | Mathlib/Topology/Metrizable/CompletelyMetrizable.lean | sum | The disjoint union of two completely metrizable spaces is completely metrizable. |
_root_.Topology.IsClosedEmbedding.IsCompletelyMetrizableSpace [TopologicalSpace X]
[TopologicalSpace Y] [IsCompletelyMetrizableSpace Y] {f : X → Y} (hf : IsClosedEmbedding f) :
IsCompletelyMetrizableSpace X := by
letI := upgradeIsCompletelyMetrizable Y
letI : MetricSpace X := hf.isEmbedding.comapMetricSpace... | theorem | Topology | [
"Mathlib.Topology.MetricSpace.Gluing",
"Mathlib.Topology.Metrizable.Uniformity"
] | Mathlib/Topology/Metrizable/CompletelyMetrizable.lean | _root_.Topology.IsClosedEmbedding.IsCompletelyMetrizableSpace | Given a closed embedding into a completely metrizable space,
the source space is also completely metrizable. |
_root_.IsClosed.isCompletelyMetrizableSpace
[TopologicalSpace X] [IsCompletelyMetrizableSpace X]
{s : Set X} (hs : IsClosed s) : IsCompletelyMetrizableSpace s :=
hs.isClosedEmbedding_subtypeVal.IsCompletelyMetrizableSpace | theorem | Topology | [
"Mathlib.Topology.MetricSpace.Gluing",
"Mathlib.Topology.Metrizable.Uniformity"
] | Mathlib/Topology/Metrizable/CompletelyMetrizable.lean | _root_.IsClosed.isCompletelyMetrizableSpace | Any discrete space is completely metrizable. -/
instance (priority := 50) discrete [TopologicalSpace X] [DiscreteTopology X] :
IsCompletelyMetrizableSpace X := by
classical
let m : MetricSpace X :=
{ dist x y := if x = y then 0 else 1
dist_self x := by simp
dist_comm x y := by
obtain h |... |
univ [TopologicalSpace X] [IsCompletelyMetrizableSpace X] :
IsCompletelyMetrizableSpace (univ : Set X) :=
isClosed_univ.isCompletelyMetrizableSpace | instance | Topology | [
"Mathlib.Topology.MetricSpace.Gluing",
"Mathlib.Topology.Metrizable.Uniformity"
] | Mathlib/Topology/Metrizable/CompletelyMetrizable.lean | univ | null |
noncomputable ofPreNNDist (d : X → X → ℝ≥0) (dist_self : ∀ x, d x x = 0)
(dist_comm : ∀ x y, d x y = d y x) : PseudoMetricSpace X where
dist x y := ↑(⨅ l : List X, ((x::l).zipWith d (l ++ [y])).sum : ℝ≥0)
dist_self x := NNReal.coe_eq_zero.2 <|
nonpos_iff_eq_zero.1 <| (ciInf_le (OrderBot.bddBelow _) []).tr... | def | Topology | [
"Mathlib.Data.Nat.Lattice",
"Mathlib.Data.NNReal.Basic",
"Mathlib.Topology.Metrizable.Basic"
] | Mathlib/Topology/Metrizable/Uniformity.lean | ofPreNNDist | The maximal pseudo metric space structure on `X` such that `dist x y ≤ d x y` for all `x y`,
where `d : X → X → ℝ≥0` is a function such that `d x x = 0` and `d x y = d y x` for all `x`, `y`. |
dist_ofPreNNDist (d : X → X → ℝ≥0) (dist_self : ∀ x, d x x = 0)
(dist_comm : ∀ x y, d x y = d y x) (x y : X) :
@dist X (@PseudoMetricSpace.toDist X (PseudoMetricSpace.ofPreNNDist d dist_self dist_comm)) x
y =
↑(⨅ l : List X, ((x::l).zipWith d (l ++ [y])).sum : ℝ≥0) :=
rfl | theorem | Topology | [
"Mathlib.Data.Nat.Lattice",
"Mathlib.Data.NNReal.Basic",
"Mathlib.Topology.Metrizable.Basic"
] | Mathlib/Topology/Metrizable/Uniformity.lean | dist_ofPreNNDist | null |
dist_ofPreNNDist_le (d : X → X → ℝ≥0) (dist_self : ∀ x, d x x = 0)
(dist_comm : ∀ x y, d x y = d y x) (x y : X) :
@dist X (@PseudoMetricSpace.toDist X (PseudoMetricSpace.ofPreNNDist d dist_self dist_comm)) x
y ≤
d x y :=
NNReal.coe_le_coe.2 <| (ciInf_le (OrderBot.bddBelow _) []).trans_eq <| by s... | theorem | Topology | [
"Mathlib.Data.Nat.Lattice",
"Mathlib.Data.NNReal.Basic",
"Mathlib.Topology.Metrizable.Basic"
] | Mathlib/Topology/Metrizable/Uniformity.lean | dist_ofPreNNDist_le | null |
le_two_mul_dist_ofPreNNDist (d : X → X → ℝ≥0) (dist_self : ∀ x, d x x = 0)
(dist_comm : ∀ x y, d x y = d y x)
(hd : ∀ x₁ x₂ x₃ x₄, d x₁ x₄ ≤ 2 * max (d x₁ x₂) (max (d x₂ x₃) (d x₃ x₄))) (x y : X) :
↑(d x y) ≤ 2 * @dist X
(@PseudoMetricSpace.toDist X (PseudoMetricSpace.ofPreNNDist d dist_self dist_comm... | theorem | Topology | [
"Mathlib.Data.Nat.Lattice",
"Mathlib.Data.NNReal.Basic",
"Mathlib.Topology.Metrizable.Basic"
] | Mathlib/Topology/Metrizable/Uniformity.lean | le_two_mul_dist_ofPreNNDist | Consider a function `d : X → X → ℝ≥0` such that `d x x = 0` and `d x y = d y x` for all `x`,
`y`. Let `dist` be the largest pseudometric distance such that `dist x y ≤ d x y`, see
`PseudoMetricSpace.ofPreNNDist`. Suppose that `d` satisfies the following triangle-like
inequality: `d x₁ x₄ ≤ 2 * max (d x₁ x₂, d x₂ x₃, d ... |
protected UniformSpace.metrizable_uniformity (X : Type*) [UniformSpace X]
[IsCountablyGenerated (𝓤 X)] : ∃ I : PseudoMetricSpace X, I.toUniformSpace = ‹_› := by
classical
/- Choose a fast decreasing antitone basis `U : ℕ → set (X × X)` of the uniformity filter `𝓤 X`.
Define `d x y : ℝ≥0` to be `(1 / 2) ^ ... | theorem | Topology | [
"Mathlib.Data.Nat.Lattice",
"Mathlib.Data.NNReal.Basic",
"Mathlib.Topology.Metrizable.Basic"
] | Mathlib/Topology/Metrizable/Uniformity.lean | UniformSpace.metrizable_uniformity | If `X` is a uniform space with countably generated uniformity filter, there exists a
`PseudoMetricSpace` structure compatible with the `UniformSpace` structure. Use
`UniformSpace.pseudoMetricSpace` or `UniformSpace.metricSpace` instead. |
protected noncomputable UniformSpace.pseudoMetricSpace (X : Type*) [UniformSpace X]
[IsCountablyGenerated (𝓤 X)] : PseudoMetricSpace X :=
(UniformSpace.metrizable_uniformity X).choose.replaceUniformity <|
congr_arg _ (UniformSpace.metrizable_uniformity X).choose_spec.symm | def | Topology | [
"Mathlib.Data.Nat.Lattice",
"Mathlib.Data.NNReal.Basic",
"Mathlib.Topology.Metrizable.Basic"
] | Mathlib/Topology/Metrizable/Uniformity.lean | UniformSpace.pseudoMetricSpace | A `PseudoMetricSpace` instance compatible with a given `UniformSpace` structure. |
protected noncomputable UniformSpace.metricSpace (X : Type*) [UniformSpace X]
[IsCountablyGenerated (𝓤 X)] [T0Space X] : MetricSpace X :=
@MetricSpace.ofT0PseudoMetricSpace X (UniformSpace.pseudoMetricSpace X) _ | def | Topology | [
"Mathlib.Data.Nat.Lattice",
"Mathlib.Data.NNReal.Basic",
"Mathlib.Topology.Metrizable.Basic"
] | Mathlib/Topology/Metrizable/Uniformity.lean | UniformSpace.metricSpace | A `MetricSpace` instance compatible with a given `UniformSpace` structure. |
UniformSpace.metrizableSpace [UniformSpace X] [IsCountablyGenerated (𝓤 X)] [T0Space X] :
TopologicalSpace.MetrizableSpace X := by
letI := UniformSpace.metricSpace X
infer_instance | theorem | Topology | [
"Mathlib.Data.Nat.Lattice",
"Mathlib.Data.NNReal.Basic",
"Mathlib.Topology.Metrizable.Basic"
] | Mathlib/Topology/Metrizable/Uniformity.lean | UniformSpace.metrizableSpace | A uniform space with countably generated `𝓤 X` is pseudo metrizable. -/
instance (priority := 100) UniformSpace.pseudoMetrizableSpace [UniformSpace X]
[IsCountablyGenerated (𝓤 X)] : TopologicalSpace.PseudoMetrizableSpace X := by
letI := UniformSpace.pseudoMetricSpace X
infer_instance
/-- A T₀ uniform space w... |
TotallyBounded.isSeparable [UniformSpace X] [i : IsCountablyGenerated (𝓤 X)]
{s : Set X} (h : TotallyBounded s) : TopologicalSpace.IsSeparable s := by
letI := (UniformSpace.pseudoMetricSpace (X := X)).toPseudoEMetricSpace
rw [EMetric.totallyBounded_iff] at h
have h' : ∀ ε > 0, ∃ t, Set.Countable t ∧ s ⊆ ⋃ y ... | lemma | Topology | [
"Mathlib.Data.Nat.Lattice",
"Mathlib.Data.NNReal.Basic",
"Mathlib.Topology.Metrizable.Basic"
] | Mathlib/Topology/Metrizable/Uniformity.lean | TotallyBounded.isSeparable | A totally bounded set is separable in countably generated uniform spaces. This can be obtained
from the more general `EMetric.subset_countable_closure_of_almost_dense_set`. |
exists_isInducing_l_infty : ∃ f : X → ℕ →ᵇ ℝ, IsInducing f := by
rcases exists_countable_basis X with ⟨B, hBc, -, hB⟩
let s : Set (Set X × Set X) := { UV ∈ B ×ˢ B | closure UV.1 ⊆ UV.2 }
haveI : Encodable s := ((hBc.prod hBc).mono inter_subset_left).toEncodable
letI : TopologicalSpace s := ⊥
haveI : DiscreteT... | theorem | Topology | [
"Mathlib.Analysis.SpecificLimits.Basic",
"Mathlib.Topology.UrysohnsLemma",
"Mathlib.Topology.Metrizable.Basic",
"Mathlib.Topology.ContinuousMap.Bounded.Basic"
] | Mathlib/Topology/Metrizable/Urysohn.lean | exists_isInducing_l_infty | For a regular topological space with second countable topology,
there exists an inducing map to `l^∞ = ℕ →ᵇ ℝ`. |
exists_embedding_l_infty : ∃ f : X → ℕ →ᵇ ℝ, IsEmbedding f :=
let ⟨f, hf⟩ := exists_isInducing_l_infty X; ⟨f, hf.isEmbedding⟩ | theorem | Topology | [
"Mathlib.Analysis.SpecificLimits.Basic",
"Mathlib.Topology.UrysohnsLemma",
"Mathlib.Topology.Metrizable.Basic",
"Mathlib.Topology.ContinuousMap.Bounded.Basic"
] | Mathlib/Topology/Metrizable/Urysohn.lean | exists_embedding_l_infty | *Urysohn's metrization theorem* (Tychonoff's version):
a regular topological space with second countable topology `X` is metrizable,
i.e., there exists a pseudometric space structure that generates the same topology. -/
instance (priority := 90) PseudoMetrizableSpace.of_regularSpace_secondCountableTopology :
Pseudo... |
is equal to the order topology.
We prove many basic properties of such topologies. | structure | Topology | [
"Mathlib.Order.Filter.Interval",
"Mathlib.Order.Interval.Set.Pi",
"Mathlib.Order.OrdContinuous",
"Mathlib.Tactic.TFAE",
"Mathlib.Tactic.NormNum",
"Mathlib.Topology.Order.LeftRight",
"Mathlib.Topology.Order.OrderClosed"
] | Mathlib/Topology/Order/Basic.lean | is | null |
OrderTopology (α : Type*) [t : TopologicalSpace α] [Preorder α] : Prop where
/-- The topology is generated by open intervals `Set.Ioi _` and `Set.Iio _`. -/
topology_eq_generate_intervals : t = generateFrom { s | ∃ a, s = Ioi a ∨ s = Iio a } | class | Topology | [
"Mathlib.Order.Filter.Interval",
"Mathlib.Order.Interval.Set.Pi",
"Mathlib.Order.OrdContinuous",
"Mathlib.Tactic.TFAE",
"Mathlib.Tactic.NormNum",
"Mathlib.Topology.Order.LeftRight",
"Mathlib.Topology.Order.OrderClosed"
] | Mathlib/Topology/Order/Basic.lean | OrderTopology | The order topology on an ordered type is the topology generated by open intervals. We register
it on a preorder, but it is mostly interesting in linear orders, where it is also order-closed.
We define it as a mixin. If you want to introduce the order topology on a preorder, use
`Preorder.topology`. |
Preorder.topology (α : Type*) [Preorder α] : TopologicalSpace α :=
generateFrom { s : Set α | ∃ a : α, s = { b : α | a < b } ∨ s = { b : α | b < a } } | def | Topology | [
"Mathlib.Order.Filter.Interval",
"Mathlib.Order.Interval.Set.Pi",
"Mathlib.Order.OrdContinuous",
"Mathlib.Tactic.TFAE",
"Mathlib.Tactic.NormNum",
"Mathlib.Topology.Order.LeftRight",
"Mathlib.Topology.Order.OrderClosed"
] | Mathlib/Topology/Order/Basic.lean | Preorder.topology | (Order) topology on a partial order `α` generated by the subbase of open intervals
`(a, ∞) = { x ∣ a < x }, (-∞, b) = {x ∣ x < b}` for all `a, b` in `α`. We do not register it as an
instance as many ordered sets are already endowed with the same topology, most often in a non-defeq
way though. Register as a local instan... |
protected OrderTopology.continuous_iff [OrderTopology α] [TopologicalSpace β] {f : β → α} :
Continuous f ↔ ∀ a, IsOpen (f ⁻¹' Ioi a) ∧ IsOpen (f ⁻¹' Iio a) := by
simp_rw [OrderTopology.topology_eq_generate_intervals, continuous_generateFrom_iff]
aesop | theorem | Topology | [
"Mathlib.Order.Filter.Interval",
"Mathlib.Order.Interval.Set.Pi",
"Mathlib.Order.OrdContinuous",
"Mathlib.Tactic.TFAE",
"Mathlib.Tactic.NormNum",
"Mathlib.Topology.Order.LeftRight",
"Mathlib.Topology.Order.OrderClosed"
] | Mathlib/Topology/Order/Basic.lean | OrderTopology.continuous_iff | null |
isOpen_iff_generate_intervals [t : OrderTopology α] {s : Set α} :
IsOpen s ↔ GenerateOpen { s | ∃ a, s = Ioi a ∨ s = Iio a } s := by
rw [t.topology_eq_generate_intervals]; rfl | theorem | Topology | [
"Mathlib.Order.Filter.Interval",
"Mathlib.Order.Interval.Set.Pi",
"Mathlib.Order.OrdContinuous",
"Mathlib.Tactic.TFAE",
"Mathlib.Tactic.NormNum",
"Mathlib.Topology.Order.LeftRight",
"Mathlib.Topology.Order.OrderClosed"
] | Mathlib/Topology/Order/Basic.lean | isOpen_iff_generate_intervals | null |
isOpen_lt' [OrderTopology α] (a : α) : IsOpen { b : α | a < b } :=
isOpen_iff_generate_intervals.2 <| .basic _ ⟨a, .inl rfl⟩ | theorem | Topology | [
"Mathlib.Order.Filter.Interval",
"Mathlib.Order.Interval.Set.Pi",
"Mathlib.Order.OrdContinuous",
"Mathlib.Tactic.TFAE",
"Mathlib.Tactic.NormNum",
"Mathlib.Topology.Order.LeftRight",
"Mathlib.Topology.Order.OrderClosed"
] | Mathlib/Topology/Order/Basic.lean | isOpen_lt' | null |
isOpen_Ioi' [OrderTopology α] (a : α) : IsOpen (Ioi a) := isOpen_lt' a | theorem | Topology | [
"Mathlib.Order.Filter.Interval",
"Mathlib.Order.Interval.Set.Pi",
"Mathlib.Order.OrdContinuous",
"Mathlib.Tactic.TFAE",
"Mathlib.Tactic.NormNum",
"Mathlib.Topology.Order.LeftRight",
"Mathlib.Topology.Order.OrderClosed"
] | Mathlib/Topology/Order/Basic.lean | isOpen_Ioi' | null |
isOpen_gt' [OrderTopology α] (a : α) : IsOpen { b : α | b < a } :=
isOpen_iff_generate_intervals.2 <| .basic _ ⟨a, .inr rfl⟩ | theorem | Topology | [
"Mathlib.Order.Filter.Interval",
"Mathlib.Order.Interval.Set.Pi",
"Mathlib.Order.OrdContinuous",
"Mathlib.Tactic.TFAE",
"Mathlib.Tactic.NormNum",
"Mathlib.Topology.Order.LeftRight",
"Mathlib.Topology.Order.OrderClosed"
] | Mathlib/Topology/Order/Basic.lean | isOpen_gt' | null |
isOpen_Iio' [OrderTopology α] (a : α) : IsOpen (Iio a) := isOpen_gt' a | theorem | Topology | [
"Mathlib.Order.Filter.Interval",
"Mathlib.Order.Interval.Set.Pi",
"Mathlib.Order.OrdContinuous",
"Mathlib.Tactic.TFAE",
"Mathlib.Tactic.NormNum",
"Mathlib.Topology.Order.LeftRight",
"Mathlib.Topology.Order.OrderClosed"
] | Mathlib/Topology/Order/Basic.lean | isOpen_Iio' | null |
lt_mem_nhds [OrderTopology α] {a b : α} (h : a < b) : ∀ᶠ x in 𝓝 b, a < x :=
(isOpen_lt' _).mem_nhds h | theorem | Topology | [
"Mathlib.Order.Filter.Interval",
"Mathlib.Order.Interval.Set.Pi",
"Mathlib.Order.OrdContinuous",
"Mathlib.Tactic.TFAE",
"Mathlib.Tactic.NormNum",
"Mathlib.Topology.Order.LeftRight",
"Mathlib.Topology.Order.OrderClosed"
] | Mathlib/Topology/Order/Basic.lean | lt_mem_nhds | null |
le_mem_nhds [OrderTopology α] {a b : α} (h : a < b) : ∀ᶠ x in 𝓝 b, a ≤ x :=
(lt_mem_nhds h).mono fun _ => le_of_lt | theorem | Topology | [
"Mathlib.Order.Filter.Interval",
"Mathlib.Order.Interval.Set.Pi",
"Mathlib.Order.OrdContinuous",
"Mathlib.Tactic.TFAE",
"Mathlib.Tactic.NormNum",
"Mathlib.Topology.Order.LeftRight",
"Mathlib.Topology.Order.OrderClosed"
] | Mathlib/Topology/Order/Basic.lean | le_mem_nhds | null |
gt_mem_nhds [OrderTopology α] {a b : α} (h : a < b) : ∀ᶠ x in 𝓝 a, x < b :=
(isOpen_gt' _).mem_nhds h | theorem | Topology | [
"Mathlib.Order.Filter.Interval",
"Mathlib.Order.Interval.Set.Pi",
"Mathlib.Order.OrdContinuous",
"Mathlib.Tactic.TFAE",
"Mathlib.Tactic.NormNum",
"Mathlib.Topology.Order.LeftRight",
"Mathlib.Topology.Order.OrderClosed"
] | Mathlib/Topology/Order/Basic.lean | gt_mem_nhds | null |
ge_mem_nhds [OrderTopology α] {a b : α} (h : a < b) : ∀ᶠ x in 𝓝 a, x ≤ b :=
(gt_mem_nhds h).mono fun _ => le_of_lt | theorem | Topology | [
"Mathlib.Order.Filter.Interval",
"Mathlib.Order.Interval.Set.Pi",
"Mathlib.Order.OrdContinuous",
"Mathlib.Tactic.TFAE",
"Mathlib.Tactic.NormNum",
"Mathlib.Topology.Order.LeftRight",
"Mathlib.Topology.Order.OrderClosed"
] | Mathlib/Topology/Order/Basic.lean | ge_mem_nhds | null |
nhds_eq_order [OrderTopology α] (a : α) :
𝓝 a = (⨅ b ∈ Iio a, 𝓟 (Ioi b)) ⊓ ⨅ b ∈ Ioi a, 𝓟 (Iio b) := by
rw [OrderTopology.topology_eq_generate_intervals (α := α), nhds_generateFrom]
simp_rw [mem_setOf_eq, @and_comm (a ∈ _), exists_or, or_and_right, iInf_or, iInf_and,
iInf_exists, iInf_inf_eq, iInf_comm (... | theorem | Topology | [
"Mathlib.Order.Filter.Interval",
"Mathlib.Order.Interval.Set.Pi",
"Mathlib.Order.OrdContinuous",
"Mathlib.Tactic.TFAE",
"Mathlib.Tactic.NormNum",
"Mathlib.Topology.Order.LeftRight",
"Mathlib.Topology.Order.OrderClosed"
] | Mathlib/Topology/Order/Basic.lean | nhds_eq_order | null |
tendsto_order [OrderTopology α] {f : β → α} {a : α} {x : Filter β} :
Tendsto f x (𝓝 a) ↔ (∀ a' < a, ∀ᶠ b in x, a' < f b) ∧ ∀ a' > a, ∀ᶠ b in x, f b < a' := by
simp only [nhds_eq_order a, tendsto_inf, tendsto_iInf, tendsto_principal]; rfl | theorem | Topology | [
"Mathlib.Order.Filter.Interval",
"Mathlib.Order.Interval.Set.Pi",
"Mathlib.Order.OrdContinuous",
"Mathlib.Tactic.TFAE",
"Mathlib.Tactic.NormNum",
"Mathlib.Topology.Order.LeftRight",
"Mathlib.Topology.Order.OrderClosed"
] | Mathlib/Topology/Order/Basic.lean | tendsto_order | null |
tendstoIccClassNhds [OrderTopology α] (a : α) : TendstoIxxClass Icc (𝓝 a) (𝓝 a) := by
simp only [nhds_eq_order, iInf_subtype']
refine
((hasBasis_iInf_principal_finite _).inf (hasBasis_iInf_principal_finite _)).tendstoIxxClass
fun s _ => ?_
refine ((ordConnected_biInter ?_).inter (ordConnected_biInter ... | instance | Topology | [
"Mathlib.Order.Filter.Interval",
"Mathlib.Order.Interval.Set.Pi",
"Mathlib.Order.OrdContinuous",
"Mathlib.Tactic.TFAE",
"Mathlib.Tactic.NormNum",
"Mathlib.Topology.Order.LeftRight",
"Mathlib.Topology.Order.OrderClosed"
] | Mathlib/Topology/Order/Basic.lean | tendstoIccClassNhds | null |
tendstoIcoClassNhds [OrderTopology α] (a : α) : TendstoIxxClass Ico (𝓝 a) (𝓝 a) :=
tendstoIxxClass_of_subset fun _ _ => Ico_subset_Icc_self | instance | Topology | [
"Mathlib.Order.Filter.Interval",
"Mathlib.Order.Interval.Set.Pi",
"Mathlib.Order.OrdContinuous",
"Mathlib.Tactic.TFAE",
"Mathlib.Tactic.NormNum",
"Mathlib.Topology.Order.LeftRight",
"Mathlib.Topology.Order.OrderClosed"
] | Mathlib/Topology/Order/Basic.lean | tendstoIcoClassNhds | null |
tendstoIocClassNhds [OrderTopology α] (a : α) : TendstoIxxClass Ioc (𝓝 a) (𝓝 a) :=
tendstoIxxClass_of_subset fun _ _ => Ioc_subset_Icc_self | instance | Topology | [
"Mathlib.Order.Filter.Interval",
"Mathlib.Order.Interval.Set.Pi",
"Mathlib.Order.OrdContinuous",
"Mathlib.Tactic.TFAE",
"Mathlib.Tactic.NormNum",
"Mathlib.Topology.Order.LeftRight",
"Mathlib.Topology.Order.OrderClosed"
] | Mathlib/Topology/Order/Basic.lean | tendstoIocClassNhds | null |
tendstoIooClassNhds [OrderTopology α] (a : α) : TendstoIxxClass Ioo (𝓝 a) (𝓝 a) :=
tendstoIxxClass_of_subset fun _ _ => Ioo_subset_Icc_self
variable (α) in | instance | Topology | [
"Mathlib.Order.Filter.Interval",
"Mathlib.Order.Interval.Set.Pi",
"Mathlib.Order.OrdContinuous",
"Mathlib.Tactic.TFAE",
"Mathlib.Tactic.NormNum",
"Mathlib.Topology.Order.LeftRight",
"Mathlib.Topology.Order.OrderClosed"
] | Mathlib/Topology/Order/Basic.lean | tendstoIooClassNhds | null |
exists_countable_generateFrom_Ioi_Iio
[OrderTopology α] [SecondCountableTopology α] :
∃ (c : Set α), c.Countable ∧ ts = generateFrom { s | ∃ a ∈ c, s = Ioi a ∨ s = Iio a } := by
rcases isEmpty_or_nonempty α with hα | hα
· exact ⟨∅, by simp, Subsingleton.elim _ _⟩
obtain ⟨t, t_subs, t_count, ht⟩ : ∃ t ⊆ { ... | lemma | Topology | [
"Mathlib.Order.Filter.Interval",
"Mathlib.Order.Interval.Set.Pi",
"Mathlib.Order.OrdContinuous",
"Mathlib.Tactic.TFAE",
"Mathlib.Tactic.NormNum",
"Mathlib.Topology.Order.LeftRight",
"Mathlib.Topology.Order.OrderClosed"
] | Mathlib/Topology/Order/Basic.lean | exists_countable_generateFrom_Ioi_Iio | In a second countable topological space with the order topology, the topology is generated
by half-infinite open intervals with endpoints in a countable set. |
isTopologicalBasis_biInter_Ioi_Iio_of_generateFrom (c : Set α)
(h : ts = generateFrom { s | ∃ a ∈ c, s = Ioi a ∨ s = Iio a }) :
IsTopologicalBasis {s | ∃ (f g : Set α), f ⊆ c ∧ g ⊆ c ∧ f.Finite ∧ g.Finite
∧ s = (⋂ a ∈ f, Ioi a) ∩ (⋂ a ∈ g, Iio a)} := by
refine IsTopologicalBasis.of_isOpen_of_subset ?_ (... | lemma | Topology | [
"Mathlib.Order.Filter.Interval",
"Mathlib.Order.Interval.Set.Pi",
"Mathlib.Order.OrdContinuous",
"Mathlib.Tactic.TFAE",
"Mathlib.Tactic.NormNum",
"Mathlib.Topology.Order.LeftRight",
"Mathlib.Topology.Order.OrderClosed"
] | Mathlib/Topology/Order/Basic.lean | isTopologicalBasis_biInter_Ioi_Iio_of_generateFrom | If a topology is generated by half-open intervals with endpoints in a set `c`, then the sets
formed by intersecting finitely many of these intervals form a topological basis. |
tendsto_of_tendsto_of_tendsto_of_le_of_le' [OrderTopology α] {f g h : β → α} {b : Filter β}
{a : α} (hg : Tendsto g b (𝓝 a)) (hh : Tendsto h b (𝓝 a)) (hgf : ∀ᶠ b in b, g b ≤ f b)
(hfh : ∀ᶠ b in b, f b ≤ h b) : Tendsto f b (𝓝 a) :=
(hg.Icc hh).of_smallSets <| hgf.and hfh
alias Filter.Tendsto.squeeze' := ten... | theorem | Topology | [
"Mathlib.Order.Filter.Interval",
"Mathlib.Order.Interval.Set.Pi",
"Mathlib.Order.OrdContinuous",
"Mathlib.Tactic.TFAE",
"Mathlib.Tactic.NormNum",
"Mathlib.Topology.Order.LeftRight",
"Mathlib.Topology.Order.OrderClosed"
] | Mathlib/Topology/Order/Basic.lean | tendsto_of_tendsto_of_tendsto_of_le_of_le' | **Squeeze theorem** (also known as **sandwich theorem**). This version assumes that inequalities
hold eventually for the filter. |
tendsto_of_tendsto_of_tendsto_of_le_of_le [OrderTopology α] {f g h : β → α} {b : Filter β}
{a : α} (hg : Tendsto g b (𝓝 a)) (hh : Tendsto h b (𝓝 a)) (hgf : g ≤ f) (hfh : f ≤ h) :
Tendsto f b (𝓝 a) :=
tendsto_of_tendsto_of_tendsto_of_le_of_le' hg hh (Eventually.of_forall hgf)
(Eventually.of_forall hfh)
... | theorem | Topology | [
"Mathlib.Order.Filter.Interval",
"Mathlib.Order.Interval.Set.Pi",
"Mathlib.Order.OrdContinuous",
"Mathlib.Tactic.TFAE",
"Mathlib.Tactic.NormNum",
"Mathlib.Topology.Order.LeftRight",
"Mathlib.Topology.Order.OrderClosed"
] | Mathlib/Topology/Order/Basic.lean | tendsto_of_tendsto_of_tendsto_of_le_of_le | **Squeeze theorem** (also known as **sandwich theorem**). This version assumes that inequalities
hold everywhere. |
nhds_order_unbounded [OrderTopology α] {a : α} (hu : ∃ u, a < u) (hl : ∃ l, l < a) :
𝓝 a = ⨅ (l) (_ : l < a) (u) (_ : a < u), 𝓟 (Ioo l u) := by
simp only [nhds_eq_order, ← inf_biInf, ← biInf_inf, *, ← inf_principal, ← Ioi_inter_Iio]; rfl | theorem | Topology | [
"Mathlib.Order.Filter.Interval",
"Mathlib.Order.Interval.Set.Pi",
"Mathlib.Order.OrdContinuous",
"Mathlib.Tactic.TFAE",
"Mathlib.Tactic.NormNum",
"Mathlib.Topology.Order.LeftRight",
"Mathlib.Topology.Order.OrderClosed"
] | Mathlib/Topology/Order/Basic.lean | nhds_order_unbounded | null |
tendsto_order_unbounded [OrderTopology α] {f : β → α} {a : α} {x : Filter β}
(hu : ∃ u, a < u) (hl : ∃ l, l < a) (h : ∀ l u, l < a → a < u → ∀ᶠ b in x, l < f b ∧ f b < u) :
Tendsto f x (𝓝 a) := by
simp only [nhds_order_unbounded hu hl, tendsto_iInf, tendsto_principal]
exact fun l hl u => h l u hl | theorem | Topology | [
"Mathlib.Order.Filter.Interval",
"Mathlib.Order.Interval.Set.Pi",
"Mathlib.Order.OrdContinuous",
"Mathlib.Tactic.TFAE",
"Mathlib.Tactic.NormNum",
"Mathlib.Topology.Order.LeftRight",
"Mathlib.Topology.Order.OrderClosed"
] | Mathlib/Topology/Order/Basic.lean | tendsto_order_unbounded | null |
tendstoIxxNhdsWithin {α : Type*} [TopologicalSpace α] (a : α) {s t : Set α}
{Ixx} [TendstoIxxClass Ixx (𝓝 a) (𝓝 a)] [TendstoIxxClass Ixx (𝓟 s) (𝓟 t)] :
TendstoIxxClass Ixx (𝓝[s] a) (𝓝[t] a) :=
Filter.tendstoIxxClass_inf | instance | Topology | [
"Mathlib.Order.Filter.Interval",
"Mathlib.Order.Interval.Set.Pi",
"Mathlib.Order.OrdContinuous",
"Mathlib.Tactic.TFAE",
"Mathlib.Tactic.NormNum",
"Mathlib.Topology.Order.LeftRight",
"Mathlib.Topology.Order.OrderClosed"
] | Mathlib/Topology/Order/Basic.lean | tendstoIxxNhdsWithin | null |
tendstoIccClassNhdsPi {ι : Type*} {α : ι → Type*} [∀ i, Preorder (α i)]
[∀ i, TopologicalSpace (α i)] [∀ i, OrderTopology (α i)] (f : ∀ i, α i) :
TendstoIxxClass Icc (𝓝 f) (𝓝 f) := by
constructor
conv in (𝓝 f).smallSets => rw [nhds_pi, Filter.pi]
simp only [smallSets_iInf, smallSets_comap_eq_comap_imag... | instance | Topology | [
"Mathlib.Order.Filter.Interval",
"Mathlib.Order.Interval.Set.Pi",
"Mathlib.Order.OrdContinuous",
"Mathlib.Tactic.TFAE",
"Mathlib.Tactic.NormNum",
"Mathlib.Topology.Order.LeftRight",
"Mathlib.Topology.Order.OrderClosed"
] | Mathlib/Topology/Order/Basic.lean | tendstoIccClassNhdsPi | null |
induced_topology_le_preorder [Preorder α] [Preorder β] [TopologicalSpace β]
[OrderTopology β] {f : α → β} (hf : ∀ {x y}, f x < f y ↔ x < y) :
induced f ‹TopologicalSpace β› ≤ Preorder.topology α := by
let _ := Preorder.topology α; have : OrderTopology α := ⟨rfl⟩
refine le_of_nhds_le_nhds fun x => ?_
simp ... | theorem | Topology | [
"Mathlib.Order.Filter.Interval",
"Mathlib.Order.Interval.Set.Pi",
"Mathlib.Order.OrdContinuous",
"Mathlib.Tactic.TFAE",
"Mathlib.Tactic.NormNum",
"Mathlib.Topology.Order.LeftRight",
"Mathlib.Topology.Order.OrderClosed"
] | Mathlib/Topology/Order/Basic.lean | induced_topology_le_preorder | null |
induced_topology_eq_preorder [Preorder α] [Preorder β] [TopologicalSpace β]
[OrderTopology β] {f : α → β} (hf : ∀ {x y}, f x < f y ↔ x < y)
(H₁ : ∀ {a b x}, b < f a → ¬(b < f x) → ∃ y, y < a ∧ b ≤ f y)
(H₂ : ∀ {a b x}, f a < b → ¬(f x < b) → ∃ y, a < y ∧ f y ≤ b) :
induced f ‹TopologicalSpace β› = Preor... | theorem | Topology | [
"Mathlib.Order.Filter.Interval",
"Mathlib.Order.Interval.Set.Pi",
"Mathlib.Order.OrdContinuous",
"Mathlib.Tactic.TFAE",
"Mathlib.Tactic.NormNum",
"Mathlib.Topology.Order.LeftRight",
"Mathlib.Topology.Order.OrderClosed"
] | Mathlib/Topology/Order/Basic.lean | induced_topology_eq_preorder | null |
induced_orderTopology' {α : Type u} {β : Type v} [Preorder α] [ta : TopologicalSpace β]
[Preorder β] [OrderTopology β] (f : α → β) (hf : ∀ {x y}, f x < f y ↔ x < y)
(H₁ : ∀ {a x}, x < f a → ∃ b < a, x ≤ f b) (H₂ : ∀ {a x}, f a < x → ∃ b > a, f b ≤ x) :
@OrderTopology _ (induced f ta) _ :=
let _ := induced... | theorem | Topology | [
"Mathlib.Order.Filter.Interval",
"Mathlib.Order.Interval.Set.Pi",
"Mathlib.Order.OrdContinuous",
"Mathlib.Tactic.TFAE",
"Mathlib.Tactic.NormNum",
"Mathlib.Topology.Order.LeftRight",
"Mathlib.Topology.Order.OrderClosed"
] | Mathlib/Topology/Order/Basic.lean | induced_orderTopology' | null |
induced_orderTopology {α : Type u} {β : Type v} [Preorder α] [ta : TopologicalSpace β]
[Preorder β] [OrderTopology β] (f : α → β) (hf : ∀ {x y}, f x < f y ↔ x < y)
(H : ∀ {x y}, x < y → ∃ a, x < f a ∧ f a < y) : @OrderTopology _ (induced f ta) _ :=
induced_orderTopology' f (hf)
(fun xa => let ⟨b, xb, ba⟩ ... | theorem | Topology | [
"Mathlib.Order.Filter.Interval",
"Mathlib.Order.Interval.Set.Pi",
"Mathlib.Order.OrdContinuous",
"Mathlib.Tactic.TFAE",
"Mathlib.Tactic.NormNum",
"Mathlib.Topology.Order.LeftRight",
"Mathlib.Topology.Order.OrderClosed"
] | Mathlib/Topology/Order/Basic.lean | induced_orderTopology | null |
StrictMono.isEmbedding_of_ordConnected {α β : Type*} [LinearOrder α] [LinearOrder β]
[TopologicalSpace α] [h : OrderTopology α] [TopologicalSpace β] [OrderTopology β] {f : α → β}
(hf : StrictMono f) (hc : OrdConnected (range f)) : IsEmbedding f :=
⟨⟨h.1.trans <| Eq.symm <| hf.induced_topology_eq_preorder hc⟩,... | theorem | Topology | [
"Mathlib.Order.Filter.Interval",
"Mathlib.Order.Interval.Set.Pi",
"Mathlib.Order.OrdContinuous",
"Mathlib.Tactic.TFAE",
"Mathlib.Tactic.NormNum",
"Mathlib.Topology.Order.LeftRight",
"Mathlib.Topology.Order.OrderClosed"
] | Mathlib/Topology/Order/Basic.lean | StrictMono.isEmbedding_of_ordConnected | The topology induced by a strictly monotone function with order-connected range is the preorder
topology. -/
nonrec theorem StrictMono.induced_topology_eq_preorder {α β : Type*} [LinearOrder α]
[LinearOrder β] [t : TopologicalSpace β] [OrderTopology β] {f : α → β}
(hf : StrictMono f) (hc : OrdConnected (range f... |
OrderEmbedding.isEmbedding_of_ordConnected {α β : Type*} [LinearOrder α] [LinearOrder β]
[TopologicalSpace α] [OrderTopology α] [TopologicalSpace β] [OrderTopology β]
(f : α ↪o β) (hc : OrdConnected (range f)) : Topology.IsEmbedding f :=
f.strictMono.isEmbedding_of_ordConnected hc | lemma | Topology | [
"Mathlib.Order.Filter.Interval",
"Mathlib.Order.Interval.Set.Pi",
"Mathlib.Order.OrdContinuous",
"Mathlib.Tactic.TFAE",
"Mathlib.Tactic.NormNum",
"Mathlib.Topology.Order.LeftRight",
"Mathlib.Topology.Order.OrderClosed"
] | Mathlib/Topology/Order/Basic.lean | OrderEmbedding.isEmbedding_of_ordConnected | An `OrderEmbedding` is a topological embedding provided that the range of `f` is
order-connected |
orderTopology_of_ordConnected {α : Type u} [TopologicalSpace α] [LinearOrder α]
[OrderTopology α] {t : Set α} [ht : OrdConnected t] : OrderTopology t :=
⟨(Subtype.strictMono_coe t).induced_topology_eq_preorder <| by
rwa [← @Subtype.range_val _ t] at ht⟩ | instance | Topology | [
"Mathlib.Order.Filter.Interval",
"Mathlib.Order.Interval.Set.Pi",
"Mathlib.Order.OrdContinuous",
"Mathlib.Tactic.TFAE",
"Mathlib.Tactic.NormNum",
"Mathlib.Topology.Order.LeftRight",
"Mathlib.Topology.Order.OrderClosed"
] | Mathlib/Topology/Order/Basic.lean | orderTopology_of_ordConnected | On a `Set.OrdConnected` subset of a linear order, the order topology for the restriction of the
order is the same as the restriction to the subset of the order topology. |
nhdsGE_eq_iInf_inf_principal [TopologicalSpace α] [Preorder α] [OrderTopology α] (a : α) :
𝓝[≥] a = (⨅ (u) (_ : a < u), 𝓟 (Iio u)) ⊓ 𝓟 (Ici a) := by
rw [nhdsWithin, nhds_eq_order]
refine le_antisymm (inf_le_inf_right _ inf_le_right) (le_inf (le_inf ?_ inf_le_left) inf_le_right)
exact inf_le_right.trans (le... | theorem | Topology | [
"Mathlib.Order.Filter.Interval",
"Mathlib.Order.Interval.Set.Pi",
"Mathlib.Order.OrdContinuous",
"Mathlib.Tactic.TFAE",
"Mathlib.Tactic.NormNum",
"Mathlib.Topology.Order.LeftRight",
"Mathlib.Topology.Order.OrderClosed"
] | Mathlib/Topology/Order/Basic.lean | nhdsGE_eq_iInf_inf_principal | null |
nhdsLE_eq_iInf_inf_principal [TopologicalSpace α] [Preorder α] [OrderTopology α] (a : α) :
𝓝[≤] a = (⨅ l < a, 𝓟 (Ioi l)) ⊓ 𝓟 (Iic a) :=
nhdsGE_eq_iInf_inf_principal (toDual a) | theorem | Topology | [
"Mathlib.Order.Filter.Interval",
"Mathlib.Order.Interval.Set.Pi",
"Mathlib.Order.OrdContinuous",
"Mathlib.Tactic.TFAE",
"Mathlib.Tactic.NormNum",
"Mathlib.Topology.Order.LeftRight",
"Mathlib.Topology.Order.OrderClosed"
] | Mathlib/Topology/Order/Basic.lean | nhdsLE_eq_iInf_inf_principal | null |
nhdsGE_eq_iInf_principal [TopologicalSpace α] [Preorder α] [OrderTopology α] {a : α}
(ha : ∃ u, a < u) : 𝓝[≥] a = ⨅ (u) (_ : a < u), 𝓟 (Ico a u) := by
simp only [nhdsGE_eq_iInf_inf_principal, biInf_inf ha, inf_principal, Iio_inter_Ici] | theorem | Topology | [
"Mathlib.Order.Filter.Interval",
"Mathlib.Order.Interval.Set.Pi",
"Mathlib.Order.OrdContinuous",
"Mathlib.Tactic.TFAE",
"Mathlib.Tactic.NormNum",
"Mathlib.Topology.Order.LeftRight",
"Mathlib.Topology.Order.OrderClosed"
] | Mathlib/Topology/Order/Basic.lean | nhdsGE_eq_iInf_principal | null |
nhdsLE_eq_iInf_principal [TopologicalSpace α] [Preorder α] [OrderTopology α] {a : α}
(ha : ∃ l, l < a) : 𝓝[≤] a = ⨅ l < a, 𝓟 (Ioc l a) := by
simp only [nhdsLE_eq_iInf_inf_principal, biInf_inf ha, inf_principal, Ioi_inter_Iic] | theorem | Topology | [
"Mathlib.Order.Filter.Interval",
"Mathlib.Order.Interval.Set.Pi",
"Mathlib.Order.OrdContinuous",
"Mathlib.Tactic.TFAE",
"Mathlib.Tactic.NormNum",
"Mathlib.Topology.Order.LeftRight",
"Mathlib.Topology.Order.OrderClosed"
] | Mathlib/Topology/Order/Basic.lean | nhdsLE_eq_iInf_principal | null |
nhdsGE_basis_of_exists_gt [TopologicalSpace α] [LinearOrder α] [OrderTopology α] {a : α}
(ha : ∃ u, a < u) : (𝓝[≥] a).HasBasis (fun u => a < u) fun u => Ico a u :=
(nhdsGE_eq_iInf_principal ha).symm ▸
hasBasis_biInf_principal
(fun b hb c hc => ⟨min b c, lt_min hb hc, Ico_subset_Ico_right (min_le_left _... | theorem | Topology | [
"Mathlib.Order.Filter.Interval",
"Mathlib.Order.Interval.Set.Pi",
"Mathlib.Order.OrdContinuous",
"Mathlib.Tactic.TFAE",
"Mathlib.Tactic.NormNum",
"Mathlib.Topology.Order.LeftRight",
"Mathlib.Topology.Order.OrderClosed"
] | Mathlib/Topology/Order/Basic.lean | nhdsGE_basis_of_exists_gt | null |
nhdsLE_basis_of_exists_lt [TopologicalSpace α] [LinearOrder α] [OrderTopology α] {a : α}
(ha : ∃ l, l < a) : (𝓝[≤] a).HasBasis (fun l => l < a) fun l => Ioc l a := by
convert nhdsGE_basis_of_exists_gt (α := αᵒᵈ) ha using 2
exact Ico_toDual.symm | theorem | Topology | [
"Mathlib.Order.Filter.Interval",
"Mathlib.Order.Interval.Set.Pi",
"Mathlib.Order.OrdContinuous",
"Mathlib.Tactic.TFAE",
"Mathlib.Tactic.NormNum",
"Mathlib.Topology.Order.LeftRight",
"Mathlib.Topology.Order.OrderClosed"
] | Mathlib/Topology/Order/Basic.lean | nhdsLE_basis_of_exists_lt | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.