fact
stringlengths 6
3.84k
| type
stringclasses 11
values | library
stringclasses 32
values | imports
listlengths 1
14
| filename
stringlengths 20
95
| symbolic_name
stringlengths 1
90
| docstring
stringlengths 7
20k
⌀ |
|---|---|---|---|---|---|---|
bdd_le_mul_tendsto_zero' {f g : α → 𝕜} (C : 𝕜) (hf : ∀ᶠ x in l, |f x| ≤ C)
(hg : Tendsto g l (𝓝 0)) : Tendsto (fun x ↦ f x * g x) l (𝓝 0) := by
rw [tendsto_zero_iff_abs_tendsto_zero]
have hC : Tendsto (fun x ↦ |C * g x|) l (𝓝 0) := by
convert (hg.const_mul C).abs
simp_rw [mul_zero, abs_zero]
apply tendsto_of_tendsto_of_tendsto_of_le_of_le' tendsto_const_nhds hC
· filter_upwards [hf] with x _ using abs_nonneg _
· filter_upwards [hf] with x hx
simp only [comp_apply, abs_mul]
exact mul_le_mul_of_nonneg_right (hx.trans (le_abs_self C)) (abs_nonneg _)
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.Group.Pointwise.Interval",
"Mathlib.Order.Filter.AtTopBot.Field",
"Mathlib.Topology.Algebra.Field",
"Mathlib.Topology.Algebra.Order.Group"
] |
Mathlib/Topology/Algebra/Order/Field.lean
|
bdd_le_mul_tendsto_zero'
|
If `g` tends to zero and there exists a constant `C : 𝕜` such that eventually `|f x| ≤ C`,
then the product `f * g` tends to zero.
|
bdd_le_mul_tendsto_zero {f g : α → 𝕜} {b B : 𝕜} (hb : ∀ᶠ x in l, b ≤ f x)
(hB : ∀ᶠ x in l, f x ≤ B) (hg : Tendsto g l (𝓝 0)) :
Tendsto (fun x ↦ f x * g x) l (𝓝 0) := by
set C := max |b| |B|
have hbC : -C ≤ b := neg_le.mpr (le_max_of_le_left (neg_le_abs b))
have hBC : B ≤ C := le_max_of_le_right (le_abs_self B)
apply bdd_le_mul_tendsto_zero' C _ hg
filter_upwards [hb, hB]
exact fun x hbx hBx ↦ abs_le.mpr ⟨hbC.trans hbx, hBx.trans hBC⟩
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.Group.Pointwise.Interval",
"Mathlib.Order.Filter.AtTopBot.Field",
"Mathlib.Topology.Algebra.Field",
"Mathlib.Topology.Algebra.Order.Group"
] |
Mathlib/Topology/Algebra/Order/Field.lean
|
bdd_le_mul_tendsto_zero
|
If `g` tends to zero and there exist constants `b B : 𝕜` such that eventually `b ≤ f x| ≤ B`,
then the product `f * g` tends to zero.
|
tendsto_bdd_div_atTop_nhds_zero {f g : α → 𝕜} {b B : 𝕜}
(hb : ∀ᶠ x in l, b ≤ f x) (hB : ∀ᶠ x in l, f x ≤ B) (hg : Tendsto g l atTop) :
Tendsto (fun x => f x / g x) l (𝓝 0) := by
simp only [div_eq_mul_inv]
exact bdd_le_mul_tendsto_zero hb hB hg.inv_tendsto_atTop
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.Group.Pointwise.Interval",
"Mathlib.Order.Filter.AtTopBot.Field",
"Mathlib.Topology.Algebra.Field",
"Mathlib.Topology.Algebra.Order.Group"
] |
Mathlib/Topology/Algebra/Order/Field.lean
|
tendsto_bdd_div_atTop_nhds_zero
|
If `g` tends to `atTop` and there exist constants `b B : 𝕜` such that eventually
`b ≤ f x| ≤ B`, then the quotient `f / g` tends to zero.
|
tendsto_const_mul_zpow_atTop_zero {n : ℤ} {c : 𝕜} (hn : n < 0) :
Tendsto (fun x => c * x ^ n) atTop (𝓝 0) :=
mul_zero c ▸ Filter.Tendsto.const_mul c (tendsto_zpow_atTop_zero hn)
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.Group.Pointwise.Interval",
"Mathlib.Order.Filter.AtTopBot.Field",
"Mathlib.Topology.Algebra.Field",
"Mathlib.Topology.Algebra.Order.Group"
] |
Mathlib/Topology/Algebra/Order/Field.lean
|
tendsto_const_mul_zpow_atTop_zero
| null |
tendsto_const_mul_pow_nhds_iff' {n : ℕ} {c d : 𝕜} :
Tendsto (fun x : 𝕜 => c * x ^ n) atTop (𝓝 d) ↔ (c = 0 ∨ n = 0) ∧ c = d := by
rcases eq_or_ne n 0 with (rfl | hn)
· simp [tendsto_const_nhds_iff]
rcases lt_trichotomy c 0 with (hc | rfl | hc)
· have := tendsto_const_mul_pow_atBot_iff.2 ⟨hn, hc⟩
simp [not_tendsto_nhds_of_tendsto_atBot this, hc.ne, hn]
· simp [tendsto_const_nhds_iff]
· have := tendsto_const_mul_pow_atTop_iff.2 ⟨hn, hc⟩
simp [not_tendsto_nhds_of_tendsto_atTop this, hc.ne', hn]
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.Group.Pointwise.Interval",
"Mathlib.Order.Filter.AtTopBot.Field",
"Mathlib.Topology.Algebra.Field",
"Mathlib.Topology.Algebra.Order.Group"
] |
Mathlib/Topology/Algebra/Order/Field.lean
|
tendsto_const_mul_pow_nhds_iff'
| null |
tendsto_const_mul_pow_nhds_iff {n : ℕ} {c d : 𝕜} (hc : c ≠ 0) :
Tendsto (fun x : 𝕜 => c * x ^ n) atTop (𝓝 d) ↔ n = 0 ∧ c = d := by
simp [tendsto_const_mul_pow_nhds_iff', hc]
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.Group.Pointwise.Interval",
"Mathlib.Order.Filter.AtTopBot.Field",
"Mathlib.Topology.Algebra.Field",
"Mathlib.Topology.Algebra.Order.Group"
] |
Mathlib/Topology/Algebra/Order/Field.lean
|
tendsto_const_mul_pow_nhds_iff
| null |
tendsto_const_mul_zpow_atTop_nhds_iff {n : ℤ} {c d : 𝕜} (hc : c ≠ 0) :
Tendsto (fun x : 𝕜 => c * x ^ n) atTop (𝓝 d) ↔ n = 0 ∧ c = d ∨ n < 0 ∧ d = 0 := by
refine ⟨fun h => ?_, fun h => ?_⟩
· cases n with
| ofNat n =>
left
simpa [tendsto_const_mul_pow_nhds_iff hc] using h
| negSucc n =>
have hn := Int.negSucc_lt_zero n
exact Or.inr ⟨hn, tendsto_nhds_unique h (tendsto_const_mul_zpow_atTop_zero hn)⟩
· rcases h with h | h
· simp only [h.left, h.right, zpow_zero, mul_one]
exact tendsto_const_nhds
· exact h.2.symm ▸ tendsto_const_mul_zpow_atTop_zero h.1
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.Group.Pointwise.Interval",
"Mathlib.Order.Filter.AtTopBot.Field",
"Mathlib.Topology.Algebra.Field",
"Mathlib.Topology.Algebra.Order.Group"
] |
Mathlib/Topology/Algebra/Order/Field.lean
|
tendsto_const_mul_zpow_atTop_nhds_iff
| null |
comap_mulLeft_nhdsGT_zero {x : 𝕜} (hx : 0 < x) : comap (x * ·) (𝓝[>] 0) = 𝓝[>] 0 := by
rw [nhdsWithin, comap_inf, comap_principal, preimage_const_mul_Ioi _ hx, zero_div]
congr 1
refine ((Homeomorph.mulLeft₀ x hx.ne').comap_nhds_eq _).trans ?_
simp
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.Group.Pointwise.Interval",
"Mathlib.Order.Filter.AtTopBot.Field",
"Mathlib.Topology.Algebra.Field",
"Mathlib.Topology.Algebra.Order.Group"
] |
Mathlib/Topology/Algebra/Order/Field.lean
|
comap_mulLeft_nhdsGT_zero
| null |
eventually_nhdsGT_zero_mul_left {x : 𝕜} (hx : 0 < x) {p : 𝕜 → Prop}
(h : ∀ᶠ ε in 𝓝[>] 0, p ε) : ∀ᶠ ε in 𝓝[>] 0, p (x * ε) := by
rw [← comap_mulLeft_nhdsGT_zero hx]
exact h.comap fun ε => x * ε
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.Group.Pointwise.Interval",
"Mathlib.Order.Filter.AtTopBot.Field",
"Mathlib.Topology.Algebra.Field",
"Mathlib.Topology.Algebra.Order.Group"
] |
Mathlib/Topology/Algebra/Order/Field.lean
|
eventually_nhdsGT_zero_mul_left
| null |
tendsto_mul_pow_div_factorial_sub_atTop (a c : K) (d : ℕ) :
Tendsto (fun n ↦ a * c ^ n / (n - d)!) atTop (𝓝 0) := by
rw [tendsto_order]
constructor
all_goals
intro ε hε
filter_upwards [eventually_mul_pow_lt_factorial_sub (a * ε⁻¹) c d] with n h
rw [mul_right_comm, ← div_eq_mul_inv] at h
· rw [div_lt_iff_of_neg hε] at h
rwa [lt_div_iff₀' (Nat.cast_pos.mpr (Nat.factorial_pos _))]
· rw [div_lt_iff₀ hε] at h
rwa [div_lt_iff₀' (Nat.cast_pos.mpr (Nat.factorial_pos _))]
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.Floor.Ring",
"Mathlib.Order.Filter.AtTopBot.Floor",
"Mathlib.Topology.Algebra.Order.Group"
] |
Mathlib/Topology/Algebra/Order/Floor.lean
|
tendsto_mul_pow_div_factorial_sub_atTop
| null |
tendsto_pow_div_factorial_atTop (c : K) :
Tendsto (fun n ↦ c ^ n / n !) atTop (𝓝 0) := by
convert tendsto_mul_pow_div_factorial_sub_atTop 1 c 0
rw [one_mul]
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.Floor.Ring",
"Mathlib.Order.Filter.AtTopBot.Floor",
"Mathlib.Topology.Algebra.Order.Group"
] |
Mathlib/Topology/Algebra/Order/Floor.lean
|
tendsto_pow_div_factorial_atTop
| null |
tendsto_floor_atTop : Tendsto (floor : α → ℤ) atTop atTop :=
floor_mono.tendsto_atTop_atTop fun b =>
⟨(b + 1 : ℤ), by rw [floor_intCast]; exact (lt_add_one _).le⟩
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.Floor.Ring",
"Mathlib.Order.Filter.AtTopBot.Floor",
"Mathlib.Topology.Algebra.Order.Group"
] |
Mathlib/Topology/Algebra/Order/Floor.lean
|
tendsto_floor_atTop
| null |
tendsto_floor_atBot : Tendsto (floor : α → ℤ) atBot atBot :=
floor_mono.tendsto_atBot_atBot fun b => ⟨b, (floor_intCast _).le⟩
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.Floor.Ring",
"Mathlib.Order.Filter.AtTopBot.Floor",
"Mathlib.Topology.Algebra.Order.Group"
] |
Mathlib/Topology/Algebra/Order/Floor.lean
|
tendsto_floor_atBot
| null |
tendsto_ceil_atTop : Tendsto (ceil : α → ℤ) atTop atTop :=
ceil_mono.tendsto_atTop_atTop fun b => ⟨b, (ceil_intCast _).ge⟩
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.Floor.Ring",
"Mathlib.Order.Filter.AtTopBot.Floor",
"Mathlib.Topology.Algebra.Order.Group"
] |
Mathlib/Topology/Algebra/Order/Floor.lean
|
tendsto_ceil_atTop
| null |
tendsto_ceil_atBot : Tendsto (ceil : α → ℤ) atBot atBot :=
ceil_mono.tendsto_atBot_atBot fun b =>
⟨(b - 1 : ℤ), by rw [ceil_intCast]; exact (sub_one_lt _).le⟩
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.Floor.Ring",
"Mathlib.Order.Filter.AtTopBot.Floor",
"Mathlib.Topology.Algebra.Order.Group"
] |
Mathlib/Topology/Algebra/Order/Floor.lean
|
tendsto_ceil_atBot
| null |
continuousOn_floor (n : ℤ) :
ContinuousOn (fun x => floor x : α → α) (Ico n (n + 1) : Set α) :=
(continuousOn_congr <| floor_eq_on_Ico' n).mpr continuousOn_const
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.Floor.Ring",
"Mathlib.Order.Filter.AtTopBot.Floor",
"Mathlib.Topology.Algebra.Order.Group"
] |
Mathlib/Topology/Algebra/Order/Floor.lean
|
continuousOn_floor
| null |
continuousOn_ceil [IsStrictOrderedRing α] (n : ℤ) :
ContinuousOn (fun x => ceil x : α → α) (Ioc (n - 1) n : Set α) :=
(continuousOn_congr <| ceil_eq_on_Ioc' n).mpr continuousOn_const
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.Floor.Ring",
"Mathlib.Order.Filter.AtTopBot.Floor",
"Mathlib.Topology.Algebra.Order.Group"
] |
Mathlib/Topology/Algebra/Order/Floor.lean
|
continuousOn_ceil
| null |
tendsto_floor_right_pure_floor (x : α) : Tendsto (floor : α → ℤ) (𝓝[≥] x) (pure ⌊x⌋) :=
tendsto_pure.2 <| mem_of_superset (Ico_mem_nhdsGE <| lt_floor_add_one x) fun _y hy =>
floor_eq_on_Ico _ _ ⟨(floor_le x).trans hy.1, hy.2⟩
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.Floor.Ring",
"Mathlib.Order.Filter.AtTopBot.Floor",
"Mathlib.Topology.Algebra.Order.Group"
] |
Mathlib/Topology/Algebra/Order/Floor.lean
|
tendsto_floor_right_pure_floor
| null |
tendsto_floor_right_pure (n : ℤ) : Tendsto (floor : α → ℤ) (𝓝[≥] n) (pure n) := by
simpa only [floor_intCast] using tendsto_floor_right_pure_floor (n : α)
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.Floor.Ring",
"Mathlib.Order.Filter.AtTopBot.Floor",
"Mathlib.Topology.Algebra.Order.Group"
] |
Mathlib/Topology/Algebra/Order/Floor.lean
|
tendsto_floor_right_pure
| null |
tendsto_ceil_left_pure_ceil (x : α) : Tendsto (ceil : α → ℤ) (𝓝[≤] x) (pure ⌈x⌉) :=
tendsto_pure.2 <| mem_of_superset
(Ioc_mem_nhdsLE <| sub_lt_iff_lt_add.2 <| ceil_lt_add_one _) fun _y hy =>
ceil_eq_on_Ioc _ _ ⟨hy.1, hy.2.trans (le_ceil _)⟩
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.Floor.Ring",
"Mathlib.Order.Filter.AtTopBot.Floor",
"Mathlib.Topology.Algebra.Order.Group"
] |
Mathlib/Topology/Algebra/Order/Floor.lean
|
tendsto_ceil_left_pure_ceil
| null |
tendsto_ceil_left_pure (n : ℤ) : Tendsto (ceil : α → ℤ) (𝓝[≤] n) (pure n) := by
simpa only [ceil_intCast] using tendsto_ceil_left_pure_ceil (n : α)
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.Floor.Ring",
"Mathlib.Order.Filter.AtTopBot.Floor",
"Mathlib.Topology.Algebra.Order.Group"
] |
Mathlib/Topology/Algebra/Order/Floor.lean
|
tendsto_ceil_left_pure
| null |
tendsto_floor_left_pure_ceil_sub_one (x : α) :
Tendsto (floor : α → ℤ) (𝓝[<] x) (pure (⌈x⌉ - 1)) :=
have h₁ : ↑(⌈x⌉ - 1) < x := by rw [cast_sub, cast_one, sub_lt_iff_lt_add]; exact ceil_lt_add_one _
have h₂ : x ≤ ↑(⌈x⌉ - 1) + 1 := by rw [cast_sub, cast_one, sub_add_cancel]; exact le_ceil _
tendsto_pure.2 <| mem_of_superset (Ico_mem_nhdsLT h₁) fun _y hy =>
floor_eq_on_Ico _ _ ⟨hy.1, hy.2.trans_le h₂⟩
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.Floor.Ring",
"Mathlib.Order.Filter.AtTopBot.Floor",
"Mathlib.Topology.Algebra.Order.Group"
] |
Mathlib/Topology/Algebra/Order/Floor.lean
|
tendsto_floor_left_pure_ceil_sub_one
| null |
tendsto_floor_left_pure_sub_one (n : ℤ) :
Tendsto (floor : α → ℤ) (𝓝[<] n) (pure (n - 1)) := by
simpa only [ceil_intCast] using tendsto_floor_left_pure_ceil_sub_one (n : α)
omit [IsStrictOrderedRing α] in
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.Floor.Ring",
"Mathlib.Order.Filter.AtTopBot.Floor",
"Mathlib.Topology.Algebra.Order.Group"
] |
Mathlib/Topology/Algebra/Order/Floor.lean
|
tendsto_floor_left_pure_sub_one
| null |
tendsto_ceil_right_pure_floor_add_one (x : α) :
Tendsto (ceil : α → ℤ) (𝓝[>] x) (pure (⌊x⌋ + 1)) :=
have : ↑(⌊x⌋ + 1) - 1 ≤ x := by rw [cast_add, cast_one, add_sub_cancel_right]; exact floor_le _
tendsto_pure.2 <| mem_of_superset (Ioc_mem_nhdsGT <| lt_succ_floor _) fun _y hy =>
ceil_eq_on_Ioc _ _ ⟨this.trans_lt hy.1, hy.2⟩
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.Floor.Ring",
"Mathlib.Order.Filter.AtTopBot.Floor",
"Mathlib.Topology.Algebra.Order.Group"
] |
Mathlib/Topology/Algebra/Order/Floor.lean
|
tendsto_ceil_right_pure_floor_add_one
| null |
tendsto_ceil_right_pure_add_one (n : ℤ) :
Tendsto (ceil : α → ℤ) (𝓝[>] n) (pure (n + 1)) := by
simpa only [floor_intCast] using tendsto_ceil_right_pure_floor_add_one (n : α)
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.Floor.Ring",
"Mathlib.Order.Filter.AtTopBot.Floor",
"Mathlib.Topology.Algebra.Order.Group"
] |
Mathlib/Topology/Algebra/Order/Floor.lean
|
tendsto_ceil_right_pure_add_one
| null |
tendsto_floor_right (n : ℤ) : Tendsto (fun x => floor x : α → α) (𝓝[≥] n) (𝓝[≥] n) :=
((tendsto_pure_pure _ _).comp (tendsto_floor_right_pure n)).mono_right <|
pure_le_nhdsWithin le_rfl
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.Floor.Ring",
"Mathlib.Order.Filter.AtTopBot.Floor",
"Mathlib.Topology.Algebra.Order.Group"
] |
Mathlib/Topology/Algebra/Order/Floor.lean
|
tendsto_floor_right
| null |
tendsto_floor_right' (n : ℤ) : Tendsto (fun x => floor x : α → α) (𝓝[≥] n) (𝓝 n) :=
(tendsto_floor_right n).mono_right inf_le_left
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.Floor.Ring",
"Mathlib.Order.Filter.AtTopBot.Floor",
"Mathlib.Topology.Algebra.Order.Group"
] |
Mathlib/Topology/Algebra/Order/Floor.lean
|
tendsto_floor_right'
| null |
tendsto_ceil_left (n : ℤ) : Tendsto (fun x => ceil x : α → α) (𝓝[≤] n) (𝓝[≤] n) :=
((tendsto_pure_pure _ _).comp (tendsto_ceil_left_pure n)).mono_right <|
pure_le_nhdsWithin le_rfl
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.Floor.Ring",
"Mathlib.Order.Filter.AtTopBot.Floor",
"Mathlib.Topology.Algebra.Order.Group"
] |
Mathlib/Topology/Algebra/Order/Floor.lean
|
tendsto_ceil_left
| null |
tendsto_ceil_left' (n : ℤ) :
Tendsto (fun x => ceil x : α → α) (𝓝[≤] n) (𝓝 n) :=
(tendsto_ceil_left n).mono_right inf_le_left
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.Floor.Ring",
"Mathlib.Order.Filter.AtTopBot.Floor",
"Mathlib.Topology.Algebra.Order.Group"
] |
Mathlib/Topology/Algebra/Order/Floor.lean
|
tendsto_ceil_left'
| null |
tendsto_floor_left (n : ℤ) :
Tendsto (fun x => floor x : α → α) (𝓝[<] n) (𝓝[≤] (n - 1)) :=
((tendsto_pure_pure _ _).comp (tendsto_floor_left_pure_sub_one n)).mono_right <| by
rw [← @cast_one α, ← cast_sub]; exact pure_le_nhdsWithin le_rfl
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.Floor.Ring",
"Mathlib.Order.Filter.AtTopBot.Floor",
"Mathlib.Topology.Algebra.Order.Group"
] |
Mathlib/Topology/Algebra/Order/Floor.lean
|
tendsto_floor_left
| null |
tendsto_ceil_right (n : ℤ) :
Tendsto (fun x => ceil x : α → α) (𝓝[>] n) (𝓝[≥] (n + 1)) :=
((tendsto_pure_pure _ _).comp (tendsto_ceil_right_pure_add_one n)).mono_right <| by
rw [← @cast_one α, ← cast_add]; exact pure_le_nhdsWithin le_rfl
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.Floor.Ring",
"Mathlib.Order.Filter.AtTopBot.Floor",
"Mathlib.Topology.Algebra.Order.Group"
] |
Mathlib/Topology/Algebra/Order/Floor.lean
|
tendsto_ceil_right
| null |
tendsto_floor_left' (n : ℤ) :
Tendsto (fun x => floor x : α → α) (𝓝[<] n) (𝓝 (n - 1)) :=
(tendsto_floor_left n).mono_right inf_le_left
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.Floor.Ring",
"Mathlib.Order.Filter.AtTopBot.Floor",
"Mathlib.Topology.Algebra.Order.Group"
] |
Mathlib/Topology/Algebra/Order/Floor.lean
|
tendsto_floor_left'
| null |
tendsto_ceil_right' (n : ℤ) :
Tendsto (fun x => ceil x : α → α) (𝓝[>] n) (𝓝 (n + 1)) :=
(tendsto_ceil_right n).mono_right inf_le_left
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.Floor.Ring",
"Mathlib.Order.Filter.AtTopBot.Floor",
"Mathlib.Topology.Algebra.Order.Group"
] |
Mathlib/Topology/Algebra/Order/Floor.lean
|
tendsto_ceil_right'
| null |
continuousOn_fract [IsTopologicalAddGroup α] (n : ℤ) :
ContinuousOn (fract : α → α) (Ico n (n + 1) : Set α) :=
continuousOn_id.sub (continuousOn_floor n)
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.Floor.Ring",
"Mathlib.Order.Filter.AtTopBot.Floor",
"Mathlib.Topology.Algebra.Order.Group"
] |
Mathlib/Topology/Algebra/Order/Floor.lean
|
continuousOn_fract
| null |
continuousAt_fract [OrderClosedTopology α] [IsTopologicalAddGroup α]
{x : α} (h : x ≠ ⌊x⌋) : ContinuousAt fract x :=
(continuousOn_fract ⌊x⌋).continuousAt <|
Ico_mem_nhds ((floor_le _).lt_of_ne h.symm) (lt_floor_add_one _)
variable [IsStrictOrderedRing α]
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.Floor.Ring",
"Mathlib.Order.Filter.AtTopBot.Floor",
"Mathlib.Topology.Algebra.Order.Group"
] |
Mathlib/Topology/Algebra/Order/Floor.lean
|
continuousAt_fract
| null |
tendsto_fract_left' [OrderClosedTopology α] [IsTopologicalAddGroup α] (n : ℤ) :
Tendsto (fract : α → α) (𝓝[<] n) (𝓝 1) := by
rw [← sub_sub_cancel (n : α) 1]
refine (tendsto_id.mono_left nhdsWithin_le_nhds).sub ?_
exact tendsto_floor_left' n
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.Floor.Ring",
"Mathlib.Order.Filter.AtTopBot.Floor",
"Mathlib.Topology.Algebra.Order.Group"
] |
Mathlib/Topology/Algebra/Order/Floor.lean
|
tendsto_fract_left'
| null |
tendsto_fract_left [OrderClosedTopology α] [IsTopologicalAddGroup α] (n : ℤ) :
Tendsto (fract : α → α) (𝓝[<] n) (𝓝[<] 1) :=
tendsto_nhdsWithin_of_tendsto_nhds_of_eventually_within _ (tendsto_fract_left' _)
(Eventually.of_forall fract_lt_one)
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.Floor.Ring",
"Mathlib.Order.Filter.AtTopBot.Floor",
"Mathlib.Topology.Algebra.Order.Group"
] |
Mathlib/Topology/Algebra/Order/Floor.lean
|
tendsto_fract_left
| null |
tendsto_fract_right' [OrderClosedTopology α] [IsTopologicalAddGroup α] (n : ℤ) :
Tendsto (fract : α → α) (𝓝[≥] n) (𝓝 0) :=
sub_self (n : α) ▸ (tendsto_nhdsWithin_of_tendsto_nhds tendsto_id).sub (tendsto_floor_right' n)
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.Floor.Ring",
"Mathlib.Order.Filter.AtTopBot.Floor",
"Mathlib.Topology.Algebra.Order.Group"
] |
Mathlib/Topology/Algebra/Order/Floor.lean
|
tendsto_fract_right'
| null |
tendsto_fract_right [OrderClosedTopology α] [IsTopologicalAddGroup α] (n : ℤ) :
Tendsto (fract : α → α) (𝓝[≥] n) (𝓝[≥] 0) :=
tendsto_nhdsWithin_of_tendsto_nhds_of_eventually_within _ (tendsto_fract_right' _)
(Eventually.of_forall fract_nonneg)
local notation "I" => (Icc 0 1 : Set α)
variable [OrderTopology α] [TopologicalSpace β] [TopologicalSpace γ]
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.Floor.Ring",
"Mathlib.Order.Filter.AtTopBot.Floor",
"Mathlib.Topology.Algebra.Order.Group"
] |
Mathlib/Topology/Algebra/Order/Floor.lean
|
tendsto_fract_right
| null |
ContinuousOn.comp_fract' {f : β → α → γ} (h : ContinuousOn (uncurry f) <| univ ×ˢ I)
(hf : ∀ s, f s 0 = f s 1) : Continuous fun st : β × α => f st.1 (fract st.2) := by
change Continuous (uncurry f ∘ Prod.map id fract)
rw [continuous_iff_continuousAt]
rintro ⟨s, t⟩
rcases em (∃ n : ℤ, t = n) with (⟨n, rfl⟩ | ht)
· rw [ContinuousAt, nhds_prod_eq, ← nhdsLT_sup_nhdsGE (n : α), prod_sup, tendsto_sup]
constructor
· refine (((h (s, 1) ⟨trivial, zero_le_one, le_rfl⟩).tendsto.mono_left ?_).comp
(tendsto_id.prodMap (tendsto_fract_left _))).mono_right (le_of_eq ?_)
· rw [nhdsWithin_prod_eq, nhdsWithin_univ, ← nhdsWithin_Ico_eq_nhdsLT one_pos]
exact Filter.prod_mono le_rfl (nhdsWithin_mono _ Ico_subset_Icc_self)
· simp [hf]
· refine (((h (s, 0) ⟨trivial, le_rfl, zero_le_one⟩).tendsto.mono_left <| le_of_eq ?_).comp
(tendsto_id.prodMap (tendsto_fract_right _))).mono_right (le_of_eq ?_) <;>
simp [nhdsWithin_prod_eq, nhdsWithin_univ]
· replace ht : t ≠ ⌊t⌋ := fun ht' => ht ⟨_, ht'⟩
refine (h.continuousAt ?_).comp (continuousAt_id.prodMap (continuousAt_fract ht))
exact prod_mem_nhds univ_mem (Icc_mem_nhds (fract_pos.2 ht) (fract_lt_one _))
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.Floor.Ring",
"Mathlib.Order.Filter.AtTopBot.Floor",
"Mathlib.Topology.Algebra.Order.Group"
] |
Mathlib/Topology/Algebra/Order/Floor.lean
|
ContinuousOn.comp_fract'
|
Do not use this, use `ContinuousOn.comp_fract` instead.
|
ContinuousOn.comp_fract {s : β → α} {f : β → α → γ}
(h : ContinuousOn (uncurry f) <| univ ×ˢ Icc 0 1) (hs : Continuous s)
(hf : ∀ s, f s 0 = f s 1) : Continuous fun x : β => f x <| Int.fract (s x) :=
(h.comp_fract' hf).comp (continuous_id.prodMk hs)
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.Floor.Ring",
"Mathlib.Order.Filter.AtTopBot.Floor",
"Mathlib.Topology.Algebra.Order.Group"
] |
Mathlib/Topology/Algebra/Order/Floor.lean
|
ContinuousOn.comp_fract
| null |
ContinuousOn.comp_fract'' {f : α → β} (h : ContinuousOn f I) (hf : f 0 = f 1) :
Continuous (f ∘ fract) :=
ContinuousOn.comp_fract (h.comp continuousOn_snd fun _x hx => (mem_prod.mp hx).2) continuous_id
fun _ => hf
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.Floor.Ring",
"Mathlib.Order.Filter.AtTopBot.Floor",
"Mathlib.Topology.Algebra.Order.Group"
] |
Mathlib/Topology/Algebra/Order/Floor.lean
|
ContinuousOn.comp_fract''
|
A special case of `ContinuousOn.comp_fract`.
|
@[to_additive (attr := continuity)]
continuous_mabs : Continuous (mabs : G → G) :=
continuous_id.max continuous_inv
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.Group.Basic",
"Mathlib.Topology.Algebra.Group.Defs",
"Mathlib.Topology.Order.LeftRightNhds"
] |
Mathlib/Topology/Algebra/Order/Group.lean
|
continuous_mabs
| null |
@[to_additive]
protected Filter.Tendsto.mabs {a : G} (h : Tendsto f l (𝓝 a)) :
Tendsto (fun x => |f x|ₘ) l (𝓝 |a|ₘ) :=
(continuous_mabs.tendsto _).comp h
@[to_additive (attr := simp)]
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.Group.Basic",
"Mathlib.Topology.Algebra.Group.Defs",
"Mathlib.Topology.Order.LeftRightNhds"
] |
Mathlib/Topology/Algebra/Order/Group.lean
|
Filter.Tendsto.mabs
| null |
comap_mabs_nhds_one : comap mabs (𝓝 (1 : G)) = 𝓝 1 := by
simp [nhds_eq_iInf_mabs_div]
@[to_additive]
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.Group.Basic",
"Mathlib.Topology.Algebra.Group.Defs",
"Mathlib.Topology.Order.LeftRightNhds"
] |
Mathlib/Topology/Algebra/Order/Group.lean
|
comap_mabs_nhds_one
| null |
tendsto_one_iff_mabs_tendsto_one (f : α → G) :
Tendsto f l (𝓝 1) ↔ Tendsto (mabs ∘ f) l (𝓝 1) := by
rw [← tendsto_comap_iff, comap_mabs_nhds_one]
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.Group.Basic",
"Mathlib.Topology.Algebra.Group.Defs",
"Mathlib.Topology.Order.LeftRightNhds"
] |
Mathlib/Topology/Algebra/Order/Group.lean
|
tendsto_one_iff_mabs_tendsto_one
| null |
@[to_additive (attr := fun_prop)]
protected Continuous.mabs (h : Continuous f) : Continuous fun x => |f x|ₘ :=
continuous_mabs.comp h
@[to_additive (attr := fun_prop)]
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.Group.Basic",
"Mathlib.Topology.Algebra.Group.Defs",
"Mathlib.Topology.Order.LeftRightNhds"
] |
Mathlib/Topology/Algebra/Order/Group.lean
|
Continuous.mabs
| null |
protected ContinuousAt.mabs (h : ContinuousAt f x) : ContinuousAt (fun x => |f x|ₘ) x :=
Filter.Tendsto.mabs h
@[to_additive]
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.Group.Basic",
"Mathlib.Topology.Algebra.Group.Defs",
"Mathlib.Topology.Order.LeftRightNhds"
] |
Mathlib/Topology/Algebra/Order/Group.lean
|
ContinuousAt.mabs
| null |
protected ContinuousWithinAt.mabs (h : ContinuousWithinAt f s x) :
ContinuousWithinAt (fun x => |f x|ₘ) s x :=
Filter.Tendsto.mabs h
@[to_additive (attr := fun_prop)]
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.Group.Basic",
"Mathlib.Topology.Algebra.Group.Defs",
"Mathlib.Topology.Order.LeftRightNhds"
] |
Mathlib/Topology/Algebra/Order/Group.lean
|
ContinuousWithinAt.mabs
| null |
protected ContinuousOn.mabs (h : ContinuousOn f s) : ContinuousOn (fun x => |f x|ₘ) s :=
fun x hx => (h x hx).mabs
@[to_additive]
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.Group.Basic",
"Mathlib.Topology.Algebra.Group.Defs",
"Mathlib.Topology.Order.LeftRightNhds"
] |
Mathlib/Topology/Algebra/Order/Group.lean
|
ContinuousOn.mabs
| null |
tendsto_mabs_nhdsNE_one : Tendsto (mabs : G → G) (𝓝[≠] 1) (𝓝[>] 1) :=
(continuous_mabs.tendsto' (1 : G) 1 mabs_one).inf <|
tendsto_principal_principal.2 fun _x => one_lt_mabs.2
@[deprecated (since := "2025-03-18")]
alias tendsto_abs_nhdsWithin_zero := tendsto_abs_nhdsNE_zero
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.Group.Basic",
"Mathlib.Topology.Algebra.Group.Defs",
"Mathlib.Topology.Order.LeftRightNhds"
] |
Mathlib/Topology/Algebra/Order/Group.lean
|
tendsto_mabs_nhdsNE_one
| null |
@[to_additive /-- In a linearly ordered additive group, the integer multiples of an element are
dense iff they are the whole group. -/]
denseRange_zpow_iff_surjective {a : G} :
DenseRange (a ^ · : ℤ → G) ↔ Surjective (a ^ · : ℤ → G) := by
refine ⟨fun h ↦ ?_, fun h ↦ h.denseRange⟩
wlog ha₀ : 1 < a generalizing a
· simp only [← range_eq_univ, DenseRange] at *
rcases (not_lt.1 ha₀).eq_or_lt with rfl | hlt
· simpa only [one_zpow, range_const, dense_iff_closure_eq, closure_singleton] using h
· have H : range (a⁻¹ ^ · : ℤ → G) = range (a ^ · : ℤ → G) := by
simpa only [← inv_zpow, zpow_neg, comp_def] using neg_surjective.range_comp (a ^ · : ℤ → G)
rw [← H]
apply this <;> simpa only [H, one_lt_inv']
intro b
obtain ⟨m, hm, hm'⟩ : ∃ m : ℤ, a ^ m ∈ Ioo b (b * a * a) := by
have hne : (Ioo b (b * a * a)).Nonempty := ⟨b * a, by simpa⟩
simpa using h.exists_mem_open isOpen_Ioo hne
rcases eq_or_ne b (a ^ (m - 1)) with rfl | hne; · simp
suffices (Ioo (a ^ m) (a ^ (m + 1))).Nonempty by
rcases h.exists_mem_open isOpen_Ioo this with ⟨l, hl⟩
have : m < l ∧ l < m + 1 := by simpa [zpow_lt_zpow_iff_right ha₀] using hl
cutsat
rcases hne.lt_or_gt with hlt | hlt
· refine ⟨b * a * a, hm', ?_⟩
simpa only [zpow_add, zpow_sub, zpow_one, ← div_eq_mul_inv, lt_div_iff_mul_lt,
mul_lt_mul_iff_right] using hlt
· use b * a
simp only [mem_Ioo, zpow_add, zpow_sub, zpow_one, ← div_eq_mul_inv,
mul_lt_mul_iff_right] at hlt ⊢
exact ⟨div_lt_iff_lt_mul.1 hlt, hm⟩
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.Group.Basic",
"Mathlib.Topology.Algebra.Group.Defs",
"Mathlib.Topology.Order.LeftRightNhds"
] |
Mathlib/Topology/Algebra/Order/Group.lean
|
denseRange_zpow_iff_surjective
|
In a linearly ordered multiplicative group, the integer powers of an element are dense
iff they are the whole group.
|
@[to_additive /-- In a nontrivial densely linearly ordered additive group,
the integer multiples of an element can't be dense. -/]
not_denseRange_zpow [Nontrivial G] [DenselyOrdered G] {a : G} :
¬DenseRange (a ^ · : ℤ → G) :=
denseRange_zpow_iff_surjective.not.mpr fun h ↦
not_isCyclic_of_denselyOrdered G ⟨⟨a, h⟩⟩
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.Group.Basic",
"Mathlib.Topology.Algebra.Group.Defs",
"Mathlib.Topology.Order.LeftRightNhds"
] |
Mathlib/Topology/Algebra/Order/Group.lean
|
not_denseRange_zpow
|
In a nontrivial densely linearly ordered commutative group,
the integer powers of an element can't be dense.
|
le_limsup_add (h₁ : IsBoundedUnder (fun x1 x2 ↦ x1 ≤ x2) f u := by isBoundedDefault)
(h₂ : IsCoboundedUnder (fun x1 x2 ↦ x1 ≤ x2) f u := by isBoundedDefault)
(h₃ : IsBoundedUnder (fun x1 x2 ↦ x1 ≤ x2) f v := by isBoundedDefault)
(h₄ : IsBoundedUnder (fun x1 x2 ↦ x1 ≥ x2) f v := by isBoundedDefault) :
(limsup u f) + liminf v f ≤ limsup (u + v) f := by
have h := isCoboundedUnder_le_add h₄ h₂ -- These `have` tactic improve performance.
have h' := isBoundedUnder_le_add h₃ h₁
rw [add_comm] at h h'
refine add_le_of_forall_lt fun a a_u b b_v ↦ (le_limsup_iff h h').2 fun c c_ab ↦ ?_
refine ((frequently_lt_of_lt_limsup h₂ a_u).and_eventually
(eventually_lt_of_lt_liminf b_v h₄)).mono fun _ ab_x ↦ ?_
exact c_ab.trans (add_lt_add ab_x.1 ab_x.2)
|
lemma
|
Topology
|
[
"Mathlib.Algebra.Order.Group.DenselyOrdered",
"Mathlib.Data.Real.Archimedean",
"Mathlib.Topology.Algebra.Group.Basic",
"Mathlib.Topology.Order.LiminfLimsup"
] |
Mathlib/Topology/Algebra/Order/LiminfLimsup.lean
|
le_limsup_add
| null |
limsup_add_le (h₁ : IsBoundedUnder (fun x1 x2 ↦ x1 ≥ x2) f u := by isBoundedDefault)
(h₂ : IsBoundedUnder (fun x1 x2 ↦ x1 ≤ x2) f u := by isBoundedDefault)
(h₃ : IsCoboundedUnder (fun x1 x2 ↦ x1 ≤ x2) f v := by isBoundedDefault)
(h₄ : IsBoundedUnder (fun x1 x2 ↦ x1 ≤ x2) f v := by isBoundedDefault) :
limsup (u + v) f ≤ (limsup u f) + limsup v f := by
have h := isCoboundedUnder_le_add h₁ h₃
have h' := isBoundedUnder_le_add h₂ h₄
refine le_add_of_forall_lt fun a a_u b b_v ↦ ?_
rw [limsup_le_iff h h']
intro c c_ab
filter_upwards [eventually_lt_of_limsup_lt a_u, eventually_lt_of_limsup_lt b_v] with x a_x b_x
exact (add_lt_add a_x b_x).trans c_ab
|
lemma
|
Topology
|
[
"Mathlib.Algebra.Order.Group.DenselyOrdered",
"Mathlib.Data.Real.Archimedean",
"Mathlib.Topology.Algebra.Group.Basic",
"Mathlib.Topology.Order.LiminfLimsup"
] |
Mathlib/Topology/Algebra/Order/LiminfLimsup.lean
|
limsup_add_le
| null |
le_liminf_add (h₁ : IsBoundedUnder (fun x1 x2 ↦ x1 ≥ x2) f u := by isBoundedDefault)
(h₂ : IsBoundedUnder (fun x1 x2 ↦ x1 ≤ x2) f u := by isBoundedDefault)
(h₃ : IsBoundedUnder (fun x1 x2 ↦ x1 ≥ x2) f v := by isBoundedDefault)
(h₄ : IsCoboundedUnder (fun x1 x2 ↦ x1 ≥ x2) f v := by isBoundedDefault) :
(liminf u f) + liminf v f ≤ liminf (u + v) f := by
have h := isCoboundedUnder_ge_add h₂ h₄
have h' := isBoundedUnder_ge_add h₁ h₃
refine add_le_of_forall_lt fun a a_u b b_v ↦ ?_
rw [le_liminf_iff h h']
intro c c_ab
filter_upwards [eventually_lt_of_lt_liminf a_u, eventually_lt_of_lt_liminf b_v] with x a_x b_x
exact c_ab.trans (add_lt_add a_x b_x)
|
lemma
|
Topology
|
[
"Mathlib.Algebra.Order.Group.DenselyOrdered",
"Mathlib.Data.Real.Archimedean",
"Mathlib.Topology.Algebra.Group.Basic",
"Mathlib.Topology.Order.LiminfLimsup"
] |
Mathlib/Topology/Algebra/Order/LiminfLimsup.lean
|
le_liminf_add
| null |
liminf_add_le (h₁ : IsBoundedUnder (fun x1 x2 ↦ x1 ≥ x2) f u := by isBoundedDefault)
(h₂ : IsBoundedUnder (fun x1 x2 ↦ x1 ≤ x2) f u := by isBoundedDefault)
(h₃ : IsBoundedUnder (fun x1 x2 ↦ x1 ≥ x2) f v := by isBoundedDefault)
(h₄ : IsCoboundedUnder (fun x1 x2 ↦ x1 ≥ x2) f v := by isBoundedDefault) :
liminf (u + v) f ≤ (limsup u f) + liminf v f := by
have h := isCoboundedUnder_ge_add h₂ h₄
have h' := isBoundedUnder_ge_add h₁ h₃
refine le_add_of_forall_lt fun a a_u b b_v ↦ (liminf_le_iff h h').2 fun _ c_ab ↦ ?_
refine ((frequently_lt_of_liminf_lt h₄ b_v).and_eventually
(eventually_lt_of_limsup_lt a_u h₂)).mono fun _ ab_x ↦ ?_
exact (add_lt_add ab_x.2 ab_x.1).trans c_ab
|
lemma
|
Topology
|
[
"Mathlib.Algebra.Order.Group.DenselyOrdered",
"Mathlib.Data.Real.Archimedean",
"Mathlib.Topology.Algebra.Group.Basic",
"Mathlib.Topology.Order.LiminfLimsup"
] |
Mathlib/Topology/Algebra/Order/LiminfLimsup.lean
|
liminf_add_le
| null |
le_limsup_mul (h₁ : ∃ᶠ x in f, 0 ≤ u x) (h₂ : IsBoundedUnder (fun x1 x2 ↦ x1 ≤ x2) f u)
(h₃ : 0 ≤ᶠ[f] v) (h₄ : IsBoundedUnder (fun x1 x2 ↦ x1 ≤ x2) f v) :
(limsup u f) * liminf v f ≤ limsup (u * v) f := by
have h := IsCoboundedUnder.of_frequently_ge (a := 0)
<| (h₁.and_eventually h₃).mono fun x ⟨ux_0, vx_0⟩ ↦ mul_nonneg ux_0 vx_0
have h' := isBoundedUnder_le_mul_of_nonneg h₁ h₂ h₃ h₄
have u0 : 0 ≤ limsup u f := le_limsup_of_frequently_le h₁ h₂
have uv : 0 ≤ limsup (u * v) f :=
le_limsup_of_frequently_le ((h₁.and_eventually h₃).mono fun _ ⟨hu, hv⟩ ↦ mul_nonneg hu hv) h'
refine mul_le_of_forall_lt_of_nonneg u0 uv fun a a0 au b b0 bv ↦ ?_
refine (le_limsup_iff h h').2 fun c c_ab ↦ ?_
replace h₁ := IsCoboundedUnder.of_frequently_ge h₁ -- Pre-compute it to gain 4 s.
have h₅ := frequently_lt_of_lt_limsup h₁ au
have h₆ := eventually_lt_of_lt_liminf bv (isBoundedUnder_of_eventually_ge h₃)
apply (h₅.and_eventually (h₆.and h₃)).mono
exact fun x ⟨xa, ⟨xb, _⟩⟩ ↦ c_ab.trans_le <| mul_le_mul xa.le xb.le b0 (a0.trans xa.le)
|
lemma
|
Topology
|
[
"Mathlib.Algebra.Order.Group.DenselyOrdered",
"Mathlib.Data.Real.Archimedean",
"Mathlib.Topology.Algebra.Group.Basic",
"Mathlib.Topology.Order.LiminfLimsup"
] |
Mathlib/Topology/Algebra/Order/LiminfLimsup.lean
|
le_limsup_mul
| null |
limsup_mul_le (h₁ : ∃ᶠ x in f, 0 ≤ u x) (h₂ : IsBoundedUnder (fun x1 x2 ↦ x1 ≤ x2) f u)
(h₃ : 0 ≤ᶠ[f] v) (h₄ : IsBoundedUnder (fun x1 x2 ↦ x1 ≤ x2) f v) :
limsup (u * v) f ≤ (limsup u f) * limsup v f := by
have h := IsCoboundedUnder.of_frequently_ge (a := 0)
<| (h₁.and_eventually h₃).mono fun x ⟨ux_0, vx_0⟩ ↦ mul_nonneg ux_0 vx_0
have h' := isBoundedUnder_le_mul_of_nonneg h₁ h₂ h₃ h₄
refine le_mul_of_forall_lt₀ fun a a_u b b_v ↦ (limsup_le_iff h h').2 fun c c_ab ↦ ?_
filter_upwards [eventually_lt_of_limsup_lt a_u, eventually_lt_of_limsup_lt b_v, h₃]
with x x_a x_b v_0
apply lt_of_le_of_lt _ c_ab
rcases lt_or_ge (u x) 0 with u_0 | u_0
· apply (mul_nonpos_of_nonpos_of_nonneg u_0.le v_0).trans
exact mul_nonneg ((le_limsup_of_frequently_le h₁ h₂).trans a_u.le) (v_0.trans x_b.le)
· exact mul_le_mul x_a.le x_b.le v_0 (u_0.trans x_a.le)
|
lemma
|
Topology
|
[
"Mathlib.Algebra.Order.Group.DenselyOrdered",
"Mathlib.Data.Real.Archimedean",
"Mathlib.Topology.Algebra.Group.Basic",
"Mathlib.Topology.Order.LiminfLimsup"
] |
Mathlib/Topology/Algebra/Order/LiminfLimsup.lean
|
limsup_mul_le
| null |
le_liminf_mul [f.NeBot] (h₁ : 0 ≤ᶠ[f] u) (h₂ : IsBoundedUnder (fun x1 x2 ↦ x1 ≤ x2) f u)
(h₃ : 0 ≤ᶠ[f] v) (h₄ : IsCoboundedUnder (fun x1 x2 ↦ x1 ≥ x2) f v) :
(liminf u f) * liminf v f ≤ liminf (u * v) f := by
have h := isCoboundedUnder_ge_mul_of_nonneg h₁ h₂ h₃ h₄
have h' := isBoundedUnder_of_eventually_ge (a := 0)
<| (h₁.and h₃).mono fun x ⟨u0, v0⟩ ↦ mul_nonneg u0 v0
apply mul_le_of_forall_lt_of_nonneg (le_liminf_of_le h₂.isCoboundedUnder_ge h₁)
(le_liminf_of_le h ((h₁.and h₃).mono fun x ⟨u0, v0⟩ ↦ mul_nonneg u0 v0))
intro a a0 au b b0 bv
refine (le_liminf_iff h h').2 fun c c_ab ↦ ?_
filter_upwards [eventually_lt_of_lt_liminf au (isBoundedUnder_of_eventually_ge h₁),
eventually_lt_of_lt_liminf bv (isBoundedUnder_of_eventually_ge h₃)] with x xa xb
exact c_ab.trans_le (mul_le_mul xa.le xb.le b0 (a0.trans xa.le))
|
lemma
|
Topology
|
[
"Mathlib.Algebra.Order.Group.DenselyOrdered",
"Mathlib.Data.Real.Archimedean",
"Mathlib.Topology.Algebra.Group.Basic",
"Mathlib.Topology.Order.LiminfLimsup"
] |
Mathlib/Topology/Algebra/Order/LiminfLimsup.lean
|
le_liminf_mul
| null |
liminf_mul_le [f.NeBot] (h₁ : 0 ≤ᶠ[f] u) (h₂ : IsBoundedUnder (fun x1 x2 ↦ x1 ≤ x2) f u)
(h₃ : 0 ≤ᶠ[f] v) (h₄ : IsCoboundedUnder (fun x1 x2 ↦ x1 ≥ x2) f v) :
liminf (u * v) f ≤ (limsup u f) * liminf v f := by
have h := isCoboundedUnder_ge_mul_of_nonneg h₁ h₂ h₃ h₄
have h' := isBoundedUnder_of_eventually_ge (a := 0)
<| (h₁.and h₃).mono fun x ⟨u_0, v_0⟩ ↦ mul_nonneg u_0 v_0
refine le_mul_of_forall_lt₀ fun a a_u b b_v ↦ (liminf_le_iff h h').2 fun c c_ab ↦ ?_
refine ((frequently_lt_of_liminf_lt h₄ b_v).and_eventually ((eventually_lt_of_limsup_lt a_u).and
(h₁.and h₃))).mono fun x ⟨x_v, x_u, u_0, v_0⟩ ↦ ?_
exact (mul_le_mul x_u.le x_v.le v_0 (u_0.trans x_u.le)).trans_lt c_ab
|
lemma
|
Topology
|
[
"Mathlib.Algebra.Order.Group.DenselyOrdered",
"Mathlib.Data.Real.Archimedean",
"Mathlib.Topology.Algebra.Group.Basic",
"Mathlib.Topology.Order.LiminfLimsup"
] |
Mathlib/Topology/Algebra/Order/LiminfLimsup.lean
|
liminf_mul_le
| null |
limsup_const_add (F : Filter ι) [NeBot F] [Add R] [ContinuousAdd R]
[AddLeftMono R] (f : ι → R) (c : R)
(bdd_above : F.IsBoundedUnder (· ≤ ·) f) (cobdd : F.IsCoboundedUnder (· ≤ ·) f) :
Filter.limsup (fun i ↦ c + f i) F = c + Filter.limsup f F :=
(Monotone.map_limsSup_of_continuousAt (F := F.map f) (f := fun (x : R) ↦ c + x)
(fun _ _ h ↦ add_le_add_left h c) (continuous_add_left c).continuousAt bdd_above cobdd).symm
|
lemma
|
Topology
|
[
"Mathlib.Algebra.Order.Group.DenselyOrdered",
"Mathlib.Data.Real.Archimedean",
"Mathlib.Topology.Algebra.Group.Basic",
"Mathlib.Topology.Order.LiminfLimsup"
] |
Mathlib/Topology/Algebra/Order/LiminfLimsup.lean
|
limsup_const_add
|
`liminf (c + xᵢ) = c + liminf xᵢ`.
|
limsup_add_const (F : Filter ι) [NeBot F] [Add R] [ContinuousAdd R]
[AddRightMono R] (f : ι → R) (c : R)
(bdd_above : F.IsBoundedUnder (· ≤ ·) f) (cobdd : F.IsCoboundedUnder (· ≤ ·) f) :
Filter.limsup (fun i ↦ f i + c) F = Filter.limsup f F + c :=
(Monotone.map_limsSup_of_continuousAt (F := F.map f) (f := fun (x : R) ↦ x + c)
(fun _ _ h ↦ add_le_add_right h c) (continuous_add_right c).continuousAt bdd_above cobdd).symm
|
lemma
|
Topology
|
[
"Mathlib.Algebra.Order.Group.DenselyOrdered",
"Mathlib.Data.Real.Archimedean",
"Mathlib.Topology.Algebra.Group.Basic",
"Mathlib.Topology.Order.LiminfLimsup"
] |
Mathlib/Topology/Algebra/Order/LiminfLimsup.lean
|
limsup_add_const
|
`limsup (xᵢ + c) = (limsup xᵢ) + c`.
|
liminf_const_add (F : Filter ι) [NeBot F] [Add R] [ContinuousAdd R]
[AddLeftMono R] (f : ι → R) (c : R)
(cobdd : F.IsCoboundedUnder (· ≥ ·) f) (bdd_below : F.IsBoundedUnder (· ≥ ·) f) :
Filter.liminf (fun i ↦ c + f i) F = c + Filter.liminf f F :=
(Monotone.map_limsInf_of_continuousAt (F := F.map f) (f := fun (x : R) ↦ c + x)
(fun _ _ h ↦ add_le_add_left h c) (continuous_add_left c).continuousAt cobdd bdd_below).symm
|
lemma
|
Topology
|
[
"Mathlib.Algebra.Order.Group.DenselyOrdered",
"Mathlib.Data.Real.Archimedean",
"Mathlib.Topology.Algebra.Group.Basic",
"Mathlib.Topology.Order.LiminfLimsup"
] |
Mathlib/Topology/Algebra/Order/LiminfLimsup.lean
|
liminf_const_add
|
`liminf (c + xᵢ) = c + liminf xᵢ`.
|
liminf_add_const (F : Filter ι) [NeBot F] [Add R] [ContinuousAdd R]
[AddRightMono R] (f : ι → R) (c : R)
(cobdd : F.IsCoboundedUnder (· ≥ ·) f) (bdd_below : F.IsBoundedUnder (· ≥ ·) f) :
Filter.liminf (fun i ↦ f i + c) F = Filter.liminf f F + c :=
(Monotone.map_limsInf_of_continuousAt (F := F.map f) (f := fun (x : R) ↦ x + c)
(fun _ _ h ↦ add_le_add_right h c) (continuous_add_right c).continuousAt cobdd bdd_below).symm
|
lemma
|
Topology
|
[
"Mathlib.Algebra.Order.Group.DenselyOrdered",
"Mathlib.Data.Real.Archimedean",
"Mathlib.Topology.Algebra.Group.Basic",
"Mathlib.Topology.Order.LiminfLimsup"
] |
Mathlib/Topology/Algebra/Order/LiminfLimsup.lean
|
liminf_add_const
|
`liminf (xᵢ + c) = (liminf xᵢ) + c`.
|
limsup_const_sub (F : Filter ι) [AddCommSemigroup R] [Sub R] [ContinuousSub R] [OrderedSub R]
[AddLeftMono R] (f : ι → R) (c : R)
(cobdd : F.IsCoboundedUnder (· ≥ ·) f) (bdd_below : F.IsBoundedUnder (· ≥ ·) f) :
Filter.limsup (fun i ↦ c - f i) F = c - Filter.liminf f F := by
rcases F.eq_or_neBot with rfl | _
· simp only [liminf, limsInf, limsup, limsSup, map_bot, eventually_bot, Set.setOf_true]
simp only [IsCoboundedUnder, IsCobounded, map_bot, eventually_bot, true_implies] at cobdd
rcases cobdd with ⟨x, hx⟩
refine (csInf_le ?_ (Set.mem_univ _)).antisymm
(tsub_le_iff_tsub_le.1 (le_csSup ?_ (Set.mem_univ _)))
· refine ⟨x - x, mem_lowerBounds.2 fun y ↦ ?_⟩
simp only [Set.mem_univ, true_implies]
exact tsub_le_iff_tsub_le.1 (hx (x - y))
· refine ⟨x, mem_upperBounds.2 fun y ↦ ?_⟩
simp only [Set.mem_univ, hx y, implies_true]
· exact (Antitone.map_limsInf_of_continuousAt (F := F.map f) (f := fun (x : R) ↦ c - x)
(fun _ _ h ↦ tsub_le_tsub_left h c) (continuous_sub_left c).continuousAt cobdd bdd_below).symm
|
lemma
|
Topology
|
[
"Mathlib.Algebra.Order.Group.DenselyOrdered",
"Mathlib.Data.Real.Archimedean",
"Mathlib.Topology.Algebra.Group.Basic",
"Mathlib.Topology.Order.LiminfLimsup"
] |
Mathlib/Topology/Algebra/Order/LiminfLimsup.lean
|
limsup_const_sub
|
`limsup (c - xᵢ) = c - liminf xᵢ`.
|
limsup_sub_const (F : Filter ι) [AddCommSemigroup R] [Sub R] [ContinuousSub R] [OrderedSub R]
(f : ι → R) (c : R)
(bdd_above : F.IsBoundedUnder (· ≤ ·) f) (cobdd : F.IsCoboundedUnder (· ≤ ·) f) :
Filter.limsup (fun i ↦ f i - c) F = Filter.limsup f F - c := by
rcases F.eq_or_neBot with rfl | _
· have {a : R} : sInf Set.univ ≤ a := by
apply csInf_le _ (Set.mem_univ a)
simp only [IsCoboundedUnder, IsCobounded, map_bot, eventually_bot, true_implies] at cobdd
rcases cobdd with ⟨x, hx⟩
refine ⟨x, mem_lowerBounds.2 fun y ↦ ?_⟩
simp only [Set.mem_univ, hx y, implies_true]
simp only [limsup, limsSup, map_bot, eventually_bot, Set.setOf_true]
exact this.antisymm (tsub_le_iff_right.2 this)
· apply (Monotone.map_limsSup_of_continuousAt (F := F.map f) (f := fun (x : R) ↦ x - c) _ _).symm
· exact fun _ _ h ↦ tsub_le_tsub_right h c
· exact (continuous_sub_right c).continuousAt
|
lemma
|
Topology
|
[
"Mathlib.Algebra.Order.Group.DenselyOrdered",
"Mathlib.Data.Real.Archimedean",
"Mathlib.Topology.Algebra.Group.Basic",
"Mathlib.Topology.Order.LiminfLimsup"
] |
Mathlib/Topology/Algebra/Order/LiminfLimsup.lean
|
limsup_sub_const
|
`limsup (xᵢ - c) = (limsup xᵢ) - c`.
|
liminf_const_sub (F : Filter ι) [NeBot F] [AddCommSemigroup R] [Sub R] [ContinuousSub R]
[OrderedSub R] [AddLeftMono R] (f : ι → R) (c : R)
(bdd_above : F.IsBoundedUnder (· ≤ ·) f) (cobdd : F.IsCoboundedUnder (· ≤ ·) f) :
Filter.liminf (fun i ↦ c - f i) F = c - Filter.limsup f F :=
(Antitone.map_limsSup_of_continuousAt (F := F.map f) (f := fun (x : R) ↦ c - x)
(fun _ _ h ↦ tsub_le_tsub_left h c) (continuous_sub_left c).continuousAt bdd_above cobdd).symm
|
lemma
|
Topology
|
[
"Mathlib.Algebra.Order.Group.DenselyOrdered",
"Mathlib.Data.Real.Archimedean",
"Mathlib.Topology.Algebra.Group.Basic",
"Mathlib.Topology.Order.LiminfLimsup"
] |
Mathlib/Topology/Algebra/Order/LiminfLimsup.lean
|
liminf_const_sub
|
`liminf (c - xᵢ) = c - limsup xᵢ`.
|
liminf_sub_const (F : Filter ι) [NeBot F] [AddCommSemigroup R] [Sub R] [ContinuousSub R]
[OrderedSub R] (f : ι → R) (c : R)
(cobdd : F.IsCoboundedUnder (· ≥ ·) f) (bdd_below : F.IsBoundedUnder (· ≥ ·) f) :
Filter.liminf (fun i ↦ f i - c) F = Filter.liminf f F - c :=
(Monotone.map_limsInf_of_continuousAt (F := F.map f) (f := fun (x : R) ↦ x - c)
(fun _ _ h ↦ tsub_le_tsub_right h c) (continuous_sub_right c).continuousAt cobdd bdd_below).symm
|
lemma
|
Topology
|
[
"Mathlib.Algebra.Order.Group.DenselyOrdered",
"Mathlib.Data.Real.Archimedean",
"Mathlib.Topology.Algebra.Group.Basic",
"Mathlib.Topology.Order.LiminfLimsup"
] |
Mathlib/Topology/Algebra/Order/LiminfLimsup.lean
|
liminf_sub_const
|
`liminf (xᵢ - c) = (liminf xᵢ) - c`.
|
@[to_additive]
HasCompactMulSupport.sup {f g : X → M} (hf : HasCompactMulSupport f)
(hg : HasCompactMulSupport g) : HasCompactMulSupport (f ⊔ g) := by
apply IsCompact.of_isClosed_subset (IsCompact.union hf hg) (isClosed_mulTSupport _)
rw [mulTSupport, mulTSupport, mulTSupport, ← closure_union]
apply closure_mono
exact Function.mulSupport_sup f g
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.Group.Indicator",
"Mathlib.Topology.Algebra.Support"
] |
Mathlib/Topology/Algebra/Order/Support.lean
|
HasCompactMulSupport.sup
| null |
@[to_additive]
HasCompactMulSupport.inf {f g : X → M} (hf : HasCompactMulSupport f)
(hg : HasCompactMulSupport g) : HasCompactMulSupport (f ⊓ g) := by
apply IsCompact.of_isClosed_subset (IsCompact.union hf hg) (isClosed_mulTSupport _)
rw [mulTSupport, mulTSupport, mulTSupport, ← closure_union]
apply closure_mono
exact Function.mulSupport_inf f g
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.Group.Indicator",
"Mathlib.Topology.Algebra.Support"
] |
Mathlib/Topology/Algebra/Order/Support.lean
|
HasCompactMulSupport.inf
| null |
HasUpperLowerClosure (α : Type*) [TopologicalSpace α] [Preorder α] : Prop where
isUpperSet_closure : ∀ s : Set α, IsUpperSet s → IsUpperSet (closure s)
isLowerSet_closure : ∀ s : Set α, IsLowerSet s → IsLowerSet (closure s)
isOpen_upperClosure : ∀ s : Set α, IsOpen s → IsOpen (upperClosure s : Set α)
isOpen_lowerClosure : ∀ s : Set α, IsOpen s → IsOpen (lowerClosure s : Set α)
variable {α : Type*} [TopologicalSpace α]
@[to_additive]
|
class
|
Topology
|
[
"Mathlib.Algebra.Order.UpperLower",
"Mathlib.Topology.Algebra.Group.Pointwise"
] |
Mathlib/Topology/Algebra/Order/UpperLower.lean
|
HasUpperLowerClosure
|
Ad hoc class stating that the closure of an upper set is an upper set. This is used to state
lemmas that do not mention algebraic operations for both the additive and multiplicative versions
simultaneously. If you find a satisfying replacement for this typeclass, please remove it!
|
protected IsUpperSet.closure : IsUpperSet s → IsUpperSet (closure s) :=
HasUpperLowerClosure.isUpperSet_closure _
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.UpperLower",
"Mathlib.Topology.Algebra.Group.Pointwise"
] |
Mathlib/Topology/Algebra/Order/UpperLower.lean
|
IsUpperSet.closure
| null |
protected IsLowerSet.closure : IsLowerSet s → IsLowerSet (closure s) :=
HasUpperLowerClosure.isLowerSet_closure _
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.UpperLower",
"Mathlib.Topology.Algebra.Group.Pointwise"
] |
Mathlib/Topology/Algebra/Order/UpperLower.lean
|
IsLowerSet.closure
| null |
protected IsOpen.upperClosure : IsOpen s → IsOpen (upperClosure s : Set α) :=
HasUpperLowerClosure.isOpen_upperClosure _
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.UpperLower",
"Mathlib.Topology.Algebra.Group.Pointwise"
] |
Mathlib/Topology/Algebra/Order/UpperLower.lean
|
IsOpen.upperClosure
| null |
protected IsOpen.lowerClosure : IsOpen s → IsOpen (lowerClosure s : Set α) :=
HasUpperLowerClosure.isOpen_lowerClosure _
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.UpperLower",
"Mathlib.Topology.Algebra.Group.Pointwise"
] |
Mathlib/Topology/Algebra/Order/UpperLower.lean
|
IsOpen.lowerClosure
| null |
protected IsUpperSet.interior (h : IsUpperSet s) : IsUpperSet (interior s) := by
rw [← isLowerSet_compl, ← closure_compl]
exact h.compl.closure
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.UpperLower",
"Mathlib.Topology.Algebra.Group.Pointwise"
] |
Mathlib/Topology/Algebra/Order/UpperLower.lean
|
IsUpperSet.interior
| null |
protected IsLowerSet.interior (h : IsLowerSet s) : IsLowerSet (interior s) :=
h.toDual.interior
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.UpperLower",
"Mathlib.Topology.Algebra.Group.Pointwise"
] |
Mathlib/Topology/Algebra/Order/UpperLower.lean
|
IsLowerSet.interior
| null |
protected Set.OrdConnected.interior (h : s.OrdConnected) : (interior s).OrdConnected := by
rw [← h.upperClosure_inter_lowerClosure, interior_inter]
exact
(upperClosure s).upper.interior.ordConnected.inter (lowerClosure s).lower.interior.ordConnected
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Order.UpperLower",
"Mathlib.Topology.Algebra.Group.Pointwise"
] |
Mathlib/Topology/Algebra/Order/UpperLower.lean
|
Set.OrdConnected.interior
| null |
ProperVAdd (G X : Type*) [TopologicalSpace G] [TopologicalSpace X] [AddGroup G]
[AddAction G X] : Prop where
/-- Proper group action in the sense of Bourbaki:
the map `G × X → X × X` is a proper map (see `IsProperMap`). -/
isProperMap_vadd_pair : IsProperMap (fun gx ↦ (gx.1 +ᵥ gx.2, gx.2) : G × X → X × X)
|
class
|
Topology
|
[
"Mathlib.Topology.Algebra.MulAction",
"Mathlib.Topology.Maps.Proper.Basic",
"Mathlib.Topology.Maps.OpenQuotient"
] |
Mathlib/Topology/Algebra/ProperAction/Basic.lean
|
ProperVAdd
|
Proper group action in the sense of Bourbaki:
the map `G × X → X × X` is a proper map (see `IsProperMap`).
|
@[to_additive existing (attr := mk_iff)]
ProperSMul (G X : Type*) [TopologicalSpace G] [TopologicalSpace X] [Group G]
[MulAction G X] : Prop where
/-- Proper group action in the sense of Bourbaki:
the map `G × X → X × X` is a proper map (see `IsProperMap`). -/
isProperMap_smul_pair : IsProperMap (fun gx ↦ (gx.1 • gx.2, gx.2) : G × X → X × X)
attribute [to_additive existing] properSMul_iff
variable {G X : Type*} [Group G] [MulAction G X]
variable [TopologicalSpace G] [TopologicalSpace X]
|
class
|
Topology
|
[
"Mathlib.Topology.Algebra.MulAction",
"Mathlib.Topology.Maps.Proper.Basic",
"Mathlib.Topology.Maps.OpenQuotient"
] |
Mathlib/Topology/Algebra/ProperAction/Basic.lean
|
ProperSMul
|
Proper group action in the sense of Bourbaki:
the map `G × X → X × X` is a proper map (see `IsProperMap`).
|
@[to_additive /-- An additive group `G` acts properly on a topological space `X` if and only if
for all ultrafilters `𝒰` on `X`, if `𝒰` converges to `(x₁, x₂)`
along the map `(g, x) ↦ (g • x, x)`, then there exists `g : G` such that `g • x₂ = x₁`
and `𝒰.fst` converges to `g`. -/]
properSMul_iff_continuousSMul_ultrafilter_tendsto :
ProperSMul G X ↔ ContinuousSMul G X ∧
(∀ 𝒰 : Ultrafilter (G × X), ∀ x₁ x₂ : X,
Tendsto (fun gx : G × X ↦ (gx.1 • gx.2, gx.2)) 𝒰 (𝓝 (x₁, x₂)) →
∃ g : G, g • x₂ = x₁ ∧ Tendsto (Prod.fst : G × X → G) 𝒰 (𝓝 g)) := by
refine ⟨fun h ↦ ⟨inferInstance, fun 𝒰 x₁ x₂ h' ↦ ?_⟩, fun ⟨cont, h⟩ ↦ ?_⟩
· rw [properSMul_iff, isProperMap_iff_ultrafilter] at h
rcases h.2 h' with ⟨gx, hgx1, hgx2⟩
refine ⟨gx.1, ?_, (continuous_fst.tendsto gx).mono_left hgx2⟩
simp only [Prod.mk.injEq] at hgx1
rw [← hgx1.2, hgx1.1]
· rw [properSMul_iff, isProperMap_iff_ultrafilter]
refine ⟨by fun_prop, fun 𝒰 (x₁, x₂) hxx ↦ ?_⟩
rcases h 𝒰 x₁ x₂ hxx with ⟨g, hg1, hg2⟩
refine ⟨(g, x₂), by simp_rw [hg1], ?_⟩
rw [nhds_prod_eq, 𝒰.le_prod]
exact ⟨hg2, (continuous_snd.tendsto _).comp hxx⟩
|
theorem
|
Topology
|
[
"Mathlib.Topology.Algebra.MulAction",
"Mathlib.Topology.Maps.Proper.Basic",
"Mathlib.Topology.Maps.OpenQuotient"
] |
Mathlib/Topology/Algebra/ProperAction/Basic.lean
|
properSMul_iff_continuousSMul_ultrafilter_tendsto
|
If a group acts properly then in particular it acts continuously. -/
@[to_additive /-- If a group acts properly then in particular it acts continuously. -/]
-- See note [lower instance property]
instance (priority := 100) ProperSMul.toContinuousSMul [ProperSMul G X] : ContinuousSMul G X where
continuous_smul := isProperMap_smul_pair.continuous.fst
/-- A group `G` acts properly on a topological space `X` if and only if for all ultrafilters
`𝒰` on `X × G`, if `𝒰` converges to `(x₁, x₂)` along the map `(g, x) ↦ (g • x, x)`,
then there exists `g : G` such that `g • x₂ = x₁` and `𝒰.fst` converges to `g`.
|
properSMul_iff_continuousSMul_ultrafilter_tendsto_t2 [T2Space X] :
ProperSMul G X ↔ ContinuousSMul G X ∧
(∀ 𝒰 : Ultrafilter (G × X), ∀ x₁ x₂ : X,
Tendsto (fun gx : G × X ↦ (gx.1 • gx.2, gx.2)) 𝒰 (𝓝 (x₁, x₂)) →
∃ g : G, Tendsto (Prod.fst : G × X → G) 𝒰 (𝓝 g)) := by
rw [properSMul_iff_continuousSMul_ultrafilter_tendsto]
refine and_congr_right fun hc ↦ ?_
congrm ∀ 𝒰 x₁ x₂ hxx, ∃ g, ?_
exact and_iff_right_of_imp fun hg ↦ tendsto_nhds_unique
(hg.smul ((continuous_snd.tendsto _).comp hxx)) ((continuous_fst.tendsto _).comp hxx)
|
theorem
|
Topology
|
[
"Mathlib.Topology.Algebra.MulAction",
"Mathlib.Topology.Maps.Proper.Basic",
"Mathlib.Topology.Maps.OpenQuotient"
] |
Mathlib/Topology/Algebra/ProperAction/Basic.lean
|
properSMul_iff_continuousSMul_ultrafilter_tendsto_t2
|
A group `G` acts properly on a T2 topological space `X` if and only if for all ultrafilters
`𝒰` on `X × G`, if `𝒰` converges to `(x₁, x₂)` along the map `(g, x) ↦ (g • x, x)`,
then there exists `g : G` such that `𝒰.fst` converges to `g`.
|
@[to_additive /-- If `G` acts properly on `X`, then the quotient space is Hausdorff (T2). -/]
t2Space_quotient_mulAction_of_properSMul [ProperSMul G X] :
T2Space (Quotient (MulAction.orbitRel G X)) := by
rw [t2_iff_isClosed_diagonal]
set R := MulAction.orbitRel G X
let π : X → Quotient R := Quotient.mk'
have : IsOpenQuotientMap (Prod.map π π) :=
MulAction.isOpenQuotientMap_quotientMk.prodMap MulAction.isOpenQuotientMap_quotientMk
rw [← this.isQuotientMap.isClosed_preimage]
convert ProperSMul.isProperMap_smul_pair.isClosedMap.isClosed_range
· ext ⟨x₁, x₂⟩
simp only [mem_preimage, map_apply, mem_diagonal_iff, mem_range, Prod.mk.injEq, Prod.exists,
exists_eq_right]
rw [Quotient.eq', MulAction.orbitRel_apply, MulAction.mem_orbit_iff]
all_goals infer_instance
|
theorem
|
Topology
|
[
"Mathlib.Topology.Algebra.MulAction",
"Mathlib.Topology.Maps.Proper.Basic",
"Mathlib.Topology.Maps.OpenQuotient"
] |
Mathlib/Topology/Algebra/ProperAction/Basic.lean
|
t2Space_quotient_mulAction_of_properSMul
|
If `G` acts properly on `X`, then the quotient space is Hausdorff (T2).
|
@[to_additive /-- If a T1 group acts properly on a topological space,
then this topological space is T2. -/]
t2Space_of_properSMul_of_t1Group [h_proper : ProperSMul G X] [T1Space G] : T2Space X := by
let f := fun x : X ↦ ((1 : G), x)
have proper_f : IsProperMap f := by
refine IsClosedEmbedding.isProperMap ⟨?_, ?_⟩
· let g := fun gx : G × X ↦ gx.2
have : Function.LeftInverse g f := fun x ↦ by simp [f, g]
exact this.isEmbedding (by fun_prop) (by fun_prop)
· have : range f = ({1} ×ˢ univ) := by simp [f, Set.singleton_prod]
rw [this]
exact isClosed_singleton.prod isClosed_univ
rw [t2_iff_isClosed_diagonal]
let g := fun gx : G × X ↦ (gx.1 • gx.2, gx.2)
have proper_g : IsProperMap g := (properSMul_iff G X).1 h_proper
have : g ∘ f = fun x ↦ (x, x) := by ext x <;> simp [f, g]
have range_gf : range (g ∘ f) = diagonal X := by simp [this]
rw [← range_gf]
exact (proper_f.comp proper_g).isClosed_range
@[deprecated (since := "2025-03-21")]
alias t2Space_of_properSMul_of_t2Group := t2Space_of_properSMul_of_t1Group
|
theorem
|
Topology
|
[
"Mathlib.Topology.Algebra.MulAction",
"Mathlib.Topology.Maps.Proper.Basic",
"Mathlib.Topology.Maps.OpenQuotient"
] |
Mathlib/Topology/Algebra/ProperAction/Basic.lean
|
t2Space_of_properSMul_of_t1Group
|
If a T1 group acts properly on a topological space, then this topological space is T2.
|
@[to_additive /-- If two groups `H` and `G` act on a topological space `X` such that `G` acts
properly and there exists a group homomorphism `H → G` which is a closed embedding compatible with
the actions, then `H` also acts properly on `X`. -/]
properSMul_of_isClosedEmbedding {H : Type*} [Group H] [MulAction H X] [TopologicalSpace H]
[ProperSMul G X] (f : H →* G) (f_clemb : IsClosedEmbedding f)
(f_compat : ∀ (h : H) (x : X), f h • x = h • x) : ProperSMul H X where
isProperMap_smul_pair := by
have h : IsProperMap (Prod.map f (fun x : X ↦ x)) := f_clemb.isProperMap.prodMap isProperMap_id
have : (fun hx : H × X ↦ (hx.1 • hx.2, hx.2)) = (fun hx ↦ (f hx.1 • hx.2, hx.2)) := by
simp [f_compat]
rw [this]
exact h.comp <| ProperSMul.isProperMap_smul_pair
|
theorem
|
Topology
|
[
"Mathlib.Topology.Algebra.MulAction",
"Mathlib.Topology.Maps.Proper.Basic",
"Mathlib.Topology.Maps.OpenQuotient"
] |
Mathlib/Topology/Algebra/ProperAction/Basic.lean
|
properSMul_of_isClosedEmbedding
|
If two groups `H` and `G` act on a topological space `X` such that `G` acts properly and
there exists a group homomorphism `H → G` which is a closed embedding compatible with the actions,
then `H` also acts properly on `X`.
|
properlyDiscontinuousSMul_iff_properSMul [T2Space X] [DiscreteTopology G]
[ContinuousConstSMul G X] [CompactlyGeneratedSpace (X × X)] :
ProperlyDiscontinuousSMul G X ↔ ProperSMul G X := by
constructor
· intro h
rw [properSMul_iff]
refine isProperMap_iff_isCompact_preimage.2
⟨(continuous_prod_of_discrete_left.2 continuous_const_smul).prodMk (by fun_prop),
fun K hK ↦ ?_⟩
let K' := fst '' K ∪ snd '' K
have hK' : IsCompact K' := (hK.image continuous_fst).union (hK.image continuous_snd)
let E := {g : G | Set.Nonempty ((g • ·) '' K' ∩ K')}
have fin : Set.Finite E := by
simp_rw [E, nonempty_iff_ne_empty]
exact h.finite_disjoint_inter_image hK' hK'
have : (fun gx : G × X ↦ (gx.1 • gx.2, gx.2)) ⁻¹' (K' ×ˢ K') =
⋃ g ∈ E, {g} ×ˢ ((g⁻¹ • ·) '' K' ∩ K') := by
ext gx
simp only [mem_preimage, mem_prod, nonempty_def, mem_inter_iff, mem_image,
exists_exists_and_eq_and, mem_setOf_eq, singleton_prod, iUnion_exists, biUnion_and',
mem_iUnion, exists_prop, E]
constructor
· exact fun ⟨gx_mem, x_mem⟩ ↦ ⟨gx.2, x_mem, gx.1, gx_mem,
⟨gx.2, ⟨⟨gx.1 • gx.2, gx_mem, by simp⟩, x_mem⟩, rfl⟩⟩
· rintro ⟨x, -, g, -, ⟨-, ⟨⟨x', x'_mem, rfl⟩, ginvx'_mem⟩, rfl⟩⟩
exact ⟨by simpa, by simpa⟩
have : IsCompact ((fun gx : G × X ↦ (gx.1 • gx.2, gx.2)) ⁻¹' (K' ×ˢ K')) :=
this ▸ fin.isCompact_biUnion fun g hg ↦
isCompact_singleton.prod <| (hK'.image <| continuous_const_smul _).inter hK'
exact this.of_isClosed_subset (hK.isClosed.preimage <|
(continuous_prod_of_discrete_left.2 continuous_const_smul).prodMk (by fun_prop)) <|
preimage_mono fun x hx ↦ ⟨Or.inl ⟨x, hx, rfl⟩, Or.inr ⟨x, hx, rfl⟩⟩
· intro h; constructor
intro K L hK hL
simp_rw [← nonempty_iff_ne_empty]
apply IsCompact.finite_of_discrete
have : IsProperMap (fun gx : G × X ↦ (gx.1⁻¹ • gx.2, gx.2)) :=
(IsProperMap.prodMap (Homeomorph.isProperMap (Homeomorph.inv G)) isProperMap_id).comp <|
ProperSMul.isProperMap_smul_pair
have eq : {g | Set.Nonempty ((g • ·) '' K ∩ L)} =
fst '' ((fun gx : G × X ↦ (gx.1⁻¹ • gx.2, gx.2)) ⁻¹' (K ×ˢ L)) := by
simp_rw [nonempty_def]
ext g; constructor
· exact fun ⟨_, ⟨x, x_mem, rfl⟩, hx⟩ ↦ ⟨(g, g • x), ⟨by simpa, hx⟩, rfl⟩
· rintro ⟨gx, hgx, rfl⟩
exact ⟨gx.2, ⟨gx.1⁻¹ • gx.2, hgx.1, by simp⟩, hgx.2⟩
exact eq ▸ IsCompact.image (this.isCompact_preimage <| hK.prod hL) continuous_fst
|
theorem
|
Topology
|
[
"Mathlib.Topology.Algebra.ProperAction.Basic",
"Mathlib.Topology.Maps.Proper.CompactlyGenerated"
] |
Mathlib/Topology/Algebra/ProperAction/ProperlyDiscontinuous.lean
|
properlyDiscontinuousSMul_iff_properSMul
|
If a discrete group acts on a T2 space `X` such that `X × X` is compactly
generated, and if the action is continuous in the second variable, then the action is properly
discontinuous if and only if it is proper. This is in particular true if `X` is first-countable or
weakly locally compact.
There was an older version of this theorem which was changed to this one to make use
of the `CompactlyGeneratedSpace` typeclass. (since 2024-11-10)
|
RestrictedProduct (𝓕 : Filter ι) : Type _ := {x : Π i, R i // ∀ᶠ i in 𝓕, x i ∈ A i}
open Batteries.ExtendedBinder
|
def
|
Topology
|
[
"Mathlib.Algebra.Ring.Pi",
"Mathlib.Algebra.Ring.Subring.Defs",
"Mathlib.GroupTheory.GroupAction.SubMulAction",
"Mathlib.Order.Filter.Cofinite -- for `Πʳ i, [R i, A i]` notation, confuses shake",
"Mathlib.Algebra.Module.Pi"
] |
Mathlib/Topology/Algebra/RestrictedProduct/Basic.lean
|
RestrictedProduct
|
The **restricted product** of a family `R : ι → Type*` of types, relative to subsets
`A : (i : ι) → Set (R i)` and the filter `𝓕 : Filter ι`, is the set of all `x : Π i, R i`
such that the set `{j | x j ∈ A j}` belongs to `𝓕`. We denote it by `Πʳ i, [R i, A i]_[𝓕]`.
The most common use case is with `𝓕 = cofinite`, in which case the restricted product is the set
of all `x : Π i, R i` such that `x j ∈ A j` for all but finitely many `j`. We denote it simply
by `Πʳ i, [R i, A i]`.
Similarly, if `S` is a principal filter, the restricted product `Πʳ i, [R i, A i]_[𝓟 s]`
is the set of all `x : Π i, R i` such that `∀ j ∈ S, x j ∈ A j`.
|
mk (x : Π i, R i) (hx : ∀ᶠ i in 𝓕, x i ∈ A i) : Πʳ i, [R i, A i]_[𝓕] :=
⟨x, hx⟩
@[simp]
|
abbrev
|
Topology
|
[
"Mathlib.Algebra.Ring.Pi",
"Mathlib.Algebra.Ring.Subring.Defs",
"Mathlib.GroupTheory.GroupAction.SubMulAction",
"Mathlib.Order.Filter.Cofinite -- for `Πʳ i, [R i, A i]` notation, confuses shake",
"Mathlib.Algebra.Module.Pi"
] |
Mathlib/Topology/Algebra/RestrictedProduct/Basic.lean
|
mk
|
`Πʳ i, [R i, A i]_[𝓕]` is `RestrictedProduct R A 𝓕`. -/
scoped[RestrictedProduct]
notation3 "Πʳ "(...)", ""["r:(scoped R => R)", "a:(scoped A => A)"]_[" f "]" =>
RestrictedProduct r a f
/-- `Πʳ i, [R i, A i]` is `RestrictedProduct R A cofinite`. -/
scoped[RestrictedProduct]
notation3"Πʳ "(...)", ""["r:(scoped R => R)", "a:(scoped A => A)"]" =>
RestrictedProduct r a cofinite
namespace RestrictedProduct
open scoped RestrictedProduct
variable {𝓕 𝓖 : Filter ι}
instance : DFunLike (Πʳ i, [R i, A i]_[𝓕]) ι R where
coe x i := x.1 i
coe_injective' _ _ := Subtype.ext
variable {R A} in
/-- Constructor for `RestrictedProduct`.
|
mk_apply (x : Π i, R i) (hx : ∀ᶠ i in 𝓕, x i ∈ A i) (i : ι) :
(mk x hx) i = x i := rfl
@[ext]
|
lemma
|
Topology
|
[
"Mathlib.Algebra.Ring.Pi",
"Mathlib.Algebra.Ring.Subring.Defs",
"Mathlib.GroupTheory.GroupAction.SubMulAction",
"Mathlib.Order.Filter.Cofinite -- for `Πʳ i, [R i, A i]` notation, confuses shake",
"Mathlib.Algebra.Module.Pi"
] |
Mathlib/Topology/Algebra/RestrictedProduct/Basic.lean
|
mk_apply
| null |
ext {x y : Πʳ i, [R i, A i]_[𝓕]} (h : ∀ i, x i = y i) : x = y :=
Subtype.ext <| funext h
|
lemma
|
Topology
|
[
"Mathlib.Algebra.Ring.Pi",
"Mathlib.Algebra.Ring.Subring.Defs",
"Mathlib.GroupTheory.GroupAction.SubMulAction",
"Mathlib.Order.Filter.Cofinite -- for `Πʳ i, [R i, A i]` notation, confuses shake",
"Mathlib.Algebra.Module.Pi"
] |
Mathlib/Topology/Algebra/RestrictedProduct/Basic.lean
|
ext
| null |
range_coe :
range ((↑) : Πʳ i, [R i, A i]_[𝓕] → Π i, R i) = {x | ∀ᶠ i in 𝓕, x i ∈ A i} :=
Subtype.range_val_subtype
|
lemma
|
Topology
|
[
"Mathlib.Algebra.Ring.Pi",
"Mathlib.Algebra.Ring.Subring.Defs",
"Mathlib.GroupTheory.GroupAction.SubMulAction",
"Mathlib.Order.Filter.Cofinite -- for `Πʳ i, [R i, A i]` notation, confuses shake",
"Mathlib.Algebra.Module.Pi"
] |
Mathlib/Topology/Algebra/RestrictedProduct/Basic.lean
|
range_coe
| null |
range_coe_principal {S : Set ι} :
range ((↑) : Πʳ i, [R i, A i]_[𝓟 S] → Π i, R i) = S.pi A :=
range_coe R A
@[simp] lemma eventually (x : Πʳ i, [R i, A i]_[𝓕]) : ∀ᶠ i in 𝓕, x i ∈ A i := x.2
variable (𝓕) in
|
lemma
|
Topology
|
[
"Mathlib.Algebra.Ring.Pi",
"Mathlib.Algebra.Ring.Subring.Defs",
"Mathlib.GroupTheory.GroupAction.SubMulAction",
"Mathlib.Order.Filter.Cofinite -- for `Πʳ i, [R i, A i]` notation, confuses shake",
"Mathlib.Algebra.Module.Pi"
] |
Mathlib/Topology/Algebra/RestrictedProduct/Basic.lean
|
range_coe_principal
| null |
structureMap (x : Π i, A i) : Πʳ i, [R i, A i]_[𝓕] :=
⟨fun i ↦ x i, .of_forall fun i ↦ (x i).2⟩
|
def
|
Topology
|
[
"Mathlib.Algebra.Ring.Pi",
"Mathlib.Algebra.Ring.Subring.Defs",
"Mathlib.GroupTheory.GroupAction.SubMulAction",
"Mathlib.Order.Filter.Cofinite -- for `Πʳ i, [R i, A i]` notation, confuses shake",
"Mathlib.Algebra.Module.Pi"
] |
Mathlib/Topology/Algebra/RestrictedProduct/Basic.lean
|
structureMap
|
The *structure map* of the restricted product is the obvious inclusion from `Π i, A i`
into `Πʳ i, [R i, A i]_[𝓕]`.
|
inclusion (h : 𝓕 ≤ 𝓖) (x : Πʳ i, [R i, A i]_[𝓖]) :
Πʳ i, [R i, A i]_[𝓕] :=
⟨x, x.2.filter_mono h⟩
variable (𝓕) in
|
def
|
Topology
|
[
"Mathlib.Algebra.Ring.Pi",
"Mathlib.Algebra.Ring.Subring.Defs",
"Mathlib.GroupTheory.GroupAction.SubMulAction",
"Mathlib.Order.Filter.Cofinite -- for `Πʳ i, [R i, A i]` notation, confuses shake",
"Mathlib.Algebra.Module.Pi"
] |
Mathlib/Topology/Algebra/RestrictedProduct/Basic.lean
|
inclusion
|
If `𝓕 ≤ 𝓖`, the restricted product `Πʳ i, [R i, A i]_[𝓖]` is naturally included in
`Πʳ i, [R i, A i]_[𝓕]`. This is the corresponding map.
|
inclusion_eq_id : inclusion R A (le_refl 𝓕) = id := rfl
|
lemma
|
Topology
|
[
"Mathlib.Algebra.Ring.Pi",
"Mathlib.Algebra.Ring.Subring.Defs",
"Mathlib.GroupTheory.GroupAction.SubMulAction",
"Mathlib.Order.Filter.Cofinite -- for `Πʳ i, [R i, A i]` notation, confuses shake",
"Mathlib.Algebra.Module.Pi"
] |
Mathlib/Topology/Algebra/RestrictedProduct/Basic.lean
|
inclusion_eq_id
| null |
exists_inclusion_eq_of_eventually (h : 𝓕 ≤ 𝓖) {x : Πʳ i, [R i, A i]_[𝓕]}
(hx𝓖 : ∀ᶠ i in 𝓖, x i ∈ A i) :
∃ x' : Πʳ i, [R i, A i]_[𝓖], inclusion R A h x' = x :=
⟨⟨x.1, hx𝓖⟩, rfl⟩
|
lemma
|
Topology
|
[
"Mathlib.Algebra.Ring.Pi",
"Mathlib.Algebra.Ring.Subring.Defs",
"Mathlib.GroupTheory.GroupAction.SubMulAction",
"Mathlib.Order.Filter.Cofinite -- for `Πʳ i, [R i, A i]` notation, confuses shake",
"Mathlib.Algebra.Module.Pi"
] |
Mathlib/Topology/Algebra/RestrictedProduct/Basic.lean
|
exists_inclusion_eq_of_eventually
| null |
exists_structureMap_eq_of_forall {x : Πʳ i, [R i, A i]_[𝓕]}
(hx : ∀ i, x.1 i ∈ A i) :
∃ x' : Π i, A i, structureMap R A 𝓕 x' = x :=
⟨fun i ↦ ⟨x i, hx i⟩, rfl⟩
|
lemma
|
Topology
|
[
"Mathlib.Algebra.Ring.Pi",
"Mathlib.Algebra.Ring.Subring.Defs",
"Mathlib.GroupTheory.GroupAction.SubMulAction",
"Mathlib.Order.Filter.Cofinite -- for `Πʳ i, [R i, A i]` notation, confuses shake",
"Mathlib.Algebra.Module.Pi"
] |
Mathlib/Topology/Algebra/RestrictedProduct/Basic.lean
|
exists_structureMap_eq_of_forall
| null |
range_inclusion (h : 𝓕 ≤ 𝓖) :
Set.range (inclusion R A h) = {x | ∀ᶠ i in 𝓖, x i ∈ A i} :=
subset_antisymm (range_subset_iff.mpr fun x ↦ x.2)
(fun _ hx ↦ mem_range.mpr <| exists_inclusion_eq_of_eventually R A h hx)
|
lemma
|
Topology
|
[
"Mathlib.Algebra.Ring.Pi",
"Mathlib.Algebra.Ring.Subring.Defs",
"Mathlib.GroupTheory.GroupAction.SubMulAction",
"Mathlib.Order.Filter.Cofinite -- for `Πʳ i, [R i, A i]` notation, confuses shake",
"Mathlib.Algebra.Module.Pi"
] |
Mathlib/Topology/Algebra/RestrictedProduct/Basic.lean
|
range_inclusion
| null |
range_structureMap :
Set.range (structureMap R A 𝓕) = {f | ∀ i, f.1 i ∈ A i} :=
subset_antisymm (range_subset_iff.mpr fun x i ↦ (x i).2)
(fun _ hx ↦ mem_range.mpr <| exists_structureMap_eq_of_forall R A hx)
|
lemma
|
Topology
|
[
"Mathlib.Algebra.Ring.Pi",
"Mathlib.Algebra.Ring.Subring.Defs",
"Mathlib.GroupTheory.GroupAction.SubMulAction",
"Mathlib.Order.Filter.Cofinite -- for `Πʳ i, [R i, A i]` notation, confuses shake",
"Mathlib.Algebra.Module.Pi"
] |
Mathlib/Topology/Algebra/RestrictedProduct/Basic.lean
|
range_structureMap
| null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.