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 ⌀ |
|---|---|---|---|---|---|---|
closedBall_iSup {ι : Sort*} {p : ι → Seminorm 𝕜 E} (hp : BddAbove (range p)) (e : E)
{r : ℝ} (hr : 0 < r) : closedBall (⨆ i, p i) e r = ⋂ i, closedBall (p i) e r := by
cases isEmpty_or_nonempty ι
· rw [iSup_of_empty', iInter_of_empty, Seminorm.sSup_empty]
exact closedBall_bot _ hr
· ext x
have := Seminorm.bddAbove_range_iff.mp hp (x - e)
simp only [mem_closedBall, mem_iInter, Seminorm.iSup_apply hp, ciSup_le_iff this] | theorem | Analysis | [
"Mathlib.Algebra.Order.Pi",
"Mathlib.Analysis.Convex.Function",
"Mathlib.Analysis.LocallyConvex.Basic",
"Mathlib.Analysis.Normed.Module.Basic",
"Mathlib.Data.Real.Pointwise"
] | Mathlib/Analysis/Seminorm.lean | closedBall_iSup | null |
ball_norm_mul_subset {p : Seminorm 𝕜 E} {k : 𝕜} {r : ℝ} :
p.ball 0 (‖k‖ * r) ⊆ k • p.ball 0 r := by
rcases eq_or_ne k 0 with (rfl | hk)
· rw [norm_zero, zero_mul, ball_eq_emptyset _ le_rfl]
exact empty_subset _
· intro x
rw [Set.mem_smul_set, Seminorm.mem_ball_zero]
refine fun hx => ⟨k⁻¹ • x, ?_, ?_⟩
· rwa [Seminorm.mem_ball_zero, map_smul_eq_mul, norm_inv, ←
mul_lt_mul_iff_right₀ <| norm_pos_iff.mpr hk, ← mul_assoc, ← div_eq_mul_inv ‖k‖ ‖k‖,
div_self (ne_of_gt <| norm_pos_iff.mpr hk), one_mul]
rw [← smul_assoc, smul_eq_mul, ← div_eq_mul_inv, div_self hk, one_smul] | theorem | Analysis | [
"Mathlib.Algebra.Order.Pi",
"Mathlib.Analysis.Convex.Function",
"Mathlib.Analysis.LocallyConvex.Basic",
"Mathlib.Analysis.Normed.Module.Basic",
"Mathlib.Data.Real.Pointwise"
] | Mathlib/Analysis/Seminorm.lean | ball_norm_mul_subset | null |
smul_ball_zero {p : Seminorm 𝕜 E} {k : 𝕜} {r : ℝ} (hk : k ≠ 0) :
k • p.ball 0 r = p.ball 0 (‖k‖ * r) := by
ext
rw [mem_smul_set_iff_inv_smul_mem₀ hk, p.mem_ball_zero, p.mem_ball_zero, map_smul_eq_mul,
norm_inv, ← div_eq_inv_mul, div_lt_iff₀ (norm_pos_iff.2 hk), mul_comm] | theorem | Analysis | [
"Mathlib.Algebra.Order.Pi",
"Mathlib.Analysis.Convex.Function",
"Mathlib.Analysis.LocallyConvex.Basic",
"Mathlib.Analysis.Normed.Module.Basic",
"Mathlib.Data.Real.Pointwise"
] | Mathlib/Analysis/Seminorm.lean | smul_ball_zero | null |
smul_closedBall_subset {p : Seminorm 𝕜 E} {k : 𝕜} {r : ℝ} :
k • p.closedBall 0 r ⊆ p.closedBall 0 (‖k‖ * r) := by
rintro x ⟨y, hy, h⟩
rw [Seminorm.mem_closedBall_zero, ← h, map_smul_eq_mul]
rw [Seminorm.mem_closedBall_zero] at hy
gcongr | theorem | Analysis | [
"Mathlib.Algebra.Order.Pi",
"Mathlib.Analysis.Convex.Function",
"Mathlib.Analysis.LocallyConvex.Basic",
"Mathlib.Analysis.Normed.Module.Basic",
"Mathlib.Data.Real.Pointwise"
] | Mathlib/Analysis/Seminorm.lean | smul_closedBall_subset | null |
smul_closedBall_zero {p : Seminorm 𝕜 E} {k : 𝕜} {r : ℝ} (hk : 0 < ‖k‖) :
k • p.closedBall 0 r = p.closedBall 0 (‖k‖ * r) := by
refine subset_antisymm smul_closedBall_subset ?_
intro x
rw [Set.mem_smul_set, Seminorm.mem_closedBall_zero]
refine fun hx => ⟨k⁻¹ • x, ?_, ?_⟩
· rwa [Seminorm.mem_closedBall_zero, map_smul_eq_mul, norm_inv, inv_mul_le_iff₀ hk]
rw [← smul_assoc, smul_eq_mul, ← div_eq_mul_inv, div_self (norm_pos_iff.mp hk), one_smul] | theorem | Analysis | [
"Mathlib.Algebra.Order.Pi",
"Mathlib.Analysis.Convex.Function",
"Mathlib.Analysis.LocallyConvex.Basic",
"Mathlib.Analysis.Normed.Module.Basic",
"Mathlib.Data.Real.Pointwise"
] | Mathlib/Analysis/Seminorm.lean | smul_closedBall_zero | null |
ball_zero_absorbs_ball_zero (p : Seminorm 𝕜 E) {r₁ r₂ : ℝ} (hr₁ : 0 < r₁) :
Absorbs 𝕜 (p.ball 0 r₁) (p.ball 0 r₂) := by
rcases exists_pos_lt_mul hr₁ r₂ with ⟨r, hr₀, hr⟩
refine .of_norm ⟨r, fun a ha x hx => ?_⟩
rw [smul_ball_zero (norm_pos_iff.1 <| hr₀.trans_le ha), p.mem_ball_zero]
rw [p.mem_ball_zero] at hx
exact hx.trans (hr.trans_le <| by gcongr) | theorem | Analysis | [
"Mathlib.Algebra.Order.Pi",
"Mathlib.Analysis.Convex.Function",
"Mathlib.Analysis.LocallyConvex.Basic",
"Mathlib.Analysis.Normed.Module.Basic",
"Mathlib.Data.Real.Pointwise"
] | Mathlib/Analysis/Seminorm.lean | ball_zero_absorbs_ball_zero | null |
protected absorbent_ball_zero (hr : 0 < r) : Absorbent 𝕜 (ball p (0 : E) r) :=
absorbent_iff_forall_absorbs_singleton.2 fun _ =>
(p.ball_zero_absorbs_ball_zero hr).mono_right <|
singleton_subset_iff.2 <| p.mem_ball_zero.2 <| lt_add_one _ | theorem | Analysis | [
"Mathlib.Algebra.Order.Pi",
"Mathlib.Analysis.Convex.Function",
"Mathlib.Analysis.LocallyConvex.Basic",
"Mathlib.Analysis.Normed.Module.Basic",
"Mathlib.Data.Real.Pointwise"
] | Mathlib/Analysis/Seminorm.lean | absorbent_ball_zero | Seminorm-balls at the origin are absorbent. |
protected absorbent_closedBall_zero (hr : 0 < r) : Absorbent 𝕜 (closedBall p (0 : E) r) :=
(p.absorbent_ball_zero hr).mono (p.ball_subset_closedBall _ _) | theorem | Analysis | [
"Mathlib.Algebra.Order.Pi",
"Mathlib.Analysis.Convex.Function",
"Mathlib.Analysis.LocallyConvex.Basic",
"Mathlib.Analysis.Normed.Module.Basic",
"Mathlib.Data.Real.Pointwise"
] | Mathlib/Analysis/Seminorm.lean | absorbent_closedBall_zero | Closed seminorm-balls at the origin are absorbent. |
protected absorbent_ball (hpr : p x < r) : Absorbent 𝕜 (ball p x r) := by
refine (p.absorbent_ball_zero <| sub_pos.2 hpr).mono fun y hy => ?_
rw [p.mem_ball_zero] at hy
exact p.mem_ball.2 ((map_sub_le_add p _ _).trans_lt <| add_lt_of_lt_sub_right hy) | theorem | Analysis | [
"Mathlib.Algebra.Order.Pi",
"Mathlib.Analysis.Convex.Function",
"Mathlib.Analysis.LocallyConvex.Basic",
"Mathlib.Analysis.Normed.Module.Basic",
"Mathlib.Data.Real.Pointwise"
] | Mathlib/Analysis/Seminorm.lean | absorbent_ball | Seminorm-balls containing the origin are absorbent. |
protected absorbent_closedBall (hpr : p x < r) : Absorbent 𝕜 (closedBall p x r) := by
refine (p.absorbent_closedBall_zero <| sub_pos.2 hpr).mono fun y hy => ?_
rw [p.mem_closedBall_zero] at hy
exact p.mem_closedBall.2 ((map_sub_le_add p _ _).trans <| add_le_of_le_sub_right hy)
@[simp] | theorem | Analysis | [
"Mathlib.Algebra.Order.Pi",
"Mathlib.Analysis.Convex.Function",
"Mathlib.Analysis.LocallyConvex.Basic",
"Mathlib.Analysis.Normed.Module.Basic",
"Mathlib.Data.Real.Pointwise"
] | Mathlib/Analysis/Seminorm.lean | absorbent_closedBall | Seminorm-balls containing the origin are absorbent. |
smul_ball_preimage (p : Seminorm 𝕜 E) (y : E) (r : ℝ) (a : 𝕜) (ha : a ≠ 0) :
(a • ·) ⁻¹' p.ball y r = p.ball (a⁻¹ • y) (r / ‖a‖) :=
Set.ext fun _ => by
rw [mem_preimage, mem_ball, mem_ball, lt_div_iff₀ (norm_pos_iff.mpr ha), mul_comm, ←
map_smul_eq_mul p, smul_sub, smul_inv_smul₀ ha]
@[simp] | theorem | Analysis | [
"Mathlib.Algebra.Order.Pi",
"Mathlib.Analysis.Convex.Function",
"Mathlib.Analysis.LocallyConvex.Basic",
"Mathlib.Analysis.Normed.Module.Basic",
"Mathlib.Data.Real.Pointwise"
] | Mathlib/Analysis/Seminorm.lean | smul_ball_preimage | null |
smul_closedBall_preimage (p : Seminorm 𝕜 E) (y : E) (r : ℝ) (a : 𝕜) (ha : a ≠ 0) :
(a • ·) ⁻¹' p.closedBall y r = p.closedBall (a⁻¹ • y) (r / ‖a‖) :=
Set.ext fun _ => by
rw [mem_preimage, mem_closedBall, mem_closedBall, le_div_iff₀ (norm_pos_iff.mpr ha), mul_comm, ←
map_smul_eq_mul p, smul_sub, smul_inv_smul₀ ha] | theorem | Analysis | [
"Mathlib.Algebra.Order.Pi",
"Mathlib.Analysis.Convex.Function",
"Mathlib.Analysis.LocallyConvex.Basic",
"Mathlib.Analysis.Normed.Module.Basic",
"Mathlib.Data.Real.Pointwise"
] | Mathlib/Analysis/Seminorm.lean | smul_closedBall_preimage | null |
protected convexOn : ConvexOn ℝ univ p := by
refine ⟨convex_univ, fun x _ y _ a b ha hb _ => ?_⟩
calc
p (a • x + b • y) ≤ p (a • x) + p (b • y) := map_add_le_add p _ _
_ = ‖a • (1 : 𝕜)‖ * p x + ‖b • (1 : 𝕜)‖ * p y := by
rw [← map_smul_eq_mul p, ← map_smul_eq_mul p, smul_one_smul, smul_one_smul]
_ = a * p x + b * p y := by
rw [norm_smul, norm_smul, norm_one, mul_one, mul_one, Real.norm_of_nonneg ha,
Real.norm_of_nonneg hb] | theorem | Analysis | [
"Mathlib.Algebra.Order.Pi",
"Mathlib.Analysis.Convex.Function",
"Mathlib.Analysis.LocallyConvex.Basic",
"Mathlib.Analysis.Normed.Module.Basic",
"Mathlib.Data.Real.Pointwise"
] | Mathlib/Analysis/Seminorm.lean | convexOn | A seminorm is convex. Also see `convexOn_norm`. |
convex_ball : Convex ℝ (ball p x r) := by
convert (p.convexOn.translate_left (-x)).convex_lt r
ext y
rw [preimage_univ, sep_univ, p.mem_ball, sub_eq_add_neg]
rfl | theorem | Analysis | [
"Mathlib.Algebra.Order.Pi",
"Mathlib.Analysis.Convex.Function",
"Mathlib.Analysis.LocallyConvex.Basic",
"Mathlib.Analysis.Normed.Module.Basic",
"Mathlib.Data.Real.Pointwise"
] | Mathlib/Analysis/Seminorm.lean | convex_ball | Seminorm-balls are convex. |
convex_closedBall : Convex ℝ (closedBall p x r) := by
rw [closedBall_eq_biInter_ball]
exact convex_iInter₂ fun _ _ => convex_ball _ _ _ | theorem | Analysis | [
"Mathlib.Algebra.Order.Pi",
"Mathlib.Analysis.Convex.Function",
"Mathlib.Analysis.LocallyConvex.Basic",
"Mathlib.Analysis.Normed.Module.Basic",
"Mathlib.Data.Real.Pointwise"
] | Mathlib/Analysis/Seminorm.lean | convex_closedBall | Closed seminorm-balls are convex. |
protected restrictScalars (p : Seminorm 𝕜' E) : Seminorm 𝕜 E :=
{ p with
smul' := fun a x => by rw [← smul_one_smul 𝕜' a x, p.smul', norm_smul, norm_one, mul_one] }
@[simp] | def | Analysis | [
"Mathlib.Algebra.Order.Pi",
"Mathlib.Analysis.Convex.Function",
"Mathlib.Analysis.LocallyConvex.Basic",
"Mathlib.Analysis.Normed.Module.Basic",
"Mathlib.Data.Real.Pointwise"
] | Mathlib/Analysis/Seminorm.lean | restrictScalars | Reinterpret a seminorm over a field `𝕜'` as a seminorm over a smaller field `𝕜`. This will
typically be used with `RCLike 𝕜'` and `𝕜 = ℝ`. |
coe_restrictScalars (p : Seminorm 𝕜' E) : (p.restrictScalars 𝕜 : E → ℝ) = p :=
rfl
@[simp] | theorem | Analysis | [
"Mathlib.Algebra.Order.Pi",
"Mathlib.Analysis.Convex.Function",
"Mathlib.Analysis.LocallyConvex.Basic",
"Mathlib.Analysis.Normed.Module.Basic",
"Mathlib.Data.Real.Pointwise"
] | Mathlib/Analysis/Seminorm.lean | coe_restrictScalars | null |
restrictScalars_ball (p : Seminorm 𝕜' E) : (p.restrictScalars 𝕜).ball = p.ball :=
rfl
@[simp] | theorem | Analysis | [
"Mathlib.Algebra.Order.Pi",
"Mathlib.Analysis.Convex.Function",
"Mathlib.Analysis.LocallyConvex.Basic",
"Mathlib.Analysis.Normed.Module.Basic",
"Mathlib.Data.Real.Pointwise"
] | Mathlib/Analysis/Seminorm.lean | restrictScalars_ball | null |
restrictScalars_closedBall (p : Seminorm 𝕜' E) :
(p.restrictScalars 𝕜).closedBall = p.closedBall :=
rfl | theorem | Analysis | [
"Mathlib.Algebra.Order.Pi",
"Mathlib.Analysis.Convex.Function",
"Mathlib.Analysis.LocallyConvex.Basic",
"Mathlib.Analysis.Normed.Module.Basic",
"Mathlib.Data.Real.Pointwise"
] | Mathlib/Analysis/Seminorm.lean | restrictScalars_closedBall | null |
continuousAt_zero_of_forall' [TopologicalSpace E] {p : Seminorm 𝕝 E}
(hp : ∀ r > 0, p.closedBall 0 r ∈ (𝓝 0 : Filter E)) :
ContinuousAt p 0 := by
simp_rw [Seminorm.closedBall_zero_eq_preimage_closedBall] at hp
rwa [ContinuousAt, Metric.nhds_basis_closedBall.tendsto_right_iff, map_zero] | theorem | Analysis | [
"Mathlib.Algebra.Order.Pi",
"Mathlib.Analysis.Convex.Function",
"Mathlib.Analysis.LocallyConvex.Basic",
"Mathlib.Analysis.Normed.Module.Basic",
"Mathlib.Data.Real.Pointwise"
] | Mathlib/Analysis/Seminorm.lean | continuousAt_zero_of_forall' | A seminorm is continuous at `0` if `p.closedBall 0 r ∈ 𝓝 0` for *all* `r > 0`.
Over a `NontriviallyNormedField` it is actually enough to check that this is true
for *some* `r`, see `Seminorm.continuousAt_zero'`. |
continuousAt_zero' [TopologicalSpace E] [ContinuousConstSMul 𝕜 E] {p : Seminorm 𝕜 E}
{r : ℝ} (hp : p.closedBall 0 r ∈ (𝓝 0 : Filter E)) : ContinuousAt p 0 := by
refine continuousAt_zero_of_forall' fun ε hε ↦ ?_
obtain ⟨k, hk₀, hk⟩ : ∃ k : 𝕜, 0 < ‖k‖ ∧ ‖k‖ * r < ε := by
rcases le_or_gt r 0 with hr | hr
· use 1; simpa using hr.trans_lt hε
· simpa [lt_div_iff₀ hr] using exists_norm_lt 𝕜 (div_pos hε hr)
rw [← set_smul_mem_nhds_zero_iff (norm_pos_iff.1 hk₀), smul_closedBall_zero hk₀] at hp
exact mem_of_superset hp <| p.closedBall_mono hk.le | theorem | Analysis | [
"Mathlib.Algebra.Order.Pi",
"Mathlib.Analysis.Convex.Function",
"Mathlib.Analysis.LocallyConvex.Basic",
"Mathlib.Analysis.Normed.Module.Basic",
"Mathlib.Data.Real.Pointwise"
] | Mathlib/Analysis/Seminorm.lean | continuousAt_zero' | null |
continuousAt_zero_of_forall [TopologicalSpace E] {p : Seminorm 𝕝 E}
(hp : ∀ r > 0, p.ball 0 r ∈ (𝓝 0 : Filter E)) :
ContinuousAt p 0 :=
continuousAt_zero_of_forall'
(fun r hr ↦ Filter.mem_of_superset (hp r hr) <| p.ball_subset_closedBall _ _) | theorem | Analysis | [
"Mathlib.Algebra.Order.Pi",
"Mathlib.Analysis.Convex.Function",
"Mathlib.Analysis.LocallyConvex.Basic",
"Mathlib.Analysis.Normed.Module.Basic",
"Mathlib.Data.Real.Pointwise"
] | Mathlib/Analysis/Seminorm.lean | continuousAt_zero_of_forall | A seminorm is continuous at `0` if `p.ball 0 r ∈ 𝓝 0` for *all* `r > 0`.
Over a `NontriviallyNormedField` it is actually enough to check that this is true
for *some* `r`, see `Seminorm.continuousAt_zero'`. |
continuousAt_zero [TopologicalSpace E] [ContinuousConstSMul 𝕜 E] {p : Seminorm 𝕜 E} {r : ℝ}
(hp : p.ball 0 r ∈ (𝓝 0 : Filter E)) : ContinuousAt p 0 :=
continuousAt_zero' (Filter.mem_of_superset hp <| p.ball_subset_closedBall _ _) | theorem | Analysis | [
"Mathlib.Algebra.Order.Pi",
"Mathlib.Analysis.Convex.Function",
"Mathlib.Analysis.LocallyConvex.Basic",
"Mathlib.Analysis.Normed.Module.Basic",
"Mathlib.Data.Real.Pointwise"
] | Mathlib/Analysis/Seminorm.lean | continuousAt_zero | null |
protected uniformContinuous_of_continuousAt_zero [UniformSpace E] [IsUniformAddGroup E]
{p : Seminorm 𝕝 E} (hp : ContinuousAt p 0) : UniformContinuous p := by
have hp : Filter.Tendsto p (𝓝 0) (𝓝 0) := map_zero p ▸ hp
rw [UniformContinuous, uniformity_eq_comap_nhds_zero_swapped,
Metric.uniformity_eq_comap_nhds_zero, Filter.tendsto_comap_iff]
exact
tendsto_of_tendsto_of_tendsto_of_le_of_le tendsto_const_nhds (hp.comp Filter.tendsto_comap)
(fun xy => dist_nonneg) fun xy => p.norm_sub_map_le_sub _ _ | theorem | Analysis | [
"Mathlib.Algebra.Order.Pi",
"Mathlib.Analysis.Convex.Function",
"Mathlib.Analysis.LocallyConvex.Basic",
"Mathlib.Analysis.Normed.Module.Basic",
"Mathlib.Data.Real.Pointwise"
] | Mathlib/Analysis/Seminorm.lean | uniformContinuous_of_continuousAt_zero | null |
protected continuous_of_continuousAt_zero [TopologicalSpace E] [IsTopologicalAddGroup E]
{p : Seminorm 𝕝 E} (hp : ContinuousAt p 0) : Continuous p := by
letI := IsTopologicalAddGroup.toUniformSpace E
haveI : IsUniformAddGroup E := isUniformAddGroup_of_addCommGroup
exact (Seminorm.uniformContinuous_of_continuousAt_zero hp).continuous | theorem | Analysis | [
"Mathlib.Algebra.Order.Pi",
"Mathlib.Analysis.Convex.Function",
"Mathlib.Analysis.LocallyConvex.Basic",
"Mathlib.Analysis.Normed.Module.Basic",
"Mathlib.Data.Real.Pointwise"
] | Mathlib/Analysis/Seminorm.lean | continuous_of_continuousAt_zero | null |
protected uniformContinuous_of_forall [UniformSpace E] [IsUniformAddGroup E]
{p : Seminorm 𝕝 E} (hp : ∀ r > 0, p.ball 0 r ∈ (𝓝 0 : Filter E)) :
UniformContinuous p :=
Seminorm.uniformContinuous_of_continuousAt_zero (continuousAt_zero_of_forall hp) | theorem | Analysis | [
"Mathlib.Algebra.Order.Pi",
"Mathlib.Analysis.Convex.Function",
"Mathlib.Analysis.LocallyConvex.Basic",
"Mathlib.Analysis.Normed.Module.Basic",
"Mathlib.Data.Real.Pointwise"
] | Mathlib/Analysis/Seminorm.lean | uniformContinuous_of_forall | A seminorm is uniformly continuous if `p.ball 0 r ∈ 𝓝 0` for *all* `r > 0`.
Over a `NontriviallyNormedField` it is actually enough to check that this is true
for *some* `r`, see `Seminorm.uniformContinuous`. |
protected uniformContinuous [UniformSpace E] [IsUniformAddGroup E]
[ContinuousConstSMul 𝕜 E] {p : Seminorm 𝕜 E} {r : ℝ} (hp : p.ball 0 r ∈ (𝓝 0 : Filter E)) :
UniformContinuous p :=
Seminorm.uniformContinuous_of_continuousAt_zero (continuousAt_zero hp) | theorem | Analysis | [
"Mathlib.Algebra.Order.Pi",
"Mathlib.Analysis.Convex.Function",
"Mathlib.Analysis.LocallyConvex.Basic",
"Mathlib.Analysis.Normed.Module.Basic",
"Mathlib.Data.Real.Pointwise"
] | Mathlib/Analysis/Seminorm.lean | uniformContinuous | null |
protected uniformContinuous_of_forall' [UniformSpace E] [IsUniformAddGroup E]
{p : Seminorm 𝕝 E} (hp : ∀ r > 0, p.closedBall 0 r ∈ (𝓝 0 : Filter E)) :
UniformContinuous p :=
Seminorm.uniformContinuous_of_continuousAt_zero (continuousAt_zero_of_forall' hp) | theorem | Analysis | [
"Mathlib.Algebra.Order.Pi",
"Mathlib.Analysis.Convex.Function",
"Mathlib.Analysis.LocallyConvex.Basic",
"Mathlib.Analysis.Normed.Module.Basic",
"Mathlib.Data.Real.Pointwise"
] | Mathlib/Analysis/Seminorm.lean | uniformContinuous_of_forall' | A seminorm is uniformly continuous if `p.closedBall 0 r ∈ 𝓝 0` for *all* `r > 0`.
Over a `NontriviallyNormedField` it is actually enough to check that this is true
for *some* `r`, see `Seminorm.uniformContinuous'`. |
protected uniformContinuous' [UniformSpace E] [IsUniformAddGroup E]
[ContinuousConstSMul 𝕜 E] {p : Seminorm 𝕜 E} {r : ℝ}
(hp : p.closedBall 0 r ∈ (𝓝 0 : Filter E)) : UniformContinuous p :=
Seminorm.uniformContinuous_of_continuousAt_zero (continuousAt_zero' hp) | theorem | Analysis | [
"Mathlib.Algebra.Order.Pi",
"Mathlib.Analysis.Convex.Function",
"Mathlib.Analysis.LocallyConvex.Basic",
"Mathlib.Analysis.Normed.Module.Basic",
"Mathlib.Data.Real.Pointwise"
] | Mathlib/Analysis/Seminorm.lean | uniformContinuous' | null |
protected continuous_of_forall [TopologicalSpace E] [IsTopologicalAddGroup E]
{p : Seminorm 𝕝 E} (hp : ∀ r > 0, p.ball 0 r ∈ (𝓝 0 : Filter E)) :
Continuous p :=
Seminorm.continuous_of_continuousAt_zero (continuousAt_zero_of_forall hp) | theorem | Analysis | [
"Mathlib.Algebra.Order.Pi",
"Mathlib.Analysis.Convex.Function",
"Mathlib.Analysis.LocallyConvex.Basic",
"Mathlib.Analysis.Normed.Module.Basic",
"Mathlib.Data.Real.Pointwise"
] | Mathlib/Analysis/Seminorm.lean | continuous_of_forall | A seminorm is continuous if `p.ball 0 r ∈ 𝓝 0` for *all* `r > 0`.
Over a `NontriviallyNormedField` it is actually enough to check that this is true
for *some* `r`, see `Seminorm.continuous`. |
protected continuous [TopologicalSpace E] [IsTopologicalAddGroup E]
[ContinuousConstSMul 𝕜 E] {p : Seminorm 𝕜 E} {r : ℝ} (hp : p.ball 0 r ∈ (𝓝 0 : Filter E)) :
Continuous p :=
Seminorm.continuous_of_continuousAt_zero (continuousAt_zero hp) | theorem | Analysis | [
"Mathlib.Algebra.Order.Pi",
"Mathlib.Analysis.Convex.Function",
"Mathlib.Analysis.LocallyConvex.Basic",
"Mathlib.Analysis.Normed.Module.Basic",
"Mathlib.Data.Real.Pointwise"
] | Mathlib/Analysis/Seminorm.lean | continuous | null |
protected continuous_iff [TopologicalSpace E] [IsTopologicalAddGroup E]
[ContinuousConstSMul 𝕜 E] {p : Seminorm 𝕜 E} {r : ℝ} (hr : 0 < r) :
Continuous p ↔ p.ball 0 r ∈ 𝓝 0 :=
⟨fun H ↦ p.ball_zero_eq ▸ (H.tendsto' 0 0 (map_zero p)).eventually_lt_const hr, p.continuous⟩ | theorem | Analysis | [
"Mathlib.Algebra.Order.Pi",
"Mathlib.Analysis.Convex.Function",
"Mathlib.Analysis.LocallyConvex.Basic",
"Mathlib.Analysis.Normed.Module.Basic",
"Mathlib.Data.Real.Pointwise"
] | Mathlib/Analysis/Seminorm.lean | continuous_iff | null |
protected continuous_of_forall' [TopologicalSpace E] [IsTopologicalAddGroup E]
{p : Seminorm 𝕝 E} (hp : ∀ r > 0, p.closedBall 0 r ∈ (𝓝 0 : Filter E)) :
Continuous p :=
Seminorm.continuous_of_continuousAt_zero (continuousAt_zero_of_forall' hp) | theorem | Analysis | [
"Mathlib.Algebra.Order.Pi",
"Mathlib.Analysis.Convex.Function",
"Mathlib.Analysis.LocallyConvex.Basic",
"Mathlib.Analysis.Normed.Module.Basic",
"Mathlib.Data.Real.Pointwise"
] | Mathlib/Analysis/Seminorm.lean | continuous_of_forall' | A seminorm is continuous if `p.closedBall 0 r ∈ 𝓝 0` for *all* `r > 0`.
Over a `NontriviallyNormedField` it is actually enough to check that this is true
for *some* `r`, see `Seminorm.continuous'`. |
protected continuous' [TopologicalSpace E] [IsTopologicalAddGroup E]
[ContinuousConstSMul 𝕜 E] {p : Seminorm 𝕜 E} {r : ℝ}
(hp : p.closedBall 0 r ∈ (𝓝 0 : Filter E)) : Continuous p :=
Seminorm.continuous_of_continuousAt_zero (continuousAt_zero' hp) | theorem | Analysis | [
"Mathlib.Algebra.Order.Pi",
"Mathlib.Analysis.Convex.Function",
"Mathlib.Analysis.LocallyConvex.Basic",
"Mathlib.Analysis.Normed.Module.Basic",
"Mathlib.Data.Real.Pointwise"
] | Mathlib/Analysis/Seminorm.lean | continuous' | null |
continuous_of_le [TopologicalSpace E] [IsTopologicalAddGroup E]
{p q : Seminorm 𝕝 E} (hq : Continuous q) (hpq : p ≤ q) : Continuous p := by
refine Seminorm.continuous_of_forall (fun r hr ↦ Filter.mem_of_superset
(IsOpen.mem_nhds ?_ <| q.mem_ball_self hr) (ball_antitone hpq))
rw [ball_zero_eq]
exact isOpen_lt hq continuous_const | theorem | Analysis | [
"Mathlib.Algebra.Order.Pi",
"Mathlib.Analysis.Convex.Function",
"Mathlib.Analysis.LocallyConvex.Basic",
"Mathlib.Analysis.Normed.Module.Basic",
"Mathlib.Data.Real.Pointwise"
] | Mathlib/Analysis/Seminorm.lean | continuous_of_le | null |
ball_mem_nhds [TopologicalSpace E] {p : Seminorm 𝕝 E} (hp : Continuous p) {r : ℝ}
(hr : 0 < r) : p.ball 0 r ∈ (𝓝 0 : Filter E) :=
have this : Tendsto p (𝓝 0) (𝓝 0) := map_zero p ▸ hp.tendsto 0
by simpa only [p.ball_zero_eq] using this (Iio_mem_nhds hr) | lemma | Analysis | [
"Mathlib.Algebra.Order.Pi",
"Mathlib.Analysis.Convex.Function",
"Mathlib.Analysis.LocallyConvex.Basic",
"Mathlib.Analysis.Normed.Module.Basic",
"Mathlib.Data.Real.Pointwise"
] | Mathlib/Analysis/Seminorm.lean | ball_mem_nhds | null |
uniformSpace_eq_of_hasBasis
{ι} [UniformSpace E] [IsUniformAddGroup E] [ContinuousConstSMul 𝕜 E]
{p' : ι → Prop} {s : ι → Set E} (p : Seminorm 𝕜 E) (hb : (𝓝 0 : Filter E).HasBasis p' s)
(h₁ : ∃ r, p.closedBall 0 r ∈ 𝓝 0) (h₂ : ∀ i, p' i → ∃ r > 0, p.ball 0 r ⊆ s i) :
‹UniformSpace E› = p.toAddGroupSeminorm.toSeminormedAddGroup.toUniformSpace := by
refine IsUniformAddGroup.ext ‹_›
p.toAddGroupSeminorm.toSeminormedAddCommGroup.to_isUniformAddGroup ?_
apply le_antisymm
· rw [← @comap_norm_nhds_zero E p.toAddGroupSeminorm.toSeminormedAddGroup, ← tendsto_iff_comap]
suffices Continuous p from this.tendsto' 0 _ (map_zero p)
rcases h₁ with ⟨r, hr⟩
exact p.continuous' hr
· rw [(@NormedAddCommGroup.nhds_zero_basis_norm_lt E
p.toAddGroupSeminorm.toSeminormedAddGroup).le_basis_iff hb]
simpa only [subset_def, mem_ball_zero] using h₂ | lemma | Analysis | [
"Mathlib.Algebra.Order.Pi",
"Mathlib.Analysis.Convex.Function",
"Mathlib.Analysis.LocallyConvex.Basic",
"Mathlib.Analysis.Normed.Module.Basic",
"Mathlib.Data.Real.Pointwise"
] | Mathlib/Analysis/Seminorm.lean | uniformSpace_eq_of_hasBasis | null |
uniformity_eq_of_hasBasis
{ι} [UniformSpace E] [IsUniformAddGroup E] [ContinuousConstSMul 𝕜 E]
{p' : ι → Prop} {s : ι → Set E} (p : Seminorm 𝕜 E) (hb : (𝓝 0 : Filter E).HasBasis p' s)
(h₁ : ∃ r, p.closedBall 0 r ∈ 𝓝 0) (h₂ : ∀ i, p' i → ∃ r > 0, p.ball 0 r ⊆ s i) :
𝓤 E = ⨅ r > 0, 𝓟 {x | p (x.1 - x.2) < r} := by
rw [uniformSpace_eq_of_hasBasis p hb h₁ h₂]; rfl | lemma | Analysis | [
"Mathlib.Algebra.Order.Pi",
"Mathlib.Analysis.Convex.Function",
"Mathlib.Analysis.LocallyConvex.Basic",
"Mathlib.Analysis.Normed.Module.Basic",
"Mathlib.Data.Real.Pointwise"
] | Mathlib/Analysis/Seminorm.lean | uniformity_eq_of_hasBasis | null |
rescale_to_shell_zpow (p : Seminorm 𝕜 E) {c : 𝕜} (hc : 1 < ‖c‖) {ε : ℝ}
(εpos : 0 < ε) {x : E} (hx : p x ≠ 0) : ∃ n : ℤ, c^n ≠ 0 ∧
p (c^n • x) < ε ∧ (ε / ‖c‖ ≤ p (c^n • x)) ∧ (‖c^n‖⁻¹ ≤ ε⁻¹ * ‖c‖ * p x) := by
have xεpos : 0 < (p x)/ε := by positivity
rcases exists_mem_Ico_zpow xεpos hc with ⟨n, hn⟩
have cpos : 0 < ‖c‖ := by positivity
have cnpos : 0 < ‖c^(n + 1)‖ := by rw [norm_zpow]; exact xεpos.trans hn.2
refine ⟨-(n + 1), ?_, ?_, ?_, ?_⟩
· show c ^ (-(n + 1)) ≠ 0; exact zpow_ne_zero _ (norm_pos_iff.1 cpos)
· show p ((c ^ (-(n + 1))) • x) < ε
rw [map_smul_eq_mul, zpow_neg, norm_inv, ← div_eq_inv_mul, div_lt_iff₀ cnpos, mul_comm,
norm_zpow]
exact (div_lt_iff₀ εpos).1 (hn.2)
· show ε / ‖c‖ ≤ p (c ^ (-(n + 1)) • x)
rw [zpow_neg, div_le_iff₀ cpos, map_smul_eq_mul, norm_inv, norm_zpow, zpow_add₀ (ne_of_gt cpos),
zpow_one, mul_inv_rev, mul_comm, ← mul_assoc, ← mul_assoc, mul_inv_cancel₀ (ne_of_gt cpos),
one_mul, ← div_eq_inv_mul, le_div_iff₀ (zpow_pos cpos _), mul_comm]
exact (le_div_iff₀ εpos).1 hn.1
· show ‖(c ^ (-(n + 1)))‖⁻¹ ≤ ε⁻¹ * ‖c‖ * p x
have : ε⁻¹ * ‖c‖ * p x = ε⁻¹ * p x * ‖c‖ := by ring
rw [zpow_neg, norm_inv, inv_inv, norm_zpow, zpow_add₀ (ne_of_gt cpos), zpow_one, this,
← div_eq_inv_mul]
exact mul_le_mul_of_nonneg_right hn.1 (norm_nonneg _) | lemma | Analysis | [
"Mathlib.Algebra.Order.Pi",
"Mathlib.Analysis.Convex.Function",
"Mathlib.Analysis.LocallyConvex.Basic",
"Mathlib.Analysis.Normed.Module.Basic",
"Mathlib.Data.Real.Pointwise"
] | Mathlib/Analysis/Seminorm.lean | rescale_to_shell_zpow | Let `p` be a seminorm on a vector space over a `NormedField`.
If there is a scalar `c` with `‖c‖>1`, then any `x` such that `p x ≠ 0` can be
moved by scalar multiplication to any `p`-shell of width `‖c‖`. Also recap information on the
value of `p` on the rescaling element that shows up in applications. |
rescale_to_shell (p : Seminorm 𝕜 E) {c : 𝕜} (hc : 1 < ‖c‖) {ε : ℝ} (εpos : 0 < ε) {x : E}
(hx : p x ≠ 0) :
∃ d : 𝕜, d ≠ 0 ∧ p (d • x) < ε ∧ (ε/‖c‖ ≤ p (d • x)) ∧ (‖d‖⁻¹ ≤ ε⁻¹ * ‖c‖ * p x) :=
let ⟨_, hn⟩ := p.rescale_to_shell_zpow hc εpos hx; ⟨_, hn⟩ | lemma | Analysis | [
"Mathlib.Algebra.Order.Pi",
"Mathlib.Analysis.Convex.Function",
"Mathlib.Analysis.LocallyConvex.Basic",
"Mathlib.Analysis.Normed.Module.Basic",
"Mathlib.Data.Real.Pointwise"
] | Mathlib/Analysis/Seminorm.lean | rescale_to_shell | Let `p` be a seminorm on a vector space over a `NormedField`.
If there is a scalar `c` with `‖c‖>1`, then any `x` such that `p x ≠ 0` can be
moved by scalar multiplication to any `p`-shell of width `‖c‖`. Also recap information on the
value of `p` on the rescaling element that shows up in applications. |
bound_of_shell
(p q : Seminorm 𝕜 E) {ε C : ℝ} (ε_pos : 0 < ε) {c : 𝕜} (hc : 1 < ‖c‖)
(hf : ∀ x, ε / ‖c‖ ≤ p x → p x < ε → q x ≤ C * p x) {x : E} (hx : p x ≠ 0) :
q x ≤ C * p x := by
rcases p.rescale_to_shell hc ε_pos hx with ⟨δ, hδ, δxle, leδx, -⟩
simpa only [map_smul_eq_mul, mul_left_comm C, mul_le_mul_iff_right₀ (norm_pos_iff.2 hδ)]
using hf (δ • x) leδx δxle | lemma | Analysis | [
"Mathlib.Algebra.Order.Pi",
"Mathlib.Analysis.Convex.Function",
"Mathlib.Analysis.LocallyConvex.Basic",
"Mathlib.Analysis.Normed.Module.Basic",
"Mathlib.Data.Real.Pointwise"
] | Mathlib/Analysis/Seminorm.lean | bound_of_shell | Let `p` and `q` be two seminorms on a vector space over a `NontriviallyNormedField`.
If we have `q x ≤ C * p x` on some shell of the form `{x | ε/‖c‖ ≤ p x < ε}` (where `ε > 0`
and `‖c‖ > 1`), then we also have `q x ≤ C * p x` for all `x` such that `p x ≠ 0`. |
bound_of_shell_smul
(p q : Seminorm 𝕜 E) {ε : ℝ} {C : ℝ≥0} (ε_pos : 0 < ε) {c : 𝕜} (hc : 1 < ‖c‖)
(hf : ∀ x, ε / ‖c‖ ≤ p x → p x < ε → q x ≤ (C • p) x) {x : E} (hx : p x ≠ 0) :
q x ≤ (C • p) x :=
Seminorm.bound_of_shell p q ε_pos hc hf hx | lemma | Analysis | [
"Mathlib.Algebra.Order.Pi",
"Mathlib.Analysis.Convex.Function",
"Mathlib.Analysis.LocallyConvex.Basic",
"Mathlib.Analysis.Normed.Module.Basic",
"Mathlib.Data.Real.Pointwise"
] | Mathlib/Analysis/Seminorm.lean | bound_of_shell_smul | A version of `Seminorm.bound_of_shell` expressed using pointwise scalar multiplication of
seminorms. |
bound_of_shell_sup (p : ι → Seminorm 𝕜 E) (s : Finset ι)
(q : Seminorm 𝕜 E) {ε : ℝ} {C : ℝ≥0} (ε_pos : 0 < ε) {c : 𝕜} (hc : 1 < ‖c‖)
(hf : ∀ x, (∀ i ∈ s, p i x < ε) → ∀ j ∈ s, ε / ‖c‖ ≤ p j x → q x ≤ (C • p j) x)
{x : E} (hx : ∃ j, j ∈ s ∧ p j x ≠ 0) :
q x ≤ (C • s.sup p) x := by
rcases hx with ⟨j, hj, hjx⟩
have : (s.sup p) x ≠ 0 :=
ne_of_gt ((hjx.symm.lt_of_le <| apply_nonneg _ _).trans_le (le_finset_sup_apply hj))
refine (s.sup p).bound_of_shell_smul q ε_pos hc (fun y hle hlt ↦ ?_) this
rcases exists_apply_eq_finset_sup p ⟨j, hj⟩ y with ⟨i, hi, hiy⟩
rw [smul_apply, hiy]
exact hf y (fun k hk ↦ (le_finset_sup_apply hk).trans_lt hlt) i hi (hiy ▸ hle) | lemma | Analysis | [
"Mathlib.Algebra.Order.Pi",
"Mathlib.Analysis.Convex.Function",
"Mathlib.Analysis.LocallyConvex.Basic",
"Mathlib.Analysis.Normed.Module.Basic",
"Mathlib.Data.Real.Pointwise"
] | Mathlib/Analysis/Seminorm.lean | bound_of_shell_sup | null |
bddAbove_of_absorbent {ι : Sort*} {p : ι → Seminorm 𝕜 E} {s : Set E} (hs : Absorbent 𝕜 s)
(h : ∀ x ∈ s, BddAbove (range (p · x))) : BddAbove (range p) := by
rw [Seminorm.bddAbove_range_iff]
intro x
obtain ⟨c, hc₀, hc⟩ : ∃ c ≠ 0, (c : 𝕜) • x ∈ s :=
(eventually_mem_nhdsWithin.and (hs.eventually_nhdsNE_zero x)).exists
rcases h _ hc with ⟨M, hM⟩
refine ⟨M / ‖c‖, forall_mem_range.mpr fun i ↦ (le_div_iff₀' (norm_pos_iff.2 hc₀)).2 ?_⟩
exact hM ⟨i, map_smul_eq_mul ..⟩ | lemma | Analysis | [
"Mathlib.Algebra.Order.Pi",
"Mathlib.Analysis.Convex.Function",
"Mathlib.Analysis.LocallyConvex.Basic",
"Mathlib.Analysis.Normed.Module.Basic",
"Mathlib.Data.Real.Pointwise"
] | Mathlib/Analysis/Seminorm.lean | bddAbove_of_absorbent | Let `p i` be a family of seminorms on `E`. Let `s` be an absorbent set in `𝕜`.
If all seminorms are uniformly bounded at every point of `s`,
then they are bounded in the space of seminorms. |
normSeminorm : Seminorm 𝕜 E :=
{ normAddGroupSeminorm E with smul' := norm_smul }
@[simp] | def | Analysis | [
"Mathlib.Algebra.Order.Pi",
"Mathlib.Analysis.Convex.Function",
"Mathlib.Analysis.LocallyConvex.Basic",
"Mathlib.Analysis.Normed.Module.Basic",
"Mathlib.Data.Real.Pointwise"
] | Mathlib/Analysis/Seminorm.lean | normSeminorm | The norm of a seminormed group as a seminorm. |
coe_normSeminorm : ⇑(normSeminorm 𝕜 E) = norm :=
rfl
@[simp] | theorem | Analysis | [
"Mathlib.Algebra.Order.Pi",
"Mathlib.Analysis.Convex.Function",
"Mathlib.Analysis.LocallyConvex.Basic",
"Mathlib.Analysis.Normed.Module.Basic",
"Mathlib.Data.Real.Pointwise"
] | Mathlib/Analysis/Seminorm.lean | coe_normSeminorm | null |
ball_normSeminorm : (normSeminorm 𝕜 E).ball = Metric.ball := by
ext x r y
simp only [Seminorm.mem_ball, Metric.mem_ball, coe_normSeminorm, dist_eq_norm]
@[simp] | theorem | Analysis | [
"Mathlib.Algebra.Order.Pi",
"Mathlib.Analysis.Convex.Function",
"Mathlib.Analysis.LocallyConvex.Basic",
"Mathlib.Analysis.Normed.Module.Basic",
"Mathlib.Data.Real.Pointwise"
] | Mathlib/Analysis/Seminorm.lean | ball_normSeminorm | null |
closedBall_normSeminorm : (normSeminorm 𝕜 E).closedBall = Metric.closedBall := by
ext x r y
simp only [Seminorm.mem_closedBall, Metric.mem_closedBall, coe_normSeminorm, dist_eq_norm]
variable {𝕜 E} {x : E} | theorem | Analysis | [
"Mathlib.Algebra.Order.Pi",
"Mathlib.Analysis.Convex.Function",
"Mathlib.Analysis.LocallyConvex.Basic",
"Mathlib.Analysis.Normed.Module.Basic",
"Mathlib.Data.Real.Pointwise"
] | Mathlib/Analysis/Seminorm.lean | closedBall_normSeminorm | null |
absorbent_ball_zero (hr : 0 < r) : Absorbent 𝕜 (Metric.ball (0 : E) r) := by
rw [← ball_normSeminorm 𝕜]
exact (normSeminorm _ _).absorbent_ball_zero hr | theorem | Analysis | [
"Mathlib.Algebra.Order.Pi",
"Mathlib.Analysis.Convex.Function",
"Mathlib.Analysis.LocallyConvex.Basic",
"Mathlib.Analysis.Normed.Module.Basic",
"Mathlib.Data.Real.Pointwise"
] | Mathlib/Analysis/Seminorm.lean | absorbent_ball_zero | Balls at the origin are absorbent. |
absorbent_ball (hx : ‖x‖ < r) : Absorbent 𝕜 (Metric.ball x r) := by
rw [← ball_normSeminorm 𝕜]
exact (normSeminorm _ _).absorbent_ball hx | theorem | Analysis | [
"Mathlib.Algebra.Order.Pi",
"Mathlib.Analysis.Convex.Function",
"Mathlib.Analysis.LocallyConvex.Basic",
"Mathlib.Analysis.Normed.Module.Basic",
"Mathlib.Data.Real.Pointwise"
] | Mathlib/Analysis/Seminorm.lean | absorbent_ball | Balls containing the origin are absorbent. |
balanced_ball_zero : Balanced 𝕜 (Metric.ball (0 : E) r) := by
rw [← ball_normSeminorm 𝕜]
exact (normSeminorm _ _).balanced_ball_zero r | theorem | Analysis | [
"Mathlib.Algebra.Order.Pi",
"Mathlib.Analysis.Convex.Function",
"Mathlib.Analysis.LocallyConvex.Basic",
"Mathlib.Analysis.Normed.Module.Basic",
"Mathlib.Data.Real.Pointwise"
] | Mathlib/Analysis/Seminorm.lean | balanced_ball_zero | Balls at the origin are balanced. |
balanced_closedBall_zero : Balanced 𝕜 (Metric.closedBall (0 : E) r) := by
rw [← closedBall_normSeminorm 𝕜]
exact (normSeminorm _ _).balanced_closedBall_zero r | theorem | Analysis | [
"Mathlib.Algebra.Order.Pi",
"Mathlib.Analysis.Convex.Function",
"Mathlib.Analysis.LocallyConvex.Basic",
"Mathlib.Analysis.Normed.Module.Basic",
"Mathlib.Data.Real.Pointwise"
] | Mathlib/Analysis/Seminorm.lean | balanced_closedBall_zero | Closed balls at the origin are balanced. |
rescale_to_shell_semi_normed_zpow {c : 𝕜} (hc : 1 < ‖c‖) {ε : ℝ} (εpos : 0 < ε) {x : E}
(hx : ‖x‖ ≠ 0) :
∃ n : ℤ, c^n ≠ 0 ∧ ‖c^n • x‖ < ε ∧ (ε / ‖c‖ ≤ ‖c^n • x‖) ∧ (‖c^n‖⁻¹ ≤ ε⁻¹ * ‖c‖ * ‖x‖) :=
(normSeminorm 𝕜 E).rescale_to_shell_zpow hc εpos hx | lemma | Analysis | [
"Mathlib.Algebra.Order.Pi",
"Mathlib.Analysis.Convex.Function",
"Mathlib.Analysis.LocallyConvex.Basic",
"Mathlib.Analysis.Normed.Module.Basic",
"Mathlib.Data.Real.Pointwise"
] | Mathlib/Analysis/Seminorm.lean | rescale_to_shell_semi_normed_zpow | If there is a scalar `c` with `‖c‖>1`, then any element with nonzero norm can be
moved by scalar multiplication to any shell of width `‖c‖`. Also recap information on the norm of
the rescaling element that shows up in applications. |
rescale_to_shell_semi_normed {c : 𝕜} (hc : 1 < ‖c‖) {ε : ℝ} (εpos : 0 < ε)
{x : E} (hx : ‖x‖ ≠ 0) :
∃ d : 𝕜, d ≠ 0 ∧ ‖d • x‖ < ε ∧ (ε/‖c‖ ≤ ‖d • x‖) ∧ (‖d‖⁻¹ ≤ ε⁻¹ * ‖c‖ * ‖x‖) :=
(normSeminorm 𝕜 E).rescale_to_shell hc εpos hx | lemma | Analysis | [
"Mathlib.Algebra.Order.Pi",
"Mathlib.Analysis.Convex.Function",
"Mathlib.Analysis.LocallyConvex.Basic",
"Mathlib.Analysis.Normed.Module.Basic",
"Mathlib.Data.Real.Pointwise"
] | Mathlib/Analysis/Seminorm.lean | rescale_to_shell_semi_normed | If there is a scalar `c` with `‖c‖>1`, then any element with nonzero norm can be
moved by scalar multiplication to any shell of width `‖c‖`. Also recap information on the norm of
the rescaling element that shows up in applications. |
rescale_to_shell_zpow [NormedAddCommGroup F] [NormedSpace 𝕜 F] {c : 𝕜} (hc : 1 < ‖c‖)
{ε : ℝ} (εpos : 0 < ε) {x : F} (hx : x ≠ 0) :
∃ n : ℤ, c^n ≠ 0 ∧ ‖c^n • x‖ < ε ∧ (ε / ‖c‖ ≤ ‖c^n • x‖) ∧ (‖c^n‖⁻¹ ≤ ε⁻¹ * ‖c‖ * ‖x‖) :=
rescale_to_shell_semi_normed_zpow hc εpos (norm_ne_zero_iff.mpr hx) | lemma | Analysis | [
"Mathlib.Algebra.Order.Pi",
"Mathlib.Analysis.Convex.Function",
"Mathlib.Analysis.LocallyConvex.Basic",
"Mathlib.Analysis.Normed.Module.Basic",
"Mathlib.Data.Real.Pointwise"
] | Mathlib/Analysis/Seminorm.lean | rescale_to_shell_zpow | null |
rescale_to_shell [NormedAddCommGroup F] [NormedSpace 𝕜 F] {c : 𝕜} (hc : 1 < ‖c‖)
{ε : ℝ} (εpos : 0 < ε) {x : F} (hx : x ≠ 0) :
∃ d : 𝕜, d ≠ 0 ∧ ‖d • x‖ < ε ∧ (ε/‖c‖ ≤ ‖d • x‖) ∧ (‖d‖⁻¹ ≤ ε⁻¹ * ‖c‖ * ‖x‖) :=
rescale_to_shell_semi_normed hc εpos (norm_ne_zero_iff.mpr hx) | lemma | Analysis | [
"Mathlib.Algebra.Order.Pi",
"Mathlib.Analysis.Convex.Function",
"Mathlib.Analysis.LocallyConvex.Basic",
"Mathlib.Analysis.Normed.Module.Basic",
"Mathlib.Data.Real.Pointwise"
] | Mathlib/Analysis/Seminorm.lean | rescale_to_shell | If there is a scalar `c` with `‖c‖>1`, then any element can be moved by scalar multiplication to
any shell of width `‖c‖`. Also recap information on the norm of the rescaling element that shows
up in applications. |
Subadditive (u : ℕ → ℝ) : Prop :=
∀ m n, u (m + n) ≤ u m + u n | def | Analysis | [
"Mathlib.Order.Filter.AtTopBot.Archimedean",
"Mathlib.Order.Filter.AtTopBot.Finite",
"Mathlib.Order.Filter.AtTopBot.Prod",
"Mathlib.Topology.Algebra.Ring.Real"
] | Mathlib/Analysis/Subadditive.lean | Subadditive | A real-valued sequence is subadditive if it satisfies the inequality `u (m + n) ≤ u m + u n`
for all `m, n`. |
@[nolint unusedArguments, irreducible]
protected lim (_h : Subadditive u) :=
sInf ((fun n : ℕ => u n / n) '' Ici 1) | def | Analysis | [
"Mathlib.Order.Filter.AtTopBot.Archimedean",
"Mathlib.Order.Filter.AtTopBot.Finite",
"Mathlib.Order.Filter.AtTopBot.Prod",
"Mathlib.Topology.Algebra.Ring.Real"
] | Mathlib/Analysis/Subadditive.lean | lim | The limit of a bounded-below subadditive sequence. The fact that the sequence indeed tends to
this limit is given in `Subadditive.tendsto_lim` |
lim_le_div (hbdd : BddBelow (range fun n => u n / n)) {n : ℕ} (hn : n ≠ 0) :
h.lim ≤ u n / n := by
rw [Subadditive.lim]
exact csInf_le (hbdd.mono <| image_subset_range _ _) ⟨n, hn.bot_lt, rfl⟩
include h in | theorem | Analysis | [
"Mathlib.Order.Filter.AtTopBot.Archimedean",
"Mathlib.Order.Filter.AtTopBot.Finite",
"Mathlib.Order.Filter.AtTopBot.Prod",
"Mathlib.Topology.Algebra.Ring.Real"
] | Mathlib/Analysis/Subadditive.lean | lim_le_div | null |
apply_mul_add_le (k n r) : u (k * n + r) ≤ k * u n + u r := by
induction k with
| zero => simp only [Nat.cast_zero, zero_mul, zero_add]; rfl
| succ k IH =>
calc
u ((k + 1) * n + r) = u (n + (k * n + r)) := by congr 1; ring
_ ≤ u n + u (k * n + r) := h _ _
_ ≤ u n + (k * u n + u r) := add_le_add_left IH _
_ = (k + 1 : ℕ) * u n + u r := by simp; ring
include h in | theorem | Analysis | [
"Mathlib.Order.Filter.AtTopBot.Archimedean",
"Mathlib.Order.Filter.AtTopBot.Finite",
"Mathlib.Order.Filter.AtTopBot.Prod",
"Mathlib.Topology.Algebra.Ring.Real"
] | Mathlib/Analysis/Subadditive.lean | apply_mul_add_le | null |
eventually_div_lt_of_div_lt {L : ℝ} {n : ℕ} (hn : n ≠ 0) (hL : u n / n < L) :
∀ᶠ p in atTop, u p / p < L := by
/- It suffices to prove the statement for each arithmetic progression `(n * · + r)`. -/
refine .atTop_of_arithmetic hn fun r _ => ?_
/- `(k * u n + u r) / (k * n + r)` tends to `u n / n < L`, hence
`(k * u n + u r) / (k * n + r) < L` for sufficiently large `k`. -/
have A : Tendsto (fun x : ℝ => (u n + u r / x) / (n + r / x)) atTop (𝓝 ((u n + 0) / (n + 0))) :=
(tendsto_const_nhds.add <| tendsto_const_nhds.div_atTop tendsto_id).div
(tendsto_const_nhds.add <| tendsto_const_nhds.div_atTop tendsto_id) <| by simpa
have B : Tendsto (fun x => (x * u n + u r) / (x * n + r)) atTop (𝓝 (u n / n)) := by
rw [add_zero, add_zero] at A
refine A.congr' <| (eventually_ne_atTop 0).mono fun x hx => ?_
simp only [add_div' _ _ _ hx, div_div_div_cancel_right₀ hx, mul_comm]
refine ((B.comp tendsto_natCast_atTop_atTop).eventually (gt_mem_nhds hL)).mono fun k hk => ?_
/- Finally, we use an upper estimate on `u (k * n + r)` to get an estimate on
`u (k * n + r) / (k * n + r)`. -/
rw [mul_comm]
refine lt_of_le_of_lt ?_ hk
simp only [(· ∘ ·), ← Nat.cast_add, ← Nat.cast_mul]
gcongr
apply h.apply_mul_add_le | theorem | Analysis | [
"Mathlib.Order.Filter.AtTopBot.Archimedean",
"Mathlib.Order.Filter.AtTopBot.Finite",
"Mathlib.Order.Filter.AtTopBot.Prod",
"Mathlib.Topology.Algebra.Ring.Real"
] | Mathlib/Analysis/Subadditive.lean | eventually_div_lt_of_div_lt | null |
tendsto_lim (hbdd : BddBelow (range fun n => u n / n)) :
Tendsto (fun n => u n / n) atTop (𝓝 h.lim) := by
refine tendsto_order.2 ⟨fun l hl => ?_, fun L hL => ?_⟩
· refine eventually_atTop.2
⟨1, fun n hn => hl.trans_le (h.lim_le_div hbdd (zero_lt_one.trans_le hn).ne')⟩
· obtain ⟨n, npos, hn⟩ : ∃ n : ℕ, 0 < n ∧ u n / n < L := by
rw [Subadditive.lim] at hL
rcases exists_lt_of_csInf_lt (by simp) hL with ⟨x, hx, xL⟩
rcases (mem_image _ _ _).1 hx with ⟨n, hn, rfl⟩
exact ⟨n, zero_lt_one.trans_le hn, xL⟩
exact h.eventually_div_lt_of_div_lt npos.ne' hn | theorem | Analysis | [
"Mathlib.Order.Filter.AtTopBot.Archimedean",
"Mathlib.Order.Filter.AtTopBot.Finite",
"Mathlib.Order.Filter.AtTopBot.Prod",
"Mathlib.Topology.Algebra.Ring.Real"
] | Mathlib/Analysis/Subadditive.lean | tendsto_lim | Fekete's lemma: a subadditive sequence which is bounded below converges. |
sum_Ico_le_integral_of_le
(hab : a ≤ b) (h : ∀ i ∈ Ico a b, ∀ x ∈ Ico (i : ℝ) (i + 1 : ℕ), f i ≤ g x)
(hg : IntegrableOn g (Set.Ico a b)) :
∑ i ∈ Finset.Ico a b, f i ≤ ∫ x in a..b, g x := by
have A i (hi : i ∈ Finset.Ico a b) : IntervalIntegrable g volume i (i + 1 : ℕ) := by
rw [intervalIntegrable_iff_integrableOn_Ico_of_le (by simp)]
apply hg.mono _ le_rfl
rintro x ⟨hx, h'x⟩
simp only [Finset.mem_Ico, mem_Ico] at hi ⊢
exact ⟨le_trans (mod_cast hi.1) hx, h'x.trans_le (mod_cast hi.2)⟩
calc
∑ i ∈ Finset.Ico a b, f i
_ = ∑ i ∈ Finset.Ico a b, (∫ x in (i : ℝ)..(i + 1 : ℕ), f i) := by simp
_ ≤ ∑ i ∈ Finset.Ico a b, (∫ x in (i : ℝ)..(i + 1 : ℕ), g x) := by
gcongr with i hi
apply intervalIntegral.integral_mono_on_of_le_Ioo (by simp) (by simp) (A _ hi) (fun x hx ↦ ?_)
exact h _ (by simpa using hi) _ (Ioo_subset_Ico_self hx)
_ = ∫ x in a..b, g x := by
rw [intervalIntegral.sum_integral_adjacent_intervals_Ico (a := fun i ↦ i) hab]
intro i hi
exact A _ (by simpa using hi) | lemma | Analysis | [
"Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic",
"Mathlib.Data.Set.Function"
] | Mathlib/Analysis/SumIntegralComparisons.lean | sum_Ico_le_integral_of_le | null |
integral_le_sum_Ico_of_le
(hab : a ≤ b) (h : ∀ i ∈ Ico a b, ∀ x ∈ Ico (i : ℝ) (i + 1 : ℕ), g x ≤ f i)
(hg : IntegrableOn g (Set.Ico a b)) :
∫ x in a..b, g x ≤ ∑ i ∈ Finset.Ico a b, f i := by
convert neg_le_neg (sum_Ico_le_integral_of_le (f := -f) (g := -g) hab
(fun i hi x hx ↦ neg_le_neg (h i hi x hx)) hg.neg) <;> simp | lemma | Analysis | [
"Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic",
"Mathlib.Data.Set.Function"
] | Mathlib/Analysis/SumIntegralComparisons.lean | integral_le_sum_Ico_of_le | null |
AntitoneOn.integral_le_sum (hf : AntitoneOn f (Icc x₀ (x₀ + a))) :
(∫ x in x₀..x₀ + a, f x) ≤ ∑ i ∈ Finset.range a, f (x₀ + i) := by
have hint : ∀ k : ℕ, k < a → IntervalIntegrable f volume (x₀ + k) (x₀ + (k + 1 : ℕ)) := by
intro k hk
refine (hf.mono ?_).intervalIntegrable
rw [uIcc_of_le]
· apply Icc_subset_Icc
· simp only [le_add_iff_nonneg_right, Nat.cast_nonneg]
· simp only [add_le_add_iff_left, Nat.cast_le, Nat.succ_le_of_lt hk]
· simp only [add_le_add_iff_left, Nat.cast_le, Nat.le_succ]
calc
∫ x in x₀..x₀ + a, f x = ∑ i ∈ Finset.range a, ∫ x in x₀ + i..x₀ + (i + 1 : ℕ), f x := by
convert (intervalIntegral.sum_integral_adjacent_intervals hint).symm
simp only [Nat.cast_zero, add_zero]
_ ≤ ∑ i ∈ Finset.range a, ∫ _ in x₀ + i..x₀ + (i + 1 : ℕ), f (x₀ + i) := by
apply Finset.sum_le_sum fun i hi => ?_
have ia : i < a := Finset.mem_range.1 hi
refine intervalIntegral.integral_mono_on (by simp) (hint _ ia) (by simp) fun x hx => ?_
apply hf _ _ hx.1
· simp only [ia.le, mem_Icc, le_add_iff_nonneg_right, Nat.cast_nonneg, add_le_add_iff_left,
Nat.cast_le, and_self_iff]
· refine mem_Icc.2 ⟨le_trans (by simp) hx.1, le_trans hx.2 ?_⟩
simp only [add_le_add_iff_left, Nat.cast_le, Nat.succ_le_of_lt ia]
_ = ∑ i ∈ Finset.range a, f (x₀ + i) := by simp | theorem | Analysis | [
"Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic",
"Mathlib.Data.Set.Function"
] | Mathlib/Analysis/SumIntegralComparisons.lean | AntitoneOn.integral_le_sum | null |
AntitoneOn.integral_le_sum_Ico (hab : a ≤ b) (hf : AntitoneOn f (Set.Icc a b)) :
(∫ x in a..b, f x) ≤ ∑ x ∈ Finset.Ico a b, f x := by
rw [(Nat.sub_add_cancel hab).symm, Nat.cast_add]
conv =>
congr
congr
· skip
· skip
rw [add_comm]
· skip
· skip
congr
congr
rw [← zero_add a]
rw [← Finset.sum_Ico_add, Nat.Ico_zero_eq_range]
conv =>
rhs
congr
· skip
ext
rw [Nat.cast_add]
apply AntitoneOn.integral_le_sum
simp only [hf, hab, Nat.cast_sub, add_sub_cancel] | theorem | Analysis | [
"Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic",
"Mathlib.Data.Set.Function"
] | Mathlib/Analysis/SumIntegralComparisons.lean | AntitoneOn.integral_le_sum_Ico | null |
AntitoneOn.sum_le_integral (hf : AntitoneOn f (Icc x₀ (x₀ + a))) :
(∑ i ∈ Finset.range a, f (x₀ + (i + 1 : ℕ))) ≤ ∫ x in x₀..x₀ + a, f x := by
have hint : ∀ k : ℕ, k < a → IntervalIntegrable f volume (x₀ + k) (x₀ + (k + 1 : ℕ)) := by
intro k hk
refine (hf.mono ?_).intervalIntegrable
rw [uIcc_of_le]
· apply Icc_subset_Icc
· simp only [le_add_iff_nonneg_right, Nat.cast_nonneg]
· simp only [add_le_add_iff_left, Nat.cast_le, Nat.succ_le_of_lt hk]
· simp only [add_le_add_iff_left, Nat.cast_le, Nat.le_succ]
calc
(∑ i ∈ Finset.range a, f (x₀ + (i + 1 : ℕ))) =
∑ i ∈ Finset.range a, ∫ _ in x₀ + i..x₀ + (i + 1 : ℕ), f (x₀ + (i + 1 : ℕ)) := by simp
_ ≤ ∑ i ∈ Finset.range a, ∫ x in x₀ + i..x₀ + (i + 1 : ℕ), f x := by
apply Finset.sum_le_sum fun i hi => ?_
have ia : i + 1 ≤ a := Finset.mem_range.1 hi
refine intervalIntegral.integral_mono_on (by simp) (by simp) (hint _ ia) fun x hx => ?_
apply hf _ _ hx.2
· refine mem_Icc.2 ⟨le_trans (le_add_of_nonneg_right (Nat.cast_nonneg _)) hx.1,
le_trans hx.2 ?_⟩
simp only [Nat.cast_le, add_le_add_iff_left, ia]
· refine mem_Icc.2 ⟨le_add_of_nonneg_right (Nat.cast_nonneg _), ?_⟩
simp only [add_le_add_iff_left, Nat.cast_le, ia]
_ = ∫ x in x₀..x₀ + a, f x := by
convert intervalIntegral.sum_integral_adjacent_intervals hint
simp only [Nat.cast_zero, add_zero] | theorem | Analysis | [
"Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic",
"Mathlib.Data.Set.Function"
] | Mathlib/Analysis/SumIntegralComparisons.lean | AntitoneOn.sum_le_integral | null |
AntitoneOn.sum_le_integral_Ico (hab : a ≤ b) (hf : AntitoneOn f (Set.Icc a b)) :
(∑ i ∈ Finset.Ico a b, f (i + 1 : ℕ)) ≤ ∫ x in a..b, f x := by
rw [(Nat.sub_add_cancel hab).symm, Nat.cast_add]
conv =>
congr
congr
congr
rw [← zero_add a]
· skip
· skip
· skip
rw [add_comm]
rw [← Finset.sum_Ico_add, Nat.Ico_zero_eq_range]
conv =>
lhs
congr
congr
· skip
ext
rw [add_assoc, Nat.cast_add]
apply AntitoneOn.sum_le_integral
simp only [hf, hab, Nat.cast_sub, add_sub_cancel] | theorem | Analysis | [
"Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic",
"Mathlib.Data.Set.Function"
] | Mathlib/Analysis/SumIntegralComparisons.lean | AntitoneOn.sum_le_integral_Ico | null |
MonotoneOn.sum_le_integral (hf : MonotoneOn f (Icc x₀ (x₀ + a))) :
(∑ i ∈ Finset.range a, f (x₀ + i)) ≤ ∫ x in x₀..x₀ + a, f x := by
rw [← neg_le_neg_iff, ← Finset.sum_neg_distrib, ← intervalIntegral.integral_neg]
exact hf.neg.integral_le_sum | theorem | Analysis | [
"Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic",
"Mathlib.Data.Set.Function"
] | Mathlib/Analysis/SumIntegralComparisons.lean | MonotoneOn.sum_le_integral | null |
MonotoneOn.sum_le_integral_Ico (hab : a ≤ b) (hf : MonotoneOn f (Set.Icc a b)) :
∑ x ∈ Finset.Ico a b, f x ≤ ∫ x in a..b, f x := by
rw [← neg_le_neg_iff, ← Finset.sum_neg_distrib, ← intervalIntegral.integral_neg]
exact hf.neg.integral_le_sum_Ico hab | theorem | Analysis | [
"Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic",
"Mathlib.Data.Set.Function"
] | Mathlib/Analysis/SumIntegralComparisons.lean | MonotoneOn.sum_le_integral_Ico | null |
MonotoneOn.integral_le_sum (hf : MonotoneOn f (Icc x₀ (x₀ + a))) :
(∫ x in x₀..x₀ + a, f x) ≤ ∑ i ∈ Finset.range a, f (x₀ + (i + 1 : ℕ)) := by
rw [← neg_le_neg_iff, ← Finset.sum_neg_distrib, ← intervalIntegral.integral_neg]
exact hf.neg.sum_le_integral | theorem | Analysis | [
"Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic",
"Mathlib.Data.Set.Function"
] | Mathlib/Analysis/SumIntegralComparisons.lean | MonotoneOn.integral_le_sum | null |
MonotoneOn.integral_le_sum_Ico (hab : a ≤ b) (hf : MonotoneOn f (Set.Icc a b)) :
(∫ x in a..b, f x) ≤ ∑ i ∈ Finset.Ico a b, f (i + 1 : ℕ) := by
rw [← neg_le_neg_iff, ← Finset.sum_neg_distrib, ← intervalIntegral.integral_neg]
exact hf.neg.sum_le_integral_Ico hab | theorem | Analysis | [
"Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic",
"Mathlib.Data.Set.Function"
] | Mathlib/Analysis/SumIntegralComparisons.lean | MonotoneOn.integral_le_sum_Ico | null |
sum_mul_Ico_le_integral_of_monotone_antitone
(hab : a ≤ b) (hf : MonotoneOn f (Icc a b)) (hg : AntitoneOn g (Icc (a - 1) (b - 1)))
(fpos : 0 ≤ f a) (gpos : 0 ≤ g (b - 1)) :
∑ i ∈ Finset.Ico a b, f i * g i ≤ ∫ x in a..b, f x * g (x - 1) := by
apply sum_Ico_le_integral_of_le (f := fun x ↦ f x * g x) hab
· intro i hi x hx
simp only [Nat.cast_add, Nat.cast_one, mem_Ico] at hx hi
have I0 : (i : ℝ) ≤ b - 1 := by
simp only [le_sub_iff_add_le]
norm_cast
omega
have I1 : (i : ℝ) ∈ Icc (a - 1 : ℝ) (b - 1) := by
simp only [mem_Icc, tsub_le_iff_right]
exact ⟨by norm_cast; cutsat, I0⟩
have I2 : x ∈ Icc (a : ℝ) b := by
refine ⟨le_trans (mod_cast hi.1) hx.1, hx.2.le.trans ?_⟩
norm_cast
omega
apply mul_le_mul
· apply hf
· simp only [mem_Icc, Nat.cast_le]
exact ⟨hi.1, hi.2.le⟩
· exact I2
· exact hx.1
· apply hg
· simp only [mem_Icc, tsub_le_iff_right, sub_add_cancel]
refine ⟨le_trans (mod_cast hi.1) hx.1, hx.2.le.trans ?_⟩
norm_cast
cutsat
· exact I1
· simpa [sub_le_iff_le_add] using hx.2.le
· apply gpos.trans
apply hg I1 (by simp [hab]) I0
· apply fpos.trans
apply hf (by simp [hab]) I2
exact le_trans (mod_cast hi.1) hx.1
· apply Integrable.mono_measure _ (Measure.restrict_mono_set _ Ico_subset_Icc_self)
apply Integrable.mul_of_top_left
· exact hf.integrableOn_isCompact isCompact_Icc
· apply AntitoneOn.memLp_isCompact isCompact_Icc
intro x hx y hy hxy
apply hg
· simpa using hx
· simpa using hy
· simpa using hxy | lemma | Analysis | [
"Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic",
"Mathlib.Data.Set.Function"
] | Mathlib/Analysis/SumIntegralComparisons.lean | sum_mul_Ico_le_integral_of_monotone_antitone | null |
integral_le_sum_mul_Ico_of_antitone_monotone
(hab : a ≤ b) (hf : AntitoneOn f (Icc a b)) (hg : MonotoneOn g (Icc (a - 1) (b - 1)))
(fpos : 0 ≤ f b) (gpos : 0 ≤ g (a - 1)) :
∫ x in a..b, f x * g (x - 1) ≤ ∑ i ∈ Finset.Ico a b, f i * g i := by
apply integral_le_sum_Ico_of_le (f := fun x ↦ f x * g x) hab
· intro i hi x hx
simp only [Nat.cast_add, Nat.cast_one, mem_Ico] at hx hi
have I0 : (i : ℝ) ≤ b - 1 := by
simp only [le_sub_iff_add_le]
norm_cast
omega
have I1 : (i : ℝ) ∈ Icc (a - 1 : ℝ) (b - 1) := by
simp only [mem_Icc, tsub_le_iff_right]
exact ⟨by norm_cast; cutsat, I0⟩
have I2 : x ∈ Icc (a : ℝ) b := by
refine ⟨le_trans (mod_cast hi.1) hx.1, hx.2.le.trans ?_⟩
norm_cast
omega
apply mul_le_mul
· apply hf
· simp only [mem_Icc, Nat.cast_le]
exact ⟨hi.1, hi.2.le⟩
· exact I2
· exact hx.1
· apply hg
· simp only [mem_Icc, tsub_le_iff_right, sub_add_cancel]
refine ⟨le_trans (mod_cast hi.1) hx.1, hx.2.le.trans ?_⟩
norm_cast
cutsat
· exact I1
· simpa [sub_le_iff_le_add] using hx.2.le
· apply gpos.trans
apply hg (by simp [hab]) (by simpa using I2) (by simpa using I2.1)
· apply fpos.trans
apply hf ⟨mod_cast hi.1, mod_cast hi.2.le⟩ (by simpa using hab) (mod_cast hi.2.le)
· apply Integrable.mono_measure _ (Measure.restrict_mono_set _ Ico_subset_Icc_self)
apply Integrable.mul_of_top_left
· exact hf.integrableOn_isCompact isCompact_Icc
· apply MonotoneOn.memLp_isCompact isCompact_Icc
intro x hx y hy hxy
apply hg
· simpa using hx
· simpa using hy
· simpa using hxy | lemma | Analysis | [
"Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic",
"Mathlib.Data.Set.Function"
] | Mathlib/Analysis/SumIntegralComparisons.lean | integral_le_sum_mul_Ico_of_antitone_monotone | null |
Finset.sum_indicator_mod {R : Type*} [AddCommMonoid R] (m : ℕ) [NeZero m] (f : ℕ → R) :
f = ∑ a : ZMod m, {n : ℕ | (n : ZMod m) = a}.indicator f := by
ext n
simp only [Finset.sum_apply, Set.indicator_apply, Set.mem_setOf_eq, Finset.sum_ite_eq,
Finset.mem_univ, ↓reduceIte]
open Set in | lemma | Analysis | [
"Mathlib.Analysis.Normed.Group.Basic",
"Mathlib.Data.ZMod.Basic",
"Mathlib.Topology.Instances.ENNReal.Lemmas"
] | Mathlib/Analysis/SumOverResidueClass.lean | Finset.sum_indicator_mod | null |
summable_indicator_mod_iff_summable {R : Type*} [AddCommGroup R] [TopologicalSpace R]
[IsTopologicalAddGroup R] (m : ℕ) [hm : NeZero m] (k : ℕ) (f : ℕ → R) :
Summable ({n : ℕ | (n : ZMod m) = k}.indicator f) ↔ Summable fun n ↦ f (m * n + k) := by
trans Summable ({n : ℕ | (n : ZMod m) = k ∧ k ≤ n}.indicator f)
· rw [← (finite_lt_nat k).summable_compl_iff (f := {n : ℕ | (n : ZMod m) = k}.indicator f)]
simp only [summable_subtype_iff_indicator, indicator_indicator, inter_comm, setOf_and,
compl_setOf, not_lt]
· let g : ℕ → ℕ := fun n ↦ m * n + k
have hg : Function.Injective g := fun m n hmn ↦ by simpa [g, hm.ne] using hmn
have hg' : ∀ n ∉ range g, {n : ℕ | (n : ZMod m) = k ∧ k ≤ n}.indicator f n = 0 := by
intro n hn
contrapose! hn
exact (Nat.range_mul_add m k).symm ▸ mem_of_indicator_ne_zero hn
convert (Function.Injective.summable_iff hg hg').symm using 3
simp only [Function.comp_apply, mem_setOf_eq, Nat.cast_add, Nat.cast_mul, CharP.cast_eq_zero,
zero_mul, zero_add, le_add_iff_nonneg_left, zero_le, and_self, indicator_of_mem, g] | lemma | Analysis | [
"Mathlib.Analysis.Normed.Group.Basic",
"Mathlib.Data.ZMod.Basic",
"Mathlib.Topology.Instances.ENNReal.Lemmas"
] | Mathlib/Analysis/SumOverResidueClass.lean | summable_indicator_mod_iff_summable | A sequence `f` with values in an additive topological group `R` is summable on the
residue class of `k` mod `m` if and only if `f (m*n + k)` is summable. |
not_summable_of_antitone_of_neg {f : ℕ → ℝ} (hf : Antitone f) {n : ℕ} (hn : f n < 0) :
¬ Summable f := by
intro hs
have := hs.tendsto_atTop_zero
simp only [Metric.tendsto_atTop, dist_zero_right, Real.norm_eq_abs] at this
obtain ⟨N, hN⟩ := this (|f n|) (abs_pos_of_neg hn)
specialize hN (max n N) (n.le_max_right N)
contrapose! hN; clear hN
have H : f (max n N) ≤ f n := hf (n.le_max_left N)
rwa [abs_of_neg hn, abs_of_neg (H.trans_lt hn), neg_le_neg_iff] | lemma | Analysis | [
"Mathlib.Analysis.Normed.Group.Basic",
"Mathlib.Data.ZMod.Basic",
"Mathlib.Topology.Instances.ENNReal.Lemmas"
] | Mathlib/Analysis/SumOverResidueClass.lean | not_summable_of_antitone_of_neg | If `f : ℕ → ℝ` is decreasing and has a negative term, then `f` is not summable. |
not_summable_indicator_mod_of_antitone_of_neg {m : ℕ} [hm : NeZero m] {f : ℕ → ℝ}
(hf : Antitone f) {n : ℕ} (hn : f n < 0) (k : ZMod m) :
¬ Summable ({n : ℕ | (n : ZMod m) = k}.indicator f) := by
rw [← ZMod.natCast_zmod_val k, summable_indicator_mod_iff_summable]
exact not_summable_of_antitone_of_neg
(hf.comp_monotone <| (Covariant.monotone_of_const m).add_const k.val) <|
(hf <| (Nat.le_mul_of_pos_left n Fin.pos').trans <| Nat.le_add_right ..).trans_lt hn | lemma | Analysis | [
"Mathlib.Analysis.Normed.Group.Basic",
"Mathlib.Data.ZMod.Basic",
"Mathlib.Topology.Instances.ENNReal.Lemmas"
] | Mathlib/Analysis/SumOverResidueClass.lean | not_summable_indicator_mod_of_antitone_of_neg | If `f : ℕ → ℝ` is decreasing and has a negative term, then `f` restricted to a residue
class is not summable. |
summable_indicator_mod_iff_summable_indicator_mod {m : ℕ} [NeZero m] {f : ℕ → ℝ}
(hf : Antitone f) {k : ZMod m} (l : ZMod m)
(hs : Summable ({n : ℕ | (n : ZMod m) = k}.indicator f)) :
Summable ({n : ℕ | (n : ZMod m) = l}.indicator f) := by
by_cases hf₀ : ∀ n, 0 ≤ f n -- the interesting case
· rw [← ZMod.natCast_zmod_val k, summable_indicator_mod_iff_summable] at hs
have hl : (l.val + m : ZMod m) = l := by
simp only [ZMod.natCast_val, ZMod.cast_id', id_eq, CharP.cast_eq_zero, add_zero]
rw [← hl, ← Nat.cast_add, summable_indicator_mod_iff_summable]
exact hs.of_nonneg_of_le (fun _ ↦ hf₀ _)
fun _ ↦ hf <| Nat.add_le_add Nat.le.refl (k.val_lt.trans_le <| m.le_add_left l.val).le
· push_neg at hf₀
obtain ⟨n, hn⟩ := hf₀
exact (not_summable_indicator_mod_of_antitone_of_neg hf hn k hs).elim | lemma | Analysis | [
"Mathlib.Analysis.Normed.Group.Basic",
"Mathlib.Data.ZMod.Basic",
"Mathlib.Topology.Instances.ENNReal.Lemmas"
] | Mathlib/Analysis/SumOverResidueClass.lean | summable_indicator_mod_iff_summable_indicator_mod | If a decreasing sequence of real numbers is summable on one residue class
modulo `m`, then it is also summable on every other residue class mod `m`. |
summable_indicator_mod_iff {m : ℕ} [NeZero m] {f : ℕ → ℝ} (hf : Antitone f) (k : ZMod m) :
Summable ({n : ℕ | (n : ZMod m) = k}.indicator f) ↔ Summable f := by
refine ⟨fun H ↦ ?_, fun H ↦ Summable.indicator H _⟩
rw [Finset.sum_indicator_mod m f]
convert summable_sum (s := Finset.univ)
fun a _ ↦ summable_indicator_mod_iff_summable_indicator_mod hf a H
simp only [Finset.sum_apply]
open ZMod | lemma | Analysis | [
"Mathlib.Analysis.Normed.Group.Basic",
"Mathlib.Data.ZMod.Basic",
"Mathlib.Topology.Instances.ENNReal.Lemmas"
] | Mathlib/Analysis/SumOverResidueClass.lean | summable_indicator_mod_iff | A decreasing sequence of real numbers is summable on a residue class
if and only if it is summable. |
Nat.sumByResidueClasses {R : Type*} [AddCommGroup R] [UniformSpace R] [IsUniformAddGroup R]
[CompleteSpace R] [T0Space R] {f : ℕ → R} (hf : Summable f) (N : ℕ) [NeZero N] :
∑' n, f n = ∑ j : ZMod N, ∑' m, f (j.val + N * m) := by
rw [← (residueClassesEquiv N).symm.tsum_eq f, Summable.tsum_prod, tsum_fintype,
residueClassesEquiv, Equiv.coe_fn_symm_mk]
exact hf.comp_injective (residueClassesEquiv N).symm.injective | lemma | Analysis | [
"Mathlib.Analysis.Normed.Group.Basic",
"Mathlib.Data.ZMod.Basic",
"Mathlib.Topology.Instances.ENNReal.Lemmas"
] | Mathlib/Analysis/SumOverResidueClass.lean | Nat.sumByResidueClasses | If `f` is a summable function on `ℕ`, and `0 < N`, then we may compute `∑' n : ℕ, f n` by
summing each residue class mod `N` separately. |
@[simps]
actionAsFunctor : SingleObj M ⥤ Type u where
obj _ := X
map := (· • ·)
map_id _ := funext <| MulAction.one_smul
map_comp f g := funext fun x => (smul_smul g f x).symm | def | CategoryTheory | [
"Mathlib.CategoryTheory.Elements",
"Mathlib.CategoryTheory.IsConnected",
"Mathlib.CategoryTheory.SingleObj",
"Mathlib.GroupTheory.GroupAction.Quotient",
"Mathlib.GroupTheory.SemidirectProduct"
] | Mathlib/CategoryTheory/Action.lean | actionAsFunctor | A multiplicative action M ↻ X viewed as a functor mapping the single object of M to X
and an element `m : M` to the map `X → X` given by multiplication by `m`. |
ActionCategory :=
(actionAsFunctor M X).Elements | def | CategoryTheory | [
"Mathlib.CategoryTheory.Elements",
"Mathlib.CategoryTheory.IsConnected",
"Mathlib.CategoryTheory.SingleObj",
"Mathlib.GroupTheory.GroupAction.Quotient",
"Mathlib.GroupTheory.SemidirectProduct"
] | Mathlib/CategoryTheory/Action.lean | ActionCategory | A multiplicative action M ↻ X induces a category structure on X, where a morphism
from x to y is a scalar taking x to y. Due to implementation details, the object type
of this category is not equal to X, but is in bijection with X. |
π : ActionCategory M X ⥤ SingleObj M :=
CategoryOfElements.π _
@[simp] | def | CategoryTheory | [
"Mathlib.CategoryTheory.Elements",
"Mathlib.CategoryTheory.IsConnected",
"Mathlib.CategoryTheory.SingleObj",
"Mathlib.GroupTheory.GroupAction.Quotient",
"Mathlib.GroupTheory.SemidirectProduct"
] | Mathlib/CategoryTheory/Action.lean | π | The projection from the action category to the monoid, mapping a morphism to its
label. |
π_map (p q : ActionCategory M X) (f : p ⟶ q) : (π M X).map f = f.val :=
rfl
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Elements",
"Mathlib.CategoryTheory.IsConnected",
"Mathlib.CategoryTheory.SingleObj",
"Mathlib.GroupTheory.GroupAction.Quotient",
"Mathlib.GroupTheory.SemidirectProduct"
] | Mathlib/CategoryTheory/Action.lean | π_map | null |
π_obj (p : ActionCategory M X) : (π M X).obj p = SingleObj.star M :=
Unit.ext _ _
variable {M X} | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Elements",
"Mathlib.CategoryTheory.IsConnected",
"Mathlib.CategoryTheory.SingleObj",
"Mathlib.GroupTheory.GroupAction.Quotient",
"Mathlib.GroupTheory.SemidirectProduct"
] | Mathlib/CategoryTheory/Action.lean | π_obj | null |
protected back : ActionCategory M X → X := fun x => x.snd | def | CategoryTheory | [
"Mathlib.CategoryTheory.Elements",
"Mathlib.CategoryTheory.IsConnected",
"Mathlib.CategoryTheory.SingleObj",
"Mathlib.GroupTheory.GroupAction.Quotient",
"Mathlib.GroupTheory.SemidirectProduct"
] | Mathlib/CategoryTheory/Action.lean | back | The canonical map `ActionCategory M X → X`. It is given by `fun x => x.snd`, but
has a more explicit type. |
@[simp]
coe_back (x : X) : ActionCategory.back (x : ActionCategory M X) = x :=
rfl
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Elements",
"Mathlib.CategoryTheory.IsConnected",
"Mathlib.CategoryTheory.SingleObj",
"Mathlib.GroupTheory.GroupAction.Quotient",
"Mathlib.GroupTheory.SemidirectProduct"
] | Mathlib/CategoryTheory/Action.lean | coe_back | null |
back_coe (x : ActionCategory M X) : ↑x.back = x := by cases x; rfl
variable (M X) | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Elements",
"Mathlib.CategoryTheory.IsConnected",
"Mathlib.CategoryTheory.SingleObj",
"Mathlib.GroupTheory.GroupAction.Quotient",
"Mathlib.GroupTheory.SemidirectProduct"
] | Mathlib/CategoryTheory/Action.lean | back_coe | null |
objEquiv : X ≃ ActionCategory M X where
toFun x := x
invFun x := x.back
left_inv := coe_back
right_inv := back_coe | def | CategoryTheory | [
"Mathlib.CategoryTheory.Elements",
"Mathlib.CategoryTheory.IsConnected",
"Mathlib.CategoryTheory.SingleObj",
"Mathlib.GroupTheory.GroupAction.Quotient",
"Mathlib.GroupTheory.SemidirectProduct"
] | Mathlib/CategoryTheory/Action.lean | objEquiv | An object of the action category given by M ↻ X corresponds to an element of X. |
hom_as_subtype (p q : ActionCategory M X) : (p ⟶ q) = { m : M // m • p.back = q.back } :=
rfl | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Elements",
"Mathlib.CategoryTheory.IsConnected",
"Mathlib.CategoryTheory.SingleObj",
"Mathlib.GroupTheory.GroupAction.Quotient",
"Mathlib.GroupTheory.SemidirectProduct"
] | Mathlib/CategoryTheory/Action.lean | hom_as_subtype | null |
stabilizerIsoEnd : stabilizerSubmonoid M x ≃* @End (ActionCategory M X) _ x :=
MulEquiv.refl _
@[simp] | def | CategoryTheory | [
"Mathlib.CategoryTheory.Elements",
"Mathlib.CategoryTheory.IsConnected",
"Mathlib.CategoryTheory.SingleObj",
"Mathlib.GroupTheory.GroupAction.Quotient",
"Mathlib.GroupTheory.SemidirectProduct"
] | Mathlib/CategoryTheory/Action.lean | stabilizerIsoEnd | The stabilizer of a point is isomorphic to the endomorphism monoid at the
corresponding point. In fact they are definitionally equivalent. |
stabilizerIsoEnd_apply (f : stabilizerSubmonoid M x) :
(stabilizerIsoEnd M x) f = f :=
rfl
@[simp 1100] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Elements",
"Mathlib.CategoryTheory.IsConnected",
"Mathlib.CategoryTheory.SingleObj",
"Mathlib.GroupTheory.GroupAction.Quotient",
"Mathlib.GroupTheory.SemidirectProduct"
] | Mathlib/CategoryTheory/Action.lean | stabilizerIsoEnd_apply | null |
stabilizerIsoEnd_symm_apply (f : End _) : (stabilizerIsoEnd M x).symm f = f :=
rfl
variable {M}
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Elements",
"Mathlib.CategoryTheory.IsConnected",
"Mathlib.CategoryTheory.SingleObj",
"Mathlib.GroupTheory.GroupAction.Quotient",
"Mathlib.GroupTheory.SemidirectProduct"
] | Mathlib/CategoryTheory/Action.lean | stabilizerIsoEnd_symm_apply | null |
protected id_val (x : ActionCategory M X) : Subtype.val (𝟙 x) = 1 :=
rfl
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Elements",
"Mathlib.CategoryTheory.IsConnected",
"Mathlib.CategoryTheory.SingleObj",
"Mathlib.GroupTheory.GroupAction.Quotient",
"Mathlib.GroupTheory.SemidirectProduct"
] | Mathlib/CategoryTheory/Action.lean | id_val | null |
protected comp_val {x y z : ActionCategory M X} (f : x ⟶ y) (g : y ⟶ z) :
(f ≫ g).val = g.val * f.val :=
rfl | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Elements",
"Mathlib.CategoryTheory.IsConnected",
"Mathlib.CategoryTheory.SingleObj",
"Mathlib.GroupTheory.GroupAction.Quotient",
"Mathlib.GroupTheory.SemidirectProduct"
] | Mathlib/CategoryTheory/Action.lean | comp_val | null |
endMulEquivSubgroup (H : Subgroup G) : End (objEquiv G (G ⧸ H) ↑(1 : G)) ≃* H :=
MulEquiv.trans (stabilizerIsoEnd G ((1 : G) : G ⧸ H)).symm
(MulEquiv.subgroupCongr <| stabilizer_quotient H) | def | CategoryTheory | [
"Mathlib.CategoryTheory.Elements",
"Mathlib.CategoryTheory.IsConnected",
"Mathlib.CategoryTheory.SingleObj",
"Mathlib.GroupTheory.GroupAction.Quotient",
"Mathlib.GroupTheory.SemidirectProduct"
] | Mathlib/CategoryTheory/Action.lean | endMulEquivSubgroup | Any subgroup of `G` is a vertex group in its action groupoid. |
homOfPair (t : X) (g : G) : @Quiver.Hom (ActionCategory G X) _ (g⁻¹ • t :) t :=
Subtype.mk g (smul_inv_smul g t)
@[simp] | def | CategoryTheory | [
"Mathlib.CategoryTheory.Elements",
"Mathlib.CategoryTheory.IsConnected",
"Mathlib.CategoryTheory.SingleObj",
"Mathlib.GroupTheory.GroupAction.Quotient",
"Mathlib.GroupTheory.SemidirectProduct"
] | Mathlib/CategoryTheory/Action.lean | homOfPair | A target vertex `t` and a scalar `g` determine a morphism in the action groupoid. |
homOfPair.val (t : X) (g : G) : (homOfPair t g).val = g :=
rfl | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Elements",
"Mathlib.CategoryTheory.IsConnected",
"Mathlib.CategoryTheory.SingleObj",
"Mathlib.GroupTheory.GroupAction.Quotient",
"Mathlib.GroupTheory.SemidirectProduct"
] | Mathlib/CategoryTheory/Action.lean | homOfPair.val | null |
protected cases {P : ∀ ⦃a b : ActionCategory G X⦄, (a ⟶ b) → Sort*}
(hyp : ∀ t g, P (homOfPair t g)) ⦃a b⦄ (f : a ⟶ b) : P f := by
refine cast ?_ (hyp b.back f.val)
rcases a with ⟨⟨⟩, a : X⟩
rcases b with ⟨⟨⟩, b : X⟩
rcases f with ⟨g : G, h : g • a = b⟩
cases inv_smul_eq_iff.mpr h.symm
rfl
@[deprecated (since := "2025-08-21")]
alias cases' := ActionCategory.cases
variable {H : Type*} [Group H] | def | CategoryTheory | [
"Mathlib.CategoryTheory.Elements",
"Mathlib.CategoryTheory.IsConnected",
"Mathlib.CategoryTheory.SingleObj",
"Mathlib.GroupTheory.GroupAction.Quotient",
"Mathlib.GroupTheory.SemidirectProduct"
] | Mathlib/CategoryTheory/Action.lean | cases | Any morphism in the action groupoid is given by some pair. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.