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 ⌀ |
|---|---|---|---|---|---|---|
eventually_ne_cobounded (a : α) : ∀ᶠ x in cobounded α, x ≠ a :=
le_cofinite_iff_eventually_ne.1 (le_cofinite _) a | lemma | Topology | [
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/Topology/Bornology/Basic.lean | eventually_ne_cobounded | null |
Filter.HasBasis.disjoint_cobounded_iff [Bornology α] {ι : Sort*} {p : ι → Prop}
{s : ι → Set α} {l : Filter α} (h : l.HasBasis p s) :
Disjoint l (cobounded α) ↔ ∃ i, p i ∧ Bornology.IsBounded (s i) :=
h.disjoint_iff_left | theorem | Topology | [
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/Topology/Bornology/Basic.lean | Filter.HasBasis.disjoint_cobounded_iff | null |
Set.Finite.isBounded [Bornology α] {s : Set α} (hs : s.Finite) : IsBounded s :=
Bornology.le_cofinite α hs.compl_mem_cofinite
nonrec lemma Filter.Tendsto.eventually_ne_cobounded [Bornology α] {f : β → α} {l : Filter β}
(h : Tendsto f l (cobounded α)) (a : α) : ∀ᶠ x in l, f x ≠ a :=
h.eventually <| eventually_ne_cobounded a | theorem | Topology | [
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/Topology/Bornology/Basic.lean | Set.Finite.isBounded | null |
Bornology.cofinite : Bornology α where
cobounded := Filter.cofinite
le_cofinite := le_rfl | abbrev | Topology | [
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/Topology/Bornology/Basic.lean | Bornology.cofinite | The cofinite filter as a bornology |
BoundedSpace (α : Type*) [Bornology α] : Prop where
/-- The `Set.univ` is bounded. -/
bounded_univ : Bornology.IsBounded (univ : Set α) | class | Topology | [
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/Topology/Bornology/Basic.lean | BoundedSpace | A space with a `Bornology` is a **bounded space** if `Set.univ : Set α` is bounded. |
isBounded_univ : IsBounded (univ : Set α) ↔ BoundedSpace α :=
⟨fun h => ⟨h⟩, fun h => h.1⟩ | theorem | Topology | [
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/Topology/Bornology/Basic.lean | isBounded_univ | null |
cobounded_eq_bot_iff : cobounded α = ⊥ ↔ BoundedSpace α := by
rw [← isBounded_univ, isBounded_def, compl_univ, empty_mem_iff_bot]
variable [BoundedSpace α] | theorem | Topology | [
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/Topology/Bornology/Basic.lean | cobounded_eq_bot_iff | null |
IsBounded.all (s : Set α) : IsBounded s :=
BoundedSpace.bounded_univ.subset s.subset_univ | theorem | Topology | [
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/Topology/Bornology/Basic.lean | IsBounded.all | null |
IsCobounded.all (s : Set α) : IsCobounded s :=
compl_compl s ▸ IsBounded.all sᶜ
variable (α)
@[simp] | theorem | Topology | [
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/Topology/Bornology/Basic.lean | IsCobounded.all | null |
cobounded_eq_bot : cobounded α = ⊥ :=
cobounded_eq_bot_iff.2 ‹_› | theorem | Topology | [
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/Topology/Bornology/Basic.lean | cobounded_eq_bot | null |
instBornology : Bornology αᵒᵈ := ‹Bornology α›
@[simp] lemma isCobounded_preimage_ofDual {s : Set α} :
IsCobounded (ofDual ⁻¹' s) ↔ IsCobounded s := Iff.rfl
@[simp] lemma isCobounded_preimage_toDual {s : Set αᵒᵈ} :
IsCobounded (toDual ⁻¹' s) ↔ IsCobounded s := Iff.rfl
@[simp] lemma isBounded_preimage_ofDual {s : Set α} :
IsBounded (ofDual ⁻¹' s) ↔ IsBounded s := Iff.rfl
@[simp] lemma isBounded_preimage_toDual {s : Set αᵒᵈ} :
IsBounded (toDual ⁻¹' s) ↔ IsBounded s := Iff.rfl | instance | Topology | [
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/Topology/Bornology/Basic.lean | instBornology | null |
BoundedSub (R : Type*) [Bornology R] [Sub R] : Prop where
isBounded_sub : ∀ {s t : Set R},
Bornology.IsBounded s → Bornology.IsBounded t → Bornology.IsBounded (s - t)
variable {R : Type*} | class | Topology | [
"Mathlib.Analysis.Normed.Group.Basic",
"Mathlib.Topology.MetricSpace.ProperSpace.Real",
"Mathlib.Analysis.Normed.Ring.Lemmas"
] | Mathlib/Topology/Bornology/BoundedOperation.lean | BoundedSub | A typeclass saying that `(p : R × R) ↦ p.1 - p.2` maps any product of bounded sets to a bounded
set. This property automatically holds for seminormed additive groups, but it also holds, e.g.,
for `ℝ≥0`. |
isBounded_sub [Bornology R] [Sub R] [BoundedSub R] {s t : Set R}
(hs : Bornology.IsBounded s) (ht : Bornology.IsBounded t) :
Bornology.IsBounded (s - t) := BoundedSub.isBounded_sub hs ht | lemma | Topology | [
"Mathlib.Analysis.Normed.Group.Basic",
"Mathlib.Topology.MetricSpace.ProperSpace.Real",
"Mathlib.Analysis.Normed.Ring.Lemmas"
] | Mathlib/Topology/Bornology/BoundedOperation.lean | isBounded_sub | null |
sub_bounded_of_bounded_of_bounded {X : Type*} [PseudoMetricSpace R] [Sub R] [BoundedSub R]
{f g : X → R} (f_bdd : ∃ C, ∀ x y, dist (f x) (f y) ≤ C)
(g_bdd : ∃ C, ∀ x y, dist (g x) (g y) ≤ C) :
∃ C, ∀ x y, dist ((f - g) x) ((f - g) y) ≤ C := by
obtain ⟨C, hC⟩ := Metric.isBounded_iff.mp <|
isBounded_sub (Metric.isBounded_range_iff.mpr f_bdd) (Metric.isBounded_range_iff.mpr g_bdd)
use C
intro x y
exact hC (Set.sub_mem_sub (Set.mem_range_self (f := f) x) (Set.mem_range_self (f := g) x))
(Set.sub_mem_sub (Set.mem_range_self (f := f) y) (Set.mem_range_self (f := g) y)) | lemma | Topology | [
"Mathlib.Analysis.Normed.Group.Basic",
"Mathlib.Topology.MetricSpace.ProperSpace.Real",
"Mathlib.Analysis.Normed.Ring.Lemmas"
] | Mathlib/Topology/Bornology/BoundedOperation.lean | sub_bounded_of_bounded_of_bounded | null |
boundedSub_of_lipschitzWith_sub [PseudoMetricSpace R] [Sub R] {K : NNReal}
(lip : LipschitzWith K (fun (p : R × R) ↦ p.1 - p.2)) :
BoundedSub R where
isBounded_sub {s t} s_bdd t_bdd := by
have bdd : Bornology.IsBounded (s ×ˢ t) := Bornology.IsBounded.prod s_bdd t_bdd
convert lip.isBounded_image bdd
simp | lemma | Topology | [
"Mathlib.Analysis.Normed.Group.Basic",
"Mathlib.Topology.MetricSpace.ProperSpace.Real",
"Mathlib.Analysis.Normed.Ring.Lemmas"
] | Mathlib/Topology/Bornology/BoundedOperation.lean | boundedSub_of_lipschitzWith_sub | null |
BoundedAdd (R : Type*) [Bornology R] [Add R] : Prop where
isBounded_add : ∀ {s t : Set R},
Bornology.IsBounded s → Bornology.IsBounded t → Bornology.IsBounded (s + t) | class | Topology | [
"Mathlib.Analysis.Normed.Group.Basic",
"Mathlib.Topology.MetricSpace.ProperSpace.Real",
"Mathlib.Analysis.Normed.Ring.Lemmas"
] | Mathlib/Topology/Bornology/BoundedOperation.lean | BoundedAdd | A typeclass saying that `(p : R × R) ↦ p.1 + p.2` maps any product of bounded sets to a bounded
set. This property follows from `LipschitzAdd`, and thus automatically holds, e.g., for seminormed
additive groups. |
@[to_additive]
BoundedMul (R : Type*) [Bornology R] [Mul R] : Prop where
isBounded_mul : ∀ {s t : Set R},
Bornology.IsBounded s → Bornology.IsBounded t → Bornology.IsBounded (s * t)
variable {R : Type*}
@[to_additive] | class | Topology | [
"Mathlib.Analysis.Normed.Group.Basic",
"Mathlib.Topology.MetricSpace.ProperSpace.Real",
"Mathlib.Analysis.Normed.Ring.Lemmas"
] | Mathlib/Topology/Bornology/BoundedOperation.lean | BoundedMul | A typeclass saying that `(p : R × R) ↦ p.1 * p.2` maps any product of bounded sets to a bounded
set. This property automatically holds for non-unital seminormed rings, but it also holds, e.g.,
for `ℝ≥0`. |
isBounded_mul [Bornology R] [Mul R] [BoundedMul R] {s t : Set R}
(hs : Bornology.IsBounded s) (ht : Bornology.IsBounded t) :
Bornology.IsBounded (s * t) := BoundedMul.isBounded_mul hs ht
@[to_additive] | lemma | Topology | [
"Mathlib.Analysis.Normed.Group.Basic",
"Mathlib.Topology.MetricSpace.ProperSpace.Real",
"Mathlib.Analysis.Normed.Ring.Lemmas"
] | Mathlib/Topology/Bornology/BoundedOperation.lean | isBounded_mul | null |
isBounded_pow {R : Type*} [Bornology R] [Monoid R] [BoundedMul R] {s : Set R}
(s_bdd : Bornology.IsBounded s) (n : ℕ) :
Bornology.IsBounded ((fun x ↦ x ^ n) '' s) := by
induction n with
| zero =>
by_cases s_empty : s = ∅
· simp [s_empty]
simp_rw [← nonempty_iff_ne_empty] at s_empty
simp [s_empty]
| succ n hn =>
have obs : ((fun x ↦ x ^ (n + 1)) '' s) ⊆ ((fun x ↦ x ^ n) '' s) * s := by
intro x hx
simp only [mem_image] at hx
obtain ⟨y, y_in_s, ypow_eq_x⟩ := hx
rw [← ypow_eq_x, pow_succ y n]
apply Set.mul_mem_mul _ y_in_s
use y
exact (isBounded_mul hn s_bdd).subset obs
@[to_additive] | lemma | Topology | [
"Mathlib.Analysis.Normed.Group.Basic",
"Mathlib.Topology.MetricSpace.ProperSpace.Real",
"Mathlib.Analysis.Normed.Ring.Lemmas"
] | Mathlib/Topology/Bornology/BoundedOperation.lean | isBounded_pow | null |
mul_bounded_of_bounded_of_bounded {X : Type*} [PseudoMetricSpace R] [Mul R] [BoundedMul R]
{f g : X → R} (f_bdd : ∃ C, ∀ x y, dist (f x) (f y) ≤ C)
(g_bdd : ∃ C, ∀ x y, dist (g x) (g y) ≤ C) :
∃ C, ∀ x y, dist ((f * g) x) ((f * g) y) ≤ C := by
obtain ⟨C, hC⟩ := Metric.isBounded_iff.mp <|
isBounded_mul (Metric.isBounded_range_iff.mpr f_bdd) (Metric.isBounded_range_iff.mpr g_bdd)
use C
intro x y
exact hC (Set.mul_mem_mul (Set.mem_range_self (f := f) x) (Set.mem_range_self (f := g) x))
(Set.mul_mem_mul (Set.mem_range_self (f := f) y) (Set.mem_range_self (f := g) y))
@[to_additive] | lemma | Topology | [
"Mathlib.Analysis.Normed.Group.Basic",
"Mathlib.Topology.MetricSpace.ProperSpace.Real",
"Mathlib.Analysis.Normed.Ring.Lemmas"
] | Mathlib/Topology/Bornology/BoundedOperation.lean | mul_bounded_of_bounded_of_bounded | null |
SeminormedAddCommGroup.lipschitzWith_sub :
LipschitzWith 2 (fun (p : R × R) ↦ p.1 - p.2) := by
convert LipschitzWith.prod_fst.sub LipschitzWith.prod_snd
norm_num | lemma | Topology | [
"Mathlib.Analysis.Normed.Group.Basic",
"Mathlib.Topology.MetricSpace.ProperSpace.Real",
"Mathlib.Analysis.Normed.Ring.Lemmas"
] | Mathlib/Topology/Bornology/BoundedOperation.lean | SeminormedAddCommGroup.lipschitzWith_sub | null |
Prod.instBornology : Bornology (α × β) where
cobounded := (cobounded α).coprod (cobounded β)
le_cofinite :=
@coprod_cofinite α β ▸ coprod_mono ‹Bornology α›.le_cofinite ‹Bornology β›.le_cofinite | instance | Topology | [
"Mathlib.Algebra.Group.TypeTags.Basic",
"Mathlib.Topology.Bornology.Basic"
] | Mathlib/Topology/Bornology/Constructions.lean | Prod.instBornology | null |
Pi.instBornology : Bornology (∀ i, X i) where
cobounded := Filter.coprodᵢ fun i => cobounded (X i)
le_cofinite := iSup_le fun _ ↦ (comap_mono (Bornology.le_cofinite _)).trans (comap_cofinite_le _) | instance | Topology | [
"Mathlib.Algebra.Group.TypeTags.Basic",
"Mathlib.Topology.Bornology.Basic"
] | Mathlib/Topology/Bornology/Constructions.lean | Pi.instBornology | null |
Bornology.induced {α β : Type*} [Bornology β] (f : α → β) : Bornology α where
cobounded := comap f (cobounded β)
le_cofinite := (comap_mono (Bornology.le_cofinite β)).trans (comap_cofinite_le _) | abbrev | Topology | [
"Mathlib.Algebra.Group.TypeTags.Basic",
"Mathlib.Topology.Bornology.Basic"
] | Mathlib/Topology/Bornology/Constructions.lean | Bornology.induced | Inverse image of a bornology. |
cobounded_prod : cobounded (α × β) = (cobounded α).coprod (cobounded β) :=
rfl | theorem | Topology | [
"Mathlib.Algebra.Group.TypeTags.Basic",
"Mathlib.Topology.Bornology.Basic"
] | Mathlib/Topology/Bornology/Constructions.lean | cobounded_prod | null |
isBounded_image_fst_and_snd {s : Set (α × β)} :
IsBounded (Prod.fst '' s) ∧ IsBounded (Prod.snd '' s) ↔ IsBounded s :=
compl_mem_coprod.symm | theorem | Topology | [
"Mathlib.Algebra.Group.TypeTags.Basic",
"Mathlib.Topology.Bornology.Basic"
] | Mathlib/Topology/Bornology/Constructions.lean | isBounded_image_fst_and_snd | null |
IsBounded.image_fst {s : Set (α × β)} (hs : IsBounded s) : IsBounded (Prod.fst '' s) :=
(isBounded_image_fst_and_snd.2 hs).1 | lemma | Topology | [
"Mathlib.Algebra.Group.TypeTags.Basic",
"Mathlib.Topology.Bornology.Basic"
] | Mathlib/Topology/Bornology/Constructions.lean | IsBounded.image_fst | null |
IsBounded.image_snd {s : Set (α × β)} (hs : IsBounded s) : IsBounded (Prod.snd '' s) :=
(isBounded_image_fst_and_snd.2 hs).2
variable {s : Set α} {t : Set β} {S : ∀ i, Set (X i)} | lemma | Topology | [
"Mathlib.Algebra.Group.TypeTags.Basic",
"Mathlib.Topology.Bornology.Basic"
] | Mathlib/Topology/Bornology/Constructions.lean | IsBounded.image_snd | null |
IsBounded.fst_of_prod (h : IsBounded (s ×ˢ t)) (ht : t.Nonempty) : IsBounded s :=
fst_image_prod s ht ▸ h.image_fst | theorem | Topology | [
"Mathlib.Algebra.Group.TypeTags.Basic",
"Mathlib.Topology.Bornology.Basic"
] | Mathlib/Topology/Bornology/Constructions.lean | IsBounded.fst_of_prod | null |
IsBounded.snd_of_prod (h : IsBounded (s ×ˢ t)) (hs : s.Nonempty) : IsBounded t :=
snd_image_prod hs t ▸ h.image_snd | theorem | Topology | [
"Mathlib.Algebra.Group.TypeTags.Basic",
"Mathlib.Topology.Bornology.Basic"
] | Mathlib/Topology/Bornology/Constructions.lean | IsBounded.snd_of_prod | null |
IsBounded.prod (hs : IsBounded s) (ht : IsBounded t) : IsBounded (s ×ˢ t) :=
isBounded_image_fst_and_snd.1
⟨hs.subset <| fst_image_prod_subset _ _, ht.subset <| snd_image_prod_subset _ _⟩ | theorem | Topology | [
"Mathlib.Algebra.Group.TypeTags.Basic",
"Mathlib.Topology.Bornology.Basic"
] | Mathlib/Topology/Bornology/Constructions.lean | IsBounded.prod | null |
isBounded_prod_of_nonempty (hne : Set.Nonempty (s ×ˢ t)) :
IsBounded (s ×ˢ t) ↔ IsBounded s ∧ IsBounded t :=
⟨fun h => ⟨h.fst_of_prod hne.snd, h.snd_of_prod hne.fst⟩, fun h => h.1.prod h.2⟩ | theorem | Topology | [
"Mathlib.Algebra.Group.TypeTags.Basic",
"Mathlib.Topology.Bornology.Basic"
] | Mathlib/Topology/Bornology/Constructions.lean | isBounded_prod_of_nonempty | null |
isBounded_prod : IsBounded (s ×ˢ t) ↔ s = ∅ ∨ t = ∅ ∨ IsBounded s ∧ IsBounded t := by
rcases s.eq_empty_or_nonempty with (rfl | hs); · simp
rcases t.eq_empty_or_nonempty with (rfl | ht); · simp
simp only [hs.ne_empty, ht.ne_empty, isBounded_prod_of_nonempty (hs.prod ht), false_or] | theorem | Topology | [
"Mathlib.Algebra.Group.TypeTags.Basic",
"Mathlib.Topology.Bornology.Basic"
] | Mathlib/Topology/Bornology/Constructions.lean | isBounded_prod | null |
isBounded_prod_self : IsBounded (s ×ˢ s) ↔ IsBounded s := by
rcases s.eq_empty_or_nonempty with (rfl | hs); · simp
exact (isBounded_prod_of_nonempty (hs.prod hs)).trans and_self_iff
/-! | theorem | Topology | [
"Mathlib.Algebra.Group.TypeTags.Basic",
"Mathlib.Topology.Bornology.Basic"
] | Mathlib/Topology/Bornology/Constructions.lean | isBounded_prod_self | null |
cobounded_pi : cobounded (∀ i, X i) = Filter.coprodᵢ fun i => cobounded (X i) :=
rfl | theorem | Topology | [
"Mathlib.Algebra.Group.TypeTags.Basic",
"Mathlib.Topology.Bornology.Basic"
] | Mathlib/Topology/Bornology/Constructions.lean | cobounded_pi | null |
forall_isBounded_image_eval_iff {s : Set (∀ i, X i)} :
(∀ i, IsBounded (eval i '' s)) ↔ IsBounded s :=
compl_mem_coprodᵢ.symm | theorem | Topology | [
"Mathlib.Algebra.Group.TypeTags.Basic",
"Mathlib.Topology.Bornology.Basic"
] | Mathlib/Topology/Bornology/Constructions.lean | forall_isBounded_image_eval_iff | null |
IsBounded.image_eval {s : Set (∀ i, X i)} (hs : IsBounded s) (i : ι) :
IsBounded (eval i '' s) :=
forall_isBounded_image_eval_iff.2 hs i | lemma | Topology | [
"Mathlib.Algebra.Group.TypeTags.Basic",
"Mathlib.Topology.Bornology.Basic"
] | Mathlib/Topology/Bornology/Constructions.lean | IsBounded.image_eval | null |
IsBounded.pi (h : ∀ i, IsBounded (S i)) : IsBounded (pi univ S) :=
forall_isBounded_image_eval_iff.1 fun i => (h i).subset eval_image_univ_pi_subset | theorem | Topology | [
"Mathlib.Algebra.Group.TypeTags.Basic",
"Mathlib.Topology.Bornology.Basic"
] | Mathlib/Topology/Bornology/Constructions.lean | IsBounded.pi | null |
isBounded_pi_of_nonempty (hne : (pi univ S).Nonempty) :
IsBounded (pi univ S) ↔ ∀ i, IsBounded (S i) :=
⟨fun H i => @eval_image_univ_pi _ _ _ i hne ▸ forall_isBounded_image_eval_iff.2 H i, IsBounded.pi⟩ | theorem | Topology | [
"Mathlib.Algebra.Group.TypeTags.Basic",
"Mathlib.Topology.Bornology.Basic"
] | Mathlib/Topology/Bornology/Constructions.lean | isBounded_pi_of_nonempty | null |
isBounded_pi : IsBounded (pi univ S) ↔ (∃ i, S i = ∅) ∨ ∀ i, IsBounded (S i) := by
by_cases hne : ∃ i, S i = ∅
· simp [hne, univ_pi_eq_empty_iff.2 hne]
· simp only [hne, false_or]
simp only [not_exists, ← nonempty_iff_ne_empty, ← univ_pi_nonempty_iff] at hne
exact isBounded_pi_of_nonempty hne
/-! | theorem | Topology | [
"Mathlib.Algebra.Group.TypeTags.Basic",
"Mathlib.Topology.Bornology.Basic"
] | Mathlib/Topology/Bornology/Constructions.lean | isBounded_pi | null |
isBounded_induced {α β : Type*} [Bornology β] {f : α → β} {s : Set α} :
@IsBounded α (Bornology.induced f) s ↔ IsBounded (f '' s) :=
compl_mem_comap | theorem | Topology | [
"Mathlib.Algebra.Group.TypeTags.Basic",
"Mathlib.Topology.Bornology.Basic"
] | Mathlib/Topology/Bornology/Constructions.lean | isBounded_induced | null |
isBounded_image_subtype_val {p : α → Prop} {s : Set { x // p x }} :
IsBounded (Subtype.val '' s) ↔ IsBounded s :=
isBounded_induced.symm | theorem | Topology | [
"Mathlib.Algebra.Group.TypeTags.Basic",
"Mathlib.Topology.Bornology.Basic"
] | Mathlib/Topology/Bornology/Constructions.lean | isBounded_image_subtype_val | null |
boundedSpace_induced_iff {α β : Type*} [Bornology β] {f : α → β} :
@BoundedSpace α (Bornology.induced f) ↔ IsBounded (range f) := by
rw [← @isBounded_univ, isBounded_induced, image_univ] | theorem | Topology | [
"Mathlib.Algebra.Group.TypeTags.Basic",
"Mathlib.Topology.Bornology.Basic"
] | Mathlib/Topology/Bornology/Constructions.lean | boundedSpace_induced_iff | null |
boundedSpace_subtype_iff {p : α → Prop} :
BoundedSpace (Subtype p) ↔ IsBounded { x | p x } := by
rw [boundedSpace_induced_iff, Subtype.range_coe_subtype] | theorem | Topology | [
"Mathlib.Algebra.Group.TypeTags.Basic",
"Mathlib.Topology.Bornology.Basic"
] | Mathlib/Topology/Bornology/Constructions.lean | boundedSpace_subtype_iff | null |
boundedSpace_val_set_iff {s : Set α} : BoundedSpace s ↔ IsBounded s :=
boundedSpace_subtype_iff
alias ⟨_, Bornology.IsBounded.boundedSpace_subtype⟩ := boundedSpace_subtype_iff
alias ⟨_, Bornology.IsBounded.boundedSpace_val⟩ := boundedSpace_val_set_iff | theorem | Topology | [
"Mathlib.Algebra.Group.TypeTags.Basic",
"Mathlib.Topology.Bornology.Basic"
] | Mathlib/Topology/Bornology/Constructions.lean | boundedSpace_val_set_iff | null |
LocallyBoundedMap (α β : Type*) [Bornology α] [Bornology β] where
/-- The function underlying a locally bounded map -/
toFun : α → β
/-- The pullback of the `Bornology.cobounded` filter under the function is contained in the
cobounded filter. Equivalently, the function maps bounded sets to bounded sets. -/
comap_cobounded_le' : (cobounded β).comap toFun ≤ cobounded α | structure | Topology | [
"Mathlib.Topology.Bornology.Basic"
] | Mathlib/Topology/Bornology/Hom.lean | LocallyBoundedMap | The type of bounded maps from `α` to `β`, the maps which send a bounded set to a bounded set. |
LocallyBoundedMapClass (F : Type*) (α β : outParam Type*) [Bornology α]
[Bornology β] [FunLike F α β] : Prop where
/-- The pullback of the `Bornology.cobounded` filter under the function is contained in the
cobounded filter. Equivalently, the function maps bounded sets to bounded sets. -/
comap_cobounded_le (f : F) : (cobounded β).comap f ≤ cobounded α | class | Topology | [
"Mathlib.Topology.Bornology.Basic"
] | Mathlib/Topology/Bornology/Hom.lean | LocallyBoundedMapClass | `LocallyBoundedMapClass F α β` states that `F` is a type of bounded maps.
You should extend this class when you extend `LocallyBoundedMap`. |
Bornology.IsBounded.image [Bornology α] [Bornology β] [LocallyBoundedMapClass F α β] (f : F)
{s : Set α} (hs : IsBounded s) : IsBounded (f '' s) :=
comap_cobounded_le_iff.1 (comap_cobounded_le f) hs | theorem | Topology | [
"Mathlib.Topology.Bornology.Basic"
] | Mathlib/Topology/Bornology/Hom.lean | Bornology.IsBounded.image | null |
@[coe]
LocallyBoundedMapClass.toLocallyBoundedMap [Bornology α] [Bornology β]
[LocallyBoundedMapClass F α β] (f : F) : LocallyBoundedMap α β where
toFun := f
comap_cobounded_le' := comap_cobounded_le f | def | Topology | [
"Mathlib.Topology.Bornology.Basic"
] | Mathlib/Topology/Bornology/Hom.lean | LocallyBoundedMapClass.toLocallyBoundedMap | Turn an element of a type `F` satisfying `LocallyBoundedMapClass F α β` into an actual
`LocallyBoundedMap`. This is declared as the default coercion from `F` to
`LocallyBoundedMap α β`. |
@[ext]
ext {f g : LocallyBoundedMap α β} (h : ∀ a, f a = g a) : f = g :=
DFunLike.ext f g h | theorem | Topology | [
"Mathlib.Topology.Bornology.Basic"
] | Mathlib/Topology/Bornology/Hom.lean | ext | null |
protected copy (f : LocallyBoundedMap α β) (f' : α → β) (h : f' = f) : LocallyBoundedMap α β :=
⟨f', h.symm ▸ f.comap_cobounded_le'⟩
@[simp] | def | Topology | [
"Mathlib.Topology.Bornology.Basic"
] | Mathlib/Topology/Bornology/Hom.lean | copy | Copy of a `LocallyBoundedMap` with a new `toFun` equal to the old one. Useful to fix
definitional equalities. |
coe_copy (f : LocallyBoundedMap α β) (f' : α → β) (h : f' = f) : ⇑(f.copy f' h) = f' :=
rfl | theorem | Topology | [
"Mathlib.Topology.Bornology.Basic"
] | Mathlib/Topology/Bornology/Hom.lean | coe_copy | null |
copy_eq (f : LocallyBoundedMap α β) (f' : α → β) (h : f' = f) : f.copy f' h = f :=
DFunLike.ext' h | theorem | Topology | [
"Mathlib.Topology.Bornology.Basic"
] | Mathlib/Topology/Bornology/Hom.lean | copy_eq | null |
ofMapBounded (f : α → β) (h : ∀ ⦃s : Set α⦄, IsBounded s → IsBounded (f '' s)) :
LocallyBoundedMap α β :=
⟨f, comap_cobounded_le_iff.2 h⟩
@[simp] | def | Topology | [
"Mathlib.Topology.Bornology.Basic"
] | Mathlib/Topology/Bornology/Hom.lean | ofMapBounded | Construct a `LocallyBoundedMap` from the fact that the function maps bounded sets to bounded
sets. |
coe_ofMapBounded (f : α → β) {h} : ⇑(ofMapBounded f h) = f :=
rfl
@[simp] | theorem | Topology | [
"Mathlib.Topology.Bornology.Basic"
] | Mathlib/Topology/Bornology/Hom.lean | coe_ofMapBounded | null |
ofMapBounded_apply (f : α → β) {h} (a : α) : ofMapBounded f h a = f a :=
rfl
variable (α) | theorem | Topology | [
"Mathlib.Topology.Bornology.Basic"
] | Mathlib/Topology/Bornology/Hom.lean | ofMapBounded_apply | null |
protected id : LocallyBoundedMap α α :=
⟨id, comap_id.le⟩ | def | Topology | [
"Mathlib.Topology.Bornology.Basic"
] | Mathlib/Topology/Bornology/Hom.lean | id | `id` as a `LocallyBoundedMap`. |
@[simp, norm_cast]
coe_id : ⇑(LocallyBoundedMap.id α) = id :=
rfl
variable {α}
@[simp] | theorem | Topology | [
"Mathlib.Topology.Bornology.Basic"
] | Mathlib/Topology/Bornology/Hom.lean | coe_id | null |
id_apply (a : α) : LocallyBoundedMap.id α a = a :=
rfl | theorem | Topology | [
"Mathlib.Topology.Bornology.Basic"
] | Mathlib/Topology/Bornology/Hom.lean | id_apply | null |
comp (f : LocallyBoundedMap β γ) (g : LocallyBoundedMap α β) : LocallyBoundedMap α γ where
toFun := f ∘ g
comap_cobounded_le' :=
comap_comap.ge.trans <| (comap_mono f.comap_cobounded_le').trans g.comap_cobounded_le'
@[simp] | def | Topology | [
"Mathlib.Topology.Bornology.Basic"
] | Mathlib/Topology/Bornology/Hom.lean | comp | Composition of `LocallyBoundedMap`s as a `LocallyBoundedMap`. |
coe_comp (f : LocallyBoundedMap β γ) (g : LocallyBoundedMap α β) : ⇑(f.comp g) = f ∘ g :=
rfl
@[simp] | theorem | Topology | [
"Mathlib.Topology.Bornology.Basic"
] | Mathlib/Topology/Bornology/Hom.lean | coe_comp | null |
comp_apply (f : LocallyBoundedMap β γ) (g : LocallyBoundedMap α β) (a : α) :
f.comp g a = f (g a) :=
rfl
@[simp] | theorem | Topology | [
"Mathlib.Topology.Bornology.Basic"
] | Mathlib/Topology/Bornology/Hom.lean | comp_apply | null |
comp_assoc (f : LocallyBoundedMap γ δ) (g : LocallyBoundedMap β γ)
(h : LocallyBoundedMap α β) : (f.comp g).comp h = f.comp (g.comp h) :=
rfl
@[simp] | theorem | Topology | [
"Mathlib.Topology.Bornology.Basic"
] | Mathlib/Topology/Bornology/Hom.lean | comp_assoc | null |
comp_id (f : LocallyBoundedMap α β) : f.comp (LocallyBoundedMap.id α) = f :=
ext fun _ => rfl
@[simp] | theorem | Topology | [
"Mathlib.Topology.Bornology.Basic"
] | Mathlib/Topology/Bornology/Hom.lean | comp_id | null |
id_comp (f : LocallyBoundedMap α β) : (LocallyBoundedMap.id β).comp f = f :=
ext fun _ => rfl
@[simp] | theorem | Topology | [
"Mathlib.Topology.Bornology.Basic"
] | Mathlib/Topology/Bornology/Hom.lean | id_comp | null |
cancel_right {g₁ g₂ : LocallyBoundedMap β γ} {f : LocallyBoundedMap α β}
(hf : Surjective f) : g₁.comp f = g₂.comp f ↔ g₁ = g₂ :=
⟨fun h => ext <| hf.forall.2 <| DFunLike.ext_iff.1 h, congrArg (comp · _)⟩
@[simp] | theorem | Topology | [
"Mathlib.Topology.Bornology.Basic"
] | Mathlib/Topology/Bornology/Hom.lean | cancel_right | null |
cancel_left {g : LocallyBoundedMap β γ} {f₁ f₂ : LocallyBoundedMap α β} (hg : Injective g) :
g.comp f₁ = g.comp f₂ ↔ f₁ = f₂ :=
⟨fun h => ext fun a => hg <| by rw [← comp_apply, h, comp_apply], congr_arg _⟩ | theorem | Topology | [
"Mathlib.Topology.Bornology.Basic"
] | Mathlib/Topology/Bornology/Hom.lean | cancel_left | null |
Real.instIsOrderBornology : IsOrderBornology ℝ :=
.of_isCompactIcc 0 (by simp [closedBall_eq_Icc]) (by simp [closedBall_eq_Icc]) | instance | Topology | [
"Mathlib.Topology.MetricSpace.Bounded",
"Mathlib.Topology.Order.Bornology"
] | Mathlib/Topology/Bornology/Real.lean | Real.instIsOrderBornology | null |
Born where
/-- The underlying bornology. -/
carrier : Type*
[str : Bornology carrier]
attribute [instance] Born.str | structure | Topology | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.Topology.Bornology.Hom"
] | Mathlib/Topology/Category/Born.lean | Born | The category of bornologies. |
of (α : Type*) [Bornology α] : Born where
carrier := α | abbrev | Topology | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.Topology.Bornology.Hom"
] | Mathlib/Topology/Category/Born.lean | of | Construct a bundled `Born` from a `Bornology`. |
CompactlyGenerated where
/-- The underlying topological space of an object of `CompactlyGenerated`. -/
toTop : TopCat.{w}
/-- The underlying topological space is compactly generated. -/
[is_compactly_generated : UCompactlyGeneratedSpace.{u} toTop] | structure | Topology | [
"Mathlib.Topology.Compactness.CompactlyGeneratedSpace",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/Topology/Category/CompactlyGenerated.lean | CompactlyGenerated | `CompactlyGenerated.{u, w}` is the type of `u`-compactly generated `w`-small topological spaces.
This should always be used with explicit universe parameters. |
of : CompactlyGenerated.{u, w} where
toTop := TopCat.of X
is_compactly_generated := ‹_› | abbrev | Topology | [
"Mathlib.Topology.Compactness.CompactlyGeneratedSpace",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/Topology/Category/CompactlyGenerated.lean | of | Constructor for objects of the category `CompactlyGenerated`. |
ofHom (f : C(X, Y)) : of X ⟶ of Y := ConcreteCategory.ofHom f | abbrev | Topology | [
"Mathlib.Topology.Compactness.CompactlyGeneratedSpace",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/Topology/Category/CompactlyGenerated.lean | ofHom | Typecheck a `ContinuousMap` as a morphism in `CompactlyGenerated`. |
@[simps!]
compactlyGeneratedToTop : CompactlyGenerated.{u, w} ⥤ TopCat.{w} :=
inducedFunctor _ | def | Topology | [
"Mathlib.Topology.Compactness.CompactlyGeneratedSpace",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/Topology/Category/CompactlyGenerated.lean | compactlyGeneratedToTop | The fully faithful embedding of `CompactlyGenerated` in `TopCat`. |
fullyFaithfulCompactlyGeneratedToTop : compactlyGeneratedToTop.{u, w}.FullyFaithful :=
fullyFaithfulInducedFunctor _ | def | Topology | [
"Mathlib.Topology.Compactness.CompactlyGeneratedSpace",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/Topology/Category/CompactlyGenerated.lean | fullyFaithfulCompactlyGeneratedToTop | `compactlyGeneratedToTop` is fully faithful. |
@[simps hom inv]
isoOfHomeo {X Y : CompactlyGenerated.{u, w}} (f : X ≃ₜ Y) : X ≅ Y where
hom := ofHom ⟨f, f.continuous⟩
inv := ofHom ⟨f.symm, f.symm.continuous⟩
hom_inv_id := by
ext x
exact f.symm_apply_apply x
inv_hom_id := by
ext x
exact f.apply_symm_apply x | def | Topology | [
"Mathlib.Topology.Compactness.CompactlyGeneratedSpace",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/Topology/Category/CompactlyGenerated.lean | isoOfHomeo | Construct an isomorphism from a homeomorphism. |
@[simps]
homeoOfIso {X Y : CompactlyGenerated.{u, w}} (f : X ≅ Y) : X ≃ₜ Y where
toFun := f.hom
invFun := f.inv
left_inv := f.hom_inv_id_apply
right_inv := f.inv_hom_id_apply
continuous_toFun := f.hom.hom.continuous
continuous_invFun := f.inv.hom.continuous | def | Topology | [
"Mathlib.Topology.Compactness.CompactlyGeneratedSpace",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/Topology/Category/CompactlyGenerated.lean | homeoOfIso | Construct a homeomorphism from an isomorphism. |
@[simps]
isoEquivHomeo {X Y : CompactlyGenerated.{u, w}} : (X ≅ Y) ≃ (X ≃ₜ Y) where
toFun := homeoOfIso
invFun := isoOfHomeo | def | Topology | [
"Mathlib.Topology.Compactness.CompactlyGeneratedSpace",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/Topology/Category/CompactlyGenerated.lean | isoEquivHomeo | The equivalence between isomorphisms in `CompactlyGenerated` and homeomorphisms
of topological spaces. |
Compactum :=
Monad.Algebra β deriving Category, Inhabited | def | Topology | [
"Mathlib.CategoryTheory.Monad.Types",
"Mathlib.CategoryTheory.Monad.Limits",
"Mathlib.CategoryTheory.Equivalence",
"Mathlib.Topology.Category.CompHaus.Basic",
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Data.Set.Constructions"
] | Mathlib/Topology/Category/Compactum.lean | Compactum | The type `Compactum` of Compacta, defined as algebras for the ultrafilter monad. |
forget : Compactum ⥤ Type* :=
Monad.forget _ | def | Topology | [
"Mathlib.CategoryTheory.Monad.Types",
"Mathlib.CategoryTheory.Monad.Limits",
"Mathlib.CategoryTheory.Equivalence",
"Mathlib.Topology.Category.CompHaus.Basic",
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Data.Set.Constructions"
] | Mathlib/Topology/Category/Compactum.lean | forget | The forgetful functor to Type* |
free : Type* ⥤ Compactum :=
Monad.free _ | def | Topology | [
"Mathlib.CategoryTheory.Monad.Types",
"Mathlib.CategoryTheory.Monad.Limits",
"Mathlib.CategoryTheory.Equivalence",
"Mathlib.Topology.Category.CompHaus.Basic",
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Data.Set.Constructions"
] | Mathlib/Topology/Category/Compactum.lean | free | The "free" Compactum functor. |
adj : free ⊣ forget :=
Monad.adj _ | def | Topology | [
"Mathlib.CategoryTheory.Monad.Types",
"Mathlib.CategoryTheory.Monad.Limits",
"Mathlib.CategoryTheory.Equivalence",
"Mathlib.Topology.Category.CompHaus.Basic",
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Data.Set.Constructions"
] | Mathlib/Topology/Category/Compactum.lean | adj | The adjunction between `free` and `forget`. |
str (X : Compactum) : Ultrafilter X → X :=
X.a | def | Topology | [
"Mathlib.CategoryTheory.Monad.Types",
"Mathlib.CategoryTheory.Monad.Limits",
"Mathlib.CategoryTheory.Equivalence",
"Mathlib.Topology.Category.CompHaus.Basic",
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Data.Set.Constructions"
] | Mathlib/Topology/Category/Compactum.lean | str | The structure map for a compactum, essentially sending an ultrafilter to its limit. |
join (X : Compactum) : Ultrafilter (Ultrafilter X) → Ultrafilter X :=
(β).μ.app _ | def | Topology | [
"Mathlib.CategoryTheory.Monad.Types",
"Mathlib.CategoryTheory.Monad.Limits",
"Mathlib.CategoryTheory.Equivalence",
"Mathlib.Topology.Category.CompHaus.Basic",
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Data.Set.Constructions"
] | Mathlib/Topology/Category/Compactum.lean | join | The monadic join. |
incl (X : Compactum) : X → Ultrafilter X :=
(β).η.app _
@[simp] | def | Topology | [
"Mathlib.CategoryTheory.Monad.Types",
"Mathlib.CategoryTheory.Monad.Limits",
"Mathlib.CategoryTheory.Equivalence",
"Mathlib.Topology.Category.CompHaus.Basic",
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Data.Set.Constructions"
] | Mathlib/Topology/Category/Compactum.lean | incl | The inclusion of `X` into `Ultrafilter X`. |
str_incl (X : Compactum) (x : X) : X.str (X.incl x) = x := by
change ((β).η.app _ ≫ X.a) _ = _
rw [Monad.Algebra.unit]
rfl
@[simp] | theorem | Topology | [
"Mathlib.CategoryTheory.Monad.Types",
"Mathlib.CategoryTheory.Monad.Limits",
"Mathlib.CategoryTheory.Equivalence",
"Mathlib.Topology.Category.CompHaus.Basic",
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Data.Set.Constructions"
] | Mathlib/Topology/Category/Compactum.lean | str_incl | null |
str_hom_commute (X Y : Compactum) (f : X ⟶ Y) (xs : Ultrafilter X) :
f (X.str xs) = Y.str (map f xs) := by
change (X.a ≫ f.f) _ = _
rw [← f.h]
rfl
@[simp] | theorem | Topology | [
"Mathlib.CategoryTheory.Monad.Types",
"Mathlib.CategoryTheory.Monad.Limits",
"Mathlib.CategoryTheory.Equivalence",
"Mathlib.Topology.Category.CompHaus.Basic",
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Data.Set.Constructions"
] | Mathlib/Topology/Category/Compactum.lean | str_hom_commute | null |
join_distrib (X : Compactum) (uux : Ultrafilter (Ultrafilter X)) :
X.str (X.join uux) = X.str (map X.str uux) := by
change ((β).μ.app _ ≫ X.a) _ = _
rw [Monad.Algebra.assoc]
rfl | theorem | Topology | [
"Mathlib.CategoryTheory.Monad.Types",
"Mathlib.CategoryTheory.Monad.Limits",
"Mathlib.CategoryTheory.Equivalence",
"Mathlib.Topology.Category.CompHaus.Basic",
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Data.Set.Constructions"
] | Mathlib/Topology/Category/Compactum.lean | join_distrib | null |
isClosed_iff {X : Compactum} (S : Set X) :
IsClosed S ↔ ∀ F : Ultrafilter X, S ∈ F → X.str F ∈ S := by
rw [← isOpen_compl_iff]
constructor
· intro cond F h
by_contra c
specialize cond F c
rw [compl_mem_iff_notMem] at cond
contradiction
· intro h1 F h2
specialize h1 F
rcases F.mem_or_compl_mem S with h | h
exacts [absurd (h1 h) h2, h] | theorem | Topology | [
"Mathlib.CategoryTheory.Monad.Types",
"Mathlib.CategoryTheory.Monad.Limits",
"Mathlib.CategoryTheory.Equivalence",
"Mathlib.Topology.Category.CompHaus.Basic",
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Data.Set.Constructions"
] | Mathlib/Topology/Category/Compactum.lean | isClosed_iff | null |
private basic {X : Compactum} (A : Set X) : Set (Ultrafilter X) :=
{ F | A ∈ F } | def | Topology | [
"Mathlib.CategoryTheory.Monad.Types",
"Mathlib.CategoryTheory.Monad.Limits",
"Mathlib.CategoryTheory.Equivalence",
"Mathlib.Topology.Category.CompHaus.Basic",
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Data.Set.Constructions"
] | Mathlib/Topology/Category/Compactum.lean | basic | A local definition used only in the proofs. |
private cl {X : Compactum} (A : Set X) : Set X :=
X.str '' basic A | def | Topology | [
"Mathlib.CategoryTheory.Monad.Types",
"Mathlib.CategoryTheory.Monad.Limits",
"Mathlib.CategoryTheory.Equivalence",
"Mathlib.Topology.Category.CompHaus.Basic",
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Data.Set.Constructions"
] | Mathlib/Topology/Category/Compactum.lean | cl | A local definition used only in the proofs. |
private basic_inter {X : Compactum} (A B : Set X) : basic (A ∩ B) = basic A ∩ basic B := by
ext G
constructor
· intro hG
constructor <;> filter_upwards [hG] with _
exacts [And.left, And.right]
· rintro ⟨h1, h2⟩
exact inter_mem h1 h2 | theorem | Topology | [
"Mathlib.CategoryTheory.Monad.Types",
"Mathlib.CategoryTheory.Monad.Limits",
"Mathlib.CategoryTheory.Equivalence",
"Mathlib.Topology.Category.CompHaus.Basic",
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Data.Set.Constructions"
] | Mathlib/Topology/Category/Compactum.lean | basic_inter | null |
private subset_cl {X : Compactum} (A : Set X) : A ⊆ cl A := fun a ha =>
⟨X.incl a, ha, by simp⟩ | theorem | Topology | [
"Mathlib.CategoryTheory.Monad.Types",
"Mathlib.CategoryTheory.Monad.Limits",
"Mathlib.CategoryTheory.Equivalence",
"Mathlib.Topology.Category.CompHaus.Basic",
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Data.Set.Constructions"
] | Mathlib/Topology/Category/Compactum.lean | subset_cl | null |
private cl_cl {X : Compactum} (A : Set X) : cl (cl A) ⊆ cl A := by
rintro _ ⟨F, hF, rfl⟩
let fsu := Finset (Set (Ultrafilter X))
let ssu := Set (Set (Ultrafilter X))
let ι : fsu → ssu := fun x ↦ ↑x
let C0 : ssu := { Z | ∃ B ∈ F, X.str ⁻¹' B = Z }
let AA := { G : Ultrafilter X | A ∈ G }
let C1 := insert AA C0
let C2 := finiteInterClosure C1
have claim1 : ∀ (B) (_ : B ∈ C0) (C) (_ : C ∈ C0), B ∩ C ∈ C0 := by
rintro B ⟨Q, hQ, rfl⟩ C ⟨R, hR, rfl⟩
use Q ∩ R
simp only [and_true, Set.preimage_inter]
exact inter_sets _ hQ hR
have claim2 : ∀ B ∈ C0, Set.Nonempty B := by
rintro B ⟨Q, hQ, rfl⟩
obtain ⟨q⟩ := Filter.nonempty_of_mem hQ
use X.incl q
simpa
have claim3 : ∀ B ∈ C0, (AA ∩ B).Nonempty := by
rintro B ⟨Q, hQ, rfl⟩
have : (Q ∩ cl A).Nonempty := Filter.nonempty_of_mem (inter_mem hQ hF)
rcases this with ⟨q, hq1, P, hq2, hq3⟩
refine ⟨P, hq2, ?_⟩
rw [← hq3] at hq1
simpa
suffices ∀ T : fsu, ι T ⊆ C1 → (⋂₀ ι T).Nonempty by
obtain ⟨G, h1⟩ := exists_ultrafilter_of_finite_inter_nonempty _ this
use X.join G
have : G.map X.str = F := Ultrafilter.coe_le_coe.1 fun S hS => h1 (Or.inr ⟨S, hS, rfl⟩)
rw [join_distrib, this]
exact ⟨h1 (Or.inl rfl), rfl⟩
have claim4 := finiteInterClosure_finiteInter C1
have claim5 : FiniteInter C0 := ⟨⟨_, univ_mem, Set.preimage_univ⟩, claim1⟩
have claim6 : ∀ P ∈ C2, (P : Set (Ultrafilter X)).Nonempty := by
suffices ∀ P ∈ C2, P ∈ C0 ∨ ∃ Q ∈ C0, P = AA ∩ Q by
intro P hP
rcases this P hP with h | h
· exact claim2 _ h
· rcases h with ⟨Q, hQ, rfl⟩
exact claim3 _ hQ
intro P hP
exact claim5.finiteInterClosure_insert _ hP
intro T hT
suffices ⋂₀ ι T ∈ C2 by exact claim6 _ this
apply claim4.finiteInter_mem T
intro t ht
exact finiteInterClosure.basic (@hT t ht) | theorem | Topology | [
"Mathlib.CategoryTheory.Monad.Types",
"Mathlib.CategoryTheory.Monad.Limits",
"Mathlib.CategoryTheory.Equivalence",
"Mathlib.Topology.Category.CompHaus.Basic",
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Data.Set.Constructions"
] | Mathlib/Topology/Category/Compactum.lean | cl_cl | null |
isClosed_cl {X : Compactum} (A : Set X) : IsClosed (cl A) := by
rw [isClosed_iff]
intro F hF
exact cl_cl _ ⟨F, hF, rfl⟩ | theorem | Topology | [
"Mathlib.CategoryTheory.Monad.Types",
"Mathlib.CategoryTheory.Monad.Limits",
"Mathlib.CategoryTheory.Equivalence",
"Mathlib.Topology.Category.CompHaus.Basic",
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Data.Set.Constructions"
] | Mathlib/Topology/Category/Compactum.lean | isClosed_cl | null |
str_eq_of_le_nhds {X : Compactum} (F : Ultrafilter X) (x : X) : ↑F ≤ 𝓝 x → X.str F = x := by
let fsu := Finset (Set (Ultrafilter X))
let ssu := Set (Set (Ultrafilter X))
let ι : fsu → ssu := fun x ↦ ↑x
let T0 : ssu := { S | ∃ A ∈ F, S = basic A }
let AA := X.str ⁻¹' {x}
let T1 := insert AA T0
let T2 := finiteInterClosure T1
intro cond
have claim1 : ∀ A : Set X, IsClosed A → A ∈ F → x ∈ A := by
intro A hA h
by_contra H
rw [le_nhds_iff] at cond
specialize cond Aᶜ H hA.isOpen_compl
rw [Ultrafilter.mem_coe, Ultrafilter.compl_mem_iff_notMem] at cond
contradiction
have claim2 : ∀ A : Set X, A ∈ F → x ∈ cl A := by
intro A hA
exact claim1 (cl A) (isClosed_cl A) (mem_of_superset hA (subset_cl A))
have claim3 : ∀ (S1) (_ : S1 ∈ T0) (S2) (_ : S2 ∈ T0), S1 ∩ S2 ∈ T0 := by
rintro S1 ⟨S1, hS1, rfl⟩ S2 ⟨S2, hS2, rfl⟩
exact ⟨S1 ∩ S2, inter_mem hS1 hS2, by simp [basic_inter]⟩
have claim4 : ∀ S ∈ T0, (AA ∩ S).Nonempty := by
rintro S ⟨S, hS, rfl⟩
rcases claim2 _ hS with ⟨G, hG, hG2⟩
exact ⟨G, hG2, hG⟩
have claim5 : ∀ S ∈ T0, Set.Nonempty S := by
rintro S ⟨S, hS, rfl⟩
exact ⟨F, hS⟩
have claim6 : ∀ S ∈ T2, Set.Nonempty S := by
suffices ∀ S ∈ T2, S ∈ T0 ∨ ∃ Q ∈ T0, S = AA ∩ Q by
intro S hS
rcases this _ hS with h | h
· exact claim5 S h
· rcases h with ⟨Q, hQ, rfl⟩
exact claim4 Q hQ
intro S hS
apply finiteInterClosure_insert
· constructor
· use Set.univ
refine ⟨Filter.univ_sets _, ?_⟩
ext
refine ⟨?_, by tauto⟩
· intro
apply Filter.univ_sets
· exact claim3
· exact hS
suffices ∀ F : fsu, ↑F ⊆ T1 → (⋂₀ ι F).Nonempty by
obtain ⟨G, h1⟩ := Ultrafilter.exists_ultrafilter_of_finite_inter_nonempty _ this
have c1 : X.join G = F := Ultrafilter.coe_le_coe.1 fun P hP => h1 (Or.inr ⟨P, hP, rfl⟩)
have c2 : G.map X.str = X.incl x := by
... | theorem | Topology | [
"Mathlib.CategoryTheory.Monad.Types",
"Mathlib.CategoryTheory.Monad.Limits",
"Mathlib.CategoryTheory.Equivalence",
"Mathlib.Topology.Category.CompHaus.Basic",
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Data.Set.Constructions"
] | Mathlib/Topology/Category/Compactum.lean | str_eq_of_le_nhds | null |
le_nhds_of_str_eq {X : Compactum} (F : Ultrafilter X) (x : X) : X.str F = x → ↑F ≤ 𝓝 x :=
fun h => le_nhds_iff.mpr fun s hx hs => hs _ <| by rwa [h] | theorem | Topology | [
"Mathlib.CategoryTheory.Monad.Types",
"Mathlib.CategoryTheory.Monad.Limits",
"Mathlib.CategoryTheory.Equivalence",
"Mathlib.Topology.Category.CompHaus.Basic",
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Data.Set.Constructions"
] | Mathlib/Topology/Category/Compactum.lean | le_nhds_of_str_eq | null |
lim_eq_str {X : Compactum} (F : Ultrafilter X) : F.lim = X.str F := by
rw [Ultrafilter.lim_eq_iff_le_nhds, le_nhds_iff]
tauto | theorem | Topology | [
"Mathlib.CategoryTheory.Monad.Types",
"Mathlib.CategoryTheory.Monad.Limits",
"Mathlib.CategoryTheory.Equivalence",
"Mathlib.Topology.Category.CompHaus.Basic",
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Data.Set.Constructions"
] | Mathlib/Topology/Category/Compactum.lean | lim_eq_str | The structure map of a compactum actually computes limits. |
cl_eq_closure {X : Compactum} (A : Set X) : cl A = closure A := by
ext
rw [mem_closure_iff_ultrafilter]
constructor
· rintro ⟨F, h1, h2⟩
exact ⟨F, h1, le_nhds_of_str_eq _ _ h2⟩
· rintro ⟨F, h1, h2⟩
exact ⟨F, h1, str_eq_of_le_nhds _ _ h2⟩ | theorem | Topology | [
"Mathlib.CategoryTheory.Monad.Types",
"Mathlib.CategoryTheory.Monad.Limits",
"Mathlib.CategoryTheory.Equivalence",
"Mathlib.Topology.Category.CompHaus.Basic",
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Data.Set.Constructions"
] | Mathlib/Topology/Category/Compactum.lean | cl_eq_closure | null |
continuous_of_hom {X Y : Compactum} (f : X ⟶ Y) : Continuous f := by
rw [continuous_iff_ultrafilter]
intro x g h
rw [Tendsto, ← coe_map]
apply le_nhds_of_str_eq
rw [← str_hom_commute, str_eq_of_le_nhds _ x _]
apply h | theorem | Topology | [
"Mathlib.CategoryTheory.Monad.Types",
"Mathlib.CategoryTheory.Monad.Limits",
"Mathlib.CategoryTheory.Equivalence",
"Mathlib.Topology.Category.CompHaus.Basic",
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Data.Set.Constructions"
] | Mathlib/Topology/Category/Compactum.lean | continuous_of_hom | Any morphism of compacta is continuous. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.