Context stringlengths 57 6.04k | file_name stringlengths 21 79 | start int64 14 1.49k | end int64 18 1.5k | theorem stringlengths 25 1.55k | proof stringlengths 5 7.36k | rank int64 0 2.4k |
|---|---|---|---|---|---|---|
import Mathlib.Order.ConditionallyCompleteLattice.Basic
import Mathlib.Data.Int.LeastGreatest
#align_import data.int.conditionally_complete_order from "leanprover-community/mathlib"@"1e05171a5e8cf18d98d9cf7b207540acb044acae"
open Int
noncomputable section
open scoped Classical
instance instConditionallyCompleteLinearOrder : ConditionallyCompleteLinearOrder β€ where
__ := instLinearOrder
__ := LinearOrder.toLattice
sSup s :=
if h : s.Nonempty β§ BddAbove s then
greatestOfBdd (Classical.choose h.2) (Classical.choose_spec h.2) h.1
else 0
sInf s :=
if h : s.Nonempty β§ BddBelow s then
leastOfBdd (Classical.choose h.2) (Classical.choose_spec h.2) h.1
else 0
le_csSup s n hs hns := by
have : s.Nonempty β§ BddAbove s := β¨β¨n, hnsβ©, hsβ©
-- Porting note: this was `rw [dif_pos this]`
simp only [this, and_self, dite_true, ge_iff_le]
exact (greatestOfBdd _ _ _).2.2 n hns
csSup_le s n hs hns := by
have : s.Nonempty β§ BddAbove s := β¨hs, β¨n, hnsβ©β©
-- Porting note: this was `rw [dif_pos this]`
simp only [this, and_self, dite_true, ge_iff_le]
exact hns (greatestOfBdd _ (Classical.choose_spec this.2) _).2.1
csInf_le s n hs hns := by
have : s.Nonempty β§ BddBelow s := β¨β¨n, hnsβ©, hsβ©
-- Porting note: this was `rw [dif_pos this]`
simp only [this, and_self, dite_true, ge_iff_le]
exact (leastOfBdd _ _ _).2.2 n hns
le_csInf s n hs hns := by
have : s.Nonempty β§ BddBelow s := β¨hs, β¨n, hnsβ©β©
-- Porting note: this was `rw [dif_pos this]`
simp only [this, and_self, dite_true, ge_iff_le]
exact hns (leastOfBdd _ (Classical.choose_spec this.2) _).2.1
csSup_of_not_bddAbove := fun s hs β¦ by simp [hs]
csInf_of_not_bddBelow := fun s hs β¦ by simp [hs]
namespace Int
-- Porting note: mathlib3 proof uses `convert dif_pos _ using 1`
theorem csSup_eq_greatest_of_bdd {s : Set β€} [DecidablePred (Β· β s)] (b : β€) (Hb : β z β s, z β€ b)
(Hinh : β z : β€, z β s) : sSup s = greatestOfBdd b Hb Hinh := by
have : s.Nonempty β§ BddAbove s := β¨Hinh, b, Hbβ©
simp only [sSup, this, and_self, dite_true]
convert (coe_greatestOfBdd_eq Hb (Classical.choose_spec (β¨b, Hbβ© : BddAbove s)) Hinh).symm
#align int.cSup_eq_greatest_of_bdd Int.csSup_eq_greatest_of_bdd
@[simp]
theorem csSup_empty : sSup (β
: Set β€) = 0 :=
dif_neg (by simp)
#align int.cSup_empty Int.csSup_empty
theorem csSup_of_not_bdd_above {s : Set β€} (h : Β¬BddAbove s) : sSup s = 0 :=
dif_neg (by simp [h])
#align int.cSup_of_not_bdd_above Int.csSup_of_not_bdd_above
-- Porting note: mathlib3 proof uses `convert dif_pos _ using 1`
theorem csInf_eq_least_of_bdd {s : Set β€} [DecidablePred (Β· β s)] (b : β€) (Hb : β z β s, b β€ z)
(Hinh : β z : β€, z β s) : sInf s = leastOfBdd b Hb Hinh := by
have : s.Nonempty β§ BddBelow s := β¨Hinh, b, Hbβ©
simp only [sInf, this, and_self, dite_true]
convert (coe_leastOfBdd_eq Hb (Classical.choose_spec (β¨b, Hbβ© : BddBelow s)) Hinh).symm
#align int.cInf_eq_least_of_bdd Int.csInf_eq_least_of_bdd
@[simp]
theorem csInf_empty : sInf (β
: Set β€) = 0 :=
dif_neg (by simp)
#align int.cInf_empty Int.csInf_empty
theorem csInf_of_not_bdd_below {s : Set β€} (h : Β¬BddBelow s) : sInf s = 0 :=
dif_neg (by simp [h])
#align int.cInf_of_not_bdd_below Int.csInf_of_not_bdd_below
theorem csSup_mem {s : Set β€} (h1 : s.Nonempty) (h2 : BddAbove s) : sSup s β s := by
convert (greatestOfBdd _ (Classical.choose_spec h2) h1).2.1
exact dif_pos β¨h1, h2β©
#align int.cSup_mem Int.csSup_mem
| Mathlib/Data/Int/ConditionallyCompleteOrder.lean | 99 | 101 | theorem csInf_mem {s : Set β€} (h1 : s.Nonempty) (h2 : BddBelow s) : sInf s β s := by |
convert (leastOfBdd _ (Classical.choose_spec h2) h1).2.1
exact dif_pos β¨h1, h2β©
| 1,104 |
import Mathlib.Order.Filter.Bases
import Mathlib.Order.ConditionallyCompleteLattice.Basic
#align_import order.filter.lift from "leanprover-community/mathlib"@"8631e2d5ea77f6c13054d9151d82b83069680cb1"
open Set Classical Filter Function
namespace Filter
variable {Ξ± Ξ² Ξ³ : Type*} {ΞΉ : Sort*}
section lift
protected def lift (f : Filter Ξ±) (g : Set Ξ± β Filter Ξ²) :=
β¨
s β f, g s
#align filter.lift Filter.lift
variable {f fβ fβ : Filter Ξ±} {g gβ gβ : Set Ξ± β Filter Ξ²}
@[simp]
| Mathlib/Order/Filter/Lift.lean | 32 | 32 | theorem lift_top (g : Set Ξ± β Filter Ξ²) : (β€ : Filter Ξ±).lift g = g univ := by | simp [Filter.lift]
| 1,105 |
import Mathlib.Order.Filter.Bases
import Mathlib.Order.ConditionallyCompleteLattice.Basic
#align_import order.filter.lift from "leanprover-community/mathlib"@"8631e2d5ea77f6c13054d9151d82b83069680cb1"
open Set Classical Filter Function
namespace Filter
variable {Ξ± Ξ² Ξ³ : Type*} {ΞΉ : Sort*}
section lift
protected def lift (f : Filter Ξ±) (g : Set Ξ± β Filter Ξ²) :=
β¨
s β f, g s
#align filter.lift Filter.lift
variable {f fβ fβ : Filter Ξ±} {g gβ gβ : Set Ξ± β Filter Ξ²}
@[simp]
theorem lift_top (g : Set Ξ± β Filter Ξ²) : (β€ : Filter Ξ±).lift g = g univ := by simp [Filter.lift]
#align filter.lift_top Filter.lift_top
-- Porting note: use `β i, p i β§ _` instead of `β i (hi : p i), _`
| Mathlib/Order/Filter/Lift.lean | 45 | 53 | theorem HasBasis.mem_lift_iff {ΞΉ} {p : ΞΉ β Prop} {s : ΞΉ β Set Ξ±} {f : Filter Ξ±}
(hf : f.HasBasis p s) {Ξ² : ΞΉ β Type*} {pg : β i, Ξ² i β Prop} {sg : β i, Ξ² i β Set Ξ³}
{g : Set Ξ± β Filter Ξ³} (hg : β i, (g <| s i).HasBasis (pg i) (sg i)) (gm : Monotone g)
{s : Set Ξ³} : s β f.lift g β β i, p i β§ β x, pg i x β§ sg i x β s := by |
refine (mem_biInf_of_directed ?_ β¨univ, univ_sets _β©).trans ?_
Β· intro tβ htβ tβ htβ
exact β¨tβ β© tβ, inter_mem htβ htβ, gm inter_subset_left, gm inter_subset_rightβ©
Β· simp only [β (hg _).mem_iff]
exact hf.exists_iff fun tβ tβ ht H => gm ht H
| 1,105 |
import Mathlib.Order.Filter.Bases
import Mathlib.Order.ConditionallyCompleteLattice.Basic
#align_import order.filter.lift from "leanprover-community/mathlib"@"8631e2d5ea77f6c13054d9151d82b83069680cb1"
open Set Classical Filter Function
namespace Filter
variable {Ξ± Ξ² Ξ³ : Type*} {ΞΉ : Sort*}
section lift
protected def lift (f : Filter Ξ±) (g : Set Ξ± β Filter Ξ²) :=
β¨
s β f, g s
#align filter.lift Filter.lift
variable {f fβ fβ : Filter Ξ±} {g gβ gβ : Set Ξ± β Filter Ξ²}
@[simp]
theorem lift_top (g : Set Ξ± β Filter Ξ²) : (β€ : Filter Ξ±).lift g = g univ := by simp [Filter.lift]
#align filter.lift_top Filter.lift_top
-- Porting note: use `β i, p i β§ _` instead of `β i (hi : p i), _`
theorem HasBasis.mem_lift_iff {ΞΉ} {p : ΞΉ β Prop} {s : ΞΉ β Set Ξ±} {f : Filter Ξ±}
(hf : f.HasBasis p s) {Ξ² : ΞΉ β Type*} {pg : β i, Ξ² i β Prop} {sg : β i, Ξ² i β Set Ξ³}
{g : Set Ξ± β Filter Ξ³} (hg : β i, (g <| s i).HasBasis (pg i) (sg i)) (gm : Monotone g)
{s : Set Ξ³} : s β f.lift g β β i, p i β§ β x, pg i x β§ sg i x β s := by
refine (mem_biInf_of_directed ?_ β¨univ, univ_sets _β©).trans ?_
Β· intro tβ htβ tβ htβ
exact β¨tβ β© tβ, inter_mem htβ htβ, gm inter_subset_left, gm inter_subset_rightβ©
Β· simp only [β (hg _).mem_iff]
exact hf.exists_iff fun tβ tβ ht H => gm ht H
#align filter.has_basis.mem_lift_iff Filter.HasBasis.mem_lift_iffβ
| Mathlib/Order/Filter/Lift.lean | 65 | 70 | theorem HasBasis.lift {ΞΉ} {p : ΞΉ β Prop} {s : ΞΉ β Set Ξ±} {f : Filter Ξ±} (hf : f.HasBasis p s)
{Ξ² : ΞΉ β Type*} {pg : β i, Ξ² i β Prop} {sg : β i, Ξ² i β Set Ξ³} {g : Set Ξ± β Filter Ξ³}
(hg : β i, (g (s i)).HasBasis (pg i) (sg i)) (gm : Monotone g) :
(f.lift g).HasBasis (fun i : Ξ£i, Ξ² i => p i.1 β§ pg i.1 i.2) fun i : Ξ£i, Ξ² i => sg i.1 i.2 := by |
refine β¨fun t => (hf.mem_lift_iff hg gm).trans ?_β©
simp [Sigma.exists, and_assoc, exists_and_left]
| 1,105 |
import Mathlib.Order.Filter.Bases
import Mathlib.Order.ConditionallyCompleteLattice.Basic
#align_import order.filter.lift from "leanprover-community/mathlib"@"8631e2d5ea77f6c13054d9151d82b83069680cb1"
open Set Classical Filter Function
namespace Filter
variable {Ξ± Ξ² Ξ³ : Type*} {ΞΉ : Sort*}
section lift
protected def lift (f : Filter Ξ±) (g : Set Ξ± β Filter Ξ²) :=
β¨
s β f, g s
#align filter.lift Filter.lift
variable {f fβ fβ : Filter Ξ±} {g gβ gβ : Set Ξ± β Filter Ξ²}
@[simp]
theorem lift_top (g : Set Ξ± β Filter Ξ²) : (β€ : Filter Ξ±).lift g = g univ := by simp [Filter.lift]
#align filter.lift_top Filter.lift_top
-- Porting note: use `β i, p i β§ _` instead of `β i (hi : p i), _`
theorem HasBasis.mem_lift_iff {ΞΉ} {p : ΞΉ β Prop} {s : ΞΉ β Set Ξ±} {f : Filter Ξ±}
(hf : f.HasBasis p s) {Ξ² : ΞΉ β Type*} {pg : β i, Ξ² i β Prop} {sg : β i, Ξ² i β Set Ξ³}
{g : Set Ξ± β Filter Ξ³} (hg : β i, (g <| s i).HasBasis (pg i) (sg i)) (gm : Monotone g)
{s : Set Ξ³} : s β f.lift g β β i, p i β§ β x, pg i x β§ sg i x β s := by
refine (mem_biInf_of_directed ?_ β¨univ, univ_sets _β©).trans ?_
Β· intro tβ htβ tβ htβ
exact β¨tβ β© tβ, inter_mem htβ htβ, gm inter_subset_left, gm inter_subset_rightβ©
Β· simp only [β (hg _).mem_iff]
exact hf.exists_iff fun tβ tβ ht H => gm ht H
#align filter.has_basis.mem_lift_iff Filter.HasBasis.mem_lift_iffβ
theorem HasBasis.lift {ΞΉ} {p : ΞΉ β Prop} {s : ΞΉ β Set Ξ±} {f : Filter Ξ±} (hf : f.HasBasis p s)
{Ξ² : ΞΉ β Type*} {pg : β i, Ξ² i β Prop} {sg : β i, Ξ² i β Set Ξ³} {g : Set Ξ± β Filter Ξ³}
(hg : β i, (g (s i)).HasBasis (pg i) (sg i)) (gm : Monotone g) :
(f.lift g).HasBasis (fun i : Ξ£i, Ξ² i => p i.1 β§ pg i.1 i.2) fun i : Ξ£i, Ξ² i => sg i.1 i.2 := by
refine β¨fun t => (hf.mem_lift_iff hg gm).trans ?_β©
simp [Sigma.exists, and_assoc, exists_and_left]
#align filter.has_basis.lift Filter.HasBasis.lift
theorem mem_lift_sets (hg : Monotone g) {s : Set Ξ²} : s β f.lift g β β t β f, s β g t :=
(f.basis_sets.mem_lift_iff (fun s => (g s).basis_sets) hg).trans <| by
simp only [id, exists_mem_subset_iff]
#align filter.mem_lift_sets Filter.mem_lift_sets
| Mathlib/Order/Filter/Lift.lean | 78 | 81 | theorem sInter_lift_sets (hg : Monotone g) :
ββ { s | s β f.lift g } = β s β f, ββ { t | t β g s } := by |
simp only [sInter_eq_biInter, mem_setOf_eq, Filter.mem_sets, mem_lift_sets hg, iInter_exists,
iInter_and, @iInter_comm _ (Set Ξ²)]
| 1,105 |
import Mathlib.Order.Filter.Bases
import Mathlib.Order.ConditionallyCompleteLattice.Basic
#align_import order.filter.lift from "leanprover-community/mathlib"@"8631e2d5ea77f6c13054d9151d82b83069680cb1"
open Set Classical Filter Function
namespace Filter
variable {Ξ± Ξ² Ξ³ : Type*} {ΞΉ : Sort*}
section lift
protected def lift (f : Filter Ξ±) (g : Set Ξ± β Filter Ξ²) :=
β¨
s β f, g s
#align filter.lift Filter.lift
variable {f fβ fβ : Filter Ξ±} {g gβ gβ : Set Ξ± β Filter Ξ²}
@[simp]
theorem lift_top (g : Set Ξ± β Filter Ξ²) : (β€ : Filter Ξ±).lift g = g univ := by simp [Filter.lift]
#align filter.lift_top Filter.lift_top
-- Porting note: use `β i, p i β§ _` instead of `β i (hi : p i), _`
theorem HasBasis.mem_lift_iff {ΞΉ} {p : ΞΉ β Prop} {s : ΞΉ β Set Ξ±} {f : Filter Ξ±}
(hf : f.HasBasis p s) {Ξ² : ΞΉ β Type*} {pg : β i, Ξ² i β Prop} {sg : β i, Ξ² i β Set Ξ³}
{g : Set Ξ± β Filter Ξ³} (hg : β i, (g <| s i).HasBasis (pg i) (sg i)) (gm : Monotone g)
{s : Set Ξ³} : s β f.lift g β β i, p i β§ β x, pg i x β§ sg i x β s := by
refine (mem_biInf_of_directed ?_ β¨univ, univ_sets _β©).trans ?_
Β· intro tβ htβ tβ htβ
exact β¨tβ β© tβ, inter_mem htβ htβ, gm inter_subset_left, gm inter_subset_rightβ©
Β· simp only [β (hg _).mem_iff]
exact hf.exists_iff fun tβ tβ ht H => gm ht H
#align filter.has_basis.mem_lift_iff Filter.HasBasis.mem_lift_iffβ
theorem HasBasis.lift {ΞΉ} {p : ΞΉ β Prop} {s : ΞΉ β Set Ξ±} {f : Filter Ξ±} (hf : f.HasBasis p s)
{Ξ² : ΞΉ β Type*} {pg : β i, Ξ² i β Prop} {sg : β i, Ξ² i β Set Ξ³} {g : Set Ξ± β Filter Ξ³}
(hg : β i, (g (s i)).HasBasis (pg i) (sg i)) (gm : Monotone g) :
(f.lift g).HasBasis (fun i : Ξ£i, Ξ² i => p i.1 β§ pg i.1 i.2) fun i : Ξ£i, Ξ² i => sg i.1 i.2 := by
refine β¨fun t => (hf.mem_lift_iff hg gm).trans ?_β©
simp [Sigma.exists, and_assoc, exists_and_left]
#align filter.has_basis.lift Filter.HasBasis.lift
theorem mem_lift_sets (hg : Monotone g) {s : Set Ξ²} : s β f.lift g β β t β f, s β g t :=
(f.basis_sets.mem_lift_iff (fun s => (g s).basis_sets) hg).trans <| by
simp only [id, exists_mem_subset_iff]
#align filter.mem_lift_sets Filter.mem_lift_sets
theorem sInter_lift_sets (hg : Monotone g) :
ββ { s | s β f.lift g } = β s β f, ββ { t | t β g s } := by
simp only [sInter_eq_biInter, mem_setOf_eq, Filter.mem_sets, mem_lift_sets hg, iInter_exists,
iInter_and, @iInter_comm _ (Set Ξ²)]
#align filter.sInter_lift_sets Filter.sInter_lift_sets
theorem mem_lift {s : Set Ξ²} {t : Set Ξ±} (ht : t β f) (hs : s β g t) : s β f.lift g :=
le_principal_iff.mp <|
show f.lift g β€ π s from iInf_le_of_le t <| iInf_le_of_le ht <| le_principal_iff.mpr hs
#align filter.mem_lift Filter.mem_lift
theorem lift_le {f : Filter Ξ±} {g : Set Ξ± β Filter Ξ²} {h : Filter Ξ²} {s : Set Ξ±} (hs : s β f)
(hg : g s β€ h) : f.lift g β€ h :=
iInfβ_le_of_le s hs hg
#align filter.lift_le Filter.lift_le
theorem le_lift {f : Filter Ξ±} {g : Set Ξ± β Filter Ξ²} {h : Filter Ξ²} :
h β€ f.lift g β β s β f, h β€ g s :=
le_iInfβ_iff
#align filter.le_lift Filter.le_lift
theorem lift_mono (hf : fβ β€ fβ) (hg : gβ β€ gβ) : fβ.lift gβ β€ fβ.lift gβ :=
iInf_mono fun s => iInf_mono' fun hs => β¨hf hs, hg sβ©
#align filter.lift_mono Filter.lift_mono
theorem lift_mono' (hg : β s β f, gβ s β€ gβ s) : f.lift gβ β€ f.lift gβ := iInfβ_mono hg
#align filter.lift_mono' Filter.lift_mono'
| Mathlib/Order/Filter/Lift.lean | 106 | 108 | theorem tendsto_lift {m : Ξ³ β Ξ²} {l : Filter Ξ³} :
Tendsto m l (f.lift g) β β s β f, Tendsto m l (g s) := by |
simp only [Filter.lift, tendsto_iInf]
| 1,105 |
import Mathlib.Order.Filter.Bases
import Mathlib.Order.ConditionallyCompleteLattice.Basic
#align_import order.filter.lift from "leanprover-community/mathlib"@"8631e2d5ea77f6c13054d9151d82b83069680cb1"
open Set Classical Filter Function
namespace Filter
variable {Ξ± Ξ² Ξ³ : Type*} {ΞΉ : Sort*}
section lift
protected def lift (f : Filter Ξ±) (g : Set Ξ± β Filter Ξ²) :=
β¨
s β f, g s
#align filter.lift Filter.lift
variable {f fβ fβ : Filter Ξ±} {g gβ gβ : Set Ξ± β Filter Ξ²}
@[simp]
theorem lift_top (g : Set Ξ± β Filter Ξ²) : (β€ : Filter Ξ±).lift g = g univ := by simp [Filter.lift]
#align filter.lift_top Filter.lift_top
-- Porting note: use `β i, p i β§ _` instead of `β i (hi : p i), _`
theorem HasBasis.mem_lift_iff {ΞΉ} {p : ΞΉ β Prop} {s : ΞΉ β Set Ξ±} {f : Filter Ξ±}
(hf : f.HasBasis p s) {Ξ² : ΞΉ β Type*} {pg : β i, Ξ² i β Prop} {sg : β i, Ξ² i β Set Ξ³}
{g : Set Ξ± β Filter Ξ³} (hg : β i, (g <| s i).HasBasis (pg i) (sg i)) (gm : Monotone g)
{s : Set Ξ³} : s β f.lift g β β i, p i β§ β x, pg i x β§ sg i x β s := by
refine (mem_biInf_of_directed ?_ β¨univ, univ_sets _β©).trans ?_
Β· intro tβ htβ tβ htβ
exact β¨tβ β© tβ, inter_mem htβ htβ, gm inter_subset_left, gm inter_subset_rightβ©
Β· simp only [β (hg _).mem_iff]
exact hf.exists_iff fun tβ tβ ht H => gm ht H
#align filter.has_basis.mem_lift_iff Filter.HasBasis.mem_lift_iffβ
theorem HasBasis.lift {ΞΉ} {p : ΞΉ β Prop} {s : ΞΉ β Set Ξ±} {f : Filter Ξ±} (hf : f.HasBasis p s)
{Ξ² : ΞΉ β Type*} {pg : β i, Ξ² i β Prop} {sg : β i, Ξ² i β Set Ξ³} {g : Set Ξ± β Filter Ξ³}
(hg : β i, (g (s i)).HasBasis (pg i) (sg i)) (gm : Monotone g) :
(f.lift g).HasBasis (fun i : Ξ£i, Ξ² i => p i.1 β§ pg i.1 i.2) fun i : Ξ£i, Ξ² i => sg i.1 i.2 := by
refine β¨fun t => (hf.mem_lift_iff hg gm).trans ?_β©
simp [Sigma.exists, and_assoc, exists_and_left]
#align filter.has_basis.lift Filter.HasBasis.lift
theorem mem_lift_sets (hg : Monotone g) {s : Set Ξ²} : s β f.lift g β β t β f, s β g t :=
(f.basis_sets.mem_lift_iff (fun s => (g s).basis_sets) hg).trans <| by
simp only [id, exists_mem_subset_iff]
#align filter.mem_lift_sets Filter.mem_lift_sets
theorem sInter_lift_sets (hg : Monotone g) :
ββ { s | s β f.lift g } = β s β f, ββ { t | t β g s } := by
simp only [sInter_eq_biInter, mem_setOf_eq, Filter.mem_sets, mem_lift_sets hg, iInter_exists,
iInter_and, @iInter_comm _ (Set Ξ²)]
#align filter.sInter_lift_sets Filter.sInter_lift_sets
theorem mem_lift {s : Set Ξ²} {t : Set Ξ±} (ht : t β f) (hs : s β g t) : s β f.lift g :=
le_principal_iff.mp <|
show f.lift g β€ π s from iInf_le_of_le t <| iInf_le_of_le ht <| le_principal_iff.mpr hs
#align filter.mem_lift Filter.mem_lift
theorem lift_le {f : Filter Ξ±} {g : Set Ξ± β Filter Ξ²} {h : Filter Ξ²} {s : Set Ξ±} (hs : s β f)
(hg : g s β€ h) : f.lift g β€ h :=
iInfβ_le_of_le s hs hg
#align filter.lift_le Filter.lift_le
theorem le_lift {f : Filter Ξ±} {g : Set Ξ± β Filter Ξ²} {h : Filter Ξ²} :
h β€ f.lift g β β s β f, h β€ g s :=
le_iInfβ_iff
#align filter.le_lift Filter.le_lift
theorem lift_mono (hf : fβ β€ fβ) (hg : gβ β€ gβ) : fβ.lift gβ β€ fβ.lift gβ :=
iInf_mono fun s => iInf_mono' fun hs => β¨hf hs, hg sβ©
#align filter.lift_mono Filter.lift_mono
theorem lift_mono' (hg : β s β f, gβ s β€ gβ s) : f.lift gβ β€ f.lift gβ := iInfβ_mono hg
#align filter.lift_mono' Filter.lift_mono'
theorem tendsto_lift {m : Ξ³ β Ξ²} {l : Filter Ξ³} :
Tendsto m l (f.lift g) β β s β f, Tendsto m l (g s) := by
simp only [Filter.lift, tendsto_iInf]
#align filter.tendsto_lift Filter.tendsto_lift
theorem map_lift_eq {m : Ξ² β Ξ³} (hg : Monotone g) : map m (f.lift g) = f.lift (map m β g) :=
have : Monotone (map m β g) := map_mono.comp hg
Filter.ext fun s => by
simp only [mem_lift_sets hg, mem_lift_sets this, exists_prop, mem_map, Function.comp_apply]
#align filter.map_lift_eq Filter.map_lift_eq
| Mathlib/Order/Filter/Lift.lean | 117 | 118 | theorem comap_lift_eq {m : Ξ³ β Ξ²} : comap m (f.lift g) = f.lift (comap m β g) := by |
simp only [Filter.lift, comap_iInf]; rfl
| 1,105 |
import Mathlib.Order.Filter.Lift
import Mathlib.Topology.Separation
import Mathlib.Order.Interval.Set.Monotone
#align_import topology.filter from "leanprover-community/mathlib"@"4c19a16e4b705bf135cf9a80ac18fcc99c438514"
open Set Filter TopologicalSpace
open Filter Topology
variable {ΞΉ : Sort*} {Ξ± Ξ² X Y : Type*}
namespace Filter
instance : TopologicalSpace (Filter Ξ±) :=
generateFrom <| range <| Iic β π
theorem isOpen_Iic_principal {s : Set Ξ±} : IsOpen (Iic (π s)) :=
GenerateOpen.basic _ (mem_range_self _)
#align filter.is_open_Iic_principal Filter.isOpen_Iic_principal
| Mathlib/Topology/Filter.lean | 55 | 56 | theorem isOpen_setOf_mem {s : Set Ξ±} : IsOpen { l : Filter Ξ± | s β l } := by |
simpa only [Iic_principal] using isOpen_Iic_principal
| 1,106 |
import Mathlib.Order.Filter.Lift
import Mathlib.Topology.Separation
import Mathlib.Order.Interval.Set.Monotone
#align_import topology.filter from "leanprover-community/mathlib"@"4c19a16e4b705bf135cf9a80ac18fcc99c438514"
open Set Filter TopologicalSpace
open Filter Topology
variable {ΞΉ : Sort*} {Ξ± Ξ² X Y : Type*}
namespace Filter
instance : TopologicalSpace (Filter Ξ±) :=
generateFrom <| range <| Iic β π
theorem isOpen_Iic_principal {s : Set Ξ±} : IsOpen (Iic (π s)) :=
GenerateOpen.basic _ (mem_range_self _)
#align filter.is_open_Iic_principal Filter.isOpen_Iic_principal
theorem isOpen_setOf_mem {s : Set Ξ±} : IsOpen { l : Filter Ξ± | s β l } := by
simpa only [Iic_principal] using isOpen_Iic_principal
#align filter.is_open_set_of_mem Filter.isOpen_setOf_mem
| Mathlib/Topology/Filter.lean | 59 | 66 | theorem isTopologicalBasis_Iic_principal :
IsTopologicalBasis (range (Iic β π : Set Ξ± β Set (Filter Ξ±))) :=
{ exists_subset_inter := by |
rintro _ β¨s, rflβ© _ β¨t, rflβ© l hl
exact β¨Iic (π s) β© Iic (π t), β¨s β© t, by simpβ©, hl, Subset.rflβ©
sUnion_eq := sUnion_eq_univ_iff.2 fun l => β¨Iic β€, β¨univ, congr_arg Iic principal_univβ©,
mem_Iic.2 le_topβ©
eq_generateFrom := rfl }
| 1,106 |
import Mathlib.Order.Filter.Lift
import Mathlib.Topology.Separation
import Mathlib.Order.Interval.Set.Monotone
#align_import topology.filter from "leanprover-community/mathlib"@"4c19a16e4b705bf135cf9a80ac18fcc99c438514"
open Set Filter TopologicalSpace
open Filter Topology
variable {ΞΉ : Sort*} {Ξ± Ξ² X Y : Type*}
namespace Filter
instance : TopologicalSpace (Filter Ξ±) :=
generateFrom <| range <| Iic β π
theorem isOpen_Iic_principal {s : Set Ξ±} : IsOpen (Iic (π s)) :=
GenerateOpen.basic _ (mem_range_self _)
#align filter.is_open_Iic_principal Filter.isOpen_Iic_principal
theorem isOpen_setOf_mem {s : Set Ξ±} : IsOpen { l : Filter Ξ± | s β l } := by
simpa only [Iic_principal] using isOpen_Iic_principal
#align filter.is_open_set_of_mem Filter.isOpen_setOf_mem
theorem isTopologicalBasis_Iic_principal :
IsTopologicalBasis (range (Iic β π : Set Ξ± β Set (Filter Ξ±))) :=
{ exists_subset_inter := by
rintro _ β¨s, rflβ© _ β¨t, rflβ© l hl
exact β¨Iic (π s) β© Iic (π t), β¨s β© t, by simpβ©, hl, Subset.rflβ©
sUnion_eq := sUnion_eq_univ_iff.2 fun l => β¨Iic β€, β¨univ, congr_arg Iic principal_univβ©,
mem_Iic.2 le_topβ©
eq_generateFrom := rfl }
#align filter.is_topological_basis_Iic_principal Filter.isTopologicalBasis_Iic_principal
theorem isOpen_iff {s : Set (Filter Ξ±)} : IsOpen s β β T : Set (Set Ξ±), s = β t β T, Iic (π t) :=
isTopologicalBasis_Iic_principal.open_iff_eq_sUnion.trans <| by
simp only [exists_subset_range_and_iff, sUnion_image, (Β· β Β·)]
#align filter.is_open_iff Filter.isOpen_iff
theorem nhds_eq (l : Filter Ξ±) : π l = l.lift' (Iic β π) :=
nhds_generateFrom.trans <| by
simp only [mem_setOf_eq, @and_comm (l β _), iInf_and, iInf_range, Filter.lift', Filter.lift,
(Β· β Β·), mem_Iic, le_principal_iff]
#align filter.nhds_eq Filter.nhds_eq
theorem nhds_eq' (l : Filter Ξ±) : π l = l.lift' fun s => { l' | s β l' } := by
simpa only [(Β· β Β·), Iic_principal] using nhds_eq l
#align filter.nhds_eq' Filter.nhds_eq'
protected theorem tendsto_nhds {la : Filter Ξ±} {lb : Filter Ξ²} {f : Ξ± β Filter Ξ²} :
Tendsto f la (π lb) β β s β lb, βαΆ a in la, s β f a := by
simp only [nhds_eq', tendsto_lift', mem_setOf_eq]
#align filter.tendsto_nhds Filter.tendsto_nhds
protected theorem HasBasis.nhds {l : Filter Ξ±} {p : ΞΉ β Prop} {s : ΞΉ β Set Ξ±} (h : HasBasis l p s) :
HasBasis (π l) p fun i => Iic (π (s i)) := by
rw [nhds_eq]
exact h.lift' monotone_principal.Iic
#align filter.has_basis.nhds Filter.HasBasis.nhds
protected theorem tendsto_pure_self (l : Filter X) :
Tendsto (pure : X β Filter X) l (π l) := by
rw [Filter.tendsto_nhds]
exact fun s hs β¦ Eventually.mono hs fun x β¦ id
instance {l : Filter Ξ±} [IsCountablyGenerated l] : IsCountablyGenerated (π l) :=
let β¨_b, hbβ© := l.exists_antitone_basis
HasCountableBasis.isCountablyGenerated <| β¨hb.nhds, Set.to_countable _β©
| Mathlib/Topology/Filter.lean | 105 | 106 | theorem HasBasis.nhds' {l : Filter Ξ±} {p : ΞΉ β Prop} {s : ΞΉ β Set Ξ±} (h : HasBasis l p s) :
HasBasis (π l) p fun i => { l' | s i β l' } := by | simpa only [Iic_principal] using h.nhds
| 1,106 |
import Mathlib.Order.Filter.Lift
import Mathlib.Topology.Separation
import Mathlib.Order.Interval.Set.Monotone
#align_import topology.filter from "leanprover-community/mathlib"@"4c19a16e4b705bf135cf9a80ac18fcc99c438514"
open Set Filter TopologicalSpace
open Filter Topology
variable {ΞΉ : Sort*} {Ξ± Ξ² X Y : Type*}
namespace Filter
instance : TopologicalSpace (Filter Ξ±) :=
generateFrom <| range <| Iic β π
theorem isOpen_Iic_principal {s : Set Ξ±} : IsOpen (Iic (π s)) :=
GenerateOpen.basic _ (mem_range_self _)
#align filter.is_open_Iic_principal Filter.isOpen_Iic_principal
theorem isOpen_setOf_mem {s : Set Ξ±} : IsOpen { l : Filter Ξ± | s β l } := by
simpa only [Iic_principal] using isOpen_Iic_principal
#align filter.is_open_set_of_mem Filter.isOpen_setOf_mem
theorem isTopologicalBasis_Iic_principal :
IsTopologicalBasis (range (Iic β π : Set Ξ± β Set (Filter Ξ±))) :=
{ exists_subset_inter := by
rintro _ β¨s, rflβ© _ β¨t, rflβ© l hl
exact β¨Iic (π s) β© Iic (π t), β¨s β© t, by simpβ©, hl, Subset.rflβ©
sUnion_eq := sUnion_eq_univ_iff.2 fun l => β¨Iic β€, β¨univ, congr_arg Iic principal_univβ©,
mem_Iic.2 le_topβ©
eq_generateFrom := rfl }
#align filter.is_topological_basis_Iic_principal Filter.isTopologicalBasis_Iic_principal
theorem isOpen_iff {s : Set (Filter Ξ±)} : IsOpen s β β T : Set (Set Ξ±), s = β t β T, Iic (π t) :=
isTopologicalBasis_Iic_principal.open_iff_eq_sUnion.trans <| by
simp only [exists_subset_range_and_iff, sUnion_image, (Β· β Β·)]
#align filter.is_open_iff Filter.isOpen_iff
theorem nhds_eq (l : Filter Ξ±) : π l = l.lift' (Iic β π) :=
nhds_generateFrom.trans <| by
simp only [mem_setOf_eq, @and_comm (l β _), iInf_and, iInf_range, Filter.lift', Filter.lift,
(Β· β Β·), mem_Iic, le_principal_iff]
#align filter.nhds_eq Filter.nhds_eq
theorem nhds_eq' (l : Filter Ξ±) : π l = l.lift' fun s => { l' | s β l' } := by
simpa only [(Β· β Β·), Iic_principal] using nhds_eq l
#align filter.nhds_eq' Filter.nhds_eq'
protected theorem tendsto_nhds {la : Filter Ξ±} {lb : Filter Ξ²} {f : Ξ± β Filter Ξ²} :
Tendsto f la (π lb) β β s β lb, βαΆ a in la, s β f a := by
simp only [nhds_eq', tendsto_lift', mem_setOf_eq]
#align filter.tendsto_nhds Filter.tendsto_nhds
protected theorem HasBasis.nhds {l : Filter Ξ±} {p : ΞΉ β Prop} {s : ΞΉ β Set Ξ±} (h : HasBasis l p s) :
HasBasis (π l) p fun i => Iic (π (s i)) := by
rw [nhds_eq]
exact h.lift' monotone_principal.Iic
#align filter.has_basis.nhds Filter.HasBasis.nhds
protected theorem tendsto_pure_self (l : Filter X) :
Tendsto (pure : X β Filter X) l (π l) := by
rw [Filter.tendsto_nhds]
exact fun s hs β¦ Eventually.mono hs fun x β¦ id
instance {l : Filter Ξ±} [IsCountablyGenerated l] : IsCountablyGenerated (π l) :=
let β¨_b, hbβ© := l.exists_antitone_basis
HasCountableBasis.isCountablyGenerated <| β¨hb.nhds, Set.to_countable _β©
theorem HasBasis.nhds' {l : Filter Ξ±} {p : ΞΉ β Prop} {s : ΞΉ β Set Ξ±} (h : HasBasis l p s) :
HasBasis (π l) p fun i => { l' | s i β l' } := by simpa only [Iic_principal] using h.nhds
#align filter.has_basis.nhds' Filter.HasBasis.nhds'
protected theorem mem_nhds_iff {l : Filter Ξ±} {S : Set (Filter Ξ±)} :
S β π l β β t β l, Iic (π t) β S :=
l.basis_sets.nhds.mem_iff
#align filter.mem_nhds_iff Filter.mem_nhds_iff
theorem mem_nhds_iff' {l : Filter Ξ±} {S : Set (Filter Ξ±)} :
S β π l β β t β l, β β¦l' : Filter Ξ±β¦, t β l' β l' β S :=
l.basis_sets.nhds'.mem_iff
#align filter.mem_nhds_iff' Filter.mem_nhds_iff'
@[simp]
theorem nhds_bot : π (β₯ : Filter Ξ±) = pure β₯ := by
simp [nhds_eq, (Β· β Β·), lift'_bot monotone_principal.Iic]
#align filter.nhds_bot Filter.nhds_bot
@[simp]
| Mathlib/Topology/Filter.lean | 125 | 125 | theorem nhds_top : π (β€ : Filter Ξ±) = β€ := by | simp [nhds_eq]
| 1,106 |
import Mathlib.Order.Filter.Lift
import Mathlib.Topology.Separation
import Mathlib.Order.Interval.Set.Monotone
#align_import topology.filter from "leanprover-community/mathlib"@"4c19a16e4b705bf135cf9a80ac18fcc99c438514"
open Set Filter TopologicalSpace
open Filter Topology
variable {ΞΉ : Sort*} {Ξ± Ξ² X Y : Type*}
namespace Filter
instance : TopologicalSpace (Filter Ξ±) :=
generateFrom <| range <| Iic β π
theorem isOpen_Iic_principal {s : Set Ξ±} : IsOpen (Iic (π s)) :=
GenerateOpen.basic _ (mem_range_self _)
#align filter.is_open_Iic_principal Filter.isOpen_Iic_principal
theorem isOpen_setOf_mem {s : Set Ξ±} : IsOpen { l : Filter Ξ± | s β l } := by
simpa only [Iic_principal] using isOpen_Iic_principal
#align filter.is_open_set_of_mem Filter.isOpen_setOf_mem
theorem isTopologicalBasis_Iic_principal :
IsTopologicalBasis (range (Iic β π : Set Ξ± β Set (Filter Ξ±))) :=
{ exists_subset_inter := by
rintro _ β¨s, rflβ© _ β¨t, rflβ© l hl
exact β¨Iic (π s) β© Iic (π t), β¨s β© t, by simpβ©, hl, Subset.rflβ©
sUnion_eq := sUnion_eq_univ_iff.2 fun l => β¨Iic β€, β¨univ, congr_arg Iic principal_univβ©,
mem_Iic.2 le_topβ©
eq_generateFrom := rfl }
#align filter.is_topological_basis_Iic_principal Filter.isTopologicalBasis_Iic_principal
theorem isOpen_iff {s : Set (Filter Ξ±)} : IsOpen s β β T : Set (Set Ξ±), s = β t β T, Iic (π t) :=
isTopologicalBasis_Iic_principal.open_iff_eq_sUnion.trans <| by
simp only [exists_subset_range_and_iff, sUnion_image, (Β· β Β·)]
#align filter.is_open_iff Filter.isOpen_iff
theorem nhds_eq (l : Filter Ξ±) : π l = l.lift' (Iic β π) :=
nhds_generateFrom.trans <| by
simp only [mem_setOf_eq, @and_comm (l β _), iInf_and, iInf_range, Filter.lift', Filter.lift,
(Β· β Β·), mem_Iic, le_principal_iff]
#align filter.nhds_eq Filter.nhds_eq
theorem nhds_eq' (l : Filter Ξ±) : π l = l.lift' fun s => { l' | s β l' } := by
simpa only [(Β· β Β·), Iic_principal] using nhds_eq l
#align filter.nhds_eq' Filter.nhds_eq'
protected theorem tendsto_nhds {la : Filter Ξ±} {lb : Filter Ξ²} {f : Ξ± β Filter Ξ²} :
Tendsto f la (π lb) β β s β lb, βαΆ a in la, s β f a := by
simp only [nhds_eq', tendsto_lift', mem_setOf_eq]
#align filter.tendsto_nhds Filter.tendsto_nhds
protected theorem HasBasis.nhds {l : Filter Ξ±} {p : ΞΉ β Prop} {s : ΞΉ β Set Ξ±} (h : HasBasis l p s) :
HasBasis (π l) p fun i => Iic (π (s i)) := by
rw [nhds_eq]
exact h.lift' monotone_principal.Iic
#align filter.has_basis.nhds Filter.HasBasis.nhds
protected theorem tendsto_pure_self (l : Filter X) :
Tendsto (pure : X β Filter X) l (π l) := by
rw [Filter.tendsto_nhds]
exact fun s hs β¦ Eventually.mono hs fun x β¦ id
instance {l : Filter Ξ±} [IsCountablyGenerated l] : IsCountablyGenerated (π l) :=
let β¨_b, hbβ© := l.exists_antitone_basis
HasCountableBasis.isCountablyGenerated <| β¨hb.nhds, Set.to_countable _β©
theorem HasBasis.nhds' {l : Filter Ξ±} {p : ΞΉ β Prop} {s : ΞΉ β Set Ξ±} (h : HasBasis l p s) :
HasBasis (π l) p fun i => { l' | s i β l' } := by simpa only [Iic_principal] using h.nhds
#align filter.has_basis.nhds' Filter.HasBasis.nhds'
protected theorem mem_nhds_iff {l : Filter Ξ±} {S : Set (Filter Ξ±)} :
S β π l β β t β l, Iic (π t) β S :=
l.basis_sets.nhds.mem_iff
#align filter.mem_nhds_iff Filter.mem_nhds_iff
theorem mem_nhds_iff' {l : Filter Ξ±} {S : Set (Filter Ξ±)} :
S β π l β β t β l, β β¦l' : Filter Ξ±β¦, t β l' β l' β S :=
l.basis_sets.nhds'.mem_iff
#align filter.mem_nhds_iff' Filter.mem_nhds_iff'
@[simp]
theorem nhds_bot : π (β₯ : Filter Ξ±) = pure β₯ := by
simp [nhds_eq, (Β· β Β·), lift'_bot monotone_principal.Iic]
#align filter.nhds_bot Filter.nhds_bot
@[simp]
theorem nhds_top : π (β€ : Filter Ξ±) = β€ := by simp [nhds_eq]
#align filter.nhds_top Filter.nhds_top
@[simp]
theorem nhds_principal (s : Set Ξ±) : π (π s) = π (Iic (π s)) :=
(hasBasis_principal s).nhds.eq_of_same_basis (hasBasis_principal _)
#align filter.nhds_principal Filter.nhds_principal
@[simp]
| Mathlib/Topology/Filter.lean | 134 | 135 | theorem nhds_pure (x : Ξ±) : π (pure x : Filter Ξ±) = π {β₯, pure x} := by |
rw [β principal_singleton, nhds_principal, principal_singleton, Iic_pure]
| 1,106 |
import Mathlib.Order.Filter.Lift
import Mathlib.Topology.Separation
import Mathlib.Order.Interval.Set.Monotone
#align_import topology.filter from "leanprover-community/mathlib"@"4c19a16e4b705bf135cf9a80ac18fcc99c438514"
open Set Filter TopologicalSpace
open Filter Topology
variable {ΞΉ : Sort*} {Ξ± Ξ² X Y : Type*}
namespace Filter
instance : TopologicalSpace (Filter Ξ±) :=
generateFrom <| range <| Iic β π
theorem isOpen_Iic_principal {s : Set Ξ±} : IsOpen (Iic (π s)) :=
GenerateOpen.basic _ (mem_range_self _)
#align filter.is_open_Iic_principal Filter.isOpen_Iic_principal
theorem isOpen_setOf_mem {s : Set Ξ±} : IsOpen { l : Filter Ξ± | s β l } := by
simpa only [Iic_principal] using isOpen_Iic_principal
#align filter.is_open_set_of_mem Filter.isOpen_setOf_mem
theorem isTopologicalBasis_Iic_principal :
IsTopologicalBasis (range (Iic β π : Set Ξ± β Set (Filter Ξ±))) :=
{ exists_subset_inter := by
rintro _ β¨s, rflβ© _ β¨t, rflβ© l hl
exact β¨Iic (π s) β© Iic (π t), β¨s β© t, by simpβ©, hl, Subset.rflβ©
sUnion_eq := sUnion_eq_univ_iff.2 fun l => β¨Iic β€, β¨univ, congr_arg Iic principal_univβ©,
mem_Iic.2 le_topβ©
eq_generateFrom := rfl }
#align filter.is_topological_basis_Iic_principal Filter.isTopologicalBasis_Iic_principal
theorem isOpen_iff {s : Set (Filter Ξ±)} : IsOpen s β β T : Set (Set Ξ±), s = β t β T, Iic (π t) :=
isTopologicalBasis_Iic_principal.open_iff_eq_sUnion.trans <| by
simp only [exists_subset_range_and_iff, sUnion_image, (Β· β Β·)]
#align filter.is_open_iff Filter.isOpen_iff
theorem nhds_eq (l : Filter Ξ±) : π l = l.lift' (Iic β π) :=
nhds_generateFrom.trans <| by
simp only [mem_setOf_eq, @and_comm (l β _), iInf_and, iInf_range, Filter.lift', Filter.lift,
(Β· β Β·), mem_Iic, le_principal_iff]
#align filter.nhds_eq Filter.nhds_eq
theorem nhds_eq' (l : Filter Ξ±) : π l = l.lift' fun s => { l' | s β l' } := by
simpa only [(Β· β Β·), Iic_principal] using nhds_eq l
#align filter.nhds_eq' Filter.nhds_eq'
protected theorem tendsto_nhds {la : Filter Ξ±} {lb : Filter Ξ²} {f : Ξ± β Filter Ξ²} :
Tendsto f la (π lb) β β s β lb, βαΆ a in la, s β f a := by
simp only [nhds_eq', tendsto_lift', mem_setOf_eq]
#align filter.tendsto_nhds Filter.tendsto_nhds
protected theorem HasBasis.nhds {l : Filter Ξ±} {p : ΞΉ β Prop} {s : ΞΉ β Set Ξ±} (h : HasBasis l p s) :
HasBasis (π l) p fun i => Iic (π (s i)) := by
rw [nhds_eq]
exact h.lift' monotone_principal.Iic
#align filter.has_basis.nhds Filter.HasBasis.nhds
protected theorem tendsto_pure_self (l : Filter X) :
Tendsto (pure : X β Filter X) l (π l) := by
rw [Filter.tendsto_nhds]
exact fun s hs β¦ Eventually.mono hs fun x β¦ id
instance {l : Filter Ξ±} [IsCountablyGenerated l] : IsCountablyGenerated (π l) :=
let β¨_b, hbβ© := l.exists_antitone_basis
HasCountableBasis.isCountablyGenerated <| β¨hb.nhds, Set.to_countable _β©
theorem HasBasis.nhds' {l : Filter Ξ±} {p : ΞΉ β Prop} {s : ΞΉ β Set Ξ±} (h : HasBasis l p s) :
HasBasis (π l) p fun i => { l' | s i β l' } := by simpa only [Iic_principal] using h.nhds
#align filter.has_basis.nhds' Filter.HasBasis.nhds'
protected theorem mem_nhds_iff {l : Filter Ξ±} {S : Set (Filter Ξ±)} :
S β π l β β t β l, Iic (π t) β S :=
l.basis_sets.nhds.mem_iff
#align filter.mem_nhds_iff Filter.mem_nhds_iff
theorem mem_nhds_iff' {l : Filter Ξ±} {S : Set (Filter Ξ±)} :
S β π l β β t β l, β β¦l' : Filter Ξ±β¦, t β l' β l' β S :=
l.basis_sets.nhds'.mem_iff
#align filter.mem_nhds_iff' Filter.mem_nhds_iff'
@[simp]
theorem nhds_bot : π (β₯ : Filter Ξ±) = pure β₯ := by
simp [nhds_eq, (Β· β Β·), lift'_bot monotone_principal.Iic]
#align filter.nhds_bot Filter.nhds_bot
@[simp]
theorem nhds_top : π (β€ : Filter Ξ±) = β€ := by simp [nhds_eq]
#align filter.nhds_top Filter.nhds_top
@[simp]
theorem nhds_principal (s : Set Ξ±) : π (π s) = π (Iic (π s)) :=
(hasBasis_principal s).nhds.eq_of_same_basis (hasBasis_principal _)
#align filter.nhds_principal Filter.nhds_principal
@[simp]
theorem nhds_pure (x : Ξ±) : π (pure x : Filter Ξ±) = π {β₯, pure x} := by
rw [β principal_singleton, nhds_principal, principal_singleton, Iic_pure]
#align filter.nhds_pure Filter.nhds_pure
@[simp]
| Mathlib/Topology/Filter.lean | 139 | 141 | theorem nhds_iInf (f : ΞΉ β Filter Ξ±) : π (β¨
i, f i) = β¨
i, π (f i) := by |
simp only [nhds_eq]
apply lift'_iInf_of_map_univ <;> simp
| 1,106 |
import Mathlib.Order.Filter.Lift
import Mathlib.Topology.Defs.Filter
#align_import topology.basic from "leanprover-community/mathlib"@"e354e865255654389cc46e6032160238df2e0f40"
noncomputable section
open Set Filter
universe u v w x
def TopologicalSpace.ofClosed {X : Type u} (T : Set (Set X)) (empty_mem : β
β T)
(sInter_mem : β A, A β T β ββ A β T)
(union_mem : β A, A β T β β B, B β T β A βͺ B β T) : TopologicalSpace X where
IsOpen X := XαΆ β T
isOpen_univ := by simp [empty_mem]
isOpen_inter s t hs ht := by simpa only [compl_inter] using union_mem sαΆ hs tαΆ ht
isOpen_sUnion s hs := by
simp only [Set.compl_sUnion]
exact sInter_mem (compl '' s) fun z β¨y, hy, hzβ© => hz βΈ hs y hy
#align topological_space.of_closed TopologicalSpace.ofClosed
section TopologicalSpace
variable {X : Type u} {Y : Type v} {ΞΉ : Sort w} {Ξ± Ξ² : Type*}
{x : X} {s sβ sβ t : Set X} {p pβ pβ : X β Prop}
open Topology
lemma isOpen_mk {p hβ hβ hβ} : IsOpen[β¨p, hβ, hβ, hββ©] s β p s := Iff.rfl
#align is_open_mk isOpen_mk
@[ext]
protected theorem TopologicalSpace.ext :
β {f g : TopologicalSpace X}, IsOpen[f] = IsOpen[g] β f = g
| β¨_, _, _, _β©, β¨_, _, _, _β©, rfl => rfl
#align topological_space_eq TopologicalSpace.ext
section
variable [TopologicalSpace X]
end
protected theorem TopologicalSpace.ext_iff {t t' : TopologicalSpace X} :
t = t' β β s, IsOpen[t] s β IsOpen[t'] s :=
β¨fun h s => h βΈ Iff.rfl, fun h => by ext; exact h _β©
#align topological_space_eq_iff TopologicalSpace.ext_iff
theorem isOpen_fold {t : TopologicalSpace X} : t.IsOpen s = IsOpen[t] s :=
rfl
#align is_open_fold isOpen_fold
variable [TopologicalSpace X]
theorem isOpen_iUnion {f : ΞΉ β Set X} (h : β i, IsOpen (f i)) : IsOpen (β i, f i) :=
isOpen_sUnion (forall_mem_range.2 h)
#align is_open_Union isOpen_iUnion
theorem isOpen_biUnion {s : Set Ξ±} {f : Ξ± β Set X} (h : β i β s, IsOpen (f i)) :
IsOpen (β i β s, f i) :=
isOpen_iUnion fun i => isOpen_iUnion fun hi => h i hi
#align is_open_bUnion isOpen_biUnion
| Mathlib/Topology/Basic.lean | 115 | 116 | theorem IsOpen.union (hβ : IsOpen sβ) (hβ : IsOpen sβ) : IsOpen (sβ βͺ sβ) := by |
rw [union_eq_iUnion]; exact isOpen_iUnion (Bool.forall_bool.2 β¨hβ, hββ©)
| 1,107 |
import Mathlib.Order.Filter.Lift
import Mathlib.Topology.Defs.Filter
#align_import topology.basic from "leanprover-community/mathlib"@"e354e865255654389cc46e6032160238df2e0f40"
noncomputable section
open Set Filter
universe u v w x
def TopologicalSpace.ofClosed {X : Type u} (T : Set (Set X)) (empty_mem : β
β T)
(sInter_mem : β A, A β T β ββ A β T)
(union_mem : β A, A β T β β B, B β T β A βͺ B β T) : TopologicalSpace X where
IsOpen X := XαΆ β T
isOpen_univ := by simp [empty_mem]
isOpen_inter s t hs ht := by simpa only [compl_inter] using union_mem sαΆ hs tαΆ ht
isOpen_sUnion s hs := by
simp only [Set.compl_sUnion]
exact sInter_mem (compl '' s) fun z β¨y, hy, hzβ© => hz βΈ hs y hy
#align topological_space.of_closed TopologicalSpace.ofClosed
section TopologicalSpace
variable {X : Type u} {Y : Type v} {ΞΉ : Sort w} {Ξ± Ξ² : Type*}
{x : X} {s sβ sβ t : Set X} {p pβ pβ : X β Prop}
open Topology
lemma isOpen_mk {p hβ hβ hβ} : IsOpen[β¨p, hβ, hβ, hββ©] s β p s := Iff.rfl
#align is_open_mk isOpen_mk
@[ext]
protected theorem TopologicalSpace.ext :
β {f g : TopologicalSpace X}, IsOpen[f] = IsOpen[g] β f = g
| β¨_, _, _, _β©, β¨_, _, _, _β©, rfl => rfl
#align topological_space_eq TopologicalSpace.ext
section
variable [TopologicalSpace X]
end
protected theorem TopologicalSpace.ext_iff {t t' : TopologicalSpace X} :
t = t' β β s, IsOpen[t] s β IsOpen[t'] s :=
β¨fun h s => h βΈ Iff.rfl, fun h => by ext; exact h _β©
#align topological_space_eq_iff TopologicalSpace.ext_iff
theorem isOpen_fold {t : TopologicalSpace X} : t.IsOpen s = IsOpen[t] s :=
rfl
#align is_open_fold isOpen_fold
variable [TopologicalSpace X]
theorem isOpen_iUnion {f : ΞΉ β Set X} (h : β i, IsOpen (f i)) : IsOpen (β i, f i) :=
isOpen_sUnion (forall_mem_range.2 h)
#align is_open_Union isOpen_iUnion
theorem isOpen_biUnion {s : Set Ξ±} {f : Ξ± β Set X} (h : β i β s, IsOpen (f i)) :
IsOpen (β i β s, f i) :=
isOpen_iUnion fun i => isOpen_iUnion fun hi => h i hi
#align is_open_bUnion isOpen_biUnion
theorem IsOpen.union (hβ : IsOpen sβ) (hβ : IsOpen sβ) : IsOpen (sβ βͺ sβ) := by
rw [union_eq_iUnion]; exact isOpen_iUnion (Bool.forall_bool.2 β¨hβ, hββ©)
#align is_open.union IsOpen.union
lemma isOpen_iff_of_cover {f : Ξ± β Set X} (ho : β i, IsOpen (f i)) (hU : (β i, f i) = univ) :
IsOpen s β β i, IsOpen (f i β© s) := by
refine β¨fun h i β¦ (ho i).inter h, fun h β¦ ?_β©
rw [β s.inter_univ, inter_comm, β hU, iUnion_inter]
exact isOpen_iUnion fun i β¦ h i
@[simp] theorem isOpen_empty : IsOpen (β
: Set X) := by
rw [β sUnion_empty]; exact isOpen_sUnion fun a => False.elim
#align is_open_empty isOpen_empty
theorem Set.Finite.isOpen_sInter {s : Set (Set X)} (hs : s.Finite) :
(β t β s, IsOpen t) β IsOpen (ββ s) :=
Finite.induction_on hs (fun _ => by rw [sInter_empty]; exact isOpen_univ) fun _ _ ih h => by
simp only [sInter_insert, forall_mem_insert] at h β’
exact h.1.inter (ih h.2)
#align is_open_sInter Set.Finite.isOpen_sInter
theorem Set.Finite.isOpen_biInter {s : Set Ξ±} {f : Ξ± β Set X} (hs : s.Finite)
(h : β i β s, IsOpen (f i)) :
IsOpen (β i β s, f i) :=
sInter_image f s βΈ (hs.image _).isOpen_sInter (forall_mem_image.2 h)
#align is_open_bInter Set.Finite.isOpen_biInter
theorem isOpen_iInter_of_finite [Finite ΞΉ] {s : ΞΉ β Set X} (h : β i, IsOpen (s i)) :
IsOpen (β i, s i) :=
(finite_range _).isOpen_sInter (forall_mem_range.2 h)
#align is_open_Inter isOpen_iInter_of_finite
theorem isOpen_biInter_finset {s : Finset Ξ±} {f : Ξ± β Set X} (h : β i β s, IsOpen (f i)) :
IsOpen (β i β s, f i) :=
s.finite_toSet.isOpen_biInter h
#align is_open_bInter_finset isOpen_biInter_finset
@[simp] -- Porting note: added `simp`
| Mathlib/Topology/Basic.lean | 153 | 153 | theorem isOpen_const {p : Prop} : IsOpen { _x : X | p } := by | by_cases p <;> simp [*]
| 1,107 |
import Mathlib.Order.Filter.Lift
import Mathlib.Topology.Defs.Filter
#align_import topology.basic from "leanprover-community/mathlib"@"e354e865255654389cc46e6032160238df2e0f40"
noncomputable section
open Set Filter
universe u v w x
def TopologicalSpace.ofClosed {X : Type u} (T : Set (Set X)) (empty_mem : β
β T)
(sInter_mem : β A, A β T β ββ A β T)
(union_mem : β A, A β T β β B, B β T β A βͺ B β T) : TopologicalSpace X where
IsOpen X := XαΆ β T
isOpen_univ := by simp [empty_mem]
isOpen_inter s t hs ht := by simpa only [compl_inter] using union_mem sαΆ hs tαΆ ht
isOpen_sUnion s hs := by
simp only [Set.compl_sUnion]
exact sInter_mem (compl '' s) fun z β¨y, hy, hzβ© => hz βΈ hs y hy
#align topological_space.of_closed TopologicalSpace.ofClosed
section TopologicalSpace
variable {X : Type u} {Y : Type v} {ΞΉ : Sort w} {Ξ± Ξ² : Type*}
{x : X} {s sβ sβ t : Set X} {p pβ pβ : X β Prop}
open Topology
lemma isOpen_mk {p hβ hβ hβ} : IsOpen[β¨p, hβ, hβ, hββ©] s β p s := Iff.rfl
#align is_open_mk isOpen_mk
@[ext]
protected theorem TopologicalSpace.ext :
β {f g : TopologicalSpace X}, IsOpen[f] = IsOpen[g] β f = g
| β¨_, _, _, _β©, β¨_, _, _, _β©, rfl => rfl
#align topological_space_eq TopologicalSpace.ext
section
variable [TopologicalSpace X]
end
protected theorem TopologicalSpace.ext_iff {t t' : TopologicalSpace X} :
t = t' β β s, IsOpen[t] s β IsOpen[t'] s :=
β¨fun h s => h βΈ Iff.rfl, fun h => by ext; exact h _β©
#align topological_space_eq_iff TopologicalSpace.ext_iff
theorem isOpen_fold {t : TopologicalSpace X} : t.IsOpen s = IsOpen[t] s :=
rfl
#align is_open_fold isOpen_fold
variable [TopologicalSpace X]
theorem isOpen_iUnion {f : ΞΉ β Set X} (h : β i, IsOpen (f i)) : IsOpen (β i, f i) :=
isOpen_sUnion (forall_mem_range.2 h)
#align is_open_Union isOpen_iUnion
theorem isOpen_biUnion {s : Set Ξ±} {f : Ξ± β Set X} (h : β i β s, IsOpen (f i)) :
IsOpen (β i β s, f i) :=
isOpen_iUnion fun i => isOpen_iUnion fun hi => h i hi
#align is_open_bUnion isOpen_biUnion
theorem IsOpen.union (hβ : IsOpen sβ) (hβ : IsOpen sβ) : IsOpen (sβ βͺ sβ) := by
rw [union_eq_iUnion]; exact isOpen_iUnion (Bool.forall_bool.2 β¨hβ, hββ©)
#align is_open.union IsOpen.union
lemma isOpen_iff_of_cover {f : Ξ± β Set X} (ho : β i, IsOpen (f i)) (hU : (β i, f i) = univ) :
IsOpen s β β i, IsOpen (f i β© s) := by
refine β¨fun h i β¦ (ho i).inter h, fun h β¦ ?_β©
rw [β s.inter_univ, inter_comm, β hU, iUnion_inter]
exact isOpen_iUnion fun i β¦ h i
@[simp] theorem isOpen_empty : IsOpen (β
: Set X) := by
rw [β sUnion_empty]; exact isOpen_sUnion fun a => False.elim
#align is_open_empty isOpen_empty
theorem Set.Finite.isOpen_sInter {s : Set (Set X)} (hs : s.Finite) :
(β t β s, IsOpen t) β IsOpen (ββ s) :=
Finite.induction_on hs (fun _ => by rw [sInter_empty]; exact isOpen_univ) fun _ _ ih h => by
simp only [sInter_insert, forall_mem_insert] at h β’
exact h.1.inter (ih h.2)
#align is_open_sInter Set.Finite.isOpen_sInter
theorem Set.Finite.isOpen_biInter {s : Set Ξ±} {f : Ξ± β Set X} (hs : s.Finite)
(h : β i β s, IsOpen (f i)) :
IsOpen (β i β s, f i) :=
sInter_image f s βΈ (hs.image _).isOpen_sInter (forall_mem_image.2 h)
#align is_open_bInter Set.Finite.isOpen_biInter
theorem isOpen_iInter_of_finite [Finite ΞΉ] {s : ΞΉ β Set X} (h : β i, IsOpen (s i)) :
IsOpen (β i, s i) :=
(finite_range _).isOpen_sInter (forall_mem_range.2 h)
#align is_open_Inter isOpen_iInter_of_finite
theorem isOpen_biInter_finset {s : Finset Ξ±} {f : Ξ± β Set X} (h : β i β s, IsOpen (f i)) :
IsOpen (β i β s, f i) :=
s.finite_toSet.isOpen_biInter h
#align is_open_bInter_finset isOpen_biInter_finset
@[simp] -- Porting note: added `simp`
theorem isOpen_const {p : Prop} : IsOpen { _x : X | p } := by by_cases p <;> simp [*]
#align is_open_const isOpen_const
theorem IsOpen.and : IsOpen { x | pβ x } β IsOpen { x | pβ x } β IsOpen { x | pβ x β§ pβ x } :=
IsOpen.inter
#align is_open.and IsOpen.and
@[simp] theorem isOpen_compl_iff : IsOpen sαΆ β IsClosed s :=
β¨fun h => β¨hβ©, fun h => h.isOpen_complβ©
#align is_open_compl_iff isOpen_compl_iff
| Mathlib/Topology/Basic.lean | 164 | 167 | theorem TopologicalSpace.ext_iff_isClosed {tβ tβ : TopologicalSpace X} :
tβ = tβ β β s, IsClosed[tβ] s β IsClosed[tβ] s := by |
rw [TopologicalSpace.ext_iff, compl_surjective.forall]
simp only [@isOpen_compl_iff _ _ tβ, @isOpen_compl_iff _ _ tβ]
| 1,107 |
import Mathlib.Order.Filter.Partial
import Mathlib.Topology.Basic
#align_import topology.partial from "leanprover-community/mathlib"@"4c19a16e4b705bf135cf9a80ac18fcc99c438514"
open Filter
open Topology
variable {X Y : Type*} [TopologicalSpace X]
theorem rtendsto_nhds {r : Rel Y X} {l : Filter Y} {x : X} :
RTendsto r l (π x) β β s, IsOpen s β x β s β r.core s β l :=
all_mem_nhds_filter _ _ (fun _s _t => id) _
#align rtendsto_nhds rtendsto_nhds
| Mathlib/Topology/Partial.lean | 30 | 34 | theorem rtendsto'_nhds {r : Rel Y X} {l : Filter Y} {x : X} :
RTendsto' r l (π x) β β s, IsOpen s β x β s β r.preimage s β l := by |
rw [rtendsto'_def]
apply all_mem_nhds_filter
apply Rel.preimage_mono
| 1,108 |
import Mathlib.Order.Filter.Partial
import Mathlib.Topology.Basic
#align_import topology.partial from "leanprover-community/mathlib"@"4c19a16e4b705bf135cf9a80ac18fcc99c438514"
open Filter
open Topology
variable {X Y : Type*} [TopologicalSpace X]
theorem rtendsto_nhds {r : Rel Y X} {l : Filter Y} {x : X} :
RTendsto r l (π x) β β s, IsOpen s β x β s β r.core s β l :=
all_mem_nhds_filter _ _ (fun _s _t => id) _
#align rtendsto_nhds rtendsto_nhds
theorem rtendsto'_nhds {r : Rel Y X} {l : Filter Y} {x : X} :
RTendsto' r l (π x) β β s, IsOpen s β x β s β r.preimage s β l := by
rw [rtendsto'_def]
apply all_mem_nhds_filter
apply Rel.preimage_mono
#align rtendsto'_nhds rtendsto'_nhds
theorem ptendsto_nhds {f : Y β. X} {l : Filter Y} {x : X} :
PTendsto f l (π x) β β s, IsOpen s β x β s β f.core s β l :=
rtendsto_nhds
#align ptendsto_nhds ptendsto_nhds
theorem ptendsto'_nhds {f : Y β. X} {l : Filter Y} {x : X} :
PTendsto' f l (π x) β β s, IsOpen s β x β s β f.preimage s β l :=
rtendsto'_nhds
#align ptendsto'_nhds ptendsto'_nhds
variable [TopologicalSpace Y]
def PContinuous (f : X β. Y) :=
β s, IsOpen s β IsOpen (f.preimage s)
#align pcontinuous PContinuous
| Mathlib/Topology/Partial.lean | 57 | 58 | theorem open_dom_of_pcontinuous {f : X β. Y} (h : PContinuous f) : IsOpen f.Dom := by |
rw [β PFun.preimage_univ]; exact h _ isOpen_univ
| 1,108 |
import Mathlib.Order.Filter.Partial
import Mathlib.Topology.Basic
#align_import topology.partial from "leanprover-community/mathlib"@"4c19a16e4b705bf135cf9a80ac18fcc99c438514"
open Filter
open Topology
variable {X Y : Type*} [TopologicalSpace X]
theorem rtendsto_nhds {r : Rel Y X} {l : Filter Y} {x : X} :
RTendsto r l (π x) β β s, IsOpen s β x β s β r.core s β l :=
all_mem_nhds_filter _ _ (fun _s _t => id) _
#align rtendsto_nhds rtendsto_nhds
theorem rtendsto'_nhds {r : Rel Y X} {l : Filter Y} {x : X} :
RTendsto' r l (π x) β β s, IsOpen s β x β s β r.preimage s β l := by
rw [rtendsto'_def]
apply all_mem_nhds_filter
apply Rel.preimage_mono
#align rtendsto'_nhds rtendsto'_nhds
theorem ptendsto_nhds {f : Y β. X} {l : Filter Y} {x : X} :
PTendsto f l (π x) β β s, IsOpen s β x β s β f.core s β l :=
rtendsto_nhds
#align ptendsto_nhds ptendsto_nhds
theorem ptendsto'_nhds {f : Y β. X} {l : Filter Y} {x : X} :
PTendsto' f l (π x) β β s, IsOpen s β x β s β f.preimage s β l :=
rtendsto'_nhds
#align ptendsto'_nhds ptendsto'_nhds
variable [TopologicalSpace Y]
def PContinuous (f : X β. Y) :=
β s, IsOpen s β IsOpen (f.preimage s)
#align pcontinuous PContinuous
theorem open_dom_of_pcontinuous {f : X β. Y} (h : PContinuous f) : IsOpen f.Dom := by
rw [β PFun.preimage_univ]; exact h _ isOpen_univ
#align open_dom_of_pcontinuous open_dom_of_pcontinuous
| Mathlib/Topology/Partial.lean | 61 | 83 | theorem pcontinuous_iff' {f : X β. Y} :
PContinuous f β β {x y} (h : y β f x), PTendsto' f (π x) (π y) := by |
constructor
Β· intro h x y h'
simp only [ptendsto'_def, mem_nhds_iff]
rintro s β¨t, tsubs, opent, ytβ©
exact β¨f.preimage t, PFun.preimage_mono _ tsubs, h _ opent, β¨y, yt, h'β©β©
intro hf s os
rw [isOpen_iff_nhds]
rintro x β¨y, ys, fxyβ© t
rw [mem_principal]
intro (h : f.preimage s β t)
change t β π x
apply mem_of_superset _ h
have h' : β s β π y, f.preimage s β π x := by
intro s hs
have : PTendsto' f (π x) (π y) := hf fxy
rw [ptendsto'_def] at this
exact this s hs
show f.preimage s β π x
apply h'
rw [mem_nhds_iff]
exact β¨s, Set.Subset.refl _, os, ysβ©
| 1,108 |
import Mathlib.Topology.Basic
import Mathlib.Order.UpperLower.Basic
import Mathlib.Order.OmegaCompletePartialOrder
#align_import topology.omega_complete_partial_order from "leanprover-community/mathlib"@"2705404e701abc6b3127da906f40bae062a169c9"
open Set OmegaCompletePartialOrder
open scoped Classical
universe u
-- "Scott", "ΟSup"
set_option linter.uppercaseLean3 false
namespace Scott
def IsΟSup {Ξ± : Type u} [Preorder Ξ±] (c : Chain Ξ±) (x : Ξ±) : Prop :=
(β i, c i β€ x) β§ β y, (β i, c i β€ y) β x β€ y
#align Scott.is_ΟSup Scott.IsΟSup
| Mathlib/Topology/OmegaCompletePartialOrder.lean | 41 | 43 | theorem isΟSup_iff_isLUB {Ξ± : Type u} [Preorder Ξ±] {c : Chain Ξ±} {x : Ξ±} :
IsΟSup c x β IsLUB (range c) x := by |
simp [IsΟSup, IsLUB, IsLeast, upperBounds, lowerBounds]
| 1,109 |
import Mathlib.Topology.Basic
import Mathlib.Order.UpperLower.Basic
import Mathlib.Order.OmegaCompletePartialOrder
#align_import topology.omega_complete_partial_order from "leanprover-community/mathlib"@"2705404e701abc6b3127da906f40bae062a169c9"
open Set OmegaCompletePartialOrder
open scoped Classical
universe u
-- "Scott", "ΟSup"
set_option linter.uppercaseLean3 false
namespace Scott
def IsΟSup {Ξ± : Type u} [Preorder Ξ±] (c : Chain Ξ±) (x : Ξ±) : Prop :=
(β i, c i β€ x) β§ β y, (β i, c i β€ y) β x β€ y
#align Scott.is_ΟSup Scott.IsΟSup
theorem isΟSup_iff_isLUB {Ξ± : Type u} [Preorder Ξ±] {c : Chain Ξ±} {x : Ξ±} :
IsΟSup c x β IsLUB (range c) x := by
simp [IsΟSup, IsLUB, IsLeast, upperBounds, lowerBounds]
#align Scott.is_ΟSup_iff_is_lub Scott.isΟSup_iff_isLUB
variable (Ξ± : Type u) [OmegaCompletePartialOrder Ξ±]
def IsOpen (s : Set Ξ±) : Prop :=
Continuous' fun x β¦ x β s
#align Scott.is_open Scott.IsOpen
theorem isOpen_univ : IsOpen Ξ± univ :=
β¨fun _ _ _ _ β¦ mem_univ _, @CompleteLattice.top_continuous Ξ± Prop _ _β©
#align Scott.is_open_univ Scott.isOpen_univ
theorem IsOpen.inter (s t : Set Ξ±) : IsOpen Ξ± s β IsOpen Ξ± t β IsOpen Ξ± (s β© t) :=
CompleteLattice.inf_continuous'
#align Scott.is_open.inter Scott.IsOpen.inter
| Mathlib/Topology/OmegaCompletePartialOrder.lean | 62 | 66 | theorem isOpen_sUnion (s : Set (Set Ξ±)) (hs : β t β s, IsOpen Ξ± t) : IsOpen Ξ± (ββ s) := by |
simp only [IsOpen] at hs β’
convert CompleteLattice.sSup_continuous' (setOf β»ΒΉ' s) hs
simp only [sSup_apply, setOf_bijective.surjective.exists, exists_prop, mem_preimage,
SetCoe.exists, iSup_Prop_eq, mem_setOf_eq, mem_sUnion]
| 1,109 |
import Mathlib.Topology.Defs.Induced
import Mathlib.Topology.Basic
#align_import topology.order from "leanprover-community/mathlib"@"bcfa726826abd57587355b4b5b7e78ad6527b7e4"
open Function Set Filter Topology
universe u v w
namespace TopologicalSpace
variable {Ξ± : Type u}
inductive GenerateOpen (g : Set (Set Ξ±)) : Set Ξ± β Prop
| basic : β s β g, GenerateOpen g s
| univ : GenerateOpen g univ
| inter : β s t, GenerateOpen g s β GenerateOpen g t β GenerateOpen g (s β© t)
| sUnion : β S : Set (Set Ξ±), (β s β S, GenerateOpen g s) β GenerateOpen g (ββ S)
#align topological_space.generate_open TopologicalSpace.GenerateOpen
def generateFrom (g : Set (Set Ξ±)) : TopologicalSpace Ξ± where
IsOpen := GenerateOpen g
isOpen_univ := GenerateOpen.univ
isOpen_inter := GenerateOpen.inter
isOpen_sUnion := GenerateOpen.sUnion
#align topological_space.generate_from TopologicalSpace.generateFrom
theorem isOpen_generateFrom_of_mem {g : Set (Set Ξ±)} {s : Set Ξ±} (hs : s β g) :
IsOpen[generateFrom g] s :=
GenerateOpen.basic s hs
#align topological_space.is_open_generate_from_of_mem TopologicalSpace.isOpen_generateFrom_of_mem
| Mathlib/Topology/Order.lean | 78 | 90 | theorem nhds_generateFrom {g : Set (Set Ξ±)} {a : Ξ±} :
@nhds Ξ± (generateFrom g) a = β¨
s β { s | a β s β§ s β g }, π s := by |
letI := generateFrom g
rw [nhds_def]
refine le_antisymm (biInf_mono fun s β¨as, sgβ© => β¨as, .basic _ sgβ©) <| le_iInfβ ?_
rintro s β¨ha, hsβ©
induction hs with
| basic _ hs => exact iInfβ_le _ β¨ha, hsβ©
| univ => exact le_top.trans_eq principal_univ.symm
| inter _ _ _ _ hs ht => exact (le_inf (hs ha.1) (ht ha.2)).trans_eq inf_principal
| sUnion _ _ hS =>
let β¨t, htS, hatβ© := ha
exact (hS t htS hat).trans (principal_mono.2 <| subset_sUnion_of_mem htS)
| 1,110 |
import Mathlib.Topology.Defs.Induced
import Mathlib.Topology.Basic
#align_import topology.order from "leanprover-community/mathlib"@"bcfa726826abd57587355b4b5b7e78ad6527b7e4"
open Function Set Filter Topology
universe u v w
namespace TopologicalSpace
variable {Ξ± : Type u}
inductive GenerateOpen (g : Set (Set Ξ±)) : Set Ξ± β Prop
| basic : β s β g, GenerateOpen g s
| univ : GenerateOpen g univ
| inter : β s t, GenerateOpen g s β GenerateOpen g t β GenerateOpen g (s β© t)
| sUnion : β S : Set (Set Ξ±), (β s β S, GenerateOpen g s) β GenerateOpen g (ββ S)
#align topological_space.generate_open TopologicalSpace.GenerateOpen
def generateFrom (g : Set (Set Ξ±)) : TopologicalSpace Ξ± where
IsOpen := GenerateOpen g
isOpen_univ := GenerateOpen.univ
isOpen_inter := GenerateOpen.inter
isOpen_sUnion := GenerateOpen.sUnion
#align topological_space.generate_from TopologicalSpace.generateFrom
theorem isOpen_generateFrom_of_mem {g : Set (Set Ξ±)} {s : Set Ξ±} (hs : s β g) :
IsOpen[generateFrom g] s :=
GenerateOpen.basic s hs
#align topological_space.is_open_generate_from_of_mem TopologicalSpace.isOpen_generateFrom_of_mem
theorem nhds_generateFrom {g : Set (Set Ξ±)} {a : Ξ±} :
@nhds Ξ± (generateFrom g) a = β¨
s β { s | a β s β§ s β g }, π s := by
letI := generateFrom g
rw [nhds_def]
refine le_antisymm (biInf_mono fun s β¨as, sgβ© => β¨as, .basic _ sgβ©) <| le_iInfβ ?_
rintro s β¨ha, hsβ©
induction hs with
| basic _ hs => exact iInfβ_le _ β¨ha, hsβ©
| univ => exact le_top.trans_eq principal_univ.symm
| inter _ _ _ _ hs ht => exact (le_inf (hs ha.1) (ht ha.2)).trans_eq inf_principal
| sUnion _ _ hS =>
let β¨t, htS, hatβ© := ha
exact (hS t htS hat).trans (principal_mono.2 <| subset_sUnion_of_mem htS)
#align topological_space.nhds_generate_from TopologicalSpace.nhds_generateFrom
lemma tendsto_nhds_generateFrom_iff {Ξ² : Type*} {m : Ξ± β Ξ²} {f : Filter Ξ±} {g : Set (Set Ξ²)}
{b : Ξ²} : Tendsto m f (@nhds Ξ² (generateFrom g) b) β β s β g, b β s β m β»ΒΉ' s β f := by
simp only [nhds_generateFrom, @forall_swap (b β _), tendsto_iInf, mem_setOf_eq, and_imp,
tendsto_principal]; rfl
@[deprecated] alias β¨_, tendsto_nhds_generateFromβ© := tendsto_nhds_generateFrom_iff
#align topological_space.tendsto_nhds_generate_from TopologicalSpace.tendsto_nhds_generateFrom
protected def mkOfNhds (n : Ξ± β Filter Ξ±) : TopologicalSpace Ξ± where
IsOpen s := β a β s, s β n a
isOpen_univ _ _ := univ_mem
isOpen_inter := fun _s _t hs ht x β¨hxs, hxtβ© => inter_mem (hs x hxs) (ht x hxt)
isOpen_sUnion := fun _s hs _a β¨x, hx, hxaβ© =>
mem_of_superset (hs x hx _ hxa) (subset_sUnion_of_mem hx)
#align topological_space.mk_of_nhds TopologicalSpace.mkOfNhds
| Mathlib/Topology/Order.lean | 110 | 121 | theorem nhds_mkOfNhds_of_hasBasis {n : Ξ± β Filter Ξ±} {ΞΉ : Ξ± β Sort*} {p : β a, ΞΉ a β Prop}
{s : β a, ΞΉ a β Set Ξ±} (hb : β a, (n a).HasBasis (p a) (s a))
(hpure : β a i, p a i β a β s a i) (hopen : β a i, p a i β βαΆ x in n a, s a i β n x) (a : Ξ±) :
@nhds Ξ± (.mkOfNhds n) a = n a := by |
let t : TopologicalSpace Ξ± := .mkOfNhds n
apply le_antisymm
Β· intro U hU
replace hpure : pure β€ n := fun x β¦ (hb x).ge_iff.2 (hpure x)
refine mem_nhds_iff.2 β¨{x | U β n x}, fun x hx β¦ hpure x hx, fun x hx β¦ ?_, hUβ©
rcases (hb x).mem_iff.1 hx with β¨i, hpi, hiβ©
exact (hopen x i hpi).mono fun y hy β¦ mem_of_superset hy hi
Β· exact (nhds_basis_opens a).ge_iff.2 fun U β¨haU, hUoβ© β¦ hUo a haU
| 1,110 |
import Mathlib.Topology.Defs.Induced
import Mathlib.Topology.Basic
#align_import topology.order from "leanprover-community/mathlib"@"bcfa726826abd57587355b4b5b7e78ad6527b7e4"
open Function Set Filter Topology
universe u v w
namespace TopologicalSpace
variable {Ξ± : Type u}
inductive GenerateOpen (g : Set (Set Ξ±)) : Set Ξ± β Prop
| basic : β s β g, GenerateOpen g s
| univ : GenerateOpen g univ
| inter : β s t, GenerateOpen g s β GenerateOpen g t β GenerateOpen g (s β© t)
| sUnion : β S : Set (Set Ξ±), (β s β S, GenerateOpen g s) β GenerateOpen g (ββ S)
#align topological_space.generate_open TopologicalSpace.GenerateOpen
def generateFrom (g : Set (Set Ξ±)) : TopologicalSpace Ξ± where
IsOpen := GenerateOpen g
isOpen_univ := GenerateOpen.univ
isOpen_inter := GenerateOpen.inter
isOpen_sUnion := GenerateOpen.sUnion
#align topological_space.generate_from TopologicalSpace.generateFrom
theorem isOpen_generateFrom_of_mem {g : Set (Set Ξ±)} {s : Set Ξ±} (hs : s β g) :
IsOpen[generateFrom g] s :=
GenerateOpen.basic s hs
#align topological_space.is_open_generate_from_of_mem TopologicalSpace.isOpen_generateFrom_of_mem
theorem nhds_generateFrom {g : Set (Set Ξ±)} {a : Ξ±} :
@nhds Ξ± (generateFrom g) a = β¨
s β { s | a β s β§ s β g }, π s := by
letI := generateFrom g
rw [nhds_def]
refine le_antisymm (biInf_mono fun s β¨as, sgβ© => β¨as, .basic _ sgβ©) <| le_iInfβ ?_
rintro s β¨ha, hsβ©
induction hs with
| basic _ hs => exact iInfβ_le _ β¨ha, hsβ©
| univ => exact le_top.trans_eq principal_univ.symm
| inter _ _ _ _ hs ht => exact (le_inf (hs ha.1) (ht ha.2)).trans_eq inf_principal
| sUnion _ _ hS =>
let β¨t, htS, hatβ© := ha
exact (hS t htS hat).trans (principal_mono.2 <| subset_sUnion_of_mem htS)
#align topological_space.nhds_generate_from TopologicalSpace.nhds_generateFrom
lemma tendsto_nhds_generateFrom_iff {Ξ² : Type*} {m : Ξ± β Ξ²} {f : Filter Ξ±} {g : Set (Set Ξ²)}
{b : Ξ²} : Tendsto m f (@nhds Ξ² (generateFrom g) b) β β s β g, b β s β m β»ΒΉ' s β f := by
simp only [nhds_generateFrom, @forall_swap (b β _), tendsto_iInf, mem_setOf_eq, and_imp,
tendsto_principal]; rfl
@[deprecated] alias β¨_, tendsto_nhds_generateFromβ© := tendsto_nhds_generateFrom_iff
#align topological_space.tendsto_nhds_generate_from TopologicalSpace.tendsto_nhds_generateFrom
protected def mkOfNhds (n : Ξ± β Filter Ξ±) : TopologicalSpace Ξ± where
IsOpen s := β a β s, s β n a
isOpen_univ _ _ := univ_mem
isOpen_inter := fun _s _t hs ht x β¨hxs, hxtβ© => inter_mem (hs x hxs) (ht x hxt)
isOpen_sUnion := fun _s hs _a β¨x, hx, hxaβ© =>
mem_of_superset (hs x hx _ hxa) (subset_sUnion_of_mem hx)
#align topological_space.mk_of_nhds TopologicalSpace.mkOfNhds
theorem nhds_mkOfNhds_of_hasBasis {n : Ξ± β Filter Ξ±} {ΞΉ : Ξ± β Sort*} {p : β a, ΞΉ a β Prop}
{s : β a, ΞΉ a β Set Ξ±} (hb : β a, (n a).HasBasis (p a) (s a))
(hpure : β a i, p a i β a β s a i) (hopen : β a i, p a i β βαΆ x in n a, s a i β n x) (a : Ξ±) :
@nhds Ξ± (.mkOfNhds n) a = n a := by
let t : TopologicalSpace Ξ± := .mkOfNhds n
apply le_antisymm
Β· intro U hU
replace hpure : pure β€ n := fun x β¦ (hb x).ge_iff.2 (hpure x)
refine mem_nhds_iff.2 β¨{x | U β n x}, fun x hx β¦ hpure x hx, fun x hx β¦ ?_, hUβ©
rcases (hb x).mem_iff.1 hx with β¨i, hpi, hiβ©
exact (hopen x i hpi).mono fun y hy β¦ mem_of_superset hy hi
Β· exact (nhds_basis_opens a).ge_iff.2 fun U β¨haU, hUoβ© β¦ hUo a haU
theorem nhds_mkOfNhds (n : Ξ± β Filter Ξ±) (a : Ξ±) (hβ : pure β€ n)
(hβ : β a, β s β n a, βαΆ y in n a, s β n y) :
@nhds Ξ± (TopologicalSpace.mkOfNhds n) a = n a :=
nhds_mkOfNhds_of_hasBasis (fun a β¦ (n a).basis_sets) hβ hβ _
#align topological_space.nhds_mk_of_nhds TopologicalSpace.nhds_mkOfNhds
| Mathlib/Topology/Order.lean | 129 | 138 | theorem nhds_mkOfNhds_single [DecidableEq Ξ±] {aβ : Ξ±} {l : Filter Ξ±} (h : pure aβ β€ l) (b : Ξ±) :
@nhds Ξ± (TopologicalSpace.mkOfNhds (update pure aβ l)) b =
(update pure aβ l : Ξ± β Filter Ξ±) b := by |
refine nhds_mkOfNhds _ _ (le_update_iff.mpr β¨h, fun _ _ => le_rflβ©) fun a s hs => ?_
rcases eq_or_ne a aβ with (rfl | ha)
Β· filter_upwards [hs] with b hb
rcases eq_or_ne b a with (rfl | hb)
Β· exact hs
Β· rwa [update_noteq hb]
Β· simpa only [update_noteq ha, mem_pure, eventually_pure] using hs
| 1,110 |
import Mathlib.Topology.Order
#align_import topology.maps from "leanprover-community/mathlib"@"d91e7f7a7f1c7e9f0e18fdb6bde4f652004c735d"
open Set Filter Function
open TopologicalSpace Topology Filter
variable {X : Type*} {Y : Type*} {Z : Type*} {ΞΉ : Type*} {f : X β Y} {g : Y β Z}
section Inducing
variable [TopologicalSpace X] [TopologicalSpace Y] [TopologicalSpace Z]
theorem inducing_induced (f : X β Y) : @Inducing X Y (TopologicalSpace.induced f βΉ_βΊ) _ f :=
@Inducing.mk _ _ (TopologicalSpace.induced f βΉ_βΊ) _ _ rfl
theorem inducing_id : Inducing (@id X) :=
β¨induced_id.symmβ©
#align inducing_id inducing_id
protected theorem Inducing.comp (hg : Inducing g) (hf : Inducing f) :
Inducing (g β f) :=
β¨by rw [hf.induced, hg.induced, induced_compose]β©
#align inducing.comp Inducing.comp
| Mathlib/Topology/Maps.lean | 69 | 72 | theorem Inducing.of_comp_iff (hg : Inducing g) :
Inducing (g β f) β Inducing f := by |
refine β¨fun h β¦ ?_, hg.compβ©
rw [inducing_iff, hg.induced, induced_compose, h.induced]
| 1,111 |
import Mathlib.Topology.Order
#align_import topology.maps from "leanprover-community/mathlib"@"d91e7f7a7f1c7e9f0e18fdb6bde4f652004c735d"
open Set Filter Function
open TopologicalSpace Topology Filter
variable {X : Type*} {Y : Type*} {Z : Type*} {ΞΉ : Type*} {f : X β Y} {g : Y β Z}
section Inducing
variable [TopologicalSpace X] [TopologicalSpace Y] [TopologicalSpace Z]
theorem inducing_induced (f : X β Y) : @Inducing X Y (TopologicalSpace.induced f βΉ_βΊ) _ f :=
@Inducing.mk _ _ (TopologicalSpace.induced f βΉ_βΊ) _ _ rfl
theorem inducing_id : Inducing (@id X) :=
β¨induced_id.symmβ©
#align inducing_id inducing_id
protected theorem Inducing.comp (hg : Inducing g) (hf : Inducing f) :
Inducing (g β f) :=
β¨by rw [hf.induced, hg.induced, induced_compose]β©
#align inducing.comp Inducing.comp
theorem Inducing.of_comp_iff (hg : Inducing g) :
Inducing (g β f) β Inducing f := by
refine β¨fun h β¦ ?_, hg.compβ©
rw [inducing_iff, hg.induced, induced_compose, h.induced]
#align inducing.inducing_iff Inducing.of_comp_iff
theorem inducing_of_inducing_compose
(hf : Continuous f) (hg : Continuous g) (hgf : Inducing (g β f)) : Inducing f :=
β¨le_antisymm (by rwa [β continuous_iff_le_induced])
(by
rw [hgf.induced, β induced_compose]
exact induced_mono hg.le_induced)β©
#align inducing_of_inducing_compose inducing_of_inducing_compose
theorem inducing_iff_nhds : Inducing f β β x, π x = comap f (π (f x)) :=
(inducing_iff _).trans (induced_iff_nhds_eq f)
#align inducing_iff_nhds inducing_iff_nhds
namespace Inducing
theorem nhds_eq_comap (hf : Inducing f) : β x : X, π x = comap f (π <| f x) :=
inducing_iff_nhds.1 hf
#align inducing.nhds_eq_comap Inducing.nhds_eq_comap
theorem basis_nhds {p : ΞΉ β Prop} {s : ΞΉ β Set Y} (hf : Inducing f) {x : X}
(h_basis : (π (f x)).HasBasis p s) : (π x).HasBasis p (preimage f β s) :=
hf.nhds_eq_comap x βΈ h_basis.comap f
| Mathlib/Topology/Maps.lean | 97 | 99 | theorem nhdsSet_eq_comap (hf : Inducing f) (s : Set X) :
πΛ’ s = comap f (πΛ’ (f '' s)) := by |
simp only [nhdsSet, sSup_image, comap_iSup, hf.nhds_eq_comap, iSup_image]
| 1,111 |
import Mathlib.Topology.Order
#align_import topology.maps from "leanprover-community/mathlib"@"d91e7f7a7f1c7e9f0e18fdb6bde4f652004c735d"
open Set Filter Function
open TopologicalSpace Topology Filter
variable {X : Type*} {Y : Type*} {Z : Type*} {ΞΉ : Type*} {f : X β Y} {g : Y β Z}
section Inducing
variable [TopologicalSpace X] [TopologicalSpace Y] [TopologicalSpace Z]
theorem inducing_induced (f : X β Y) : @Inducing X Y (TopologicalSpace.induced f βΉ_βΊ) _ f :=
@Inducing.mk _ _ (TopologicalSpace.induced f βΉ_βΊ) _ _ rfl
theorem inducing_id : Inducing (@id X) :=
β¨induced_id.symmβ©
#align inducing_id inducing_id
protected theorem Inducing.comp (hg : Inducing g) (hf : Inducing f) :
Inducing (g β f) :=
β¨by rw [hf.induced, hg.induced, induced_compose]β©
#align inducing.comp Inducing.comp
theorem Inducing.of_comp_iff (hg : Inducing g) :
Inducing (g β f) β Inducing f := by
refine β¨fun h β¦ ?_, hg.compβ©
rw [inducing_iff, hg.induced, induced_compose, h.induced]
#align inducing.inducing_iff Inducing.of_comp_iff
theorem inducing_of_inducing_compose
(hf : Continuous f) (hg : Continuous g) (hgf : Inducing (g β f)) : Inducing f :=
β¨le_antisymm (by rwa [β continuous_iff_le_induced])
(by
rw [hgf.induced, β induced_compose]
exact induced_mono hg.le_induced)β©
#align inducing_of_inducing_compose inducing_of_inducing_compose
theorem inducing_iff_nhds : Inducing f β β x, π x = comap f (π (f x)) :=
(inducing_iff _).trans (induced_iff_nhds_eq f)
#align inducing_iff_nhds inducing_iff_nhds
namespace Inducing
theorem nhds_eq_comap (hf : Inducing f) : β x : X, π x = comap f (π <| f x) :=
inducing_iff_nhds.1 hf
#align inducing.nhds_eq_comap Inducing.nhds_eq_comap
theorem basis_nhds {p : ΞΉ β Prop} {s : ΞΉ β Set Y} (hf : Inducing f) {x : X}
(h_basis : (π (f x)).HasBasis p s) : (π x).HasBasis p (preimage f β s) :=
hf.nhds_eq_comap x βΈ h_basis.comap f
theorem nhdsSet_eq_comap (hf : Inducing f) (s : Set X) :
πΛ’ s = comap f (πΛ’ (f '' s)) := by
simp only [nhdsSet, sSup_image, comap_iSup, hf.nhds_eq_comap, iSup_image]
#align inducing.nhds_set_eq_comap Inducing.nhdsSet_eq_comap
theorem map_nhds_eq (hf : Inducing f) (x : X) : (π x).map f = π[range f] f x :=
hf.induced.symm βΈ map_nhds_induced_eq x
#align inducing.map_nhds_eq Inducing.map_nhds_eq
theorem map_nhds_of_mem (hf : Inducing f) (x : X) (h : range f β π (f x)) :
(π x).map f = π (f x) :=
hf.induced.symm βΈ map_nhds_induced_of_mem h
#align inducing.map_nhds_of_mem Inducing.map_nhds_of_mem
-- Porting note (#10756): new lemma
| Mathlib/Topology/Maps.lean | 112 | 115 | theorem mapClusterPt_iff (hf : Inducing f) {x : X} {l : Filter X} :
MapClusterPt (f x) l f β ClusterPt x l := by |
delta MapClusterPt ClusterPt
rw [β Filter.push_pull', β hf.nhds_eq_comap, map_neBot_iff]
| 1,111 |
import Mathlib.Topology.Order
#align_import topology.maps from "leanprover-community/mathlib"@"d91e7f7a7f1c7e9f0e18fdb6bde4f652004c735d"
open Set Filter Function
open TopologicalSpace Topology Filter
variable {X : Type*} {Y : Type*} {Z : Type*} {ΞΉ : Type*} {f : X β Y} {g : Y β Z}
section Inducing
variable [TopologicalSpace X] [TopologicalSpace Y] [TopologicalSpace Z]
theorem inducing_induced (f : X β Y) : @Inducing X Y (TopologicalSpace.induced f βΉ_βΊ) _ f :=
@Inducing.mk _ _ (TopologicalSpace.induced f βΉ_βΊ) _ _ rfl
theorem inducing_id : Inducing (@id X) :=
β¨induced_id.symmβ©
#align inducing_id inducing_id
protected theorem Inducing.comp (hg : Inducing g) (hf : Inducing f) :
Inducing (g β f) :=
β¨by rw [hf.induced, hg.induced, induced_compose]β©
#align inducing.comp Inducing.comp
theorem Inducing.of_comp_iff (hg : Inducing g) :
Inducing (g β f) β Inducing f := by
refine β¨fun h β¦ ?_, hg.compβ©
rw [inducing_iff, hg.induced, induced_compose, h.induced]
#align inducing.inducing_iff Inducing.of_comp_iff
theorem inducing_of_inducing_compose
(hf : Continuous f) (hg : Continuous g) (hgf : Inducing (g β f)) : Inducing f :=
β¨le_antisymm (by rwa [β continuous_iff_le_induced])
(by
rw [hgf.induced, β induced_compose]
exact induced_mono hg.le_induced)β©
#align inducing_of_inducing_compose inducing_of_inducing_compose
theorem inducing_iff_nhds : Inducing f β β x, π x = comap f (π (f x)) :=
(inducing_iff _).trans (induced_iff_nhds_eq f)
#align inducing_iff_nhds inducing_iff_nhds
namespace Inducing
theorem nhds_eq_comap (hf : Inducing f) : β x : X, π x = comap f (π <| f x) :=
inducing_iff_nhds.1 hf
#align inducing.nhds_eq_comap Inducing.nhds_eq_comap
theorem basis_nhds {p : ΞΉ β Prop} {s : ΞΉ β Set Y} (hf : Inducing f) {x : X}
(h_basis : (π (f x)).HasBasis p s) : (π x).HasBasis p (preimage f β s) :=
hf.nhds_eq_comap x βΈ h_basis.comap f
theorem nhdsSet_eq_comap (hf : Inducing f) (s : Set X) :
πΛ’ s = comap f (πΛ’ (f '' s)) := by
simp only [nhdsSet, sSup_image, comap_iSup, hf.nhds_eq_comap, iSup_image]
#align inducing.nhds_set_eq_comap Inducing.nhdsSet_eq_comap
theorem map_nhds_eq (hf : Inducing f) (x : X) : (π x).map f = π[range f] f x :=
hf.induced.symm βΈ map_nhds_induced_eq x
#align inducing.map_nhds_eq Inducing.map_nhds_eq
theorem map_nhds_of_mem (hf : Inducing f) (x : X) (h : range f β π (f x)) :
(π x).map f = π (f x) :=
hf.induced.symm βΈ map_nhds_induced_of_mem h
#align inducing.map_nhds_of_mem Inducing.map_nhds_of_mem
-- Porting note (#10756): new lemma
theorem mapClusterPt_iff (hf : Inducing f) {x : X} {l : Filter X} :
MapClusterPt (f x) l f β ClusterPt x l := by
delta MapClusterPt ClusterPt
rw [β Filter.push_pull', β hf.nhds_eq_comap, map_neBot_iff]
theorem image_mem_nhdsWithin (hf : Inducing f) {x : X} {s : Set X} (hs : s β π x) :
f '' s β π[range f] f x :=
hf.map_nhds_eq x βΈ image_mem_map hs
#align inducing.image_mem_nhds_within Inducing.image_mem_nhdsWithin
| Mathlib/Topology/Maps.lean | 122 | 124 | theorem tendsto_nhds_iff {f : ΞΉ β Y} {l : Filter ΞΉ} {y : Y} (hg : Inducing g) :
Tendsto f l (π y) β Tendsto (g β f) l (π (g y)) := by |
rw [hg.nhds_eq_comap, tendsto_comap_iff]
| 1,111 |
import Mathlib.Topology.Order
#align_import topology.maps from "leanprover-community/mathlib"@"d91e7f7a7f1c7e9f0e18fdb6bde4f652004c735d"
open Set Filter Function
open TopologicalSpace Topology Filter
variable {X : Type*} {Y : Type*} {Z : Type*} {ΞΉ : Type*} {f : X β Y} {g : Y β Z}
section Inducing
variable [TopologicalSpace X] [TopologicalSpace Y] [TopologicalSpace Z]
theorem inducing_induced (f : X β Y) : @Inducing X Y (TopologicalSpace.induced f βΉ_βΊ) _ f :=
@Inducing.mk _ _ (TopologicalSpace.induced f βΉ_βΊ) _ _ rfl
theorem inducing_id : Inducing (@id X) :=
β¨induced_id.symmβ©
#align inducing_id inducing_id
protected theorem Inducing.comp (hg : Inducing g) (hf : Inducing f) :
Inducing (g β f) :=
β¨by rw [hf.induced, hg.induced, induced_compose]β©
#align inducing.comp Inducing.comp
theorem Inducing.of_comp_iff (hg : Inducing g) :
Inducing (g β f) β Inducing f := by
refine β¨fun h β¦ ?_, hg.compβ©
rw [inducing_iff, hg.induced, induced_compose, h.induced]
#align inducing.inducing_iff Inducing.of_comp_iff
theorem inducing_of_inducing_compose
(hf : Continuous f) (hg : Continuous g) (hgf : Inducing (g β f)) : Inducing f :=
β¨le_antisymm (by rwa [β continuous_iff_le_induced])
(by
rw [hgf.induced, β induced_compose]
exact induced_mono hg.le_induced)β©
#align inducing_of_inducing_compose inducing_of_inducing_compose
theorem inducing_iff_nhds : Inducing f β β x, π x = comap f (π (f x)) :=
(inducing_iff _).trans (induced_iff_nhds_eq f)
#align inducing_iff_nhds inducing_iff_nhds
namespace Inducing
theorem nhds_eq_comap (hf : Inducing f) : β x : X, π x = comap f (π <| f x) :=
inducing_iff_nhds.1 hf
#align inducing.nhds_eq_comap Inducing.nhds_eq_comap
theorem basis_nhds {p : ΞΉ β Prop} {s : ΞΉ β Set Y} (hf : Inducing f) {x : X}
(h_basis : (π (f x)).HasBasis p s) : (π x).HasBasis p (preimage f β s) :=
hf.nhds_eq_comap x βΈ h_basis.comap f
theorem nhdsSet_eq_comap (hf : Inducing f) (s : Set X) :
πΛ’ s = comap f (πΛ’ (f '' s)) := by
simp only [nhdsSet, sSup_image, comap_iSup, hf.nhds_eq_comap, iSup_image]
#align inducing.nhds_set_eq_comap Inducing.nhdsSet_eq_comap
theorem map_nhds_eq (hf : Inducing f) (x : X) : (π x).map f = π[range f] f x :=
hf.induced.symm βΈ map_nhds_induced_eq x
#align inducing.map_nhds_eq Inducing.map_nhds_eq
theorem map_nhds_of_mem (hf : Inducing f) (x : X) (h : range f β π (f x)) :
(π x).map f = π (f x) :=
hf.induced.symm βΈ map_nhds_induced_of_mem h
#align inducing.map_nhds_of_mem Inducing.map_nhds_of_mem
-- Porting note (#10756): new lemma
theorem mapClusterPt_iff (hf : Inducing f) {x : X} {l : Filter X} :
MapClusterPt (f x) l f β ClusterPt x l := by
delta MapClusterPt ClusterPt
rw [β Filter.push_pull', β hf.nhds_eq_comap, map_neBot_iff]
theorem image_mem_nhdsWithin (hf : Inducing f) {x : X} {s : Set X} (hs : s β π x) :
f '' s β π[range f] f x :=
hf.map_nhds_eq x βΈ image_mem_map hs
#align inducing.image_mem_nhds_within Inducing.image_mem_nhdsWithin
theorem tendsto_nhds_iff {f : ΞΉ β Y} {l : Filter ΞΉ} {y : Y} (hg : Inducing g) :
Tendsto f l (π y) β Tendsto (g β f) l (π (g y)) := by
rw [hg.nhds_eq_comap, tendsto_comap_iff]
#align inducing.tendsto_nhds_iff Inducing.tendsto_nhds_iff
theorem continuousAt_iff (hg : Inducing g) {x : X} :
ContinuousAt f x β ContinuousAt (g β f) x :=
hg.tendsto_nhds_iff
#align inducing.continuous_at_iff Inducing.continuousAt_iff
| Mathlib/Topology/Maps.lean | 132 | 134 | theorem continuous_iff (hg : Inducing g) :
Continuous f β Continuous (g β f) := by |
simp_rw [continuous_iff_continuousAt, hg.continuousAt_iff]
| 1,111 |
import Mathlib.Topology.Order
#align_import topology.maps from "leanprover-community/mathlib"@"d91e7f7a7f1c7e9f0e18fdb6bde4f652004c735d"
open Set Filter Function
open TopologicalSpace Topology Filter
variable {X : Type*} {Y : Type*} {Z : Type*} {ΞΉ : Type*} {f : X β Y} {g : Y β Z}
section Inducing
variable [TopologicalSpace X] [TopologicalSpace Y] [TopologicalSpace Z]
theorem inducing_induced (f : X β Y) : @Inducing X Y (TopologicalSpace.induced f βΉ_βΊ) _ f :=
@Inducing.mk _ _ (TopologicalSpace.induced f βΉ_βΊ) _ _ rfl
theorem inducing_id : Inducing (@id X) :=
β¨induced_id.symmβ©
#align inducing_id inducing_id
protected theorem Inducing.comp (hg : Inducing g) (hf : Inducing f) :
Inducing (g β f) :=
β¨by rw [hf.induced, hg.induced, induced_compose]β©
#align inducing.comp Inducing.comp
theorem Inducing.of_comp_iff (hg : Inducing g) :
Inducing (g β f) β Inducing f := by
refine β¨fun h β¦ ?_, hg.compβ©
rw [inducing_iff, hg.induced, induced_compose, h.induced]
#align inducing.inducing_iff Inducing.of_comp_iff
theorem inducing_of_inducing_compose
(hf : Continuous f) (hg : Continuous g) (hgf : Inducing (g β f)) : Inducing f :=
β¨le_antisymm (by rwa [β continuous_iff_le_induced])
(by
rw [hgf.induced, β induced_compose]
exact induced_mono hg.le_induced)β©
#align inducing_of_inducing_compose inducing_of_inducing_compose
theorem inducing_iff_nhds : Inducing f β β x, π x = comap f (π (f x)) :=
(inducing_iff _).trans (induced_iff_nhds_eq f)
#align inducing_iff_nhds inducing_iff_nhds
namespace Inducing
theorem nhds_eq_comap (hf : Inducing f) : β x : X, π x = comap f (π <| f x) :=
inducing_iff_nhds.1 hf
#align inducing.nhds_eq_comap Inducing.nhds_eq_comap
theorem basis_nhds {p : ΞΉ β Prop} {s : ΞΉ β Set Y} (hf : Inducing f) {x : X}
(h_basis : (π (f x)).HasBasis p s) : (π x).HasBasis p (preimage f β s) :=
hf.nhds_eq_comap x βΈ h_basis.comap f
theorem nhdsSet_eq_comap (hf : Inducing f) (s : Set X) :
πΛ’ s = comap f (πΛ’ (f '' s)) := by
simp only [nhdsSet, sSup_image, comap_iSup, hf.nhds_eq_comap, iSup_image]
#align inducing.nhds_set_eq_comap Inducing.nhdsSet_eq_comap
theorem map_nhds_eq (hf : Inducing f) (x : X) : (π x).map f = π[range f] f x :=
hf.induced.symm βΈ map_nhds_induced_eq x
#align inducing.map_nhds_eq Inducing.map_nhds_eq
theorem map_nhds_of_mem (hf : Inducing f) (x : X) (h : range f β π (f x)) :
(π x).map f = π (f x) :=
hf.induced.symm βΈ map_nhds_induced_of_mem h
#align inducing.map_nhds_of_mem Inducing.map_nhds_of_mem
-- Porting note (#10756): new lemma
theorem mapClusterPt_iff (hf : Inducing f) {x : X} {l : Filter X} :
MapClusterPt (f x) l f β ClusterPt x l := by
delta MapClusterPt ClusterPt
rw [β Filter.push_pull', β hf.nhds_eq_comap, map_neBot_iff]
theorem image_mem_nhdsWithin (hf : Inducing f) {x : X} {s : Set X} (hs : s β π x) :
f '' s β π[range f] f x :=
hf.map_nhds_eq x βΈ image_mem_map hs
#align inducing.image_mem_nhds_within Inducing.image_mem_nhdsWithin
theorem tendsto_nhds_iff {f : ΞΉ β Y} {l : Filter ΞΉ} {y : Y} (hg : Inducing g) :
Tendsto f l (π y) β Tendsto (g β f) l (π (g y)) := by
rw [hg.nhds_eq_comap, tendsto_comap_iff]
#align inducing.tendsto_nhds_iff Inducing.tendsto_nhds_iff
theorem continuousAt_iff (hg : Inducing g) {x : X} :
ContinuousAt f x β ContinuousAt (g β f) x :=
hg.tendsto_nhds_iff
#align inducing.continuous_at_iff Inducing.continuousAt_iff
theorem continuous_iff (hg : Inducing g) :
Continuous f β Continuous (g β f) := by
simp_rw [continuous_iff_continuousAt, hg.continuousAt_iff]
#align inducing.continuous_iff Inducing.continuous_iff
| Mathlib/Topology/Maps.lean | 137 | 139 | theorem continuousAt_iff' (hf : Inducing f) {x : X} (h : range f β π (f x)) :
ContinuousAt (g β f) x β ContinuousAt g (f x) := by |
simp_rw [ContinuousAt, Filter.Tendsto, β hf.map_nhds_of_mem _ h, Filter.map_map, comp]
| 1,111 |
import Mathlib.Topology.Order
#align_import topology.maps from "leanprover-community/mathlib"@"d91e7f7a7f1c7e9f0e18fdb6bde4f652004c735d"
open Set Filter Function
open TopologicalSpace Topology Filter
variable {X : Type*} {Y : Type*} {Z : Type*} {ΞΉ : Type*} {f : X β Y} {g : Y β Z}
section Inducing
variable [TopologicalSpace X] [TopologicalSpace Y] [TopologicalSpace Z]
theorem inducing_induced (f : X β Y) : @Inducing X Y (TopologicalSpace.induced f βΉ_βΊ) _ f :=
@Inducing.mk _ _ (TopologicalSpace.induced f βΉ_βΊ) _ _ rfl
theorem inducing_id : Inducing (@id X) :=
β¨induced_id.symmβ©
#align inducing_id inducing_id
protected theorem Inducing.comp (hg : Inducing g) (hf : Inducing f) :
Inducing (g β f) :=
β¨by rw [hf.induced, hg.induced, induced_compose]β©
#align inducing.comp Inducing.comp
theorem Inducing.of_comp_iff (hg : Inducing g) :
Inducing (g β f) β Inducing f := by
refine β¨fun h β¦ ?_, hg.compβ©
rw [inducing_iff, hg.induced, induced_compose, h.induced]
#align inducing.inducing_iff Inducing.of_comp_iff
theorem inducing_of_inducing_compose
(hf : Continuous f) (hg : Continuous g) (hgf : Inducing (g β f)) : Inducing f :=
β¨le_antisymm (by rwa [β continuous_iff_le_induced])
(by
rw [hgf.induced, β induced_compose]
exact induced_mono hg.le_induced)β©
#align inducing_of_inducing_compose inducing_of_inducing_compose
theorem inducing_iff_nhds : Inducing f β β x, π x = comap f (π (f x)) :=
(inducing_iff _).trans (induced_iff_nhds_eq f)
#align inducing_iff_nhds inducing_iff_nhds
namespace Inducing
theorem nhds_eq_comap (hf : Inducing f) : β x : X, π x = comap f (π <| f x) :=
inducing_iff_nhds.1 hf
#align inducing.nhds_eq_comap Inducing.nhds_eq_comap
theorem basis_nhds {p : ΞΉ β Prop} {s : ΞΉ β Set Y} (hf : Inducing f) {x : X}
(h_basis : (π (f x)).HasBasis p s) : (π x).HasBasis p (preimage f β s) :=
hf.nhds_eq_comap x βΈ h_basis.comap f
theorem nhdsSet_eq_comap (hf : Inducing f) (s : Set X) :
πΛ’ s = comap f (πΛ’ (f '' s)) := by
simp only [nhdsSet, sSup_image, comap_iSup, hf.nhds_eq_comap, iSup_image]
#align inducing.nhds_set_eq_comap Inducing.nhdsSet_eq_comap
theorem map_nhds_eq (hf : Inducing f) (x : X) : (π x).map f = π[range f] f x :=
hf.induced.symm βΈ map_nhds_induced_eq x
#align inducing.map_nhds_eq Inducing.map_nhds_eq
theorem map_nhds_of_mem (hf : Inducing f) (x : X) (h : range f β π (f x)) :
(π x).map f = π (f x) :=
hf.induced.symm βΈ map_nhds_induced_of_mem h
#align inducing.map_nhds_of_mem Inducing.map_nhds_of_mem
-- Porting note (#10756): new lemma
theorem mapClusterPt_iff (hf : Inducing f) {x : X} {l : Filter X} :
MapClusterPt (f x) l f β ClusterPt x l := by
delta MapClusterPt ClusterPt
rw [β Filter.push_pull', β hf.nhds_eq_comap, map_neBot_iff]
theorem image_mem_nhdsWithin (hf : Inducing f) {x : X} {s : Set X} (hs : s β π x) :
f '' s β π[range f] f x :=
hf.map_nhds_eq x βΈ image_mem_map hs
#align inducing.image_mem_nhds_within Inducing.image_mem_nhdsWithin
theorem tendsto_nhds_iff {f : ΞΉ β Y} {l : Filter ΞΉ} {y : Y} (hg : Inducing g) :
Tendsto f l (π y) β Tendsto (g β f) l (π (g y)) := by
rw [hg.nhds_eq_comap, tendsto_comap_iff]
#align inducing.tendsto_nhds_iff Inducing.tendsto_nhds_iff
theorem continuousAt_iff (hg : Inducing g) {x : X} :
ContinuousAt f x β ContinuousAt (g β f) x :=
hg.tendsto_nhds_iff
#align inducing.continuous_at_iff Inducing.continuousAt_iff
theorem continuous_iff (hg : Inducing g) :
Continuous f β Continuous (g β f) := by
simp_rw [continuous_iff_continuousAt, hg.continuousAt_iff]
#align inducing.continuous_iff Inducing.continuous_iff
theorem continuousAt_iff' (hf : Inducing f) {x : X} (h : range f β π (f x)) :
ContinuousAt (g β f) x β ContinuousAt g (f x) := by
simp_rw [ContinuousAt, Filter.Tendsto, β hf.map_nhds_of_mem _ h, Filter.map_map, comp]
#align inducing.continuous_at_iff' Inducing.continuousAt_iff'
protected theorem continuous (hf : Inducing f) : Continuous f :=
hf.continuous_iff.mp continuous_id
#align inducing.continuous Inducing.continuous
| Mathlib/Topology/Maps.lean | 146 | 149 | theorem closure_eq_preimage_closure_image (hf : Inducing f) (s : Set X) :
closure s = f β»ΒΉ' closure (f '' s) := by |
ext x
rw [Set.mem_preimage, β closure_induced, hf.induced]
| 1,111 |
import Mathlib.Topology.Order
#align_import topology.maps from "leanprover-community/mathlib"@"d91e7f7a7f1c7e9f0e18fdb6bde4f652004c735d"
open Set Filter Function
open TopologicalSpace Topology Filter
variable {X : Type*} {Y : Type*} {Z : Type*} {ΞΉ : Type*} {f : X β Y} {g : Y β Z}
section Inducing
variable [TopologicalSpace X] [TopologicalSpace Y] [TopologicalSpace Z]
theorem inducing_induced (f : X β Y) : @Inducing X Y (TopologicalSpace.induced f βΉ_βΊ) _ f :=
@Inducing.mk _ _ (TopologicalSpace.induced f βΉ_βΊ) _ _ rfl
theorem inducing_id : Inducing (@id X) :=
β¨induced_id.symmβ©
#align inducing_id inducing_id
protected theorem Inducing.comp (hg : Inducing g) (hf : Inducing f) :
Inducing (g β f) :=
β¨by rw [hf.induced, hg.induced, induced_compose]β©
#align inducing.comp Inducing.comp
theorem Inducing.of_comp_iff (hg : Inducing g) :
Inducing (g β f) β Inducing f := by
refine β¨fun h β¦ ?_, hg.compβ©
rw [inducing_iff, hg.induced, induced_compose, h.induced]
#align inducing.inducing_iff Inducing.of_comp_iff
theorem inducing_of_inducing_compose
(hf : Continuous f) (hg : Continuous g) (hgf : Inducing (g β f)) : Inducing f :=
β¨le_antisymm (by rwa [β continuous_iff_le_induced])
(by
rw [hgf.induced, β induced_compose]
exact induced_mono hg.le_induced)β©
#align inducing_of_inducing_compose inducing_of_inducing_compose
theorem inducing_iff_nhds : Inducing f β β x, π x = comap f (π (f x)) :=
(inducing_iff _).trans (induced_iff_nhds_eq f)
#align inducing_iff_nhds inducing_iff_nhds
namespace Inducing
theorem nhds_eq_comap (hf : Inducing f) : β x : X, π x = comap f (π <| f x) :=
inducing_iff_nhds.1 hf
#align inducing.nhds_eq_comap Inducing.nhds_eq_comap
theorem basis_nhds {p : ΞΉ β Prop} {s : ΞΉ β Set Y} (hf : Inducing f) {x : X}
(h_basis : (π (f x)).HasBasis p s) : (π x).HasBasis p (preimage f β s) :=
hf.nhds_eq_comap x βΈ h_basis.comap f
theorem nhdsSet_eq_comap (hf : Inducing f) (s : Set X) :
πΛ’ s = comap f (πΛ’ (f '' s)) := by
simp only [nhdsSet, sSup_image, comap_iSup, hf.nhds_eq_comap, iSup_image]
#align inducing.nhds_set_eq_comap Inducing.nhdsSet_eq_comap
theorem map_nhds_eq (hf : Inducing f) (x : X) : (π x).map f = π[range f] f x :=
hf.induced.symm βΈ map_nhds_induced_eq x
#align inducing.map_nhds_eq Inducing.map_nhds_eq
theorem map_nhds_of_mem (hf : Inducing f) (x : X) (h : range f β π (f x)) :
(π x).map f = π (f x) :=
hf.induced.symm βΈ map_nhds_induced_of_mem h
#align inducing.map_nhds_of_mem Inducing.map_nhds_of_mem
-- Porting note (#10756): new lemma
theorem mapClusterPt_iff (hf : Inducing f) {x : X} {l : Filter X} :
MapClusterPt (f x) l f β ClusterPt x l := by
delta MapClusterPt ClusterPt
rw [β Filter.push_pull', β hf.nhds_eq_comap, map_neBot_iff]
theorem image_mem_nhdsWithin (hf : Inducing f) {x : X} {s : Set X} (hs : s β π x) :
f '' s β π[range f] f x :=
hf.map_nhds_eq x βΈ image_mem_map hs
#align inducing.image_mem_nhds_within Inducing.image_mem_nhdsWithin
theorem tendsto_nhds_iff {f : ΞΉ β Y} {l : Filter ΞΉ} {y : Y} (hg : Inducing g) :
Tendsto f l (π y) β Tendsto (g β f) l (π (g y)) := by
rw [hg.nhds_eq_comap, tendsto_comap_iff]
#align inducing.tendsto_nhds_iff Inducing.tendsto_nhds_iff
theorem continuousAt_iff (hg : Inducing g) {x : X} :
ContinuousAt f x β ContinuousAt (g β f) x :=
hg.tendsto_nhds_iff
#align inducing.continuous_at_iff Inducing.continuousAt_iff
theorem continuous_iff (hg : Inducing g) :
Continuous f β Continuous (g β f) := by
simp_rw [continuous_iff_continuousAt, hg.continuousAt_iff]
#align inducing.continuous_iff Inducing.continuous_iff
theorem continuousAt_iff' (hf : Inducing f) {x : X} (h : range f β π (f x)) :
ContinuousAt (g β f) x β ContinuousAt g (f x) := by
simp_rw [ContinuousAt, Filter.Tendsto, β hf.map_nhds_of_mem _ h, Filter.map_map, comp]
#align inducing.continuous_at_iff' Inducing.continuousAt_iff'
protected theorem continuous (hf : Inducing f) : Continuous f :=
hf.continuous_iff.mp continuous_id
#align inducing.continuous Inducing.continuous
theorem closure_eq_preimage_closure_image (hf : Inducing f) (s : Set X) :
closure s = f β»ΒΉ' closure (f '' s) := by
ext x
rw [Set.mem_preimage, β closure_induced, hf.induced]
#align inducing.closure_eq_preimage_closure_image Inducing.closure_eq_preimage_closure_image
| Mathlib/Topology/Maps.lean | 152 | 153 | theorem isClosed_iff (hf : Inducing f) {s : Set X} :
IsClosed s β β t, IsClosed t β§ f β»ΒΉ' t = s := by | rw [hf.induced, isClosed_induced_iff]
| 1,111 |
import Mathlib.Topology.Order
#align_import topology.maps from "leanprover-community/mathlib"@"d91e7f7a7f1c7e9f0e18fdb6bde4f652004c735d"
open Set Filter Function
open TopologicalSpace Topology Filter
variable {X : Type*} {Y : Type*} {Z : Type*} {ΞΉ : Type*} {f : X β Y} {g : Y β Z}
section Inducing
variable [TopologicalSpace X] [TopologicalSpace Y] [TopologicalSpace Z]
theorem inducing_induced (f : X β Y) : @Inducing X Y (TopologicalSpace.induced f βΉ_βΊ) _ f :=
@Inducing.mk _ _ (TopologicalSpace.induced f βΉ_βΊ) _ _ rfl
theorem inducing_id : Inducing (@id X) :=
β¨induced_id.symmβ©
#align inducing_id inducing_id
protected theorem Inducing.comp (hg : Inducing g) (hf : Inducing f) :
Inducing (g β f) :=
β¨by rw [hf.induced, hg.induced, induced_compose]β©
#align inducing.comp Inducing.comp
theorem Inducing.of_comp_iff (hg : Inducing g) :
Inducing (g β f) β Inducing f := by
refine β¨fun h β¦ ?_, hg.compβ©
rw [inducing_iff, hg.induced, induced_compose, h.induced]
#align inducing.inducing_iff Inducing.of_comp_iff
theorem inducing_of_inducing_compose
(hf : Continuous f) (hg : Continuous g) (hgf : Inducing (g β f)) : Inducing f :=
β¨le_antisymm (by rwa [β continuous_iff_le_induced])
(by
rw [hgf.induced, β induced_compose]
exact induced_mono hg.le_induced)β©
#align inducing_of_inducing_compose inducing_of_inducing_compose
theorem inducing_iff_nhds : Inducing f β β x, π x = comap f (π (f x)) :=
(inducing_iff _).trans (induced_iff_nhds_eq f)
#align inducing_iff_nhds inducing_iff_nhds
namespace Inducing
theorem nhds_eq_comap (hf : Inducing f) : β x : X, π x = comap f (π <| f x) :=
inducing_iff_nhds.1 hf
#align inducing.nhds_eq_comap Inducing.nhds_eq_comap
theorem basis_nhds {p : ΞΉ β Prop} {s : ΞΉ β Set Y} (hf : Inducing f) {x : X}
(h_basis : (π (f x)).HasBasis p s) : (π x).HasBasis p (preimage f β s) :=
hf.nhds_eq_comap x βΈ h_basis.comap f
theorem nhdsSet_eq_comap (hf : Inducing f) (s : Set X) :
πΛ’ s = comap f (πΛ’ (f '' s)) := by
simp only [nhdsSet, sSup_image, comap_iSup, hf.nhds_eq_comap, iSup_image]
#align inducing.nhds_set_eq_comap Inducing.nhdsSet_eq_comap
theorem map_nhds_eq (hf : Inducing f) (x : X) : (π x).map f = π[range f] f x :=
hf.induced.symm βΈ map_nhds_induced_eq x
#align inducing.map_nhds_eq Inducing.map_nhds_eq
theorem map_nhds_of_mem (hf : Inducing f) (x : X) (h : range f β π (f x)) :
(π x).map f = π (f x) :=
hf.induced.symm βΈ map_nhds_induced_of_mem h
#align inducing.map_nhds_of_mem Inducing.map_nhds_of_mem
-- Porting note (#10756): new lemma
theorem mapClusterPt_iff (hf : Inducing f) {x : X} {l : Filter X} :
MapClusterPt (f x) l f β ClusterPt x l := by
delta MapClusterPt ClusterPt
rw [β Filter.push_pull', β hf.nhds_eq_comap, map_neBot_iff]
theorem image_mem_nhdsWithin (hf : Inducing f) {x : X} {s : Set X} (hs : s β π x) :
f '' s β π[range f] f x :=
hf.map_nhds_eq x βΈ image_mem_map hs
#align inducing.image_mem_nhds_within Inducing.image_mem_nhdsWithin
theorem tendsto_nhds_iff {f : ΞΉ β Y} {l : Filter ΞΉ} {y : Y} (hg : Inducing g) :
Tendsto f l (π y) β Tendsto (g β f) l (π (g y)) := by
rw [hg.nhds_eq_comap, tendsto_comap_iff]
#align inducing.tendsto_nhds_iff Inducing.tendsto_nhds_iff
theorem continuousAt_iff (hg : Inducing g) {x : X} :
ContinuousAt f x β ContinuousAt (g β f) x :=
hg.tendsto_nhds_iff
#align inducing.continuous_at_iff Inducing.continuousAt_iff
theorem continuous_iff (hg : Inducing g) :
Continuous f β Continuous (g β f) := by
simp_rw [continuous_iff_continuousAt, hg.continuousAt_iff]
#align inducing.continuous_iff Inducing.continuous_iff
theorem continuousAt_iff' (hf : Inducing f) {x : X} (h : range f β π (f x)) :
ContinuousAt (g β f) x β ContinuousAt g (f x) := by
simp_rw [ContinuousAt, Filter.Tendsto, β hf.map_nhds_of_mem _ h, Filter.map_map, comp]
#align inducing.continuous_at_iff' Inducing.continuousAt_iff'
protected theorem continuous (hf : Inducing f) : Continuous f :=
hf.continuous_iff.mp continuous_id
#align inducing.continuous Inducing.continuous
theorem closure_eq_preimage_closure_image (hf : Inducing f) (s : Set X) :
closure s = f β»ΒΉ' closure (f '' s) := by
ext x
rw [Set.mem_preimage, β closure_induced, hf.induced]
#align inducing.closure_eq_preimage_closure_image Inducing.closure_eq_preimage_closure_image
theorem isClosed_iff (hf : Inducing f) {s : Set X} :
IsClosed s β β t, IsClosed t β§ f β»ΒΉ' t = s := by rw [hf.induced, isClosed_induced_iff]
#align inducing.is_closed_iff Inducing.isClosed_iff
| Mathlib/Topology/Maps.lean | 156 | 157 | theorem isClosed_iff' (hf : Inducing f) {s : Set X} :
IsClosed s β β x, f x β closure (f '' s) β x β s := by | rw [hf.induced, isClosed_induced_iff']
| 1,111 |
import Mathlib.Topology.Order
#align_import topology.maps from "leanprover-community/mathlib"@"d91e7f7a7f1c7e9f0e18fdb6bde4f652004c735d"
open Set Filter Function
open TopologicalSpace Topology Filter
variable {X : Type*} {Y : Type*} {Z : Type*} {ΞΉ : Type*} {f : X β Y} {g : Y β Z}
section OpenMap
variable [TopologicalSpace X] [TopologicalSpace Y] [TopologicalSpace Z]
namespace IsOpenMap
protected theorem id : IsOpenMap (@id X) := fun s hs => by rwa [image_id]
#align is_open_map.id IsOpenMap.id
protected theorem comp (hg : IsOpenMap g) (hf : IsOpenMap f) :
IsOpenMap (g β f) := fun s hs => by rw [image_comp]; exact hg _ (hf _ hs)
#align is_open_map.comp IsOpenMap.comp
| Mathlib/Topology/Maps.lean | 338 | 340 | theorem isOpen_range (hf : IsOpenMap f) : IsOpen (range f) := by |
rw [β image_univ]
exact hf _ isOpen_univ
| 1,111 |
import Mathlib.Topology.Order
#align_import topology.maps from "leanprover-community/mathlib"@"d91e7f7a7f1c7e9f0e18fdb6bde4f652004c735d"
open Set Filter Function
open TopologicalSpace Topology Filter
variable {X : Type*} {Y : Type*} {Z : Type*} {ΞΉ : Type*} {f : X β Y} {g : Y β Z}
section OpenMap
variable [TopologicalSpace X] [TopologicalSpace Y] [TopologicalSpace Z]
namespace IsOpenMap
protected theorem id : IsOpenMap (@id X) := fun s hs => by rwa [image_id]
#align is_open_map.id IsOpenMap.id
protected theorem comp (hg : IsOpenMap g) (hf : IsOpenMap f) :
IsOpenMap (g β f) := fun s hs => by rw [image_comp]; exact hg _ (hf _ hs)
#align is_open_map.comp IsOpenMap.comp
theorem isOpen_range (hf : IsOpenMap f) : IsOpen (range f) := by
rw [β image_univ]
exact hf _ isOpen_univ
#align is_open_map.is_open_range IsOpenMap.isOpen_range
theorem image_mem_nhds (hf : IsOpenMap f) {x : X} {s : Set X} (hx : s β π x) : f '' s β π (f x) :=
let β¨t, hts, ht, hxtβ© := mem_nhds_iff.1 hx
mem_of_superset (IsOpen.mem_nhds (hf t ht) (mem_image_of_mem _ hxt)) (image_subset _ hts)
#align is_open_map.image_mem_nhds IsOpenMap.image_mem_nhds
theorem range_mem_nhds (hf : IsOpenMap f) (x : X) : range f β π (f x) :=
hf.isOpen_range.mem_nhds <| mem_range_self _
#align is_open_map.range_mem_nhds IsOpenMap.range_mem_nhds
theorem mapsTo_interior (hf : IsOpenMap f) {s : Set X} {t : Set Y} (h : MapsTo f s t) :
MapsTo f (interior s) (interior t) :=
mapsTo'.2 <|
interior_maximal (h.mono interior_subset Subset.rfl).image_subset (hf _ isOpen_interior)
#align is_open_map.maps_to_interior IsOpenMap.mapsTo_interior
theorem image_interior_subset (hf : IsOpenMap f) (s : Set X) :
f '' interior s β interior (f '' s) :=
(hf.mapsTo_interior (mapsTo_image f s)).image_subset
#align is_open_map.image_interior_subset IsOpenMap.image_interior_subset
theorem nhds_le (hf : IsOpenMap f) (x : X) : π (f x) β€ (π x).map f :=
le_map fun _ => hf.image_mem_nhds
#align is_open_map.nhds_le IsOpenMap.nhds_le
theorem of_nhds_le (hf : β x, π (f x) β€ map f (π x)) : IsOpenMap f := fun _s hs =>
isOpen_iff_mem_nhds.2 fun _y β¨_x, hxs, hxyβ© => hxy βΈ hf _ (image_mem_map <| hs.mem_nhds hxs)
#align is_open_map.of_nhds_le IsOpenMap.of_nhds_le
| Mathlib/Topology/Maps.lean | 371 | 378 | theorem of_sections
(h : β x, β g : Y β X, ContinuousAt g (f x) β§ g (f x) = x β§ RightInverse g f) : IsOpenMap f :=
of_nhds_le fun x =>
let β¨g, hgc, hgx, hgfβ© := h x
calc
π (f x) = map f (map g (π (f x))) := by | rw [map_map, hgf.comp_eq_id, map_id]
_ β€ map f (π (g (f x))) := map_mono hgc
_ = map f (π x) := by rw [hgx]
| 1,111 |
import Mathlib.Topology.Order
#align_import topology.maps from "leanprover-community/mathlib"@"d91e7f7a7f1c7e9f0e18fdb6bde4f652004c735d"
open Set Filter Function
open TopologicalSpace Topology Filter
variable {X : Type*} {Y : Type*} {Z : Type*} {ΞΉ : Type*} {f : X β Y} {g : Y β Z}
section OpenMap
variable [TopologicalSpace X] [TopologicalSpace Y] [TopologicalSpace Z]
section IsClosedMap
variable [TopologicalSpace X] [TopologicalSpace Y] [TopologicalSpace Z]
namespace IsClosedMap
open Function
protected theorem id : IsClosedMap (@id X) := fun s hs => by rwa [image_id]
#align is_closed_map.id IsClosedMap.id
protected theorem comp (hg : IsClosedMap g) (hf : IsClosedMap f) : IsClosedMap (g β f) := by
intro s hs
rw [image_comp]
exact hg _ (hf _ hs)
#align is_closed_map.comp IsClosedMap.comp
theorem closure_image_subset (hf : IsClosedMap f) (s : Set X) :
closure (f '' s) β f '' closure s :=
closure_minimal (image_subset _ subset_closure) (hf _ isClosed_closure)
#align is_closed_map.closure_image_subset IsClosedMap.closure_image_subset
theorem of_inverse {f' : Y β X} (h : Continuous f') (l_inv : LeftInverse f f')
(r_inv : RightInverse f f') : IsClosedMap f := fun s hs => by
rw [image_eq_preimage_of_inverse r_inv l_inv]
exact hs.preimage h
#align is_closed_map.of_inverse IsClosedMap.of_inverse
| Mathlib/Topology/Maps.lean | 478 | 482 | theorem of_nonempty (h : β s, IsClosed s β s.Nonempty β IsClosed (f '' s)) :
IsClosedMap f := by |
intro s hs; rcases eq_empty_or_nonempty s with h2s | h2s
Β· simp_rw [h2s, image_empty, isClosed_empty]
Β· exact h s hs h2s
| 1,111 |
import Mathlib.Topology.Order
import Mathlib.Topology.Sets.Opens
import Mathlib.Topology.ContinuousFunction.Basic
#align_import topology.continuous_function.t0_sierpinski from "leanprover-community/mathlib"@"dc6c365e751e34d100e80fe6e314c3c3e0fd2988"
noncomputable section
namespace TopologicalSpace
| Mathlib/Topology/ContinuousFunction/T0Sierpinski.lean | 28 | 37 | theorem eq_induced_by_maps_to_sierpinski (X : Type*) [t : TopologicalSpace X] :
t = β¨
u : Opens X, sierpinskiSpace.induced (Β· β u) := by |
apply le_antisymm
Β· rw [le_iInf_iff]
exact fun u => Continuous.le_induced (isOpen_iff_continuous_mem.mp u.2)
Β· intro u h
rw [β generateFrom_iUnion_isOpen]
apply isOpen_generateFrom_of_mem
simp only [Set.mem_iUnion, Set.mem_setOf_eq, isOpen_induced_iff]
exact β¨β¨u, hβ©, {True}, isOpen_singleton_true, by simp [Set.preimage]β©
| 1,112 |
import Mathlib.Topology.Order
import Mathlib.Topology.Sets.Opens
import Mathlib.Topology.ContinuousFunction.Basic
#align_import topology.continuous_function.t0_sierpinski from "leanprover-community/mathlib"@"dc6c365e751e34d100e80fe6e314c3c3e0fd2988"
noncomputable section
namespace TopologicalSpace
theorem eq_induced_by_maps_to_sierpinski (X : Type*) [t : TopologicalSpace X] :
t = β¨
u : Opens X, sierpinskiSpace.induced (Β· β u) := by
apply le_antisymm
Β· rw [le_iInf_iff]
exact fun u => Continuous.le_induced (isOpen_iff_continuous_mem.mp u.2)
Β· intro u h
rw [β generateFrom_iUnion_isOpen]
apply isOpen_generateFrom_of_mem
simp only [Set.mem_iUnion, Set.mem_setOf_eq, isOpen_induced_iff]
exact β¨β¨u, hβ©, {True}, isOpen_singleton_true, by simp [Set.preimage]β©
#align topological_space.eq_induced_by_maps_to_sierpinski TopologicalSpace.eq_induced_by_maps_to_sierpinski
variable (X : Type*) [TopologicalSpace X]
def productOfMemOpens : C(X, Opens X β Prop) where
toFun x u := x β u
continuous_toFun := continuous_pi_iff.2 fun u => continuous_Prop.2 u.isOpen
#align topological_space.product_of_mem_opens TopologicalSpace.productOfMemOpens
| Mathlib/Topology/ContinuousFunction/T0Sierpinski.lean | 50 | 52 | theorem productOfMemOpens_inducing : Inducing (productOfMemOpens X) := by |
convert inducing_iInf_to_pi fun (u : Opens X) (x : X) => x β u
apply eq_induced_by_maps_to_sierpinski
| 1,112 |
import Mathlib.Topology.Order
import Mathlib.Topology.Sets.Opens
import Mathlib.Topology.ContinuousFunction.Basic
#align_import topology.continuous_function.t0_sierpinski from "leanprover-community/mathlib"@"dc6c365e751e34d100e80fe6e314c3c3e0fd2988"
noncomputable section
namespace TopologicalSpace
theorem eq_induced_by_maps_to_sierpinski (X : Type*) [t : TopologicalSpace X] :
t = β¨
u : Opens X, sierpinskiSpace.induced (Β· β u) := by
apply le_antisymm
Β· rw [le_iInf_iff]
exact fun u => Continuous.le_induced (isOpen_iff_continuous_mem.mp u.2)
Β· intro u h
rw [β generateFrom_iUnion_isOpen]
apply isOpen_generateFrom_of_mem
simp only [Set.mem_iUnion, Set.mem_setOf_eq, isOpen_induced_iff]
exact β¨β¨u, hβ©, {True}, isOpen_singleton_true, by simp [Set.preimage]β©
#align topological_space.eq_induced_by_maps_to_sierpinski TopologicalSpace.eq_induced_by_maps_to_sierpinski
variable (X : Type*) [TopologicalSpace X]
def productOfMemOpens : C(X, Opens X β Prop) where
toFun x u := x β u
continuous_toFun := continuous_pi_iff.2 fun u => continuous_Prop.2 u.isOpen
#align topological_space.product_of_mem_opens TopologicalSpace.productOfMemOpens
theorem productOfMemOpens_inducing : Inducing (productOfMemOpens X) := by
convert inducing_iInf_to_pi fun (u : Opens X) (x : X) => x β u
apply eq_induced_by_maps_to_sierpinski
#align topological_space.product_of_mem_opens_inducing TopologicalSpace.productOfMemOpens_inducing
| Mathlib/Topology/ContinuousFunction/T0Sierpinski.lean | 55 | 58 | theorem productOfMemOpens_injective [T0Space X] : Function.Injective (productOfMemOpens X) := by |
intro x1 x2 h
apply Inseparable.eq
rw [β Inducing.inseparable_iff (productOfMemOpens_inducing X), h]
| 1,112 |
import Mathlib.Topology.Basic
#align_import topology.nhds_set from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
open Set Filter Topology
variable {X Y : Type*} [TopologicalSpace X] [TopologicalSpace Y] {f : Filter X}
{s t sβ sβ tβ tβ : Set X} {x : X}
| Mathlib/Topology/NhdsSet.lean | 35 | 38 | theorem nhdsSet_diagonal (X) [TopologicalSpace (X Γ X)] :
πΛ’ (diagonal X) = β¨ (x : X), π (x, x) := by |
rw [nhdsSet, β range_diag, β range_comp]
rfl
| 1,113 |
import Mathlib.Topology.Basic
#align_import topology.nhds_set from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
open Set Filter Topology
variable {X Y : Type*} [TopologicalSpace X] [TopologicalSpace Y] {f : Filter X}
{s t sβ sβ tβ tβ : Set X} {x : X}
theorem nhdsSet_diagonal (X) [TopologicalSpace (X Γ X)] :
πΛ’ (diagonal X) = β¨ (x : X), π (x, x) := by
rw [nhdsSet, β range_diag, β range_comp]
rfl
#align nhds_set_diagonal nhdsSet_diagonal
| Mathlib/Topology/NhdsSet.lean | 41 | 42 | theorem mem_nhdsSet_iff_forall : s β πΛ’ t β β x : X, x β t β s β π x := by |
simp_rw [nhdsSet, Filter.mem_sSup, forall_mem_image]
| 1,113 |
import Mathlib.Topology.Basic
#align_import topology.nhds_set from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
open Set Filter Topology
variable {X Y : Type*} [TopologicalSpace X] [TopologicalSpace Y] {f : Filter X}
{s t sβ sβ tβ tβ : Set X} {x : X}
theorem nhdsSet_diagonal (X) [TopologicalSpace (X Γ X)] :
πΛ’ (diagonal X) = β¨ (x : X), π (x, x) := by
rw [nhdsSet, β range_diag, β range_comp]
rfl
#align nhds_set_diagonal nhdsSet_diagonal
theorem mem_nhdsSet_iff_forall : s β πΛ’ t β β x : X, x β t β s β π x := by
simp_rw [nhdsSet, Filter.mem_sSup, forall_mem_image]
#align mem_nhds_set_iff_forall mem_nhdsSet_iff_forall
lemma nhdsSet_le : πΛ’ s β€ f β β x β s, π x β€ f := by simp [nhdsSet]
theorem bUnion_mem_nhdsSet {t : X β Set X} (h : β x β s, t x β π x) : (β x β s, t x) β πΛ’ s :=
mem_nhdsSet_iff_forall.2 fun x hx => mem_of_superset (h x hx) <|
subset_iUnionβ (s := fun x _ => t x) x hx -- Porting note: fails to find `s`
#align bUnion_mem_nhds_set bUnion_mem_nhdsSet
| Mathlib/Topology/NhdsSet.lean | 52 | 53 | theorem subset_interior_iff_mem_nhdsSet : s β interior t β t β πΛ’ s := by |
simp_rw [mem_nhdsSet_iff_forall, subset_interior_iff_nhds]
| 1,113 |
import Mathlib.Topology.Basic
#align_import topology.nhds_set from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
open Set Filter Topology
variable {X Y : Type*} [TopologicalSpace X] [TopologicalSpace Y] {f : Filter X}
{s t sβ sβ tβ tβ : Set X} {x : X}
theorem nhdsSet_diagonal (X) [TopologicalSpace (X Γ X)] :
πΛ’ (diagonal X) = β¨ (x : X), π (x, x) := by
rw [nhdsSet, β range_diag, β range_comp]
rfl
#align nhds_set_diagonal nhdsSet_diagonal
theorem mem_nhdsSet_iff_forall : s β πΛ’ t β β x : X, x β t β s β π x := by
simp_rw [nhdsSet, Filter.mem_sSup, forall_mem_image]
#align mem_nhds_set_iff_forall mem_nhdsSet_iff_forall
lemma nhdsSet_le : πΛ’ s β€ f β β x β s, π x β€ f := by simp [nhdsSet]
theorem bUnion_mem_nhdsSet {t : X β Set X} (h : β x β s, t x β π x) : (β x β s, t x) β πΛ’ s :=
mem_nhdsSet_iff_forall.2 fun x hx => mem_of_superset (h x hx) <|
subset_iUnionβ (s := fun x _ => t x) x hx -- Porting note: fails to find `s`
#align bUnion_mem_nhds_set bUnion_mem_nhdsSet
theorem subset_interior_iff_mem_nhdsSet : s β interior t β t β πΛ’ s := by
simp_rw [mem_nhdsSet_iff_forall, subset_interior_iff_nhds]
#align subset_interior_iff_mem_nhds_set subset_interior_iff_mem_nhdsSet
| Mathlib/Topology/NhdsSet.lean | 56 | 58 | theorem disjoint_principal_nhdsSet : Disjoint (π s) (πΛ’ t) β Disjoint (closure s) t := by |
rw [disjoint_principal_left, β subset_interior_iff_mem_nhdsSet, interior_compl,
subset_compl_iff_disjoint_left]
| 1,113 |
import Mathlib.Topology.Basic
#align_import topology.nhds_set from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
open Set Filter Topology
variable {X Y : Type*} [TopologicalSpace X] [TopologicalSpace Y] {f : Filter X}
{s t sβ sβ tβ tβ : Set X} {x : X}
theorem nhdsSet_diagonal (X) [TopologicalSpace (X Γ X)] :
πΛ’ (diagonal X) = β¨ (x : X), π (x, x) := by
rw [nhdsSet, β range_diag, β range_comp]
rfl
#align nhds_set_diagonal nhdsSet_diagonal
theorem mem_nhdsSet_iff_forall : s β πΛ’ t β β x : X, x β t β s β π x := by
simp_rw [nhdsSet, Filter.mem_sSup, forall_mem_image]
#align mem_nhds_set_iff_forall mem_nhdsSet_iff_forall
lemma nhdsSet_le : πΛ’ s β€ f β β x β s, π x β€ f := by simp [nhdsSet]
theorem bUnion_mem_nhdsSet {t : X β Set X} (h : β x β s, t x β π x) : (β x β s, t x) β πΛ’ s :=
mem_nhdsSet_iff_forall.2 fun x hx => mem_of_superset (h x hx) <|
subset_iUnionβ (s := fun x _ => t x) x hx -- Porting note: fails to find `s`
#align bUnion_mem_nhds_set bUnion_mem_nhdsSet
theorem subset_interior_iff_mem_nhdsSet : s β interior t β t β πΛ’ s := by
simp_rw [mem_nhdsSet_iff_forall, subset_interior_iff_nhds]
#align subset_interior_iff_mem_nhds_set subset_interior_iff_mem_nhdsSet
theorem disjoint_principal_nhdsSet : Disjoint (π s) (πΛ’ t) β Disjoint (closure s) t := by
rw [disjoint_principal_left, β subset_interior_iff_mem_nhdsSet, interior_compl,
subset_compl_iff_disjoint_left]
| Mathlib/Topology/NhdsSet.lean | 60 | 61 | theorem disjoint_nhdsSet_principal : Disjoint (πΛ’ s) (π t) β Disjoint s (closure t) := by |
rw [disjoint_comm, disjoint_principal_nhdsSet, disjoint_comm]
| 1,113 |
import Mathlib.Topology.Basic
#align_import topology.nhds_set from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
open Set Filter Topology
variable {X Y : Type*} [TopologicalSpace X] [TopologicalSpace Y] {f : Filter X}
{s t sβ sβ tβ tβ : Set X} {x : X}
theorem nhdsSet_diagonal (X) [TopologicalSpace (X Γ X)] :
πΛ’ (diagonal X) = β¨ (x : X), π (x, x) := by
rw [nhdsSet, β range_diag, β range_comp]
rfl
#align nhds_set_diagonal nhdsSet_diagonal
theorem mem_nhdsSet_iff_forall : s β πΛ’ t β β x : X, x β t β s β π x := by
simp_rw [nhdsSet, Filter.mem_sSup, forall_mem_image]
#align mem_nhds_set_iff_forall mem_nhdsSet_iff_forall
lemma nhdsSet_le : πΛ’ s β€ f β β x β s, π x β€ f := by simp [nhdsSet]
theorem bUnion_mem_nhdsSet {t : X β Set X} (h : β x β s, t x β π x) : (β x β s, t x) β πΛ’ s :=
mem_nhdsSet_iff_forall.2 fun x hx => mem_of_superset (h x hx) <|
subset_iUnionβ (s := fun x _ => t x) x hx -- Porting note: fails to find `s`
#align bUnion_mem_nhds_set bUnion_mem_nhdsSet
theorem subset_interior_iff_mem_nhdsSet : s β interior t β t β πΛ’ s := by
simp_rw [mem_nhdsSet_iff_forall, subset_interior_iff_nhds]
#align subset_interior_iff_mem_nhds_set subset_interior_iff_mem_nhdsSet
theorem disjoint_principal_nhdsSet : Disjoint (π s) (πΛ’ t) β Disjoint (closure s) t := by
rw [disjoint_principal_left, β subset_interior_iff_mem_nhdsSet, interior_compl,
subset_compl_iff_disjoint_left]
theorem disjoint_nhdsSet_principal : Disjoint (πΛ’ s) (π t) β Disjoint s (closure t) := by
rw [disjoint_comm, disjoint_principal_nhdsSet, disjoint_comm]
| Mathlib/Topology/NhdsSet.lean | 63 | 64 | theorem mem_nhdsSet_iff_exists : s β πΛ’ t β β U : Set X, IsOpen U β§ t β U β§ U β s := by |
rw [β subset_interior_iff_mem_nhdsSet, subset_interior_iff]
| 1,113 |
import Mathlib.Topology.Basic
#align_import topology.nhds_set from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
open Set Filter Topology
variable {X Y : Type*} [TopologicalSpace X] [TopologicalSpace Y] {f : Filter X}
{s t sβ sβ tβ tβ : Set X} {x : X}
theorem nhdsSet_diagonal (X) [TopologicalSpace (X Γ X)] :
πΛ’ (diagonal X) = β¨ (x : X), π (x, x) := by
rw [nhdsSet, β range_diag, β range_comp]
rfl
#align nhds_set_diagonal nhdsSet_diagonal
theorem mem_nhdsSet_iff_forall : s β πΛ’ t β β x : X, x β t β s β π x := by
simp_rw [nhdsSet, Filter.mem_sSup, forall_mem_image]
#align mem_nhds_set_iff_forall mem_nhdsSet_iff_forall
lemma nhdsSet_le : πΛ’ s β€ f β β x β s, π x β€ f := by simp [nhdsSet]
theorem bUnion_mem_nhdsSet {t : X β Set X} (h : β x β s, t x β π x) : (β x β s, t x) β πΛ’ s :=
mem_nhdsSet_iff_forall.2 fun x hx => mem_of_superset (h x hx) <|
subset_iUnionβ (s := fun x _ => t x) x hx -- Porting note: fails to find `s`
#align bUnion_mem_nhds_set bUnion_mem_nhdsSet
theorem subset_interior_iff_mem_nhdsSet : s β interior t β t β πΛ’ s := by
simp_rw [mem_nhdsSet_iff_forall, subset_interior_iff_nhds]
#align subset_interior_iff_mem_nhds_set subset_interior_iff_mem_nhdsSet
theorem disjoint_principal_nhdsSet : Disjoint (π s) (πΛ’ t) β Disjoint (closure s) t := by
rw [disjoint_principal_left, β subset_interior_iff_mem_nhdsSet, interior_compl,
subset_compl_iff_disjoint_left]
theorem disjoint_nhdsSet_principal : Disjoint (πΛ’ s) (π t) β Disjoint s (closure t) := by
rw [disjoint_comm, disjoint_principal_nhdsSet, disjoint_comm]
theorem mem_nhdsSet_iff_exists : s β πΛ’ t β β U : Set X, IsOpen U β§ t β U β§ U β s := by
rw [β subset_interior_iff_mem_nhdsSet, subset_interior_iff]
#align mem_nhds_set_iff_exists mem_nhdsSet_iff_exists
theorem eventually_nhdsSet_iff_exists {p : X β Prop} :
(βαΆ x in πΛ’ s, p x) β β t, IsOpen t β§ s β t β§ β x, x β t β p x :=
mem_nhdsSet_iff_exists
theorem eventually_nhdsSet_iff_forall {p : X β Prop} :
(βαΆ x in πΛ’ s, p x) β β x, x β s β βαΆ y in π x, p y :=
mem_nhdsSet_iff_forall
theorem hasBasis_nhdsSet (s : Set X) : (πΛ’ s).HasBasis (fun U => IsOpen U β§ s β U) fun U => U :=
β¨fun t => by simp [mem_nhdsSet_iff_exists, and_assoc]β©
#align has_basis_nhds_set hasBasis_nhdsSet
@[simp]
lemma lift'_nhdsSet_interior (s : Set X) : (πΛ’ s).lift' interior = πΛ’ s :=
(hasBasis_nhdsSet s).lift'_interior_eq_self fun _ β¦ And.left
lemma Filter.HasBasis.nhdsSet_interior {ΞΉ : Sort*} {p : ΞΉ β Prop} {s : ΞΉ β Set X} {t : Set X}
(h : (πΛ’ t).HasBasis p s) : (πΛ’ t).HasBasis p (interior <| s Β·) :=
lift'_nhdsSet_interior t βΈ h.lift'_interior
| Mathlib/Topology/NhdsSet.lean | 90 | 91 | theorem IsOpen.mem_nhdsSet (hU : IsOpen s) : s β πΛ’ t β t β s := by |
rw [β subset_interior_iff_mem_nhdsSet, hU.interior_eq]
| 1,113 |
import Mathlib.Topology.Basic
#align_import topology.nhds_set from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
open Set Filter Topology
variable {X Y : Type*} [TopologicalSpace X] [TopologicalSpace Y] {f : Filter X}
{s t sβ sβ tβ tβ : Set X} {x : X}
theorem nhdsSet_diagonal (X) [TopologicalSpace (X Γ X)] :
πΛ’ (diagonal X) = β¨ (x : X), π (x, x) := by
rw [nhdsSet, β range_diag, β range_comp]
rfl
#align nhds_set_diagonal nhdsSet_diagonal
theorem mem_nhdsSet_iff_forall : s β πΛ’ t β β x : X, x β t β s β π x := by
simp_rw [nhdsSet, Filter.mem_sSup, forall_mem_image]
#align mem_nhds_set_iff_forall mem_nhdsSet_iff_forall
lemma nhdsSet_le : πΛ’ s β€ f β β x β s, π x β€ f := by simp [nhdsSet]
theorem bUnion_mem_nhdsSet {t : X β Set X} (h : β x β s, t x β π x) : (β x β s, t x) β πΛ’ s :=
mem_nhdsSet_iff_forall.2 fun x hx => mem_of_superset (h x hx) <|
subset_iUnionβ (s := fun x _ => t x) x hx -- Porting note: fails to find `s`
#align bUnion_mem_nhds_set bUnion_mem_nhdsSet
theorem subset_interior_iff_mem_nhdsSet : s β interior t β t β πΛ’ s := by
simp_rw [mem_nhdsSet_iff_forall, subset_interior_iff_nhds]
#align subset_interior_iff_mem_nhds_set subset_interior_iff_mem_nhdsSet
theorem disjoint_principal_nhdsSet : Disjoint (π s) (πΛ’ t) β Disjoint (closure s) t := by
rw [disjoint_principal_left, β subset_interior_iff_mem_nhdsSet, interior_compl,
subset_compl_iff_disjoint_left]
theorem disjoint_nhdsSet_principal : Disjoint (πΛ’ s) (π t) β Disjoint s (closure t) := by
rw [disjoint_comm, disjoint_principal_nhdsSet, disjoint_comm]
theorem mem_nhdsSet_iff_exists : s β πΛ’ t β β U : Set X, IsOpen U β§ t β U β§ U β s := by
rw [β subset_interior_iff_mem_nhdsSet, subset_interior_iff]
#align mem_nhds_set_iff_exists mem_nhdsSet_iff_exists
theorem eventually_nhdsSet_iff_exists {p : X β Prop} :
(βαΆ x in πΛ’ s, p x) β β t, IsOpen t β§ s β t β§ β x, x β t β p x :=
mem_nhdsSet_iff_exists
theorem eventually_nhdsSet_iff_forall {p : X β Prop} :
(βαΆ x in πΛ’ s, p x) β β x, x β s β βαΆ y in π x, p y :=
mem_nhdsSet_iff_forall
theorem hasBasis_nhdsSet (s : Set X) : (πΛ’ s).HasBasis (fun U => IsOpen U β§ s β U) fun U => U :=
β¨fun t => by simp [mem_nhdsSet_iff_exists, and_assoc]β©
#align has_basis_nhds_set hasBasis_nhdsSet
@[simp]
lemma lift'_nhdsSet_interior (s : Set X) : (πΛ’ s).lift' interior = πΛ’ s :=
(hasBasis_nhdsSet s).lift'_interior_eq_self fun _ β¦ And.left
lemma Filter.HasBasis.nhdsSet_interior {ΞΉ : Sort*} {p : ΞΉ β Prop} {s : ΞΉ β Set X} {t : Set X}
(h : (πΛ’ t).HasBasis p s) : (πΛ’ t).HasBasis p (interior <| s Β·) :=
lift'_nhdsSet_interior t βΈ h.lift'_interior
theorem IsOpen.mem_nhdsSet (hU : IsOpen s) : s β πΛ’ t β t β s := by
rw [β subset_interior_iff_mem_nhdsSet, hU.interior_eq]
#align is_open.mem_nhds_set IsOpen.mem_nhdsSet
theorem IsOpen.mem_nhdsSet_self (ho : IsOpen s) : s β πΛ’ s := ho.mem_nhdsSet.mpr Subset.rfl
theorem principal_le_nhdsSet : π s β€ πΛ’ s := fun _s hs =>
(subset_interior_iff_mem_nhdsSet.mpr hs).trans interior_subset
#align principal_le_nhds_set principal_le_nhdsSet
theorem subset_of_mem_nhdsSet (h : t β πΛ’ s) : s β t := principal_le_nhdsSet h
theorem Filter.Eventually.self_of_nhdsSet {p : X β Prop} (h : βαΆ x in πΛ’ s, p x) : β x β s, p x :=
principal_le_nhdsSet h
nonrec theorem Filter.EventuallyEq.self_of_nhdsSet {f g : X β Y} (h : f =αΆ [πΛ’ s] g) : EqOn f g s :=
h.self_of_nhdsSet
@[simp]
| Mathlib/Topology/NhdsSet.lean | 110 | 112 | theorem nhdsSet_eq_principal_iff : πΛ’ s = π s β IsOpen s := by |
rw [β principal_le_nhdsSet.le_iff_eq, le_principal_iff, mem_nhdsSet_iff_forall,
isOpen_iff_mem_nhds]
| 1,113 |
import Mathlib.Topology.Basic
#align_import topology.nhds_set from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
open Set Filter Topology
variable {X Y : Type*} [TopologicalSpace X] [TopologicalSpace Y] {f : Filter X}
{s t sβ sβ tβ tβ : Set X} {x : X}
theorem nhdsSet_diagonal (X) [TopologicalSpace (X Γ X)] :
πΛ’ (diagonal X) = β¨ (x : X), π (x, x) := by
rw [nhdsSet, β range_diag, β range_comp]
rfl
#align nhds_set_diagonal nhdsSet_diagonal
theorem mem_nhdsSet_iff_forall : s β πΛ’ t β β x : X, x β t β s β π x := by
simp_rw [nhdsSet, Filter.mem_sSup, forall_mem_image]
#align mem_nhds_set_iff_forall mem_nhdsSet_iff_forall
lemma nhdsSet_le : πΛ’ s β€ f β β x β s, π x β€ f := by simp [nhdsSet]
theorem bUnion_mem_nhdsSet {t : X β Set X} (h : β x β s, t x β π x) : (β x β s, t x) β πΛ’ s :=
mem_nhdsSet_iff_forall.2 fun x hx => mem_of_superset (h x hx) <|
subset_iUnionβ (s := fun x _ => t x) x hx -- Porting note: fails to find `s`
#align bUnion_mem_nhds_set bUnion_mem_nhdsSet
theorem subset_interior_iff_mem_nhdsSet : s β interior t β t β πΛ’ s := by
simp_rw [mem_nhdsSet_iff_forall, subset_interior_iff_nhds]
#align subset_interior_iff_mem_nhds_set subset_interior_iff_mem_nhdsSet
theorem disjoint_principal_nhdsSet : Disjoint (π s) (πΛ’ t) β Disjoint (closure s) t := by
rw [disjoint_principal_left, β subset_interior_iff_mem_nhdsSet, interior_compl,
subset_compl_iff_disjoint_left]
theorem disjoint_nhdsSet_principal : Disjoint (πΛ’ s) (π t) β Disjoint s (closure t) := by
rw [disjoint_comm, disjoint_principal_nhdsSet, disjoint_comm]
theorem mem_nhdsSet_iff_exists : s β πΛ’ t β β U : Set X, IsOpen U β§ t β U β§ U β s := by
rw [β subset_interior_iff_mem_nhdsSet, subset_interior_iff]
#align mem_nhds_set_iff_exists mem_nhdsSet_iff_exists
theorem eventually_nhdsSet_iff_exists {p : X β Prop} :
(βαΆ x in πΛ’ s, p x) β β t, IsOpen t β§ s β t β§ β x, x β t β p x :=
mem_nhdsSet_iff_exists
theorem eventually_nhdsSet_iff_forall {p : X β Prop} :
(βαΆ x in πΛ’ s, p x) β β x, x β s β βαΆ y in π x, p y :=
mem_nhdsSet_iff_forall
theorem hasBasis_nhdsSet (s : Set X) : (πΛ’ s).HasBasis (fun U => IsOpen U β§ s β U) fun U => U :=
β¨fun t => by simp [mem_nhdsSet_iff_exists, and_assoc]β©
#align has_basis_nhds_set hasBasis_nhdsSet
@[simp]
lemma lift'_nhdsSet_interior (s : Set X) : (πΛ’ s).lift' interior = πΛ’ s :=
(hasBasis_nhdsSet s).lift'_interior_eq_self fun _ β¦ And.left
lemma Filter.HasBasis.nhdsSet_interior {ΞΉ : Sort*} {p : ΞΉ β Prop} {s : ΞΉ β Set X} {t : Set X}
(h : (πΛ’ t).HasBasis p s) : (πΛ’ t).HasBasis p (interior <| s Β·) :=
lift'_nhdsSet_interior t βΈ h.lift'_interior
theorem IsOpen.mem_nhdsSet (hU : IsOpen s) : s β πΛ’ t β t β s := by
rw [β subset_interior_iff_mem_nhdsSet, hU.interior_eq]
#align is_open.mem_nhds_set IsOpen.mem_nhdsSet
theorem IsOpen.mem_nhdsSet_self (ho : IsOpen s) : s β πΛ’ s := ho.mem_nhdsSet.mpr Subset.rfl
theorem principal_le_nhdsSet : π s β€ πΛ’ s := fun _s hs =>
(subset_interior_iff_mem_nhdsSet.mpr hs).trans interior_subset
#align principal_le_nhds_set principal_le_nhdsSet
theorem subset_of_mem_nhdsSet (h : t β πΛ’ s) : s β t := principal_le_nhdsSet h
theorem Filter.Eventually.self_of_nhdsSet {p : X β Prop} (h : βαΆ x in πΛ’ s, p x) : β x β s, p x :=
principal_le_nhdsSet h
nonrec theorem Filter.EventuallyEq.self_of_nhdsSet {f g : X β Y} (h : f =αΆ [πΛ’ s] g) : EqOn f g s :=
h.self_of_nhdsSet
@[simp]
theorem nhdsSet_eq_principal_iff : πΛ’ s = π s β IsOpen s := by
rw [β principal_le_nhdsSet.le_iff_eq, le_principal_iff, mem_nhdsSet_iff_forall,
isOpen_iff_mem_nhds]
#align nhds_set_eq_principal_iff nhdsSet_eq_principal_iff
alias β¨_, IsOpen.nhdsSet_eqβ© := nhdsSet_eq_principal_iff
#align is_open.nhds_set_eq IsOpen.nhdsSet_eq
@[simp]
theorem nhdsSet_interior : πΛ’ (interior s) = π (interior s) :=
isOpen_interior.nhdsSet_eq
#align nhds_set_interior nhdsSet_interior
@[simp]
| Mathlib/Topology/NhdsSet.lean | 124 | 124 | theorem nhdsSet_singleton : πΛ’ {x} = π x := by | simp [nhdsSet]
| 1,113 |
import Mathlib.Order.Filter.Germ
import Mathlib.Topology.NhdsSet
import Mathlib.Topology.LocallyConstant.Basic
import Mathlib.Analysis.NormedSpace.Basic
variable {F G : Type*} [NormedAddCommGroup F] [NormedSpace β F]
[NormedAddCommGroup G] [NormedSpace β G]
open scoped Topology
open Filter Set
variable {X Y Z : Type*} [TopologicalSpace X] {f g : X β Y} {A : Set X} {x : X}
section RestrictGermPredicate
def RestrictGermPredicate (P : β x : X, Germ (π x) Y β Prop)
(A : Set X) : β x : X, Germ (π x) Y β Prop := fun x Ο β¦
Germ.liftOn Ο (fun f β¦ x β A β βαΆ y in π x, P y f)
haveI : β f f' : X β Y, f =αΆ [π x] f' β (βαΆ y in π x, P y f) β βαΆ y in π x, P y f' := by
intro f f' hff' hf
apply (hf.and <| Eventually.eventually_nhds hff').mono
rintro y β¨hy, hy'β©
rwa [Germ.coe_eq.mpr (EventuallyEq.symm hy')]
fun f f' hff' β¦ propext <| forall_congr' fun _ β¦ β¨this f f' hff', this f' f hff'.symmβ©
| Mathlib/Topology/Germ.lean | 94 | 102 | theorem Filter.Eventually.germ_congr_set
{P : β x : X, Germ (π x) Y β Prop} (hf : βαΆ x in πΛ’ A, P x f)
(h : βαΆ z in πΛ’ A, g z = f z) : βαΆ x in πΛ’ A, P x g := by |
rw [eventually_nhdsSet_iff_forall] at *
intro x hx
apply ((hf x hx).and (h x hx).eventually_nhds).mono
intro y hy
convert hy.1 using 1
exact Germ.coe_eq.mpr hy.2
| 1,114 |
import Mathlib.Order.Filter.Germ
import Mathlib.Topology.NhdsSet
import Mathlib.Topology.LocallyConstant.Basic
import Mathlib.Analysis.NormedSpace.Basic
variable {F G : Type*} [NormedAddCommGroup F] [NormedSpace β F]
[NormedAddCommGroup G] [NormedSpace β G]
open scoped Topology
open Filter Set
variable {X Y Z : Type*} [TopologicalSpace X] {f g : X β Y} {A : Set X} {x : X}
section RestrictGermPredicate
def RestrictGermPredicate (P : β x : X, Germ (π x) Y β Prop)
(A : Set X) : β x : X, Germ (π x) Y β Prop := fun x Ο β¦
Germ.liftOn Ο (fun f β¦ x β A β βαΆ y in π x, P y f)
haveI : β f f' : X β Y, f =αΆ [π x] f' β (βαΆ y in π x, P y f) β βαΆ y in π x, P y f' := by
intro f f' hff' hf
apply (hf.and <| Eventually.eventually_nhds hff').mono
rintro y β¨hy, hy'β©
rwa [Germ.coe_eq.mpr (EventuallyEq.symm hy')]
fun f f' hff' β¦ propext <| forall_congr' fun _ β¦ β¨this f f' hff', this f' f hff'.symmβ©
theorem Filter.Eventually.germ_congr_set
{P : β x : X, Germ (π x) Y β Prop} (hf : βαΆ x in πΛ’ A, P x f)
(h : βαΆ z in πΛ’ A, g z = f z) : βαΆ x in πΛ’ A, P x g := by
rw [eventually_nhdsSet_iff_forall] at *
intro x hx
apply ((hf x hx).and (h x hx).eventually_nhds).mono
intro y hy
convert hy.1 using 1
exact Germ.coe_eq.mpr hy.2
| Mathlib/Topology/Germ.lean | 104 | 110 | theorem restrictGermPredicate_congr {P : β x : X, Germ (π x) Y β Prop}
(hf : RestrictGermPredicate P A x f) (h : βαΆ z in πΛ’ A, g z = f z) :
RestrictGermPredicate P A x g := by |
intro hx
apply ((hf hx).and <| (eventually_nhdsSet_iff_forall.mp h x hx).eventually_nhds).mono
rintro y β¨hy, h'yβ©
rwa [Germ.coe_eq.mpr h'y]
| 1,114 |
import Mathlib.Order.Filter.Germ
import Mathlib.Topology.NhdsSet
import Mathlib.Topology.LocallyConstant.Basic
import Mathlib.Analysis.NormedSpace.Basic
variable {F G : Type*} [NormedAddCommGroup F] [NormedSpace β F]
[NormedAddCommGroup G] [NormedSpace β G]
open scoped Topology
open Filter Set
variable {X Y Z : Type*} [TopologicalSpace X] {f g : X β Y} {A : Set X} {x : X}
section RestrictGermPredicate
def RestrictGermPredicate (P : β x : X, Germ (π x) Y β Prop)
(A : Set X) : β x : X, Germ (π x) Y β Prop := fun x Ο β¦
Germ.liftOn Ο (fun f β¦ x β A β βαΆ y in π x, P y f)
haveI : β f f' : X β Y, f =αΆ [π x] f' β (βαΆ y in π x, P y f) β βαΆ y in π x, P y f' := by
intro f f' hff' hf
apply (hf.and <| Eventually.eventually_nhds hff').mono
rintro y β¨hy, hy'β©
rwa [Germ.coe_eq.mpr (EventuallyEq.symm hy')]
fun f f' hff' β¦ propext <| forall_congr' fun _ β¦ β¨this f f' hff', this f' f hff'.symmβ©
theorem Filter.Eventually.germ_congr_set
{P : β x : X, Germ (π x) Y β Prop} (hf : βαΆ x in πΛ’ A, P x f)
(h : βαΆ z in πΛ’ A, g z = f z) : βαΆ x in πΛ’ A, P x g := by
rw [eventually_nhdsSet_iff_forall] at *
intro x hx
apply ((hf x hx).and (h x hx).eventually_nhds).mono
intro y hy
convert hy.1 using 1
exact Germ.coe_eq.mpr hy.2
theorem restrictGermPredicate_congr {P : β x : X, Germ (π x) Y β Prop}
(hf : RestrictGermPredicate P A x f) (h : βαΆ z in πΛ’ A, g z = f z) :
RestrictGermPredicate P A x g := by
intro hx
apply ((hf hx).and <| (eventually_nhdsSet_iff_forall.mp h x hx).eventually_nhds).mono
rintro y β¨hy, h'yβ©
rwa [Germ.coe_eq.mpr h'y]
| Mathlib/Topology/Germ.lean | 112 | 115 | theorem forall_restrictGermPredicate_iff {P : β x : X, Germ (π x) Y β Prop} :
(β x, RestrictGermPredicate P A x f) β βαΆ x in πΛ’ A, P x f := by |
rw [eventually_nhdsSet_iff_forall]
rfl
| 1,114 |
import Mathlib.Algebra.Order.Group.OrderIso
import Mathlib.Algebra.Order.Monoid.OrderDual
import Mathlib.Data.Set.Pointwise.Basic
import Mathlib.Order.Bounds.OrderIso
import Mathlib.Order.ConditionallyCompleteLattice.Basic
#align_import algebra.bounds from "leanprover-community/mathlib"@"dd71334db81d0bd444af1ee339a29298bef40734"
open Function Set
open Pointwise
section ConditionallyCompleteLattice
section Right
variable {ΞΉ G : Type*} [Group G] [ConditionallyCompleteLattice G]
[CovariantClass G G (Function.swap (Β· * Β·)) (Β· β€ Β·)] [Nonempty ΞΉ] {f : ΞΉ β G}
@[to_additive]
theorem ciSup_mul (hf : BddAbove (range f)) (a : G) : (β¨ i, f i) * a = β¨ i, f i * a :=
(OrderIso.mulRight a).map_ciSup hf
#align csupr_mul ciSup_mul
#align csupr_add ciSup_add
@[to_additive]
| Mathlib/Algebra/Bounds.lean | 175 | 176 | theorem ciSup_div (hf : BddAbove (range f)) (a : G) : (β¨ i, f i) / a = β¨ i, f i / a := by |
simp only [div_eq_mul_inv, ciSup_mul hf]
| 1,115 |
import Mathlib.Algebra.Order.Group.OrderIso
import Mathlib.Algebra.Order.Monoid.OrderDual
import Mathlib.Data.Set.Pointwise.Basic
import Mathlib.Order.Bounds.OrderIso
import Mathlib.Order.ConditionallyCompleteLattice.Basic
#align_import algebra.bounds from "leanprover-community/mathlib"@"dd71334db81d0bd444af1ee339a29298bef40734"
open Function Set
open Pointwise
section ConditionallyCompleteLattice
section Right
variable {ΞΉ G : Type*} [Group G] [ConditionallyCompleteLattice G]
[CovariantClass G G (Function.swap (Β· * Β·)) (Β· β€ Β·)] [Nonempty ΞΉ] {f : ΞΉ β G}
@[to_additive]
theorem ciSup_mul (hf : BddAbove (range f)) (a : G) : (β¨ i, f i) * a = β¨ i, f i * a :=
(OrderIso.mulRight a).map_ciSup hf
#align csupr_mul ciSup_mul
#align csupr_add ciSup_add
@[to_additive]
theorem ciSup_div (hf : BddAbove (range f)) (a : G) : (β¨ i, f i) / a = β¨ i, f i / a := by
simp only [div_eq_mul_inv, ciSup_mul hf]
#align csupr_div ciSup_div
#align csupr_sub ciSup_sub
@[to_additive]
theorem ciInf_mul (hf : BddBelow (range f)) (a : G) : (β¨
i, f i) * a = β¨
i, f i * a :=
(OrderIso.mulRight a).map_ciInf hf
@[to_additive]
| Mathlib/Algebra/Bounds.lean | 185 | 186 | theorem ciInf_div (hf : BddBelow (range f)) (a : G) : (β¨
i, f i) / a = β¨
i, f i / a := by |
simp only [div_eq_mul_inv, ciInf_mul hf]
| 1,115 |
import Mathlib.Algebra.Bounds
import Mathlib.Algebra.Order.Archimedean
import Mathlib.Data.Real.Basic
import Mathlib.Order.Interval.Set.Disjoint
#align_import data.real.basic from "leanprover-community/mathlib"@"cb42593171ba005beaaf4549fcfe0dece9ada4c9"
open scoped Classical
open Pointwise CauSeq
namespace Real
instance instArchimedean : Archimedean β :=
archimedean_iff_rat_le.2 fun x =>
Real.ind_mk x fun f =>
let β¨M, _, Hβ© := f.bounded' 0
β¨M, mk_le_of_forall_le β¨0, fun i _ => Rat.cast_le.2 <| le_of_lt (abs_lt.1 (H i)).2β©β©
#align real.archimedean Real.instArchimedean
noncomputable instance : FloorRing β :=
Archimedean.floorRing _
theorem isCauSeq_iff_lift {f : β β β} : IsCauSeq abs f β IsCauSeq abs fun i => (f i : β) where
mp H Ξ΅ Ξ΅0 :=
let β¨Ξ΄, Ξ΄0, δΡ⩠:= exists_pos_rat_lt Ξ΅0
(H _ δ0).imp fun i hi j ij => by dsimp; exact lt_trans (mod_cast hi _ ij) δΡ
mpr H Ξ΅ Ξ΅0 :=
(H _ (Rat.cast_pos.2 Ξ΅0)).imp fun i hi j ij => by dsimp at hi; exact mod_cast hi _ ij
#align real.is_cau_seq_iff_lift Real.isCauSeq_iff_lift
theorem of_near (f : β β β) (x : β) (h : β Ξ΅ > 0, β i, β j β₯ i, |(f j : β) - x| < Ξ΅) :
β h', Real.mk β¨f, h'β© = x :=
β¨isCauSeq_iff_lift.2 (CauSeq.of_near _ (const abs x) h),
sub_eq_zero.1 <|
abs_eq_zero.1 <|
(eq_of_le_of_forall_le_of_dense (abs_nonneg _)) fun _Ξ΅ Ξ΅0 =>
mk_near_of_forall_near <| (h _ Ξ΅0).imp fun _i h j ij => le_of_lt (h j ij)β©
#align real.of_near Real.of_near
theorem exists_floor (x : β) : β ub : β€, (ub : β) β€ x β§ β z : β€, (z : β) β€ x β z β€ ub :=
Int.exists_greatest_of_bdd
(let β¨n, hnβ© := exists_int_gt x
β¨n, fun _ h' => Int.cast_le.1 <| le_trans h' <| le_of_lt hnβ©)
(let β¨n, hnβ© := exists_int_lt x
β¨n, le_of_lt hnβ©)
#align real.exists_floor Real.exists_floor
| Mathlib/Data/Real/Archimedean.lean | 58 | 106 | theorem exists_isLUB {S : Set β} (hne : S.Nonempty) (hbdd : BddAbove S) : β x, IsLUB S x := by |
rcases hne, hbdd with β¨β¨L, hLβ©, β¨U, hUβ©β©
have : β d : β, BddAbove { m : β€ | β y β S, (m : β) β€ y * d } := by
cases' exists_int_gt U with k hk
refine fun d => β¨k * d, fun z h => ?_β©
rcases h with β¨y, yS, hyβ©
refine Int.cast_le.1 (hy.trans ?_)
push_cast
exact mul_le_mul_of_nonneg_right ((hU yS).trans hk.le) d.cast_nonneg
choose f hf using fun d : β =>
Int.exists_greatest_of_bdd (this d) β¨βL * dβ, L, hL, Int.floor_le _β©
have hfβ : β n > 0, β y β S, ((f n / n : β) : β) β€ y := fun n n0 =>
let β¨y, yS, hyβ© := (hf n).1
β¨y, yS, by simpa using (div_le_iff (Nat.cast_pos.2 n0 : (_ : β) < _)).2 hyβ©
have hfβ : β n > 0, β y β S, (y - ((n : β) : β)β»ΒΉ) < (f n / n : β) := by
intro n n0 y yS
have := (Int.sub_one_lt_floor _).trans_le (Int.cast_le.2 <| (hf n).2 _ β¨y, yS, Int.floor_le _β©)
simp only [Rat.cast_div, Rat.cast_intCast, Rat.cast_natCast, gt_iff_lt]
rwa [lt_div_iff (Nat.cast_pos.2 n0 : (_ : β) < _), sub_mul, _root_.inv_mul_cancel]
exact ne_of_gt (Nat.cast_pos.2 n0)
have hg : IsCauSeq abs (fun n => f n / n : β β β) := by
intro Ξ΅ Ξ΅0
suffices β j β₯ βΞ΅β»ΒΉββ, β k β₯ βΞ΅β»ΒΉββ, (f j / j - f k / k : β) < Ξ΅ by
refine β¨_, fun j ij => abs_lt.2 β¨?_, this _ ij _ le_rflβ©β©
rw [neg_lt, neg_sub]
exact this _ le_rfl _ ij
intro j ij k ik
replace ij := le_trans (Nat.le_ceil _) (Nat.cast_le.2 ij)
replace ik := le_trans (Nat.le_ceil _) (Nat.cast_le.2 ik)
have j0 := Nat.cast_pos.1 ((inv_pos.2 Ξ΅0).trans_le ij)
have k0 := Nat.cast_pos.1 ((inv_pos.2 Ξ΅0).trans_le ik)
rcases hfβ _ j0 with β¨y, yS, hyβ©
refine lt_of_lt_of_le ((Rat.cast_lt (K := β)).1 ?_) ((inv_le Ξ΅0 (Nat.cast_pos.2 k0)).1 ik)
simpa using sub_lt_iff_lt_add'.2 (lt_of_le_of_lt hy <| sub_lt_iff_lt_add.1 <| hfβ _ k0 _ yS)
let g : CauSeq β abs := β¨fun n => f n / n, hgβ©
refine β¨mk g, β¨fun x xS => ?_, fun y h => ?_β©β©
Β· refine le_of_forall_ge_of_dense fun z xz => ?_
cases' exists_nat_gt (x - z)β»ΒΉ with K hK
refine le_mk_of_forall_le β¨K, fun n nK => ?_β©
replace xz := sub_pos.2 xz
replace hK := hK.le.trans (Nat.cast_le.2 nK)
have n0 : 0 < n := Nat.cast_pos.1 ((inv_pos.2 xz).trans_le hK)
refine le_trans ?_ (hfβ _ n0 _ xS).le
rwa [le_sub_comm, inv_le (Nat.cast_pos.2 n0 : (_ : β) < _) xz]
Β· exact
mk_le_of_forall_le
β¨1, fun n n1 =>
let β¨x, xS, hxβ© := hfβ _ n1
le_trans hx (h xS)β©
| 1,116 |
import Mathlib.Algebra.Order.Module.OrderedSMul
import Mathlib.Algebra.Order.Module.Pointwise
import Mathlib.Data.Real.Archimedean
#align_import data.real.pointwise from "leanprover-community/mathlib"@"dde670c9a3f503647fd5bfdf1037bad526d3397a"
open Set
open Pointwise
variable {ΞΉ : Sort*} {Ξ± : Type*} [LinearOrderedField Ξ±]
section MulActionWithZero
variable [MulActionWithZero Ξ± β] [OrderedSMul Ξ± β] {a : Ξ±}
| Mathlib/Data/Real/Pointwise.lean | 37 | 46 | theorem Real.sInf_smul_of_nonneg (ha : 0 β€ a) (s : Set β) : sInf (a β’ s) = a β’ sInf s := by |
obtain rfl | hs := s.eq_empty_or_nonempty
Β· rw [smul_set_empty, Real.sInf_empty, smul_zero]
obtain rfl | ha' := ha.eq_or_lt
Β· rw [zero_smul_set hs, zero_smul]
exact csInf_singleton 0
by_cases h : BddBelow s
Β· exact ((OrderIso.smulRight ha').map_csInf' hs h).symm
Β· rw [Real.sInf_of_not_bddBelow (mt (bddBelow_smul_iff_of_pos ha').1 h),
Real.sInf_of_not_bddBelow h, smul_zero]
| 1,117 |
import Mathlib.Algebra.Order.Module.OrderedSMul
import Mathlib.Algebra.Order.Module.Pointwise
import Mathlib.Data.Real.Archimedean
#align_import data.real.pointwise from "leanprover-community/mathlib"@"dde670c9a3f503647fd5bfdf1037bad526d3397a"
open Set
open Pointwise
variable {ΞΉ : Sort*} {Ξ± : Type*} [LinearOrderedField Ξ±]
section MulActionWithZero
variable [MulActionWithZero Ξ± β] [OrderedSMul Ξ± β] {a : Ξ±}
theorem Real.sInf_smul_of_nonneg (ha : 0 β€ a) (s : Set β) : sInf (a β’ s) = a β’ sInf s := by
obtain rfl | hs := s.eq_empty_or_nonempty
Β· rw [smul_set_empty, Real.sInf_empty, smul_zero]
obtain rfl | ha' := ha.eq_or_lt
Β· rw [zero_smul_set hs, zero_smul]
exact csInf_singleton 0
by_cases h : BddBelow s
Β· exact ((OrderIso.smulRight ha').map_csInf' hs h).symm
Β· rw [Real.sInf_of_not_bddBelow (mt (bddBelow_smul_iff_of_pos ha').1 h),
Real.sInf_of_not_bddBelow h, smul_zero]
#align real.Inf_smul_of_nonneg Real.sInf_smul_of_nonneg
theorem Real.smul_iInf_of_nonneg (ha : 0 β€ a) (f : ΞΉ β β) : (a β’ β¨
i, f i) = β¨
i, a β’ f i :=
(Real.sInf_smul_of_nonneg ha _).symm.trans <| congr_arg sInf <| (range_comp _ _).symm
#align real.smul_infi_of_nonneg Real.smul_iInf_of_nonneg
| Mathlib/Data/Real/Pointwise.lean | 53 | 62 | theorem Real.sSup_smul_of_nonneg (ha : 0 β€ a) (s : Set β) : sSup (a β’ s) = a β’ sSup s := by |
obtain rfl | hs := s.eq_empty_or_nonempty
Β· rw [smul_set_empty, Real.sSup_empty, smul_zero]
obtain rfl | ha' := ha.eq_or_lt
Β· rw [zero_smul_set hs, zero_smul]
exact csSup_singleton 0
by_cases h : BddAbove s
Β· exact ((OrderIso.smulRight ha').map_csSup' hs h).symm
Β· rw [Real.sSup_of_not_bddAbove (mt (bddAbove_smul_iff_of_pos ha').1 h),
Real.sSup_of_not_bddAbove h, smul_zero]
| 1,117 |
import Mathlib.Algebra.Order.Module.OrderedSMul
import Mathlib.Algebra.Order.Module.Pointwise
import Mathlib.Data.Real.Archimedean
#align_import data.real.pointwise from "leanprover-community/mathlib"@"dde670c9a3f503647fd5bfdf1037bad526d3397a"
open Set
open Pointwise
variable {ΞΉ : Sort*} {Ξ± : Type*} [LinearOrderedField Ξ±]
section Module
variable [Module Ξ± β] [OrderedSMul Ξ± β] {a : Ξ±}
| Mathlib/Data/Real/Pointwise.lean | 75 | 84 | theorem Real.sInf_smul_of_nonpos (ha : a β€ 0) (s : Set β) : sInf (a β’ s) = a β’ sSup s := by |
obtain rfl | hs := s.eq_empty_or_nonempty
Β· rw [smul_set_empty, Real.sInf_empty, Real.sSup_empty, smul_zero]
obtain rfl | ha' := ha.eq_or_lt
Β· rw [zero_smul_set hs, zero_smul]
exact csInf_singleton 0
by_cases h : BddAbove s
Β· exact ((OrderIso.smulRightDual β ha').map_csSup' hs h).symm
Β· rw [Real.sInf_of_not_bddBelow (mt (bddBelow_smul_iff_of_neg ha').1 h),
Real.sSup_of_not_bddAbove h, smul_zero]
| 1,117 |
import Mathlib.Algebra.Order.Module.OrderedSMul
import Mathlib.Algebra.Order.Module.Pointwise
import Mathlib.Data.Real.Archimedean
#align_import data.real.pointwise from "leanprover-community/mathlib"@"dde670c9a3f503647fd5bfdf1037bad526d3397a"
open Set
open Pointwise
variable {ΞΉ : Sort*} {Ξ± : Type*} [LinearOrderedField Ξ±]
section Module
variable [Module Ξ± β] [OrderedSMul Ξ± β] {a : Ξ±}
theorem Real.sInf_smul_of_nonpos (ha : a β€ 0) (s : Set β) : sInf (a β’ s) = a β’ sSup s := by
obtain rfl | hs := s.eq_empty_or_nonempty
Β· rw [smul_set_empty, Real.sInf_empty, Real.sSup_empty, smul_zero]
obtain rfl | ha' := ha.eq_or_lt
Β· rw [zero_smul_set hs, zero_smul]
exact csInf_singleton 0
by_cases h : BddAbove s
Β· exact ((OrderIso.smulRightDual β ha').map_csSup' hs h).symm
Β· rw [Real.sInf_of_not_bddBelow (mt (bddBelow_smul_iff_of_neg ha').1 h),
Real.sSup_of_not_bddAbove h, smul_zero]
#align real.Inf_smul_of_nonpos Real.sInf_smul_of_nonpos
theorem Real.smul_iSup_of_nonpos (ha : a β€ 0) (f : ΞΉ β β) : (a β’ β¨ i, f i) = β¨
i, a β’ f i :=
(Real.sInf_smul_of_nonpos ha _).symm.trans <| congr_arg sInf <| (range_comp _ _).symm
#align real.smul_supr_of_nonpos Real.smul_iSup_of_nonpos
| Mathlib/Data/Real/Pointwise.lean | 91 | 100 | theorem Real.sSup_smul_of_nonpos (ha : a β€ 0) (s : Set β) : sSup (a β’ s) = a β’ sInf s := by |
obtain rfl | hs := s.eq_empty_or_nonempty
Β· rw [smul_set_empty, Real.sSup_empty, Real.sInf_empty, smul_zero]
obtain rfl | ha' := ha.eq_or_lt
Β· rw [zero_smul_set hs, zero_smul]
exact csSup_singleton 0
by_cases h : BddBelow s
Β· exact ((OrderIso.smulRightDual β ha').map_csInf' hs h).symm
Β· rw [Real.sSup_of_not_bddAbove (mt (bddAbove_smul_iff_of_neg ha').1 h),
Real.sInf_of_not_bddBelow h, smul_zero]
| 1,117 |
import Mathlib.Algebra.Algebra.Defs
import Mathlib.Algebra.Order.BigOperators.Ring.Finset
import Mathlib.Algebra.Order.Field.Canonical.Basic
import Mathlib.Algebra.Order.Nonneg.Field
import Mathlib.Algebra.Order.Nonneg.Floor
import Mathlib.Data.Real.Pointwise
import Mathlib.Order.ConditionallyCompleteLattice.Group
import Mathlib.Tactic.GCongr.Core
#align_import data.real.nnreal from "leanprover-community/mathlib"@"b1abe23ae96fef89ad30d9f4362c307f72a55010"
open Function
-- to ensure these instances are computable
def NNReal := { r : β // 0 β€ r } deriving
Zero, One, Semiring, StrictOrderedSemiring, CommMonoidWithZero, CommSemiring,
SemilatticeInf, SemilatticeSup, DistribLattice, OrderedCommSemiring,
CanonicallyOrderedCommSemiring, Inhabited
#align nnreal NNReal
namespace NNReal
scoped notation "ββ₯0" => NNReal
noncomputable instance : FloorSemiring ββ₯0 := Nonneg.floorSemiring
instance instDenselyOrdered : DenselyOrdered ββ₯0 := Nonneg.instDenselyOrdered
instance : OrderBot ββ₯0 := inferInstance
instance : Archimedean ββ₯0 := Nonneg.archimedean
noncomputable instance : Sub ββ₯0 := Nonneg.sub
noncomputable instance : OrderedSub ββ₯0 := Nonneg.orderedSub
noncomputable instance : CanonicallyLinearOrderedSemifield ββ₯0 :=
Nonneg.canonicallyLinearOrderedSemifield
@[coe] def toReal : ββ₯0 β β := Subtype.val
instance : Coe ββ₯0 β := β¨toRealβ©
-- Simp lemma to put back `n.val` into the normal form given by the coercion.
@[simp]
theorem val_eq_coe (n : ββ₯0) : n.val = n :=
rfl
#align nnreal.val_eq_coe NNReal.val_eq_coe
instance canLift : CanLift β ββ₯0 toReal fun r => 0 β€ r :=
Subtype.canLift _
#align nnreal.can_lift NNReal.canLift
@[ext] protected theorem eq {n m : ββ₯0} : (n : β) = (m : β) β n = m :=
Subtype.eq
#align nnreal.eq NNReal.eq
protected theorem eq_iff {n m : ββ₯0} : (n : β) = (m : β) β n = m :=
Subtype.ext_iff.symm
#align nnreal.eq_iff NNReal.eq_iff
theorem ne_iff {x y : ββ₯0} : (x : β) β (y : β) β x β y :=
not_congr <| NNReal.eq_iff
#align nnreal.ne_iff NNReal.ne_iff
protected theorem Β«forallΒ» {p : ββ₯0 β Prop} :
(β x : ββ₯0, p x) β β (x : β) (hx : 0 β€ x), p β¨x, hxβ© :=
Subtype.forall
#align nnreal.forall NNReal.forall
protected theorem Β«existsΒ» {p : ββ₯0 β Prop} :
(β x : ββ₯0, p x) β β (x : β) (hx : 0 β€ x), p β¨x, hxβ© :=
Subtype.exists
#align nnreal.exists NNReal.exists
noncomputable def _root_.Real.toNNReal (r : β) : ββ₯0 :=
β¨max r 0, le_max_right _ _β©
#align real.to_nnreal Real.toNNReal
theorem _root_.Real.coe_toNNReal (r : β) (hr : 0 β€ r) : (Real.toNNReal r : β) = r :=
max_eq_left hr
#align real.coe_to_nnreal Real.coe_toNNReal
| Mathlib/Data/Real/NNReal.lean | 125 | 126 | theorem _root_.Real.toNNReal_of_nonneg {r : β} (hr : 0 β€ r) : r.toNNReal = β¨r, hrβ© := by |
simp_rw [Real.toNNReal, max_eq_left hr]
| 1,118 |
import Mathlib.Data.Real.NNReal
import Mathlib.RingTheory.Valuation.Basic
noncomputable section
open Function Multiplicative
open scoped NNReal
variable {R : Type*} [Ring R] {Ξβ : Type*} [LinearOrderedCommGroupWithZero Ξβ]
namespace Valuation
class RankOne (v : Valuation R Ξβ) where
hom : Ξβ β*β ββ₯0
strictMono' : StrictMono hom
nontrivial' : β r : R, v r β 0 β§ v r β 1
namespace RankOne
variable (v : Valuation R Ξβ) [RankOne v]
lemma strictMono : StrictMono (hom v) := strictMono'
lemma nontrivial : β r : R, v r β 0 β§ v r β 1 := nontrivial'
| Mathlib/RingTheory/Valuation/RankOne.lean | 51 | 55 | theorem zero_of_hom_zero {x : Ξβ} (hx : hom v x = 0) : x = 0 := by |
refine (eq_of_le_of_not_lt (zero_le' (a := x)) fun h_lt β¦ ?_).symm
have hs := strictMono v h_lt
rw [_root_.map_zero, hx] at hs
exact hs.false
| 1,119 |
import Mathlib.Data.Real.NNReal
import Mathlib.RingTheory.Valuation.Basic
noncomputable section
open Function Multiplicative
open scoped NNReal
variable {R : Type*} [Ring R] {Ξβ : Type*} [LinearOrderedCommGroupWithZero Ξβ]
namespace Valuation
class RankOne (v : Valuation R Ξβ) where
hom : Ξβ β*β ββ₯0
strictMono' : StrictMono hom
nontrivial' : β r : R, v r β 0 β§ v r β 1
namespace RankOne
variable (v : Valuation R Ξβ) [RankOne v]
lemma strictMono : StrictMono (hom v) := strictMono'
lemma nontrivial : β r : R, v r β 0 β§ v r β 1 := nontrivial'
theorem zero_of_hom_zero {x : Ξβ} (hx : hom v x = 0) : x = 0 := by
refine (eq_of_le_of_not_lt (zero_le' (a := x)) fun h_lt β¦ ?_).symm
have hs := strictMono v h_lt
rw [_root_.map_zero, hx] at hs
exact hs.false
theorem hom_eq_zero_iff {x : Ξβ} : RankOne.hom v x = 0 β x = 0 :=
β¨fun h β¦ zero_of_hom_zero v h, fun h β¦ by rw [h, _root_.map_zero]β©
def unit : ΞβΛ£ :=
Units.mk0 (v (nontrivial v).choose) ((nontrivial v).choose_spec).1
| Mathlib/RingTheory/Valuation/RankOne.lean | 67 | 69 | theorem unit_ne_one : unit v β 1 := by |
rw [Ne, β Units.eq_iff, Units.val_one]
exact ((nontrivial v).choose_spec ).2
| 1,119 |
import Mathlib.Analysis.Normed.Field.Basic
import Mathlib.RingTheory.Valuation.RankOne
import Mathlib.Topology.Algebra.Valuation
noncomputable section
open Filter Set Valuation
open scoped NNReal
variable {K : Type*} [hK : NormedField K] (h : IsNonarchimedean (norm : K β β))
namespace Valued
variable {L : Type*} [Field L] {Ξβ : Type*} [LinearOrderedCommGroupWithZero Ξβ]
[val : Valued L Ξβ] [hv : RankOne val.v]
def norm : L β β := fun x : L => hv.hom (Valued.v x)
| Mathlib/Topology/Algebra/NormedValued.lean | 68 | 68 | theorem norm_nonneg (x : L) : 0 β€ norm x := by | simp only [norm, NNReal.zero_le_coe]
| 1,120 |
import Mathlib.Analysis.Normed.Field.Basic
import Mathlib.RingTheory.Valuation.RankOne
import Mathlib.Topology.Algebra.Valuation
noncomputable section
open Filter Set Valuation
open scoped NNReal
variable {K : Type*} [hK : NormedField K] (h : IsNonarchimedean (norm : K β β))
namespace Valued
variable {L : Type*} [Field L] {Ξβ : Type*} [LinearOrderedCommGroupWithZero Ξβ]
[val : Valued L Ξβ] [hv : RankOne val.v]
def norm : L β β := fun x : L => hv.hom (Valued.v x)
theorem norm_nonneg (x : L) : 0 β€ norm x := by simp only [norm, NNReal.zero_le_coe]
| Mathlib/Topology/Algebra/NormedValued.lean | 70 | 72 | theorem norm_add_le (x y : L) : norm (x + y) β€ max (norm x) (norm y) := by |
simp only [norm, NNReal.coe_le_coe, le_max_iff, StrictMono.le_iff_le hv.strictMono]
exact le_max_iff.mp (Valuation.map_add_le_max' val.v _ _)
| 1,120 |
import Mathlib.Analysis.Normed.Field.Basic
import Mathlib.RingTheory.Valuation.RankOne
import Mathlib.Topology.Algebra.Valuation
noncomputable section
open Filter Set Valuation
open scoped NNReal
variable {K : Type*} [hK : NormedField K] (h : IsNonarchimedean (norm : K β β))
namespace Valued
variable {L : Type*} [Field L] {Ξβ : Type*} [LinearOrderedCommGroupWithZero Ξβ]
[val : Valued L Ξβ] [hv : RankOne val.v]
def norm : L β β := fun x : L => hv.hom (Valued.v x)
theorem norm_nonneg (x : L) : 0 β€ norm x := by simp only [norm, NNReal.zero_le_coe]
theorem norm_add_le (x y : L) : norm (x + y) β€ max (norm x) (norm y) := by
simp only [norm, NNReal.coe_le_coe, le_max_iff, StrictMono.le_iff_le hv.strictMono]
exact le_max_iff.mp (Valuation.map_add_le_max' val.v _ _)
| Mathlib/Topology/Algebra/NormedValued.lean | 74 | 75 | theorem norm_eq_zero {x : L} (hx : norm x = 0) : x = 0 := by |
simpa [norm, NNReal.coe_eq_zero, RankOne.hom_eq_zero_iff, zero_iff] using hx
| 1,120 |
import Mathlib.Data.Real.NNReal
import Mathlib.Tactic.GCongr.Core
#align_import analysis.normed.group.seminorm from "leanprover-community/mathlib"@"09079525fd01b3dda35e96adaa08d2f943e1648c"
open Set
open NNReal
variable {ΞΉ R R' E F G : Type*}
structure AddGroupSeminorm (G : Type*) [AddGroup G] where
-- Porting note: can't extend `ZeroHom G β` because otherwise `to_additive` won't work since
-- we aren't using old structures
protected toFun : G β β
protected map_zero' : toFun 0 = 0
protected add_le' : β r s, toFun (r + s) β€ toFun r + toFun s
protected neg' : β r, toFun (-r) = toFun r
#align add_group_seminorm AddGroupSeminorm
@[to_additive]
structure GroupSeminorm (G : Type*) [Group G] where
protected toFun : G β β
protected map_one' : toFun 1 = 0
protected mul_le' : β x y, toFun (x * y) β€ toFun x + toFun y
protected inv' : β x, toFun xβ»ΒΉ = toFun x
#align group_seminorm GroupSeminorm
structure NonarchAddGroupSeminorm (G : Type*) [AddGroup G] extends ZeroHom G β where
protected add_le_max' : β r s, toFun (r + s) β€ max (toFun r) (toFun s)
protected neg' : β r, toFun (-r) = toFun r
#align nonarch_add_group_seminorm NonarchAddGroupSeminorm
structure AddGroupNorm (G : Type*) [AddGroup G] extends AddGroupSeminorm G where
protected eq_zero_of_map_eq_zero' : β x, toFun x = 0 β x = 0
#align add_group_norm AddGroupNorm
@[to_additive]
structure GroupNorm (G : Type*) [Group G] extends GroupSeminorm G where
protected eq_one_of_map_eq_zero' : β x, toFun x = 0 β x = 1
#align group_norm GroupNorm
structure NonarchAddGroupNorm (G : Type*) [AddGroup G] extends NonarchAddGroupSeminorm G where
protected eq_zero_of_map_eq_zero' : β x, toFun x = 0 β x = 0
#align nonarch_add_group_norm NonarchAddGroupNorm
class NonarchAddGroupSeminormClass (F : Type*) (Ξ± : outParam Type*) [AddGroup Ξ±] [FunLike F Ξ± β]
extends NonarchimedeanHomClass F Ξ± β : Prop where
protected map_zero (f : F) : f 0 = 0
protected map_neg_eq_map' (f : F) (a : Ξ±) : f (-a) = f a
#align nonarch_add_group_seminorm_class NonarchAddGroupSeminormClass
class NonarchAddGroupNormClass (F : Type*) (Ξ± : outParam Type*) [AddGroup Ξ±] [FunLike F Ξ± β]
extends NonarchAddGroupSeminormClass F Ξ± : Prop where
protected eq_zero_of_map_eq_zero (f : F) {a : Ξ±} : f a = 0 β a = 0
#align nonarch_add_group_norm_class NonarchAddGroupNormClass
section NonarchAddGroupSeminormClass
variable [AddGroup E] [FunLike F E β] [NonarchAddGroupSeminormClass F E] (f : F) (x y : E)
| Mathlib/Analysis/Normed/Group/Seminorm.lean | 148 | 150 | theorem map_sub_le_max : f (x - y) β€ max (f x) (f y) := by |
rw [sub_eq_add_neg, β NonarchAddGroupSeminormClass.map_neg_eq_map' f y]
exact map_add_le_max _ _ _
| 1,121 |
import Mathlib.Algebra.Order.Ring.WithTop
import Mathlib.Algebra.Order.Sub.WithTop
import Mathlib.Data.Real.NNReal
import Mathlib.Order.Interval.Set.WithBotTop
#align_import data.real.ennreal from "leanprover-community/mathlib"@"c14c8fcde993801fca8946b0d80131a1a81d1520"
open Function Set NNReal
variable {Ξ± : Type*}
def ENNReal := WithTop ββ₯0
deriving Zero, AddCommMonoidWithOne, SemilatticeSup, DistribLattice, Nontrivial
#align ennreal ENNReal
@[inherit_doc]
scoped[ENNReal] notation "ββ₯0β" => ENNReal
scoped[ENNReal] notation "β" => (β€ : ENNReal)
namespace ENNReal
instance : OrderBot ββ₯0β := inferInstanceAs (OrderBot (WithTop ββ₯0))
instance : BoundedOrder ββ₯0β := inferInstanceAs (BoundedOrder (WithTop ββ₯0))
instance : CharZero ββ₯0β := inferInstanceAs (CharZero (WithTop ββ₯0))
noncomputable instance : CanonicallyOrderedCommSemiring ββ₯0β :=
inferInstanceAs (CanonicallyOrderedCommSemiring (WithTop ββ₯0))
noncomputable instance : CompleteLinearOrder ββ₯0β :=
inferInstanceAs (CompleteLinearOrder (WithTop ββ₯0))
instance : DenselyOrdered ββ₯0β := inferInstanceAs (DenselyOrdered (WithTop ββ₯0))
noncomputable instance : CanonicallyLinearOrderedAddCommMonoid ββ₯0β :=
inferInstanceAs (CanonicallyLinearOrderedAddCommMonoid (WithTop ββ₯0))
noncomputable instance instSub : Sub ββ₯0β := inferInstanceAs (Sub (WithTop ββ₯0))
noncomputable instance : OrderedSub ββ₯0β := inferInstanceAs (OrderedSub (WithTop ββ₯0))
noncomputable instance : LinearOrderedAddCommMonoidWithTop ββ₯0β :=
inferInstanceAs (LinearOrderedAddCommMonoidWithTop (WithTop ββ₯0))
-- Porting note: rfc: redefine using pattern matching?
noncomputable instance : Inv ββ₯0β := β¨fun a => sInf { b | 1 β€ a * b }β©
noncomputable instance : DivInvMonoid ββ₯0β where
variable {a b c d : ββ₯0β} {r p q : ββ₯0}
-- Porting note: are these 2 instances still required in Lean 4?
instance covariantClass_mul_le : CovariantClass ββ₯0β ββ₯0β (Β· * Β·) (Β· β€ Β·) := inferInstance
#align ennreal.covariant_class_mul_le ENNReal.covariantClass_mul_le
instance covariantClass_add_le : CovariantClass ββ₯0β ββ₯0β (Β· + Β·) (Β· β€ Β·) := inferInstance
#align ennreal.covariant_class_add_le ENNReal.covariantClass_add_le
-- Porting note (#11215): TODO: add a `WithTop` instance and use it here
noncomputable instance : LinearOrderedCommMonoidWithZero ββ₯0β :=
{ inferInstanceAs (LinearOrderedAddCommMonoidWithTop ββ₯0β),
inferInstanceAs (CommSemiring ββ₯0β) with
mul_le_mul_left := fun _ _ => mul_le_mul_left'
zero_le_one := zero_le 1 }
noncomputable instance : Unique (AddUnits ββ₯0β) where
default := 0
uniq a := AddUnits.ext <| le_zero_iff.1 <| by rw [β a.add_neg]; exact le_self_add
instance : Inhabited ββ₯0β := β¨0β©
@[coe, match_pattern] def ofNNReal : ββ₯0 β ββ₯0β := WithTop.some
instance : Coe ββ₯0 ββ₯0β := β¨ofNNRealβ©
@[elab_as_elim, induction_eliminator, cases_eliminator]
def recTopCoe {C : ββ₯0β β Sort*} (top : C β) (coe : β x : ββ₯0, C x) (x : ββ₯0β) : C x :=
WithTop.recTopCoe top coe x
instance canLift : CanLift ββ₯0β ββ₯0 ofNNReal (Β· β β) := WithTop.canLift
#align ennreal.can_lift ENNReal.canLift
@[simp] theorem none_eq_top : (none : ββ₯0β) = β := rfl
#align ennreal.none_eq_top ENNReal.none_eq_top
@[simp] theorem some_eq_coe (a : ββ₯0) : (Option.some a : ββ₯0β) = (βa : ββ₯0β) := rfl
#align ennreal.some_eq_coe ENNReal.some_eq_coe
@[simp] theorem some_eq_coe' (a : ββ₯0) : (WithTop.some a : ββ₯0β) = (βa : ββ₯0β) := rfl
lemma coe_injective : Injective ((β) : ββ₯0 β ββ₯0β) := WithTop.coe_injective
@[simp, norm_cast] lemma coe_inj : (p : ββ₯0β) = q β p = q := coe_injective.eq_iff
#align ennreal.coe_eq_coe ENNReal.coe_inj
lemma coe_ne_coe : (p : ββ₯0β) β q β p β q := coe_inj.not
theorem range_coe' : range ofNNReal = Iio β := WithTop.range_coe
theorem range_coe : range ofNNReal = {β}αΆ := (isCompl_range_some_none ββ₯0).symm.compl_eq.symm
protected def toNNReal : ββ₯0β β ββ₯0 := WithTop.untop' 0
#align ennreal.to_nnreal ENNReal.toNNReal
protected def toReal (a : ββ₯0β) : Real := a.toNNReal
#align ennreal.to_real ENNReal.toReal
protected noncomputable def ofReal (r : Real) : ββ₯0β := r.toNNReal
#align ennreal.of_real ENNReal.ofReal
@[simp, norm_cast]
theorem toNNReal_coe : (r : ββ₯0β).toNNReal = r := rfl
#align ennreal.to_nnreal_coe ENNReal.toNNReal_coe
@[simp]
theorem coe_toNNReal : β {a : ββ₯0β}, a β β β βa.toNNReal = a
| ofNNReal _, _ => rfl
| β€, h => (h rfl).elim
#align ennreal.coe_to_nnreal ENNReal.coe_toNNReal
@[simp]
| Mathlib/Data/ENNReal/Basic.lean | 212 | 213 | theorem ofReal_toReal {a : ββ₯0β} (h : a β β) : ENNReal.ofReal a.toReal = a := by |
simp [ENNReal.toReal, ENNReal.ofReal, h]
| 1,122 |
import Mathlib.Algebra.BigOperators.WithTop
import Mathlib.Algebra.GroupWithZero.Divisibility
import Mathlib.Data.ENNReal.Basic
#align_import data.real.ennreal from "leanprover-community/mathlib"@"c14c8fcde993801fca8946b0d80131a1a81d1520"
open Set NNReal ENNReal
namespace ENNReal
variable {a b c d : ββ₯0β} {r p q : ββ₯0}
section Mul
-- Porting note (#11215): TODO: generalize to `WithTop`
@[mono, gcongr]
| Mathlib/Data/ENNReal/Operations.lean | 33 | 41 | theorem mul_lt_mul (ac : a < c) (bd : b < d) : a * b < c * d := by |
rcases lt_iff_exists_nnreal_btwn.1 ac with β¨a', aa', a'cβ©
lift a to ββ₯0 using ne_top_of_lt aa'
rcases lt_iff_exists_nnreal_btwn.1 bd with β¨b', bb', b'dβ©
lift b to ββ₯0 using ne_top_of_lt bb'
norm_cast at *
calc
β(a * b) < β(a' * b') := coe_lt_coe.2 (mul_lt_mulβ aa' bb')
_ β€ c * d := mul_le_mul' a'c.le b'd.le
| 1,123 |
import Mathlib.Algebra.BigOperators.WithTop
import Mathlib.Algebra.GroupWithZero.Divisibility
import Mathlib.Data.ENNReal.Basic
#align_import data.real.ennreal from "leanprover-community/mathlib"@"c14c8fcde993801fca8946b0d80131a1a81d1520"
open Set NNReal ENNReal
namespace ENNReal
variable {a b c d : ββ₯0β} {r p q : ββ₯0}
section Mul
-- Porting note (#11215): TODO: generalize to `WithTop`
@[mono, gcongr]
theorem mul_lt_mul (ac : a < c) (bd : b < d) : a * b < c * d := by
rcases lt_iff_exists_nnreal_btwn.1 ac with β¨a', aa', a'cβ©
lift a to ββ₯0 using ne_top_of_lt aa'
rcases lt_iff_exists_nnreal_btwn.1 bd with β¨b', bb', b'dβ©
lift b to ββ₯0 using ne_top_of_lt bb'
norm_cast at *
calc
β(a * b) < β(a' * b') := coe_lt_coe.2 (mul_lt_mulβ aa' bb')
_ β€ c * d := mul_le_mul' a'c.le b'd.le
#align ennreal.mul_lt_mul ENNReal.mul_lt_mul
-- TODO: generalize to `CovariantClass Ξ± Ξ± (Β· * Β·) (Β· β€ Β·)`
theorem mul_left_mono : Monotone (a * Β·) := fun _ _ => mul_le_mul' le_rfl
#align ennreal.mul_left_mono ENNReal.mul_left_mono
-- TODO: generalize to `CovariantClass Ξ± Ξ± (swap (Β· * Β·)) (Β· β€ Β·)`
theorem mul_right_mono : Monotone (Β· * a) := fun _ _ h => mul_le_mul' h le_rfl
#align ennreal.mul_right_mono ENNReal.mul_right_mono
-- Porting note (#11215): TODO: generalize to `WithTop`
theorem pow_strictMono : β {n : β}, n β 0 β StrictMono fun x : ββ₯0β => x ^ n
| 0, h => absurd rfl h
| 1, _ => by simpa only [pow_one] using strictMono_id
| n + 2, _ => fun x y h β¦ by
simp_rw [pow_succ _ (n + 1)]; exact mul_lt_mul (pow_strictMono n.succ_ne_zero h) h
#align ennreal.pow_strict_mono ENNReal.pow_strictMono
@[gcongr] protected theorem pow_lt_pow_left (h : a < b) {n : β} (hn : n β 0) :
a ^ n < b ^ n :=
ENNReal.pow_strictMono hn h
theorem max_mul : max a b * c = max (a * c) (b * c) := mul_right_mono.map_max
#align ennreal.max_mul ENNReal.max_mul
theorem mul_max : a * max b c = max (a * b) (a * c) := mul_left_mono.map_max
#align ennreal.mul_max ENNReal.mul_max
-- Porting note (#11215): TODO: generalize to `WithTop`
| Mathlib/Data/ENNReal/Operations.lean | 71 | 77 | theorem mul_left_strictMono (h0 : a β 0) (hinf : a β β) : StrictMono (a * Β·) := by |
lift a to ββ₯0 using hinf
rw [coe_ne_zero] at h0
intro x y h
contrapose! h
simpa only [β mul_assoc, β coe_mul, inv_mul_cancel h0, coe_one, one_mul]
using mul_le_mul_left' h (βaβ»ΒΉ)
| 1,123 |
import Mathlib.Algebra.BigOperators.WithTop
import Mathlib.Algebra.GroupWithZero.Divisibility
import Mathlib.Data.ENNReal.Basic
#align_import data.real.ennreal from "leanprover-community/mathlib"@"c14c8fcde993801fca8946b0d80131a1a81d1520"
open Set NNReal ENNReal
namespace ENNReal
variable {a b c d : ββ₯0β} {r p q : ββ₯0}
section OperationsAndOrder
protected theorem pow_pos : 0 < a β β n : β, 0 < a ^ n :=
CanonicallyOrderedCommSemiring.pow_pos
#align ennreal.pow_pos ENNReal.pow_pos
protected theorem pow_ne_zero : a β 0 β β n : β, a ^ n β 0 := by
simpa only [pos_iff_ne_zero] using ENNReal.pow_pos
#align ennreal.pow_ne_zero ENNReal.pow_ne_zero
| Mathlib/Data/ENNReal/Operations.lean | 130 | 130 | theorem not_lt_zero : Β¬a < 0 := by | simp
| 1,123 |
import Mathlib.Algebra.BigOperators.WithTop
import Mathlib.Algebra.GroupWithZero.Divisibility
import Mathlib.Data.ENNReal.Basic
#align_import data.real.ennreal from "leanprover-community/mathlib"@"c14c8fcde993801fca8946b0d80131a1a81d1520"
open Set NNReal ENNReal
namespace ENNReal
variable {a b c d : ββ₯0β} {r p q : ββ₯0}
section OperationsAndOrder
protected theorem pow_pos : 0 < a β β n : β, 0 < a ^ n :=
CanonicallyOrderedCommSemiring.pow_pos
#align ennreal.pow_pos ENNReal.pow_pos
protected theorem pow_ne_zero : a β 0 β β n : β, a ^ n β 0 := by
simpa only [pos_iff_ne_zero] using ENNReal.pow_pos
#align ennreal.pow_ne_zero ENNReal.pow_ne_zero
theorem not_lt_zero : Β¬a < 0 := by simp
#align ennreal.not_lt_zero ENNReal.not_lt_zero
protected theorem le_of_add_le_add_left : a β β β a + b β€ a + c β b β€ c :=
WithTop.le_of_add_le_add_left
#align ennreal.le_of_add_le_add_left ENNReal.le_of_add_le_add_left
protected theorem le_of_add_le_add_right : a β β β b + a β€ c + a β b β€ c :=
WithTop.le_of_add_le_add_right
#align ennreal.le_of_add_le_add_right ENNReal.le_of_add_le_add_right
@[gcongr] protected theorem add_lt_add_left : a β β β b < c β a + b < a + c :=
WithTop.add_lt_add_left
#align ennreal.add_lt_add_left ENNReal.add_lt_add_left
@[gcongr] protected theorem add_lt_add_right : a β β β b < c β b + a < c + a :=
WithTop.add_lt_add_right
#align ennreal.add_lt_add_right ENNReal.add_lt_add_right
protected theorem add_le_add_iff_left : a β β β (a + b β€ a + c β b β€ c) :=
WithTop.add_le_add_iff_left
#align ennreal.add_le_add_iff_left ENNReal.add_le_add_iff_left
protected theorem add_le_add_iff_right : a β β β (b + a β€ c + a β b β€ c) :=
WithTop.add_le_add_iff_right
#align ennreal.add_le_add_iff_right ENNReal.add_le_add_iff_right
protected theorem add_lt_add_iff_left : a β β β (a + b < a + c β b < c) :=
WithTop.add_lt_add_iff_left
#align ennreal.add_lt_add_iff_left ENNReal.add_lt_add_iff_left
protected theorem add_lt_add_iff_right : a β β β (b + a < c + a β b < c) :=
WithTop.add_lt_add_iff_right
#align ennreal.add_lt_add_iff_right ENNReal.add_lt_add_iff_right
protected theorem add_lt_add_of_le_of_lt : a β β β a β€ b β c < d β a + c < b + d :=
WithTop.add_lt_add_of_le_of_lt
#align ennreal.add_lt_add_of_le_of_lt ENNReal.add_lt_add_of_le_of_lt
protected theorem add_lt_add_of_lt_of_le : c β β β a < b β c β€ d β a + c < b + d :=
WithTop.add_lt_add_of_lt_of_le
#align ennreal.add_lt_add_of_lt_of_le ENNReal.add_lt_add_of_lt_of_le
instance contravariantClass_add_lt : ContravariantClass ββ₯0β ββ₯0β (Β· + Β·) (Β· < Β·) :=
WithTop.contravariantClass_add_lt
#align ennreal.contravariant_class_add_lt ENNReal.contravariantClass_add_lt
| Mathlib/Data/ENNReal/Operations.lean | 177 | 178 | theorem lt_add_right (ha : a β β) (hb : b β 0) : a < a + b := by |
rwa [β pos_iff_ne_zero, β ENNReal.add_lt_add_iff_left ha, add_zero] at hb
| 1,123 |
import Mathlib.Algebra.BigOperators.WithTop
import Mathlib.Algebra.GroupWithZero.Divisibility
import Mathlib.Data.ENNReal.Basic
#align_import data.real.ennreal from "leanprover-community/mathlib"@"c14c8fcde993801fca8946b0d80131a1a81d1520"
open Set NNReal ENNReal
namespace ENNReal
variable {a b c d : ββ₯0β} {r p q : ββ₯0}
section OperationsAndInfty
variable {Ξ± : Type*}
@[simp] theorem add_eq_top : a + b = β β a = β β¨ b = β := WithTop.add_eq_top
#align ennreal.add_eq_top ENNReal.add_eq_top
@[simp] theorem add_lt_top : a + b < β β a < β β§ b < β := WithTop.add_lt_top
#align ennreal.add_lt_top ENNReal.add_lt_top
| Mathlib/Data/ENNReal/Operations.lean | 193 | 197 | theorem toNNReal_add {rβ rβ : ββ₯0β} (hβ : rβ β β) (hβ : rβ β β) :
(rβ + rβ).toNNReal = rβ.toNNReal + rβ.toNNReal := by |
lift rβ to ββ₯0 using hβ
lift rβ to ββ₯0 using hβ
rfl
| 1,123 |
import Mathlib.Algebra.BigOperators.WithTop
import Mathlib.Algebra.GroupWithZero.Divisibility
import Mathlib.Data.ENNReal.Basic
#align_import data.real.ennreal from "leanprover-community/mathlib"@"c14c8fcde993801fca8946b0d80131a1a81d1520"
open Set NNReal ENNReal
namespace ENNReal
variable {a b c d : ββ₯0β} {r p q : ββ₯0}
section OperationsAndInfty
variable {Ξ± : Type*}
@[simp] theorem add_eq_top : a + b = β β a = β β¨ b = β := WithTop.add_eq_top
#align ennreal.add_eq_top ENNReal.add_eq_top
@[simp] theorem add_lt_top : a + b < β β a < β β§ b < β := WithTop.add_lt_top
#align ennreal.add_lt_top ENNReal.add_lt_top
theorem toNNReal_add {rβ rβ : ββ₯0β} (hβ : rβ β β) (hβ : rβ β β) :
(rβ + rβ).toNNReal = rβ.toNNReal + rβ.toNNReal := by
lift rβ to ββ₯0 using hβ
lift rβ to ββ₯0 using hβ
rfl
#align ennreal.to_nnreal_add ENNReal.toNNReal_add
| Mathlib/Data/ENNReal/Operations.lean | 200 | 200 | theorem not_lt_top {x : ββ₯0β} : Β¬x < β β x = β := by | rw [lt_top_iff_ne_top, Classical.not_not]
| 1,123 |
import Mathlib.Algebra.BigOperators.WithTop
import Mathlib.Algebra.GroupWithZero.Divisibility
import Mathlib.Data.ENNReal.Basic
#align_import data.real.ennreal from "leanprover-community/mathlib"@"c14c8fcde993801fca8946b0d80131a1a81d1520"
open Set NNReal ENNReal
namespace ENNReal
variable {a b c d : ββ₯0β} {r p q : ββ₯0}
section OperationsAndInfty
variable {Ξ± : Type*}
@[simp] theorem add_eq_top : a + b = β β a = β β¨ b = β := WithTop.add_eq_top
#align ennreal.add_eq_top ENNReal.add_eq_top
@[simp] theorem add_lt_top : a + b < β β a < β β§ b < β := WithTop.add_lt_top
#align ennreal.add_lt_top ENNReal.add_lt_top
theorem toNNReal_add {rβ rβ : ββ₯0β} (hβ : rβ β β) (hβ : rβ β β) :
(rβ + rβ).toNNReal = rβ.toNNReal + rβ.toNNReal := by
lift rβ to ββ₯0 using hβ
lift rβ to ββ₯0 using hβ
rfl
#align ennreal.to_nnreal_add ENNReal.toNNReal_add
theorem not_lt_top {x : ββ₯0β} : Β¬x < β β x = β := by rw [lt_top_iff_ne_top, Classical.not_not]
#align ennreal.not_lt_top ENNReal.not_lt_top
| Mathlib/Data/ENNReal/Operations.lean | 203 | 203 | theorem add_ne_top : a + b β β β a β β β§ b β β := by | simpa only [lt_top_iff_ne_top] using add_lt_top
| 1,123 |
import Mathlib.Algebra.BigOperators.WithTop
import Mathlib.Algebra.GroupWithZero.Divisibility
import Mathlib.Data.ENNReal.Basic
#align_import data.real.ennreal from "leanprover-community/mathlib"@"c14c8fcde993801fca8946b0d80131a1a81d1520"
open Set NNReal ENNReal
namespace ENNReal
variable {a b c d : ββ₯0β} {r p q : ββ₯0}
section OperationsAndInfty
variable {Ξ± : Type*}
@[simp] theorem add_eq_top : a + b = β β a = β β¨ b = β := WithTop.add_eq_top
#align ennreal.add_eq_top ENNReal.add_eq_top
@[simp] theorem add_lt_top : a + b < β β a < β β§ b < β := WithTop.add_lt_top
#align ennreal.add_lt_top ENNReal.add_lt_top
theorem toNNReal_add {rβ rβ : ββ₯0β} (hβ : rβ β β) (hβ : rβ β β) :
(rβ + rβ).toNNReal = rβ.toNNReal + rβ.toNNReal := by
lift rβ to ββ₯0 using hβ
lift rβ to ββ₯0 using hβ
rfl
#align ennreal.to_nnreal_add ENNReal.toNNReal_add
theorem not_lt_top {x : ββ₯0β} : Β¬x < β β x = β := by rw [lt_top_iff_ne_top, Classical.not_not]
#align ennreal.not_lt_top ENNReal.not_lt_top
theorem add_ne_top : a + b β β β a β β β§ b β β := by simpa only [lt_top_iff_ne_top] using add_lt_top
#align ennreal.add_ne_top ENNReal.add_ne_top
| Mathlib/Data/ENNReal/Operations.lean | 206 | 206 | theorem mul_top' : a * β = if a = 0 then 0 else β := by | convert WithTop.mul_top' a
| 1,123 |
import Mathlib.Algebra.BigOperators.WithTop
import Mathlib.Algebra.GroupWithZero.Divisibility
import Mathlib.Data.ENNReal.Basic
#align_import data.real.ennreal from "leanprover-community/mathlib"@"c14c8fcde993801fca8946b0d80131a1a81d1520"
open Set NNReal ENNReal
namespace ENNReal
variable {a b c d : ββ₯0β} {r p q : ββ₯0}
section OperationsAndInfty
variable {Ξ± : Type*}
@[simp] theorem add_eq_top : a + b = β β a = β β¨ b = β := WithTop.add_eq_top
#align ennreal.add_eq_top ENNReal.add_eq_top
@[simp] theorem add_lt_top : a + b < β β a < β β§ b < β := WithTop.add_lt_top
#align ennreal.add_lt_top ENNReal.add_lt_top
theorem toNNReal_add {rβ rβ : ββ₯0β} (hβ : rβ β β) (hβ : rβ β β) :
(rβ + rβ).toNNReal = rβ.toNNReal + rβ.toNNReal := by
lift rβ to ββ₯0 using hβ
lift rβ to ββ₯0 using hβ
rfl
#align ennreal.to_nnreal_add ENNReal.toNNReal_add
theorem not_lt_top {x : ββ₯0β} : Β¬x < β β x = β := by rw [lt_top_iff_ne_top, Classical.not_not]
#align ennreal.not_lt_top ENNReal.not_lt_top
theorem add_ne_top : a + b β β β a β β β§ b β β := by simpa only [lt_top_iff_ne_top] using add_lt_top
#align ennreal.add_ne_top ENNReal.add_ne_top
theorem mul_top' : a * β = if a = 0 then 0 else β := by convert WithTop.mul_top' a
#align ennreal.mul_top ENNReal.mul_top'
-- Porting note: added because `simp` no longer uses `WithTop` lemmas for `ββ₯0β`
@[simp] theorem mul_top (h : a β 0) : a * β = β := WithTop.mul_top h
| Mathlib/Data/ENNReal/Operations.lean | 212 | 212 | theorem top_mul' : β * a = if a = 0 then 0 else β := by | convert WithTop.top_mul' a
| 1,123 |
import Mathlib.Algebra.BigOperators.WithTop
import Mathlib.Algebra.GroupWithZero.Divisibility
import Mathlib.Data.ENNReal.Basic
#align_import data.real.ennreal from "leanprover-community/mathlib"@"c14c8fcde993801fca8946b0d80131a1a81d1520"
open Set NNReal ENNReal
namespace ENNReal
variable {a b c d : ββ₯0β} {r p q : ββ₯0}
section OperationsAndInfty
variable {Ξ± : Type*}
@[simp] theorem add_eq_top : a + b = β β a = β β¨ b = β := WithTop.add_eq_top
#align ennreal.add_eq_top ENNReal.add_eq_top
@[simp] theorem add_lt_top : a + b < β β a < β β§ b < β := WithTop.add_lt_top
#align ennreal.add_lt_top ENNReal.add_lt_top
theorem toNNReal_add {rβ rβ : ββ₯0β} (hβ : rβ β β) (hβ : rβ β β) :
(rβ + rβ).toNNReal = rβ.toNNReal + rβ.toNNReal := by
lift rβ to ββ₯0 using hβ
lift rβ to ββ₯0 using hβ
rfl
#align ennreal.to_nnreal_add ENNReal.toNNReal_add
theorem not_lt_top {x : ββ₯0β} : Β¬x < β β x = β := by rw [lt_top_iff_ne_top, Classical.not_not]
#align ennreal.not_lt_top ENNReal.not_lt_top
theorem add_ne_top : a + b β β β a β β β§ b β β := by simpa only [lt_top_iff_ne_top] using add_lt_top
#align ennreal.add_ne_top ENNReal.add_ne_top
theorem mul_top' : a * β = if a = 0 then 0 else β := by convert WithTop.mul_top' a
#align ennreal.mul_top ENNReal.mul_top'
-- Porting note: added because `simp` no longer uses `WithTop` lemmas for `ββ₯0β`
@[simp] theorem mul_top (h : a β 0) : a * β = β := WithTop.mul_top h
theorem top_mul' : β * a = if a = 0 then 0 else β := by convert WithTop.top_mul' a
#align ennreal.top_mul ENNReal.top_mul'
-- Porting note: added because `simp` no longer uses `WithTop` lemmas for `ββ₯0β`
@[simp] theorem top_mul (h : a β 0) : β * a = β := WithTop.top_mul h
theorem top_mul_top : β * β = β := WithTop.top_mul_top
#align ennreal.top_mul_top ENNReal.top_mul_top
-- Porting note (#11215): TODO: assume `n β 0` instead of `0 < n`
-- Porting note (#11215): TODO: generalize to `WithTop`
theorem top_pow {n : β} (h : 0 < n) : β ^ n = β :=
Nat.le_induction (pow_one _) (fun m _ hm => by rw [pow_succ, hm, top_mul_top]) _
(Nat.succ_le_of_lt h)
#align ennreal.top_pow ENNReal.top_pow
theorem mul_eq_top : a * b = β β a β 0 β§ b = β β¨ a = β β§ b β 0 :=
WithTop.mul_eq_top_iff
#align ennreal.mul_eq_top ENNReal.mul_eq_top
theorem mul_lt_top : a β β β b β β β a * b < β := WithTop.mul_lt_top
#align ennreal.mul_lt_top ENNReal.mul_lt_top
| Mathlib/Data/ENNReal/Operations.lean | 235 | 235 | theorem mul_ne_top : a β β β b β β β a * b β β := by | simpa only [lt_top_iff_ne_top] using mul_lt_top
| 1,123 |
import Mathlib.Algebra.BigOperators.WithTop
import Mathlib.Algebra.GroupWithZero.Divisibility
import Mathlib.Data.ENNReal.Basic
#align_import data.real.ennreal from "leanprover-community/mathlib"@"c14c8fcde993801fca8946b0d80131a1a81d1520"
open Set NNReal ENNReal
namespace ENNReal
variable {a b c d : ββ₯0β} {r p q : ββ₯0}
section OperationsAndInfty
variable {Ξ± : Type*}
@[simp] theorem add_eq_top : a + b = β β a = β β¨ b = β := WithTop.add_eq_top
#align ennreal.add_eq_top ENNReal.add_eq_top
@[simp] theorem add_lt_top : a + b < β β a < β β§ b < β := WithTop.add_lt_top
#align ennreal.add_lt_top ENNReal.add_lt_top
theorem toNNReal_add {rβ rβ : ββ₯0β} (hβ : rβ β β) (hβ : rβ β β) :
(rβ + rβ).toNNReal = rβ.toNNReal + rβ.toNNReal := by
lift rβ to ββ₯0 using hβ
lift rβ to ββ₯0 using hβ
rfl
#align ennreal.to_nnreal_add ENNReal.toNNReal_add
theorem not_lt_top {x : ββ₯0β} : Β¬x < β β x = β := by rw [lt_top_iff_ne_top, Classical.not_not]
#align ennreal.not_lt_top ENNReal.not_lt_top
theorem add_ne_top : a + b β β β a β β β§ b β β := by simpa only [lt_top_iff_ne_top] using add_lt_top
#align ennreal.add_ne_top ENNReal.add_ne_top
theorem mul_top' : a * β = if a = 0 then 0 else β := by convert WithTop.mul_top' a
#align ennreal.mul_top ENNReal.mul_top'
-- Porting note: added because `simp` no longer uses `WithTop` lemmas for `ββ₯0β`
@[simp] theorem mul_top (h : a β 0) : a * β = β := WithTop.mul_top h
theorem top_mul' : β * a = if a = 0 then 0 else β := by convert WithTop.top_mul' a
#align ennreal.top_mul ENNReal.top_mul'
-- Porting note: added because `simp` no longer uses `WithTop` lemmas for `ββ₯0β`
@[simp] theorem top_mul (h : a β 0) : β * a = β := WithTop.top_mul h
theorem top_mul_top : β * β = β := WithTop.top_mul_top
#align ennreal.top_mul_top ENNReal.top_mul_top
-- Porting note (#11215): TODO: assume `n β 0` instead of `0 < n`
-- Porting note (#11215): TODO: generalize to `WithTop`
theorem top_pow {n : β} (h : 0 < n) : β ^ n = β :=
Nat.le_induction (pow_one _) (fun m _ hm => by rw [pow_succ, hm, top_mul_top]) _
(Nat.succ_le_of_lt h)
#align ennreal.top_pow ENNReal.top_pow
theorem mul_eq_top : a * b = β β a β 0 β§ b = β β¨ a = β β§ b β 0 :=
WithTop.mul_eq_top_iff
#align ennreal.mul_eq_top ENNReal.mul_eq_top
theorem mul_lt_top : a β β β b β β β a * b < β := WithTop.mul_lt_top
#align ennreal.mul_lt_top ENNReal.mul_lt_top
theorem mul_ne_top : a β β β b β β β a * b β β := by simpa only [lt_top_iff_ne_top] using mul_lt_top
#align ennreal.mul_ne_top ENNReal.mul_ne_top
theorem lt_top_of_mul_ne_top_left (h : a * b β β) (hb : b β 0) : a < β :=
lt_top_iff_ne_top.2 fun ha => h <| mul_eq_top.2 (Or.inr β¨ha, hbβ©)
#align ennreal.lt_top_of_mul_ne_top_left ENNReal.lt_top_of_mul_ne_top_left
theorem lt_top_of_mul_ne_top_right (h : a * b β β) (ha : a β 0) : b < β :=
lt_top_of_mul_ne_top_left (by rwa [mul_comm]) ha
#align ennreal.lt_top_of_mul_ne_top_right ENNReal.lt_top_of_mul_ne_top_right
| Mathlib/Data/ENNReal/Operations.lean | 246 | 252 | theorem mul_lt_top_iff {a b : ββ₯0β} : a * b < β β a < β β§ b < β β¨ a = 0 β¨ b = 0 := by |
constructor
Β· intro h
rw [β or_assoc, or_iff_not_imp_right, or_iff_not_imp_right]
intro hb ha
exact β¨lt_top_of_mul_ne_top_left h.ne hb, lt_top_of_mul_ne_top_right h.ne haβ©
Β· rintro (β¨ha, hbβ© | rfl | rfl) <;> [exact mul_lt_top ha.ne hb.ne; simp; simp]
| 1,123 |
import Mathlib.Algebra.BigOperators.WithTop
import Mathlib.Algebra.GroupWithZero.Divisibility
import Mathlib.Data.ENNReal.Basic
#align_import data.real.ennreal from "leanprover-community/mathlib"@"c14c8fcde993801fca8946b0d80131a1a81d1520"
open Set NNReal ENNReal
namespace ENNReal
variable {a b c d : ββ₯0β} {r p q : ββ₯0}
section OperationsAndInfty
variable {Ξ± : Type*}
@[simp] theorem add_eq_top : a + b = β β a = β β¨ b = β := WithTop.add_eq_top
#align ennreal.add_eq_top ENNReal.add_eq_top
@[simp] theorem add_lt_top : a + b < β β a < β β§ b < β := WithTop.add_lt_top
#align ennreal.add_lt_top ENNReal.add_lt_top
theorem toNNReal_add {rβ rβ : ββ₯0β} (hβ : rβ β β) (hβ : rβ β β) :
(rβ + rβ).toNNReal = rβ.toNNReal + rβ.toNNReal := by
lift rβ to ββ₯0 using hβ
lift rβ to ββ₯0 using hβ
rfl
#align ennreal.to_nnreal_add ENNReal.toNNReal_add
theorem not_lt_top {x : ββ₯0β} : Β¬x < β β x = β := by rw [lt_top_iff_ne_top, Classical.not_not]
#align ennreal.not_lt_top ENNReal.not_lt_top
theorem add_ne_top : a + b β β β a β β β§ b β β := by simpa only [lt_top_iff_ne_top] using add_lt_top
#align ennreal.add_ne_top ENNReal.add_ne_top
theorem mul_top' : a * β = if a = 0 then 0 else β := by convert WithTop.mul_top' a
#align ennreal.mul_top ENNReal.mul_top'
-- Porting note: added because `simp` no longer uses `WithTop` lemmas for `ββ₯0β`
@[simp] theorem mul_top (h : a β 0) : a * β = β := WithTop.mul_top h
theorem top_mul' : β * a = if a = 0 then 0 else β := by convert WithTop.top_mul' a
#align ennreal.top_mul ENNReal.top_mul'
-- Porting note: added because `simp` no longer uses `WithTop` lemmas for `ββ₯0β`
@[simp] theorem top_mul (h : a β 0) : β * a = β := WithTop.top_mul h
theorem top_mul_top : β * β = β := WithTop.top_mul_top
#align ennreal.top_mul_top ENNReal.top_mul_top
-- Porting note (#11215): TODO: assume `n β 0` instead of `0 < n`
-- Porting note (#11215): TODO: generalize to `WithTop`
theorem top_pow {n : β} (h : 0 < n) : β ^ n = β :=
Nat.le_induction (pow_one _) (fun m _ hm => by rw [pow_succ, hm, top_mul_top]) _
(Nat.succ_le_of_lt h)
#align ennreal.top_pow ENNReal.top_pow
theorem mul_eq_top : a * b = β β a β 0 β§ b = β β¨ a = β β§ b β 0 :=
WithTop.mul_eq_top_iff
#align ennreal.mul_eq_top ENNReal.mul_eq_top
theorem mul_lt_top : a β β β b β β β a * b < β := WithTop.mul_lt_top
#align ennreal.mul_lt_top ENNReal.mul_lt_top
theorem mul_ne_top : a β β β b β β β a * b β β := by simpa only [lt_top_iff_ne_top] using mul_lt_top
#align ennreal.mul_ne_top ENNReal.mul_ne_top
theorem lt_top_of_mul_ne_top_left (h : a * b β β) (hb : b β 0) : a < β :=
lt_top_iff_ne_top.2 fun ha => h <| mul_eq_top.2 (Or.inr β¨ha, hbβ©)
#align ennreal.lt_top_of_mul_ne_top_left ENNReal.lt_top_of_mul_ne_top_left
theorem lt_top_of_mul_ne_top_right (h : a * b β β) (ha : a β 0) : b < β :=
lt_top_of_mul_ne_top_left (by rwa [mul_comm]) ha
#align ennreal.lt_top_of_mul_ne_top_right ENNReal.lt_top_of_mul_ne_top_right
theorem mul_lt_top_iff {a b : ββ₯0β} : a * b < β β a < β β§ b < β β¨ a = 0 β¨ b = 0 := by
constructor
Β· intro h
rw [β or_assoc, or_iff_not_imp_right, or_iff_not_imp_right]
intro hb ha
exact β¨lt_top_of_mul_ne_top_left h.ne hb, lt_top_of_mul_ne_top_right h.ne haβ©
Β· rintro (β¨ha, hbβ© | rfl | rfl) <;> [exact mul_lt_top ha.ne hb.ne; simp; simp]
#align ennreal.mul_lt_top_iff ENNReal.mul_lt_top_iff
| Mathlib/Data/ENNReal/Operations.lean | 255 | 258 | theorem mul_self_lt_top_iff {a : ββ₯0β} : a * a < β€ β a < β€ := by |
rw [ENNReal.mul_lt_top_iff, and_self, or_self, or_iff_left_iff_imp]
rintro rfl
exact zero_lt_top
| 1,123 |
import Mathlib.Data.ENNReal.Operations
#align_import data.real.ennreal from "leanprover-community/mathlib"@"c14c8fcde993801fca8946b0d80131a1a81d1520"
open Set NNReal
namespace ENNReal
noncomputable section Inv
variable {a b c d : ββ₯0β} {r p q : ββ₯0}
protected theorem div_eq_inv_mul : a / b = bβ»ΒΉ * a := by rw [div_eq_mul_inv, mul_comm]
#align ennreal.div_eq_inv_mul ENNReal.div_eq_inv_mul
@[simp] theorem inv_zero : (0 : ββ₯0β)β»ΒΉ = β :=
show sInf { b : ββ₯0β | 1 β€ 0 * b } = β by simp
#align ennreal.inv_zero ENNReal.inv_zero
@[simp] theorem inv_top : ββ»ΒΉ = 0 :=
bot_unique <| le_of_forall_le_of_dense fun a (h : 0 < a) => sInf_le <| by simp [*, h.ne', top_mul]
#align ennreal.inv_top ENNReal.inv_top
theorem coe_inv_le : (βrβ»ΒΉ : ββ₯0β) β€ (βr)β»ΒΉ :=
le_sInf fun b (hb : 1 β€ βr * b) =>
coe_le_iff.2 <| by
rintro b rfl
apply NNReal.inv_le_of_le_mul
rwa [β coe_mul, β coe_one, coe_le_coe] at hb
#align ennreal.coe_inv_le ENNReal.coe_inv_le
@[simp, norm_cast]
theorem coe_inv (hr : r β 0) : (βrβ»ΒΉ : ββ₯0β) = (βr)β»ΒΉ :=
coe_inv_le.antisymm <| sInf_le <| mem_setOf.2 <| by rw [β coe_mul, mul_inv_cancel hr, coe_one]
#align ennreal.coe_inv ENNReal.coe_inv
@[norm_cast]
| Mathlib/Data/ENNReal/Inv.lean | 68 | 68 | theorem coe_inv_two : ((2β»ΒΉ : ββ₯0) : ββ₯0β) = 2β»ΒΉ := by | rw [coe_inv _root_.two_ne_zero, coe_two]
| 1,124 |
import Mathlib.Data.ENNReal.Operations
#align_import data.real.ennreal from "leanprover-community/mathlib"@"c14c8fcde993801fca8946b0d80131a1a81d1520"
open Set NNReal
namespace ENNReal
noncomputable section Inv
variable {a b c d : ββ₯0β} {r p q : ββ₯0}
protected theorem div_eq_inv_mul : a / b = bβ»ΒΉ * a := by rw [div_eq_mul_inv, mul_comm]
#align ennreal.div_eq_inv_mul ENNReal.div_eq_inv_mul
@[simp] theorem inv_zero : (0 : ββ₯0β)β»ΒΉ = β :=
show sInf { b : ββ₯0β | 1 β€ 0 * b } = β by simp
#align ennreal.inv_zero ENNReal.inv_zero
@[simp] theorem inv_top : ββ»ΒΉ = 0 :=
bot_unique <| le_of_forall_le_of_dense fun a (h : 0 < a) => sInf_le <| by simp [*, h.ne', top_mul]
#align ennreal.inv_top ENNReal.inv_top
theorem coe_inv_le : (βrβ»ΒΉ : ββ₯0β) β€ (βr)β»ΒΉ :=
le_sInf fun b (hb : 1 β€ βr * b) =>
coe_le_iff.2 <| by
rintro b rfl
apply NNReal.inv_le_of_le_mul
rwa [β coe_mul, β coe_one, coe_le_coe] at hb
#align ennreal.coe_inv_le ENNReal.coe_inv_le
@[simp, norm_cast]
theorem coe_inv (hr : r β 0) : (βrβ»ΒΉ : ββ₯0β) = (βr)β»ΒΉ :=
coe_inv_le.antisymm <| sInf_le <| mem_setOf.2 <| by rw [β coe_mul, mul_inv_cancel hr, coe_one]
#align ennreal.coe_inv ENNReal.coe_inv
@[norm_cast]
theorem coe_inv_two : ((2β»ΒΉ : ββ₯0) : ββ₯0β) = 2β»ΒΉ := by rw [coe_inv _root_.two_ne_zero, coe_two]
#align ennreal.coe_inv_two ENNReal.coe_inv_two
@[simp, norm_cast]
| Mathlib/Data/ENNReal/Inv.lean | 72 | 73 | theorem coe_div (hr : r β 0) : (β(p / r) : ββ₯0β) = p / r := by |
rw [div_eq_mul_inv, div_eq_mul_inv, coe_mul, coe_inv hr]
| 1,124 |
import Mathlib.Data.ENNReal.Operations
#align_import data.real.ennreal from "leanprover-community/mathlib"@"c14c8fcde993801fca8946b0d80131a1a81d1520"
open Set NNReal
namespace ENNReal
noncomputable section Inv
variable {a b c d : ββ₯0β} {r p q : ββ₯0}
protected theorem div_eq_inv_mul : a / b = bβ»ΒΉ * a := by rw [div_eq_mul_inv, mul_comm]
#align ennreal.div_eq_inv_mul ENNReal.div_eq_inv_mul
@[simp] theorem inv_zero : (0 : ββ₯0β)β»ΒΉ = β :=
show sInf { b : ββ₯0β | 1 β€ 0 * b } = β by simp
#align ennreal.inv_zero ENNReal.inv_zero
@[simp] theorem inv_top : ββ»ΒΉ = 0 :=
bot_unique <| le_of_forall_le_of_dense fun a (h : 0 < a) => sInf_le <| by simp [*, h.ne', top_mul]
#align ennreal.inv_top ENNReal.inv_top
theorem coe_inv_le : (βrβ»ΒΉ : ββ₯0β) β€ (βr)β»ΒΉ :=
le_sInf fun b (hb : 1 β€ βr * b) =>
coe_le_iff.2 <| by
rintro b rfl
apply NNReal.inv_le_of_le_mul
rwa [β coe_mul, β coe_one, coe_le_coe] at hb
#align ennreal.coe_inv_le ENNReal.coe_inv_le
@[simp, norm_cast]
theorem coe_inv (hr : r β 0) : (βrβ»ΒΉ : ββ₯0β) = (βr)β»ΒΉ :=
coe_inv_le.antisymm <| sInf_le <| mem_setOf.2 <| by rw [β coe_mul, mul_inv_cancel hr, coe_one]
#align ennreal.coe_inv ENNReal.coe_inv
@[norm_cast]
theorem coe_inv_two : ((2β»ΒΉ : ββ₯0) : ββ₯0β) = 2β»ΒΉ := by rw [coe_inv _root_.two_ne_zero, coe_two]
#align ennreal.coe_inv_two ENNReal.coe_inv_two
@[simp, norm_cast]
theorem coe_div (hr : r β 0) : (β(p / r) : ββ₯0β) = p / r := by
rw [div_eq_mul_inv, div_eq_mul_inv, coe_mul, coe_inv hr]
#align ennreal.coe_div ENNReal.coe_div
lemma coe_div_le : β(p / r) β€ (p / r : ββ₯0β) := by
simpa only [div_eq_mul_inv, coe_mul] using mul_le_mul_left' coe_inv_le _
| Mathlib/Data/ENNReal/Inv.lean | 79 | 79 | theorem div_zero (h : a β 0) : a / 0 = β := by | simp [div_eq_mul_inv, h]
| 1,124 |
import Mathlib.Data.ENNReal.Operations
#align_import data.real.ennreal from "leanprover-community/mathlib"@"c14c8fcde993801fca8946b0d80131a1a81d1520"
open Set NNReal
namespace ENNReal
noncomputable section Inv
variable {a b c d : ββ₯0β} {r p q : ββ₯0}
protected theorem div_eq_inv_mul : a / b = bβ»ΒΉ * a := by rw [div_eq_mul_inv, mul_comm]
#align ennreal.div_eq_inv_mul ENNReal.div_eq_inv_mul
@[simp] theorem inv_zero : (0 : ββ₯0β)β»ΒΉ = β :=
show sInf { b : ββ₯0β | 1 β€ 0 * b } = β by simp
#align ennreal.inv_zero ENNReal.inv_zero
@[simp] theorem inv_top : ββ»ΒΉ = 0 :=
bot_unique <| le_of_forall_le_of_dense fun a (h : 0 < a) => sInf_le <| by simp [*, h.ne', top_mul]
#align ennreal.inv_top ENNReal.inv_top
theorem coe_inv_le : (βrβ»ΒΉ : ββ₯0β) β€ (βr)β»ΒΉ :=
le_sInf fun b (hb : 1 β€ βr * b) =>
coe_le_iff.2 <| by
rintro b rfl
apply NNReal.inv_le_of_le_mul
rwa [β coe_mul, β coe_one, coe_le_coe] at hb
#align ennreal.coe_inv_le ENNReal.coe_inv_le
@[simp, norm_cast]
theorem coe_inv (hr : r β 0) : (βrβ»ΒΉ : ββ₯0β) = (βr)β»ΒΉ :=
coe_inv_le.antisymm <| sInf_le <| mem_setOf.2 <| by rw [β coe_mul, mul_inv_cancel hr, coe_one]
#align ennreal.coe_inv ENNReal.coe_inv
@[norm_cast]
theorem coe_inv_two : ((2β»ΒΉ : ββ₯0) : ββ₯0β) = 2β»ΒΉ := by rw [coe_inv _root_.two_ne_zero, coe_two]
#align ennreal.coe_inv_two ENNReal.coe_inv_two
@[simp, norm_cast]
theorem coe_div (hr : r β 0) : (β(p / r) : ββ₯0β) = p / r := by
rw [div_eq_mul_inv, div_eq_mul_inv, coe_mul, coe_inv hr]
#align ennreal.coe_div ENNReal.coe_div
lemma coe_div_le : β(p / r) β€ (p / r : ββ₯0β) := by
simpa only [div_eq_mul_inv, coe_mul] using mul_le_mul_left' coe_inv_le _
theorem div_zero (h : a β 0) : a / 0 = β := by simp [div_eq_mul_inv, h]
#align ennreal.div_zero ENNReal.div_zero
instance : DivInvOneMonoid ββ₯0β :=
{ inferInstanceAs (DivInvMonoid ββ₯0β) with
inv_one := by simpa only [coe_inv one_ne_zero, coe_one] using coe_inj.2 inv_one }
protected theorem inv_pow : β {a : ββ₯0β} {n : β}, (a ^ n)β»ΒΉ = aβ»ΒΉ ^ n
| _, 0 => by simp only [pow_zero, inv_one]
| β€, n + 1 => by simp [top_pow]
| (a : ββ₯0), n + 1 => by
rcases eq_or_ne a 0 with (rfl | ha)
Β· simp [top_pow]
Β· have := pow_ne_zero (n + 1) ha
norm_cast
rw [inv_pow]
#align ennreal.inv_pow ENNReal.inv_pow
protected theorem mul_inv_cancel (h0 : a β 0) (ht : a β β) : a * aβ»ΒΉ = 1 := by
lift a to ββ₯0 using ht
norm_cast at h0; norm_cast
exact mul_inv_cancel h0
#align ennreal.mul_inv_cancel ENNReal.mul_inv_cancel
protected theorem inv_mul_cancel (h0 : a β 0) (ht : a β β) : aβ»ΒΉ * a = 1 :=
mul_comm a aβ»ΒΉ βΈ ENNReal.mul_inv_cancel h0 ht
#align ennreal.inv_mul_cancel ENNReal.inv_mul_cancel
protected theorem div_mul_cancel (h0 : a β 0) (hI : a β β) : b / a * a = b := by
rw [div_eq_mul_inv, mul_assoc, ENNReal.inv_mul_cancel h0 hI, mul_one]
#align ennreal.div_mul_cancel ENNReal.div_mul_cancel
protected theorem mul_div_cancel' (h0 : a β 0) (hI : a β β) : a * (b / a) = b := by
rw [mul_comm, ENNReal.div_mul_cancel h0 hI]
#align ennreal.mul_div_cancel' ENNReal.mul_div_cancel'
-- Porting note: `simp only [div_eq_mul_inv, mul_comm, mul_assoc]` doesn't work in the following two
protected theorem mul_comm_div : a / b * c = a * (c / b) := by
simp only [div_eq_mul_inv, mul_right_comm, β mul_assoc]
#align ennreal.mul_comm_div ENNReal.mul_comm_div
protected theorem mul_div_right_comm : a * b / c = a / c * b := by
simp only [div_eq_mul_inv, mul_right_comm]
#align ennreal.mul_div_right_comm ENNReal.mul_div_right_comm
instance : InvolutiveInv ββ₯0β where
inv_inv a := by
by_cases a = 0 <;> cases a <;> simp_all [none_eq_top, some_eq_coe, -coe_inv, (coe_inv _).symm]
@[simp] protected lemma inv_eq_one : aβ»ΒΉ = 1 β a = 1 := by rw [β inv_inj, inv_inv, inv_one]
@[simp] theorem inv_eq_top : aβ»ΒΉ = β β a = 0 := inv_zero βΈ inv_inj
#align ennreal.inv_eq_top ENNReal.inv_eq_top
| Mathlib/Data/ENNReal/Inv.lean | 133 | 133 | theorem inv_ne_top : aβ»ΒΉ β β β a β 0 := by | simp
| 1,124 |
import Mathlib.Data.ENNReal.Operations
#align_import data.real.ennreal from "leanprover-community/mathlib"@"c14c8fcde993801fca8946b0d80131a1a81d1520"
open Set NNReal
namespace ENNReal
noncomputable section Inv
variable {a b c d : ββ₯0β} {r p q : ββ₯0}
protected theorem div_eq_inv_mul : a / b = bβ»ΒΉ * a := by rw [div_eq_mul_inv, mul_comm]
#align ennreal.div_eq_inv_mul ENNReal.div_eq_inv_mul
@[simp] theorem inv_zero : (0 : ββ₯0β)β»ΒΉ = β :=
show sInf { b : ββ₯0β | 1 β€ 0 * b } = β by simp
#align ennreal.inv_zero ENNReal.inv_zero
@[simp] theorem inv_top : ββ»ΒΉ = 0 :=
bot_unique <| le_of_forall_le_of_dense fun a (h : 0 < a) => sInf_le <| by simp [*, h.ne', top_mul]
#align ennreal.inv_top ENNReal.inv_top
theorem coe_inv_le : (βrβ»ΒΉ : ββ₯0β) β€ (βr)β»ΒΉ :=
le_sInf fun b (hb : 1 β€ βr * b) =>
coe_le_iff.2 <| by
rintro b rfl
apply NNReal.inv_le_of_le_mul
rwa [β coe_mul, β coe_one, coe_le_coe] at hb
#align ennreal.coe_inv_le ENNReal.coe_inv_le
@[simp, norm_cast]
theorem coe_inv (hr : r β 0) : (βrβ»ΒΉ : ββ₯0β) = (βr)β»ΒΉ :=
coe_inv_le.antisymm <| sInf_le <| mem_setOf.2 <| by rw [β coe_mul, mul_inv_cancel hr, coe_one]
#align ennreal.coe_inv ENNReal.coe_inv
@[norm_cast]
theorem coe_inv_two : ((2β»ΒΉ : ββ₯0) : ββ₯0β) = 2β»ΒΉ := by rw [coe_inv _root_.two_ne_zero, coe_two]
#align ennreal.coe_inv_two ENNReal.coe_inv_two
@[simp, norm_cast]
theorem coe_div (hr : r β 0) : (β(p / r) : ββ₯0β) = p / r := by
rw [div_eq_mul_inv, div_eq_mul_inv, coe_mul, coe_inv hr]
#align ennreal.coe_div ENNReal.coe_div
lemma coe_div_le : β(p / r) β€ (p / r : ββ₯0β) := by
simpa only [div_eq_mul_inv, coe_mul] using mul_le_mul_left' coe_inv_le _
theorem div_zero (h : a β 0) : a / 0 = β := by simp [div_eq_mul_inv, h]
#align ennreal.div_zero ENNReal.div_zero
instance : DivInvOneMonoid ββ₯0β :=
{ inferInstanceAs (DivInvMonoid ββ₯0β) with
inv_one := by simpa only [coe_inv one_ne_zero, coe_one] using coe_inj.2 inv_one }
protected theorem inv_pow : β {a : ββ₯0β} {n : β}, (a ^ n)β»ΒΉ = aβ»ΒΉ ^ n
| _, 0 => by simp only [pow_zero, inv_one]
| β€, n + 1 => by simp [top_pow]
| (a : ββ₯0), n + 1 => by
rcases eq_or_ne a 0 with (rfl | ha)
Β· simp [top_pow]
Β· have := pow_ne_zero (n + 1) ha
norm_cast
rw [inv_pow]
#align ennreal.inv_pow ENNReal.inv_pow
protected theorem mul_inv_cancel (h0 : a β 0) (ht : a β β) : a * aβ»ΒΉ = 1 := by
lift a to ββ₯0 using ht
norm_cast at h0; norm_cast
exact mul_inv_cancel h0
#align ennreal.mul_inv_cancel ENNReal.mul_inv_cancel
protected theorem inv_mul_cancel (h0 : a β 0) (ht : a β β) : aβ»ΒΉ * a = 1 :=
mul_comm a aβ»ΒΉ βΈ ENNReal.mul_inv_cancel h0 ht
#align ennreal.inv_mul_cancel ENNReal.inv_mul_cancel
protected theorem div_mul_cancel (h0 : a β 0) (hI : a β β) : b / a * a = b := by
rw [div_eq_mul_inv, mul_assoc, ENNReal.inv_mul_cancel h0 hI, mul_one]
#align ennreal.div_mul_cancel ENNReal.div_mul_cancel
protected theorem mul_div_cancel' (h0 : a β 0) (hI : a β β) : a * (b / a) = b := by
rw [mul_comm, ENNReal.div_mul_cancel h0 hI]
#align ennreal.mul_div_cancel' ENNReal.mul_div_cancel'
-- Porting note: `simp only [div_eq_mul_inv, mul_comm, mul_assoc]` doesn't work in the following two
protected theorem mul_comm_div : a / b * c = a * (c / b) := by
simp only [div_eq_mul_inv, mul_right_comm, β mul_assoc]
#align ennreal.mul_comm_div ENNReal.mul_comm_div
protected theorem mul_div_right_comm : a * b / c = a / c * b := by
simp only [div_eq_mul_inv, mul_right_comm]
#align ennreal.mul_div_right_comm ENNReal.mul_div_right_comm
instance : InvolutiveInv ββ₯0β where
inv_inv a := by
by_cases a = 0 <;> cases a <;> simp_all [none_eq_top, some_eq_coe, -coe_inv, (coe_inv _).symm]
@[simp] protected lemma inv_eq_one : aβ»ΒΉ = 1 β a = 1 := by rw [β inv_inj, inv_inv, inv_one]
@[simp] theorem inv_eq_top : aβ»ΒΉ = β β a = 0 := inv_zero βΈ inv_inj
#align ennreal.inv_eq_top ENNReal.inv_eq_top
theorem inv_ne_top : aβ»ΒΉ β β β a β 0 := by simp
#align ennreal.inv_ne_top ENNReal.inv_ne_top
@[simp]
| Mathlib/Data/ENNReal/Inv.lean | 137 | 138 | theorem inv_lt_top {x : ββ₯0β} : xβ»ΒΉ < β β 0 < x := by |
simp only [lt_top_iff_ne_top, inv_ne_top, pos_iff_ne_zero]
| 1,124 |
import Mathlib.Data.ENNReal.Inv
#align_import data.real.ennreal from "leanprover-community/mathlib"@"c14c8fcde993801fca8946b0d80131a1a81d1520"
open Set NNReal ENNReal
namespace ENNReal
section Real
variable {a b c d : ββ₯0β} {r p q : ββ₯0}
| Mathlib/Data/ENNReal/Real.lean | 37 | 40 | theorem toReal_add (ha : a β β) (hb : b β β) : (a + b).toReal = a.toReal + b.toReal := by |
lift a to ββ₯0 using ha
lift b to ββ₯0 using hb
rfl
| 1,125 |
import Mathlib.Data.ENNReal.Inv
#align_import data.real.ennreal from "leanprover-community/mathlib"@"c14c8fcde993801fca8946b0d80131a1a81d1520"
open Set NNReal ENNReal
namespace ENNReal
section Real
variable {a b c d : ββ₯0β} {r p q : ββ₯0}
theorem toReal_add (ha : a β β) (hb : b β β) : (a + b).toReal = a.toReal + b.toReal := by
lift a to ββ₯0 using ha
lift b to ββ₯0 using hb
rfl
#align ennreal.to_real_add ENNReal.toReal_add
| Mathlib/Data/ENNReal/Real.lean | 43 | 47 | theorem toReal_sub_of_le {a b : ββ₯0β} (h : b β€ a) (ha : a β β) :
(a - b).toReal = a.toReal - b.toReal := by |
lift b to ββ₯0 using ne_top_of_le_ne_top ha h
lift a to ββ₯0 using ha
simp only [β ENNReal.coe_sub, ENNReal.coe_toReal, NNReal.coe_sub (ENNReal.coe_le_coe.mp h)]
| 1,125 |
import Mathlib.Data.ENNReal.Inv
#align_import data.real.ennreal from "leanprover-community/mathlib"@"c14c8fcde993801fca8946b0d80131a1a81d1520"
open Set NNReal ENNReal
namespace ENNReal
section Real
variable {a b c d : ββ₯0β} {r p q : ββ₯0}
theorem toReal_add (ha : a β β) (hb : b β β) : (a + b).toReal = a.toReal + b.toReal := by
lift a to ββ₯0 using ha
lift b to ββ₯0 using hb
rfl
#align ennreal.to_real_add ENNReal.toReal_add
theorem toReal_sub_of_le {a b : ββ₯0β} (h : b β€ a) (ha : a β β) :
(a - b).toReal = a.toReal - b.toReal := by
lift b to ββ₯0 using ne_top_of_le_ne_top ha h
lift a to ββ₯0 using ha
simp only [β ENNReal.coe_sub, ENNReal.coe_toReal, NNReal.coe_sub (ENNReal.coe_le_coe.mp h)]
#align ennreal.to_real_sub_of_le ENNReal.toReal_sub_of_le
| Mathlib/Data/ENNReal/Real.lean | 50 | 55 | theorem le_toReal_sub {a b : ββ₯0β} (hb : b β β) : a.toReal - b.toReal β€ (a - b).toReal := by |
lift b to ββ₯0 using hb
induction a
Β· simp
Β· simp only [β coe_sub, NNReal.sub_def, Real.coe_toNNReal', coe_toReal]
exact le_max_left _ _
| 1,125 |
import Mathlib.Data.ENNReal.Inv
#align_import data.real.ennreal from "leanprover-community/mathlib"@"c14c8fcde993801fca8946b0d80131a1a81d1520"
open Set NNReal ENNReal
namespace ENNReal
section Real
variable {a b c d : ββ₯0β} {r p q : ββ₯0}
theorem toReal_add (ha : a β β) (hb : b β β) : (a + b).toReal = a.toReal + b.toReal := by
lift a to ββ₯0 using ha
lift b to ββ₯0 using hb
rfl
#align ennreal.to_real_add ENNReal.toReal_add
theorem toReal_sub_of_le {a b : ββ₯0β} (h : b β€ a) (ha : a β β) :
(a - b).toReal = a.toReal - b.toReal := by
lift b to ββ₯0 using ne_top_of_le_ne_top ha h
lift a to ββ₯0 using ha
simp only [β ENNReal.coe_sub, ENNReal.coe_toReal, NNReal.coe_sub (ENNReal.coe_le_coe.mp h)]
#align ennreal.to_real_sub_of_le ENNReal.toReal_sub_of_le
theorem le_toReal_sub {a b : ββ₯0β} (hb : b β β) : a.toReal - b.toReal β€ (a - b).toReal := by
lift b to ββ₯0 using hb
induction a
Β· simp
Β· simp only [β coe_sub, NNReal.sub_def, Real.coe_toNNReal', coe_toReal]
exact le_max_left _ _
#align ennreal.le_to_real_sub ENNReal.le_toReal_sub
theorem toReal_add_le : (a + b).toReal β€ a.toReal + b.toReal :=
if ha : a = β then by simp only [ha, top_add, top_toReal, zero_add, toReal_nonneg]
else
if hb : b = β then by simp only [hb, add_top, top_toReal, add_zero, toReal_nonneg]
else le_of_eq (toReal_add ha hb)
#align ennreal.to_real_add_le ENNReal.toReal_add_le
| Mathlib/Data/ENNReal/Real.lean | 65 | 68 | theorem ofReal_add {p q : β} (hp : 0 β€ p) (hq : 0 β€ q) :
ENNReal.ofReal (p + q) = ENNReal.ofReal p + ENNReal.ofReal q := by |
rw [ENNReal.ofReal, ENNReal.ofReal, ENNReal.ofReal, β coe_add, coe_inj,
Real.toNNReal_add hp hq]
| 1,125 |
import Mathlib.Data.ENNReal.Inv
#align_import data.real.ennreal from "leanprover-community/mathlib"@"c14c8fcde993801fca8946b0d80131a1a81d1520"
open Set NNReal ENNReal
namespace ENNReal
section Real
variable {a b c d : ββ₯0β} {r p q : ββ₯0}
theorem toReal_add (ha : a β β) (hb : b β β) : (a + b).toReal = a.toReal + b.toReal := by
lift a to ββ₯0 using ha
lift b to ββ₯0 using hb
rfl
#align ennreal.to_real_add ENNReal.toReal_add
theorem toReal_sub_of_le {a b : ββ₯0β} (h : b β€ a) (ha : a β β) :
(a - b).toReal = a.toReal - b.toReal := by
lift b to ββ₯0 using ne_top_of_le_ne_top ha h
lift a to ββ₯0 using ha
simp only [β ENNReal.coe_sub, ENNReal.coe_toReal, NNReal.coe_sub (ENNReal.coe_le_coe.mp h)]
#align ennreal.to_real_sub_of_le ENNReal.toReal_sub_of_le
theorem le_toReal_sub {a b : ββ₯0β} (hb : b β β) : a.toReal - b.toReal β€ (a - b).toReal := by
lift b to ββ₯0 using hb
induction a
Β· simp
Β· simp only [β coe_sub, NNReal.sub_def, Real.coe_toNNReal', coe_toReal]
exact le_max_left _ _
#align ennreal.le_to_real_sub ENNReal.le_toReal_sub
theorem toReal_add_le : (a + b).toReal β€ a.toReal + b.toReal :=
if ha : a = β then by simp only [ha, top_add, top_toReal, zero_add, toReal_nonneg]
else
if hb : b = β then by simp only [hb, add_top, top_toReal, add_zero, toReal_nonneg]
else le_of_eq (toReal_add ha hb)
#align ennreal.to_real_add_le ENNReal.toReal_add_le
theorem ofReal_add {p q : β} (hp : 0 β€ p) (hq : 0 β€ q) :
ENNReal.ofReal (p + q) = ENNReal.ofReal p + ENNReal.ofReal q := by
rw [ENNReal.ofReal, ENNReal.ofReal, ENNReal.ofReal, β coe_add, coe_inj,
Real.toNNReal_add hp hq]
#align ennreal.of_real_add ENNReal.ofReal_add
theorem ofReal_add_le {p q : β} : ENNReal.ofReal (p + q) β€ ENNReal.ofReal p + ENNReal.ofReal q :=
coe_le_coe.2 Real.toNNReal_add_le
#align ennreal.of_real_add_le ENNReal.ofReal_add_le
@[simp]
| Mathlib/Data/ENNReal/Real.lean | 76 | 79 | theorem toReal_le_toReal (ha : a β β) (hb : b β β) : a.toReal β€ b.toReal β a β€ b := by |
lift a to ββ₯0 using ha
lift b to ββ₯0 using hb
norm_cast
| 1,125 |
import Mathlib.Data.ENNReal.Inv
#align_import data.real.ennreal from "leanprover-community/mathlib"@"c14c8fcde993801fca8946b0d80131a1a81d1520"
open Set NNReal ENNReal
namespace ENNReal
section Real
variable {a b c d : ββ₯0β} {r p q : ββ₯0}
theorem toReal_add (ha : a β β) (hb : b β β) : (a + b).toReal = a.toReal + b.toReal := by
lift a to ββ₯0 using ha
lift b to ββ₯0 using hb
rfl
#align ennreal.to_real_add ENNReal.toReal_add
theorem toReal_sub_of_le {a b : ββ₯0β} (h : b β€ a) (ha : a β β) :
(a - b).toReal = a.toReal - b.toReal := by
lift b to ββ₯0 using ne_top_of_le_ne_top ha h
lift a to ββ₯0 using ha
simp only [β ENNReal.coe_sub, ENNReal.coe_toReal, NNReal.coe_sub (ENNReal.coe_le_coe.mp h)]
#align ennreal.to_real_sub_of_le ENNReal.toReal_sub_of_le
theorem le_toReal_sub {a b : ββ₯0β} (hb : b β β) : a.toReal - b.toReal β€ (a - b).toReal := by
lift b to ββ₯0 using hb
induction a
Β· simp
Β· simp only [β coe_sub, NNReal.sub_def, Real.coe_toNNReal', coe_toReal]
exact le_max_left _ _
#align ennreal.le_to_real_sub ENNReal.le_toReal_sub
theorem toReal_add_le : (a + b).toReal β€ a.toReal + b.toReal :=
if ha : a = β then by simp only [ha, top_add, top_toReal, zero_add, toReal_nonneg]
else
if hb : b = β then by simp only [hb, add_top, top_toReal, add_zero, toReal_nonneg]
else le_of_eq (toReal_add ha hb)
#align ennreal.to_real_add_le ENNReal.toReal_add_le
theorem ofReal_add {p q : β} (hp : 0 β€ p) (hq : 0 β€ q) :
ENNReal.ofReal (p + q) = ENNReal.ofReal p + ENNReal.ofReal q := by
rw [ENNReal.ofReal, ENNReal.ofReal, ENNReal.ofReal, β coe_add, coe_inj,
Real.toNNReal_add hp hq]
#align ennreal.of_real_add ENNReal.ofReal_add
theorem ofReal_add_le {p q : β} : ENNReal.ofReal (p + q) β€ ENNReal.ofReal p + ENNReal.ofReal q :=
coe_le_coe.2 Real.toNNReal_add_le
#align ennreal.of_real_add_le ENNReal.ofReal_add_le
@[simp]
theorem toReal_le_toReal (ha : a β β) (hb : b β β) : a.toReal β€ b.toReal β a β€ b := by
lift a to ββ₯0 using ha
lift b to ββ₯0 using hb
norm_cast
#align ennreal.to_real_le_to_real ENNReal.toReal_le_toReal
@[gcongr]
theorem toReal_mono (hb : b β β) (h : a β€ b) : a.toReal β€ b.toReal :=
(toReal_le_toReal (ne_top_of_le_ne_top hb h) hb).2 h
#align ennreal.to_real_mono ENNReal.toReal_mono
-- Porting note (#10756): new lemma
| Mathlib/Data/ENNReal/Real.lean | 88 | 91 | theorem toReal_mono' (h : a β€ b) (ht : b = β β a = β) : a.toReal β€ b.toReal := by |
rcases eq_or_ne a β with rfl | ha
Β· exact toReal_nonneg
Β· exact toReal_mono (mt ht ha) h
| 1,125 |
import Mathlib.Data.ENNReal.Inv
#align_import data.real.ennreal from "leanprover-community/mathlib"@"c14c8fcde993801fca8946b0d80131a1a81d1520"
open Set NNReal ENNReal
namespace ENNReal
section Real
variable {a b c d : ββ₯0β} {r p q : ββ₯0}
theorem toReal_add (ha : a β β) (hb : b β β) : (a + b).toReal = a.toReal + b.toReal := by
lift a to ββ₯0 using ha
lift b to ββ₯0 using hb
rfl
#align ennreal.to_real_add ENNReal.toReal_add
theorem toReal_sub_of_le {a b : ββ₯0β} (h : b β€ a) (ha : a β β) :
(a - b).toReal = a.toReal - b.toReal := by
lift b to ββ₯0 using ne_top_of_le_ne_top ha h
lift a to ββ₯0 using ha
simp only [β ENNReal.coe_sub, ENNReal.coe_toReal, NNReal.coe_sub (ENNReal.coe_le_coe.mp h)]
#align ennreal.to_real_sub_of_le ENNReal.toReal_sub_of_le
theorem le_toReal_sub {a b : ββ₯0β} (hb : b β β) : a.toReal - b.toReal β€ (a - b).toReal := by
lift b to ββ₯0 using hb
induction a
Β· simp
Β· simp only [β coe_sub, NNReal.sub_def, Real.coe_toNNReal', coe_toReal]
exact le_max_left _ _
#align ennreal.le_to_real_sub ENNReal.le_toReal_sub
theorem toReal_add_le : (a + b).toReal β€ a.toReal + b.toReal :=
if ha : a = β then by simp only [ha, top_add, top_toReal, zero_add, toReal_nonneg]
else
if hb : b = β then by simp only [hb, add_top, top_toReal, add_zero, toReal_nonneg]
else le_of_eq (toReal_add ha hb)
#align ennreal.to_real_add_le ENNReal.toReal_add_le
theorem ofReal_add {p q : β} (hp : 0 β€ p) (hq : 0 β€ q) :
ENNReal.ofReal (p + q) = ENNReal.ofReal p + ENNReal.ofReal q := by
rw [ENNReal.ofReal, ENNReal.ofReal, ENNReal.ofReal, β coe_add, coe_inj,
Real.toNNReal_add hp hq]
#align ennreal.of_real_add ENNReal.ofReal_add
theorem ofReal_add_le {p q : β} : ENNReal.ofReal (p + q) β€ ENNReal.ofReal p + ENNReal.ofReal q :=
coe_le_coe.2 Real.toNNReal_add_le
#align ennreal.of_real_add_le ENNReal.ofReal_add_le
@[simp]
theorem toReal_le_toReal (ha : a β β) (hb : b β β) : a.toReal β€ b.toReal β a β€ b := by
lift a to ββ₯0 using ha
lift b to ββ₯0 using hb
norm_cast
#align ennreal.to_real_le_to_real ENNReal.toReal_le_toReal
@[gcongr]
theorem toReal_mono (hb : b β β) (h : a β€ b) : a.toReal β€ b.toReal :=
(toReal_le_toReal (ne_top_of_le_ne_top hb h) hb).2 h
#align ennreal.to_real_mono ENNReal.toReal_mono
-- Porting note (#10756): new lemma
theorem toReal_mono' (h : a β€ b) (ht : b = β β a = β) : a.toReal β€ b.toReal := by
rcases eq_or_ne a β with rfl | ha
Β· exact toReal_nonneg
Β· exact toReal_mono (mt ht ha) h
@[simp]
| Mathlib/Data/ENNReal/Real.lean | 94 | 97 | theorem toReal_lt_toReal (ha : a β β) (hb : b β β) : a.toReal < b.toReal β a < b := by |
lift a to ββ₯0 using ha
lift b to ββ₯0 using hb
norm_cast
| 1,125 |
import Mathlib.Data.ENNReal.Inv
#align_import data.real.ennreal from "leanprover-community/mathlib"@"c14c8fcde993801fca8946b0d80131a1a81d1520"
open Set NNReal ENNReal
namespace ENNReal
section Real
variable {a b c d : ββ₯0β} {r p q : ββ₯0}
theorem toReal_add (ha : a β β) (hb : b β β) : (a + b).toReal = a.toReal + b.toReal := by
lift a to ββ₯0 using ha
lift b to ββ₯0 using hb
rfl
#align ennreal.to_real_add ENNReal.toReal_add
theorem toReal_sub_of_le {a b : ββ₯0β} (h : b β€ a) (ha : a β β) :
(a - b).toReal = a.toReal - b.toReal := by
lift b to ββ₯0 using ne_top_of_le_ne_top ha h
lift a to ββ₯0 using ha
simp only [β ENNReal.coe_sub, ENNReal.coe_toReal, NNReal.coe_sub (ENNReal.coe_le_coe.mp h)]
#align ennreal.to_real_sub_of_le ENNReal.toReal_sub_of_le
theorem le_toReal_sub {a b : ββ₯0β} (hb : b β β) : a.toReal - b.toReal β€ (a - b).toReal := by
lift b to ββ₯0 using hb
induction a
Β· simp
Β· simp only [β coe_sub, NNReal.sub_def, Real.coe_toNNReal', coe_toReal]
exact le_max_left _ _
#align ennreal.le_to_real_sub ENNReal.le_toReal_sub
theorem toReal_add_le : (a + b).toReal β€ a.toReal + b.toReal :=
if ha : a = β then by simp only [ha, top_add, top_toReal, zero_add, toReal_nonneg]
else
if hb : b = β then by simp only [hb, add_top, top_toReal, add_zero, toReal_nonneg]
else le_of_eq (toReal_add ha hb)
#align ennreal.to_real_add_le ENNReal.toReal_add_le
theorem ofReal_add {p q : β} (hp : 0 β€ p) (hq : 0 β€ q) :
ENNReal.ofReal (p + q) = ENNReal.ofReal p + ENNReal.ofReal q := by
rw [ENNReal.ofReal, ENNReal.ofReal, ENNReal.ofReal, β coe_add, coe_inj,
Real.toNNReal_add hp hq]
#align ennreal.of_real_add ENNReal.ofReal_add
theorem ofReal_add_le {p q : β} : ENNReal.ofReal (p + q) β€ ENNReal.ofReal p + ENNReal.ofReal q :=
coe_le_coe.2 Real.toNNReal_add_le
#align ennreal.of_real_add_le ENNReal.ofReal_add_le
@[simp]
theorem toReal_le_toReal (ha : a β β) (hb : b β β) : a.toReal β€ b.toReal β a β€ b := by
lift a to ββ₯0 using ha
lift b to ββ₯0 using hb
norm_cast
#align ennreal.to_real_le_to_real ENNReal.toReal_le_toReal
@[gcongr]
theorem toReal_mono (hb : b β β) (h : a β€ b) : a.toReal β€ b.toReal :=
(toReal_le_toReal (ne_top_of_le_ne_top hb h) hb).2 h
#align ennreal.to_real_mono ENNReal.toReal_mono
-- Porting note (#10756): new lemma
theorem toReal_mono' (h : a β€ b) (ht : b = β β a = β) : a.toReal β€ b.toReal := by
rcases eq_or_ne a β with rfl | ha
Β· exact toReal_nonneg
Β· exact toReal_mono (mt ht ha) h
@[simp]
theorem toReal_lt_toReal (ha : a β β) (hb : b β β) : a.toReal < b.toReal β a < b := by
lift a to ββ₯0 using ha
lift b to ββ₯0 using hb
norm_cast
#align ennreal.to_real_lt_to_real ENNReal.toReal_lt_toReal
@[gcongr]
theorem toReal_strict_mono (hb : b β β) (h : a < b) : a.toReal < b.toReal :=
(toReal_lt_toReal h.ne_top hb).2 h
#align ennreal.to_real_strict_mono ENNReal.toReal_strict_mono
@[gcongr]
theorem toNNReal_mono (hb : b β β) (h : a β€ b) : a.toNNReal β€ b.toNNReal :=
toReal_mono hb h
#align ennreal.to_nnreal_mono ENNReal.toNNReal_mono
-- Porting note (#10756): new lemma
| Mathlib/Data/ENNReal/Real.lean | 114 | 117 | theorem toReal_le_add' (hle : a β€ b + c) (hb : b = β β a = β) (hc : c = β β a = β) :
a.toReal β€ b.toReal + c.toReal := by |
refine le_trans (toReal_mono' hle ?_) toReal_add_le
simpa only [add_eq_top, or_imp] using And.intro hb hc
| 1,125 |
import Mathlib.Data.ENNReal.Inv
#align_import data.real.ennreal from "leanprover-community/mathlib"@"c14c8fcde993801fca8946b0d80131a1a81d1520"
open Set NNReal ENNReal
namespace ENNReal
section Real
variable {a b c d : ββ₯0β} {r p q : ββ₯0}
theorem toReal_add (ha : a β β) (hb : b β β) : (a + b).toReal = a.toReal + b.toReal := by
lift a to ββ₯0 using ha
lift b to ββ₯0 using hb
rfl
#align ennreal.to_real_add ENNReal.toReal_add
theorem toReal_sub_of_le {a b : ββ₯0β} (h : b β€ a) (ha : a β β) :
(a - b).toReal = a.toReal - b.toReal := by
lift b to ββ₯0 using ne_top_of_le_ne_top ha h
lift a to ββ₯0 using ha
simp only [β ENNReal.coe_sub, ENNReal.coe_toReal, NNReal.coe_sub (ENNReal.coe_le_coe.mp h)]
#align ennreal.to_real_sub_of_le ENNReal.toReal_sub_of_le
theorem le_toReal_sub {a b : ββ₯0β} (hb : b β β) : a.toReal - b.toReal β€ (a - b).toReal := by
lift b to ββ₯0 using hb
induction a
Β· simp
Β· simp only [β coe_sub, NNReal.sub_def, Real.coe_toNNReal', coe_toReal]
exact le_max_left _ _
#align ennreal.le_to_real_sub ENNReal.le_toReal_sub
theorem toReal_add_le : (a + b).toReal β€ a.toReal + b.toReal :=
if ha : a = β then by simp only [ha, top_add, top_toReal, zero_add, toReal_nonneg]
else
if hb : b = β then by simp only [hb, add_top, top_toReal, add_zero, toReal_nonneg]
else le_of_eq (toReal_add ha hb)
#align ennreal.to_real_add_le ENNReal.toReal_add_le
theorem ofReal_add {p q : β} (hp : 0 β€ p) (hq : 0 β€ q) :
ENNReal.ofReal (p + q) = ENNReal.ofReal p + ENNReal.ofReal q := by
rw [ENNReal.ofReal, ENNReal.ofReal, ENNReal.ofReal, β coe_add, coe_inj,
Real.toNNReal_add hp hq]
#align ennreal.of_real_add ENNReal.ofReal_add
theorem ofReal_add_le {p q : β} : ENNReal.ofReal (p + q) β€ ENNReal.ofReal p + ENNReal.ofReal q :=
coe_le_coe.2 Real.toNNReal_add_le
#align ennreal.of_real_add_le ENNReal.ofReal_add_le
@[simp]
theorem toReal_le_toReal (ha : a β β) (hb : b β β) : a.toReal β€ b.toReal β a β€ b := by
lift a to ββ₯0 using ha
lift b to ββ₯0 using hb
norm_cast
#align ennreal.to_real_le_to_real ENNReal.toReal_le_toReal
@[gcongr]
theorem toReal_mono (hb : b β β) (h : a β€ b) : a.toReal β€ b.toReal :=
(toReal_le_toReal (ne_top_of_le_ne_top hb h) hb).2 h
#align ennreal.to_real_mono ENNReal.toReal_mono
-- Porting note (#10756): new lemma
theorem toReal_mono' (h : a β€ b) (ht : b = β β a = β) : a.toReal β€ b.toReal := by
rcases eq_or_ne a β with rfl | ha
Β· exact toReal_nonneg
Β· exact toReal_mono (mt ht ha) h
@[simp]
theorem toReal_lt_toReal (ha : a β β) (hb : b β β) : a.toReal < b.toReal β a < b := by
lift a to ββ₯0 using ha
lift b to ββ₯0 using hb
norm_cast
#align ennreal.to_real_lt_to_real ENNReal.toReal_lt_toReal
@[gcongr]
theorem toReal_strict_mono (hb : b β β) (h : a < b) : a.toReal < b.toReal :=
(toReal_lt_toReal h.ne_top hb).2 h
#align ennreal.to_real_strict_mono ENNReal.toReal_strict_mono
@[gcongr]
theorem toNNReal_mono (hb : b β β) (h : a β€ b) : a.toNNReal β€ b.toNNReal :=
toReal_mono hb h
#align ennreal.to_nnreal_mono ENNReal.toNNReal_mono
-- Porting note (#10756): new lemma
theorem toReal_le_add' (hle : a β€ b + c) (hb : b = β β a = β) (hc : c = β β a = β) :
a.toReal β€ b.toReal + c.toReal := by
refine le_trans (toReal_mono' hle ?_) toReal_add_le
simpa only [add_eq_top, or_imp] using And.intro hb hc
-- Porting note (#10756): new lemma
theorem toReal_le_add (hle : a β€ b + c) (hb : b β β) (hc : c β β) :
a.toReal β€ b.toReal + c.toReal :=
toReal_le_add' hle (flip absurd hb) (flip absurd hc)
@[simp]
theorem toNNReal_le_toNNReal (ha : a β β) (hb : b β β) : a.toNNReal β€ b.toNNReal β a β€ b :=
β¨fun h => by rwa [β coe_toNNReal ha, β coe_toNNReal hb, coe_le_coe], toNNReal_mono hbβ©
#align ennreal.to_nnreal_le_to_nnreal ENNReal.toNNReal_le_toNNReal
| Mathlib/Data/ENNReal/Real.lean | 132 | 133 | theorem toNNReal_strict_mono (hb : b β β) (h : a < b) : a.toNNReal < b.toNNReal := by |
simpa [β ENNReal.coe_lt_coe, hb, h.ne_top]
| 1,125 |
import Mathlib.Data.ENNReal.Inv
#align_import data.real.ennreal from "leanprover-community/mathlib"@"c14c8fcde993801fca8946b0d80131a1a81d1520"
open Set NNReal ENNReal
namespace ENNReal
section iInf
variable {ΞΉ : Sort*} {f g : ΞΉ β ββ₯0β}
variable {a b c d : ββ₯0β} {r p q : ββ₯0}
| Mathlib/Data/ENNReal/Real.lean | 541 | 545 | theorem toNNReal_iInf (hf : β i, f i β β) : (iInf f).toNNReal = β¨
i, (f i).toNNReal := by |
cases isEmpty_or_nonempty ΞΉ
Β· rw [iInf_of_empty, top_toNNReal, NNReal.iInf_empty]
Β· lift f to ΞΉ β ββ₯0 using hf
simp_rw [β coe_iInf, toNNReal_coe]
| 1,125 |
import Mathlib.Data.ENNReal.Inv
#align_import data.real.ennreal from "leanprover-community/mathlib"@"c14c8fcde993801fca8946b0d80131a1a81d1520"
open Set NNReal ENNReal
namespace ENNReal
section iInf
variable {ΞΉ : Sort*} {f g : ΞΉ β ββ₯0β}
variable {a b c d : ββ₯0β} {r p q : ββ₯0}
theorem toNNReal_iInf (hf : β i, f i β β) : (iInf f).toNNReal = β¨
i, (f i).toNNReal := by
cases isEmpty_or_nonempty ΞΉ
Β· rw [iInf_of_empty, top_toNNReal, NNReal.iInf_empty]
Β· lift f to ΞΉ β ββ₯0 using hf
simp_rw [β coe_iInf, toNNReal_coe]
#align ennreal.to_nnreal_infi ENNReal.toNNReal_iInf
| Mathlib/Data/ENNReal/Real.lean | 548 | 553 | theorem toNNReal_sInf (s : Set ββ₯0β) (hs : β r β s, r β β) :
(sInf s).toNNReal = sInf (ENNReal.toNNReal '' s) := by |
have hf : β i, ((β) : s β ββ₯0β) i β β := fun β¨r, rsβ© => hs r rs
-- Porting note: `β sInf_image'` had to be replaced by `β image_eq_range` as the lemmas are used
-- in a different order.
simpa only [β sInf_range, β image_eq_range, Subtype.range_coe_subtype] using (toNNReal_iInf hf)
| 1,125 |
import Mathlib.Data.ENNReal.Inv
#align_import data.real.ennreal from "leanprover-community/mathlib"@"c14c8fcde993801fca8946b0d80131a1a81d1520"
open Set NNReal ENNReal
namespace ENNReal
section iInf
variable {ΞΉ : Sort*} {f g : ΞΉ β ββ₯0β}
variable {a b c d : ββ₯0β} {r p q : ββ₯0}
theorem toNNReal_iInf (hf : β i, f i β β) : (iInf f).toNNReal = β¨
i, (f i).toNNReal := by
cases isEmpty_or_nonempty ΞΉ
Β· rw [iInf_of_empty, top_toNNReal, NNReal.iInf_empty]
Β· lift f to ΞΉ β ββ₯0 using hf
simp_rw [β coe_iInf, toNNReal_coe]
#align ennreal.to_nnreal_infi ENNReal.toNNReal_iInf
theorem toNNReal_sInf (s : Set ββ₯0β) (hs : β r β s, r β β) :
(sInf s).toNNReal = sInf (ENNReal.toNNReal '' s) := by
have hf : β i, ((β) : s β ββ₯0β) i β β := fun β¨r, rsβ© => hs r rs
-- Porting note: `β sInf_image'` had to be replaced by `β image_eq_range` as the lemmas are used
-- in a different order.
simpa only [β sInf_range, β image_eq_range, Subtype.range_coe_subtype] using (toNNReal_iInf hf)
#align ennreal.to_nnreal_Inf ENNReal.toNNReal_sInf
| Mathlib/Data/ENNReal/Real.lean | 556 | 561 | theorem toNNReal_iSup (hf : β i, f i β β) : (iSup f).toNNReal = β¨ i, (f i).toNNReal := by |
lift f to ΞΉ β ββ₯0 using hf
simp_rw [toNNReal_coe]
by_cases h : BddAbove (range f)
Β· rw [β coe_iSup h, toNNReal_coe]
Β· rw [NNReal.iSup_of_not_bddAbove h, iSup_coe_eq_top.2 h, top_toNNReal]
| 1,125 |
import Mathlib.Data.ENNReal.Inv
#align_import data.real.ennreal from "leanprover-community/mathlib"@"c14c8fcde993801fca8946b0d80131a1a81d1520"
open Set NNReal ENNReal
namespace ENNReal
section iInf
variable {ΞΉ : Sort*} {f g : ΞΉ β ββ₯0β}
variable {a b c d : ββ₯0β} {r p q : ββ₯0}
theorem toNNReal_iInf (hf : β i, f i β β) : (iInf f).toNNReal = β¨
i, (f i).toNNReal := by
cases isEmpty_or_nonempty ΞΉ
Β· rw [iInf_of_empty, top_toNNReal, NNReal.iInf_empty]
Β· lift f to ΞΉ β ββ₯0 using hf
simp_rw [β coe_iInf, toNNReal_coe]
#align ennreal.to_nnreal_infi ENNReal.toNNReal_iInf
theorem toNNReal_sInf (s : Set ββ₯0β) (hs : β r β s, r β β) :
(sInf s).toNNReal = sInf (ENNReal.toNNReal '' s) := by
have hf : β i, ((β) : s β ββ₯0β) i β β := fun β¨r, rsβ© => hs r rs
-- Porting note: `β sInf_image'` had to be replaced by `β image_eq_range` as the lemmas are used
-- in a different order.
simpa only [β sInf_range, β image_eq_range, Subtype.range_coe_subtype] using (toNNReal_iInf hf)
#align ennreal.to_nnreal_Inf ENNReal.toNNReal_sInf
theorem toNNReal_iSup (hf : β i, f i β β) : (iSup f).toNNReal = β¨ i, (f i).toNNReal := by
lift f to ΞΉ β ββ₯0 using hf
simp_rw [toNNReal_coe]
by_cases h : BddAbove (range f)
Β· rw [β coe_iSup h, toNNReal_coe]
Β· rw [NNReal.iSup_of_not_bddAbove h, iSup_coe_eq_top.2 h, top_toNNReal]
#align ennreal.to_nnreal_supr ENNReal.toNNReal_iSup
| Mathlib/Data/ENNReal/Real.lean | 564 | 569 | theorem toNNReal_sSup (s : Set ββ₯0β) (hs : β r β s, r β β) :
(sSup s).toNNReal = sSup (ENNReal.toNNReal '' s) := by |
have hf : β i, ((β) : s β ββ₯0β) i β β := fun β¨r, rsβ© => hs r rs
-- Porting note: `β sSup_image'` had to be replaced by `β image_eq_range` as the lemmas are used
-- in a different order.
simpa only [β sSup_range, β image_eq_range, Subtype.range_coe_subtype] using (toNNReal_iSup hf)
| 1,125 |
import Mathlib.Data.ENNReal.Inv
#align_import data.real.ennreal from "leanprover-community/mathlib"@"c14c8fcde993801fca8946b0d80131a1a81d1520"
open Set NNReal ENNReal
namespace ENNReal
section iInf
variable {ΞΉ : Sort*} {f g : ΞΉ β ββ₯0β}
variable {a b c d : ββ₯0β} {r p q : ββ₯0}
theorem toNNReal_iInf (hf : β i, f i β β) : (iInf f).toNNReal = β¨
i, (f i).toNNReal := by
cases isEmpty_or_nonempty ΞΉ
Β· rw [iInf_of_empty, top_toNNReal, NNReal.iInf_empty]
Β· lift f to ΞΉ β ββ₯0 using hf
simp_rw [β coe_iInf, toNNReal_coe]
#align ennreal.to_nnreal_infi ENNReal.toNNReal_iInf
theorem toNNReal_sInf (s : Set ββ₯0β) (hs : β r β s, r β β) :
(sInf s).toNNReal = sInf (ENNReal.toNNReal '' s) := by
have hf : β i, ((β) : s β ββ₯0β) i β β := fun β¨r, rsβ© => hs r rs
-- Porting note: `β sInf_image'` had to be replaced by `β image_eq_range` as the lemmas are used
-- in a different order.
simpa only [β sInf_range, β image_eq_range, Subtype.range_coe_subtype] using (toNNReal_iInf hf)
#align ennreal.to_nnreal_Inf ENNReal.toNNReal_sInf
theorem toNNReal_iSup (hf : β i, f i β β) : (iSup f).toNNReal = β¨ i, (f i).toNNReal := by
lift f to ΞΉ β ββ₯0 using hf
simp_rw [toNNReal_coe]
by_cases h : BddAbove (range f)
Β· rw [β coe_iSup h, toNNReal_coe]
Β· rw [NNReal.iSup_of_not_bddAbove h, iSup_coe_eq_top.2 h, top_toNNReal]
#align ennreal.to_nnreal_supr ENNReal.toNNReal_iSup
theorem toNNReal_sSup (s : Set ββ₯0β) (hs : β r β s, r β β) :
(sSup s).toNNReal = sSup (ENNReal.toNNReal '' s) := by
have hf : β i, ((β) : s β ββ₯0β) i β β := fun β¨r, rsβ© => hs r rs
-- Porting note: `β sSup_image'` had to be replaced by `β image_eq_range` as the lemmas are used
-- in a different order.
simpa only [β sSup_range, β image_eq_range, Subtype.range_coe_subtype] using (toNNReal_iSup hf)
#align ennreal.to_nnreal_Sup ENNReal.toNNReal_sSup
| Mathlib/Data/ENNReal/Real.lean | 572 | 573 | theorem toReal_iInf (hf : β i, f i β β) : (iInf f).toReal = β¨
i, (f i).toReal := by |
simp only [ENNReal.toReal, toNNReal_iInf hf, NNReal.coe_iInf]
| 1,125 |
import Mathlib.Data.ENNReal.Inv
#align_import data.real.ennreal from "leanprover-community/mathlib"@"c14c8fcde993801fca8946b0d80131a1a81d1520"
open Set NNReal ENNReal
namespace ENNReal
section iInf
variable {ΞΉ : Sort*} {f g : ΞΉ β ββ₯0β}
variable {a b c d : ββ₯0β} {r p q : ββ₯0}
theorem toNNReal_iInf (hf : β i, f i β β) : (iInf f).toNNReal = β¨
i, (f i).toNNReal := by
cases isEmpty_or_nonempty ΞΉ
Β· rw [iInf_of_empty, top_toNNReal, NNReal.iInf_empty]
Β· lift f to ΞΉ β ββ₯0 using hf
simp_rw [β coe_iInf, toNNReal_coe]
#align ennreal.to_nnreal_infi ENNReal.toNNReal_iInf
theorem toNNReal_sInf (s : Set ββ₯0β) (hs : β r β s, r β β) :
(sInf s).toNNReal = sInf (ENNReal.toNNReal '' s) := by
have hf : β i, ((β) : s β ββ₯0β) i β β := fun β¨r, rsβ© => hs r rs
-- Porting note: `β sInf_image'` had to be replaced by `β image_eq_range` as the lemmas are used
-- in a different order.
simpa only [β sInf_range, β image_eq_range, Subtype.range_coe_subtype] using (toNNReal_iInf hf)
#align ennreal.to_nnreal_Inf ENNReal.toNNReal_sInf
theorem toNNReal_iSup (hf : β i, f i β β) : (iSup f).toNNReal = β¨ i, (f i).toNNReal := by
lift f to ΞΉ β ββ₯0 using hf
simp_rw [toNNReal_coe]
by_cases h : BddAbove (range f)
Β· rw [β coe_iSup h, toNNReal_coe]
Β· rw [NNReal.iSup_of_not_bddAbove h, iSup_coe_eq_top.2 h, top_toNNReal]
#align ennreal.to_nnreal_supr ENNReal.toNNReal_iSup
theorem toNNReal_sSup (s : Set ββ₯0β) (hs : β r β s, r β β) :
(sSup s).toNNReal = sSup (ENNReal.toNNReal '' s) := by
have hf : β i, ((β) : s β ββ₯0β) i β β := fun β¨r, rsβ© => hs r rs
-- Porting note: `β sSup_image'` had to be replaced by `β image_eq_range` as the lemmas are used
-- in a different order.
simpa only [β sSup_range, β image_eq_range, Subtype.range_coe_subtype] using (toNNReal_iSup hf)
#align ennreal.to_nnreal_Sup ENNReal.toNNReal_sSup
theorem toReal_iInf (hf : β i, f i β β) : (iInf f).toReal = β¨
i, (f i).toReal := by
simp only [ENNReal.toReal, toNNReal_iInf hf, NNReal.coe_iInf]
#align ennreal.to_real_infi ENNReal.toReal_iInf
| Mathlib/Data/ENNReal/Real.lean | 576 | 578 | theorem toReal_sInf (s : Set ββ₯0β) (hf : β r β s, r β β) :
(sInf s).toReal = sInf (ENNReal.toReal '' s) := by |
simp only [ENNReal.toReal, toNNReal_sInf s hf, NNReal.coe_sInf, Set.image_image]
| 1,125 |
import Mathlib.Data.ENNReal.Inv
#align_import data.real.ennreal from "leanprover-community/mathlib"@"c14c8fcde993801fca8946b0d80131a1a81d1520"
open Set NNReal ENNReal
namespace ENNReal
section iInf
variable {ΞΉ : Sort*} {f g : ΞΉ β ββ₯0β}
variable {a b c d : ββ₯0β} {r p q : ββ₯0}
theorem toNNReal_iInf (hf : β i, f i β β) : (iInf f).toNNReal = β¨
i, (f i).toNNReal := by
cases isEmpty_or_nonempty ΞΉ
Β· rw [iInf_of_empty, top_toNNReal, NNReal.iInf_empty]
Β· lift f to ΞΉ β ββ₯0 using hf
simp_rw [β coe_iInf, toNNReal_coe]
#align ennreal.to_nnreal_infi ENNReal.toNNReal_iInf
theorem toNNReal_sInf (s : Set ββ₯0β) (hs : β r β s, r β β) :
(sInf s).toNNReal = sInf (ENNReal.toNNReal '' s) := by
have hf : β i, ((β) : s β ββ₯0β) i β β := fun β¨r, rsβ© => hs r rs
-- Porting note: `β sInf_image'` had to be replaced by `β image_eq_range` as the lemmas are used
-- in a different order.
simpa only [β sInf_range, β image_eq_range, Subtype.range_coe_subtype] using (toNNReal_iInf hf)
#align ennreal.to_nnreal_Inf ENNReal.toNNReal_sInf
theorem toNNReal_iSup (hf : β i, f i β β) : (iSup f).toNNReal = β¨ i, (f i).toNNReal := by
lift f to ΞΉ β ββ₯0 using hf
simp_rw [toNNReal_coe]
by_cases h : BddAbove (range f)
Β· rw [β coe_iSup h, toNNReal_coe]
Β· rw [NNReal.iSup_of_not_bddAbove h, iSup_coe_eq_top.2 h, top_toNNReal]
#align ennreal.to_nnreal_supr ENNReal.toNNReal_iSup
theorem toNNReal_sSup (s : Set ββ₯0β) (hs : β r β s, r β β) :
(sSup s).toNNReal = sSup (ENNReal.toNNReal '' s) := by
have hf : β i, ((β) : s β ββ₯0β) i β β := fun β¨r, rsβ© => hs r rs
-- Porting note: `β sSup_image'` had to be replaced by `β image_eq_range` as the lemmas are used
-- in a different order.
simpa only [β sSup_range, β image_eq_range, Subtype.range_coe_subtype] using (toNNReal_iSup hf)
#align ennreal.to_nnreal_Sup ENNReal.toNNReal_sSup
theorem toReal_iInf (hf : β i, f i β β) : (iInf f).toReal = β¨
i, (f i).toReal := by
simp only [ENNReal.toReal, toNNReal_iInf hf, NNReal.coe_iInf]
#align ennreal.to_real_infi ENNReal.toReal_iInf
theorem toReal_sInf (s : Set ββ₯0β) (hf : β r β s, r β β) :
(sInf s).toReal = sInf (ENNReal.toReal '' s) := by
simp only [ENNReal.toReal, toNNReal_sInf s hf, NNReal.coe_sInf, Set.image_image]
#align ennreal.to_real_Inf ENNReal.toReal_sInf
| Mathlib/Data/ENNReal/Real.lean | 581 | 582 | theorem toReal_iSup (hf : β i, f i β β) : (iSup f).toReal = β¨ i, (f i).toReal := by |
simp only [ENNReal.toReal, toNNReal_iSup hf, NNReal.coe_iSup]
| 1,125 |
import Mathlib.Data.ENNReal.Inv
#align_import data.real.ennreal from "leanprover-community/mathlib"@"c14c8fcde993801fca8946b0d80131a1a81d1520"
open Set NNReal ENNReal
namespace ENNReal
section iInf
variable {ΞΉ : Sort*} {f g : ΞΉ β ββ₯0β}
variable {a b c d : ββ₯0β} {r p q : ββ₯0}
theorem toNNReal_iInf (hf : β i, f i β β) : (iInf f).toNNReal = β¨
i, (f i).toNNReal := by
cases isEmpty_or_nonempty ΞΉ
Β· rw [iInf_of_empty, top_toNNReal, NNReal.iInf_empty]
Β· lift f to ΞΉ β ββ₯0 using hf
simp_rw [β coe_iInf, toNNReal_coe]
#align ennreal.to_nnreal_infi ENNReal.toNNReal_iInf
theorem toNNReal_sInf (s : Set ββ₯0β) (hs : β r β s, r β β) :
(sInf s).toNNReal = sInf (ENNReal.toNNReal '' s) := by
have hf : β i, ((β) : s β ββ₯0β) i β β := fun β¨r, rsβ© => hs r rs
-- Porting note: `β sInf_image'` had to be replaced by `β image_eq_range` as the lemmas are used
-- in a different order.
simpa only [β sInf_range, β image_eq_range, Subtype.range_coe_subtype] using (toNNReal_iInf hf)
#align ennreal.to_nnreal_Inf ENNReal.toNNReal_sInf
theorem toNNReal_iSup (hf : β i, f i β β) : (iSup f).toNNReal = β¨ i, (f i).toNNReal := by
lift f to ΞΉ β ββ₯0 using hf
simp_rw [toNNReal_coe]
by_cases h : BddAbove (range f)
Β· rw [β coe_iSup h, toNNReal_coe]
Β· rw [NNReal.iSup_of_not_bddAbove h, iSup_coe_eq_top.2 h, top_toNNReal]
#align ennreal.to_nnreal_supr ENNReal.toNNReal_iSup
theorem toNNReal_sSup (s : Set ββ₯0β) (hs : β r β s, r β β) :
(sSup s).toNNReal = sSup (ENNReal.toNNReal '' s) := by
have hf : β i, ((β) : s β ββ₯0β) i β β := fun β¨r, rsβ© => hs r rs
-- Porting note: `β sSup_image'` had to be replaced by `β image_eq_range` as the lemmas are used
-- in a different order.
simpa only [β sSup_range, β image_eq_range, Subtype.range_coe_subtype] using (toNNReal_iSup hf)
#align ennreal.to_nnreal_Sup ENNReal.toNNReal_sSup
theorem toReal_iInf (hf : β i, f i β β) : (iInf f).toReal = β¨
i, (f i).toReal := by
simp only [ENNReal.toReal, toNNReal_iInf hf, NNReal.coe_iInf]
#align ennreal.to_real_infi ENNReal.toReal_iInf
theorem toReal_sInf (s : Set ββ₯0β) (hf : β r β s, r β β) :
(sInf s).toReal = sInf (ENNReal.toReal '' s) := by
simp only [ENNReal.toReal, toNNReal_sInf s hf, NNReal.coe_sInf, Set.image_image]
#align ennreal.to_real_Inf ENNReal.toReal_sInf
theorem toReal_iSup (hf : β i, f i β β) : (iSup f).toReal = β¨ i, (f i).toReal := by
simp only [ENNReal.toReal, toNNReal_iSup hf, NNReal.coe_iSup]
#align ennreal.to_real_supr ENNReal.toReal_iSup
| Mathlib/Data/ENNReal/Real.lean | 585 | 587 | theorem toReal_sSup (s : Set ββ₯0β) (hf : β r β s, r β β) :
(sSup s).toReal = sSup (ENNReal.toReal '' s) := by |
simp only [ENNReal.toReal, toNNReal_sSup s hf, NNReal.coe_sSup, Set.image_image]
| 1,125 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.