| import OAI.Analysis.C0Absorption.Signs | |
| namespace OAI | |
| namespace C0Absorption | |
| open scoped BigOperators NNReal ENNReal | |
| noncomputable section | |
| open Finset | |
| section CompletedLists | |
| open UniformSpace Completion | |
| variable {S : Type*} [MetricSpace S] (L : ℕ → Set (S → ℝ)) (o : S) | |
| def completedSigma (n : ℕ) : Seminorm ℝ (TestSpace L o) := | |
| (squareWeight n)⁻¹ • completedCoordinate L o n | |
| @[simp] theorem completedSigma_coe (n : ℕ) (m : PreSpace L o) : | |
| completedSigma L o n (toTestSpace L o m) = | |
| sigma (L (triple n).1) (listConstant n) (listExponent n) m := by | |
| simp only [completedSigma, smul_apply, NNReal.smul_def, NNReal.coe_inv, | |
| completedCoordinate_coe, smul_eq_mul] | |
| change (squareWeight n : ℝ)⁻¹ * ((squareWeight n : ℝ) * | |
| sigma (L (triple n).1) (listConstant n) (listExponent n) m) = _ | |
| rw [← mul_assoc, inv_mul_cancel₀ (ne_of_gt (squareWeight_pos n)), one_mul] | |
| theorem completedSigma_continuous (n : ℕ) : Continuous (completedSigma L o n) := | |
| continuous_const.mul (completedCoordinate_continuous L o n) | |
| theorem sigma_le_preNorm (n : ℕ) (m : PreSpace L o) : | |
| sigma (L (triple n).1) (listConstant n) (listExponent n) m ≤ | |
| (squareWeight n : ℝ)⁻¹ * ‖m‖ := by | |
| have h := selectedCoordinate_le_norm L o n m | |
| change (squareWeight n : ℝ) * | |
| sigma (L (triple n).1) (listConstant n) (listExponent n) m ≤ 1 * ‖m‖ at h | |
| rw [one_mul] at h | |
| have hm := mul_le_mul_of_nonneg_left h (inv_nonneg.mpr (squareWeight n).coe_nonneg) | |
| simpa only [← mul_assoc, inv_mul_cancel₀ (ne_of_gt (squareWeight_pos n)), one_mul] using hm | |
| theorem completedSigma_le (n : ℕ) (z : TestSpace L o) : | |
| completedSigma L o n z ≤ (squareWeight n : ℝ)⁻¹ * ‖z‖ := by | |
| induction z using Completion.induction_on with | |
| | hp => exact isClosed_le (completedSigma_continuous L o n) (by fun_prop) | |
| | ih m => | |
| change completedSigma L o n (toTestSpace L o m) ≤ | |
| (squareWeight n : ℝ)⁻¹ * ‖toTestSpace L o m‖ | |
| rw [completedSigma_coe, norm_toTestSpace] | |
| exact sigma_le_preNorm L o n m | |
| def initialList (n : ℕ) (l : AdmissibleList (L (triple n).1) (listConstant n)) : | |
| PreSpace L o →L[ℝ] PiLp (listExponent n) (fun _ : Fin l.length => ℝ) := | |
| (show PreSpace L o →ₗ[ℝ] PiLp (listExponent n) (fun _ : Fin l.length => ℝ) from | |
| l.eval (listExponent n)).mkContinuous (squareWeight n : ℝ)⁻¹ (fun m => by | |
| exact (list_le_sigma _ _ _ o l m).trans (sigma_le_preNorm L o n m)) | |
| def completedList (n : ℕ) (l : AdmissibleList (L (triple n).1) (listConstant n)) : | |
| TestSpace L o →L[ℝ] PiLp (listExponent n) (fun _ : Fin l.length => ℝ) := | |
| (initialList L o n l).extend (toTestSpace L o) | |
| @[simp] theorem completedList_coe (n : ℕ) | |
| (l : AdmissibleList (L (triple n).1) (listConstant n)) (m : PreSpace L o) : | |
| completedList L o n l (toTestSpace L o m) = l.eval (listExponent n) m := | |
| ContinuousLinearMap.extend_eq _ Completion.denseRange_coe | |
| (Completion.isUniformInducing_coe (PreSpace L o)) m | |
| theorem completedList_le_sigma (n : ℕ) | |
| (l : AdmissibleList (L (triple n).1) (listConstant n)) (z : TestSpace L o) : | |
| ‖completedList L o n l z‖ ≤ completedSigma L o n z := by | |
| induction z using Completion.induction_on with | |
| | hp => | |
| exact isClosed_le (completedList L o n l).continuous.norm | |
| (completedSigma_continuous L o n) | |
| | ih m => | |
| change ‖completedList L o n l (toTestSpace L o m)‖ ≤ | |
| completedSigma L o n (toTestSpace L o m) | |
| rw [completedList_coe, completedSigma_coe] | |
| exact list_le_sigma _ _ _ o l m | |
| def completedListNorm (n : ℕ) | |
| (l : AdmissibleList (L (triple n).1) (listConstant n)) : Seminorm ℝ (TestSpace L o) := | |
| (normSeminorm ℝ _).comp (completedList L o n l).toLinearMap | |
| theorem completedListNorm_bddAbove (n : ℕ) : | |
| BddAbove (Set.range (completedListNorm L o n)) := by | |
| refine ⟨completedSigma L o n, ?_⟩ | |
| rintro _ ⟨l, rfl⟩ z | |
| exact completedList_le_sigma L o n l z | |
| def sigmaFromLists (n : ℕ) : Seminorm ℝ (TestSpace L o) := | |
| ⨆ l, completedListNorm L o n l | |
| theorem sigmaFromLists_le (n : ℕ) (z : TestSpace L o) : | |
| sigmaFromLists L o n z ≤ (squareWeight n : ℝ)⁻¹ * ‖z‖ := by | |
| rw [sigmaFromLists, Seminorm.iSup_apply (completedListNorm_bddAbove L o n)] | |
| exact ciSup_le fun l => (completedList_le_sigma L o n l z).trans | |
| (completedSigma_le L o n z) | |
| theorem sigmaFromLists_eq (n : ℕ) (z : TestSpace L o) : | |
| sigmaFromLists L o n z = completedSigma L o n z := by | |
| induction z using Completion.induction_on with | |
| | hp => | |
| exact isClosed_eq (seminorm_lipschitz (sigmaFromLists L o n) ((squareWeight n)⁻¹) | |
| (sigmaFromLists_le L o n)).continuous (completedSigma_continuous L o n) | |
| | ih m => | |
| change sigmaFromLists L o n (toTestSpace L o m) = | |
| completedSigma L o n (toTestSpace L o m) | |
| rw [sigmaFromLists, Seminorm.iSup_apply (completedListNorm_bddAbove L o n), | |
| completedSigma_coe] | |
| refine Eq.trans ?_ (sigma_apply _ _ _ o (show Molecule S from m)).symm | |
| apply congrArg iSup | |
| funext l | |
| exact congrArg norm (completedList_coe L o n l m) | |
| theorem completedSigma_eq_iSup (n : ℕ) (z : TestSpace L o) : | |
| completedSigma L o n z = | |
| ⨆ l : AdmissibleList (L (triple n).1) (listConstant n), ‖completedList L o n l z‖ := by | |
| rw [← sigmaFromLists_eq, sigmaFromLists, | |
| Seminorm.iSup_apply (completedListNorm_bddAbove L o n)] | |
| rfl | |
| end CompletedLists | |
| section InterpolationAndDenseLimits | |
| theorem finite_lp_norm_rpow {ι : Type*} [Fintype ι] | |
| (p : ℝ≥0∞) (hp : 0 < p.toReal) (x : PiLp p (fun _ : ι => ℝ)) : | |
| ‖x‖ ^ p.toReal = ∑ i, |x i| ^ p.toReal := by | |
| rw [PiLp.norm_eq_sum hp, ← Real.rpow_mul (Finset.sum_nonneg | |
| (fun i _ => Real.rpow_nonneg (norm_nonneg _) _))] | |
| rw [one_div_mul_cancel hp.ne', Real.rpow_one] | |
| simp only [Real.norm_eq_abs] | |
| theorem finite_lp_interpolation {ι : Type*} [Fintype ι] | |
| (p q : ℝ≥0∞) (hp : 0 < p.toReal) (hq : 0 < q.toReal) | |
| (hqp : q.toReal < p.toReal) (x : ι → ℝ) (δ : ℝ) | |
| (hδ : ∀ i, |x i| ≤ δ) : | |
| ‖WithLp.toLp p x‖ ^ p.toReal ≤ | |
| δ ^ (p.toReal - q.toReal) * ‖WithLp.toLp q x‖ ^ q.toReal := by | |
| rw [finite_lp_norm_rpow p hp, finite_lp_norm_rpow q hq, Finset.mul_sum] | |
| apply Finset.sum_le_sum | |
| intro i hi | |
| change |x i| ^ p.toReal ≤ δ ^ (p.toReal - q.toReal) * |x i| ^ q.toReal | |
| calc | |
| |x i| ^ p.toReal = |x i| ^ (p.toReal - q.toReal) * |x i| ^ q.toReal := by | |
| rw [← Real.rpow_add' (abs_nonneg _) (by simpa using hp.ne'), sub_add_cancel] | |
| _ ≤ δ ^ (p.toReal - q.toReal) * |x i| ^ q.toReal := by | |
| exact mul_le_mul_of_nonneg_right | |
| (Real.rpow_le_rpow (abs_nonneg _) (hδ i) (sub_nonneg.mpr hqp.le)) | |
| (Real.rpow_nonneg (abs_nonneg _) _) | |
| theorem exists_uniform_lp_detector (p q : ℝ≥0∞) [Fact (1 ≤ p)] [Fact (1 ≤ q)] | |
| (hp : 0 < p.toReal) (hq : 0 < q.toReal) (hqp : q.toReal < p.toReal) | |
| (a B : ℝ) (ha : 0 < a) (hB : 0 < B) : | |
| ∃ δ : ℝ, 0 < δ ∧ ∀ (n : ℕ) (x : Fin n → ℝ), | |
| a ≤ ‖WithLp.toLp p x‖ → ‖WithLp.toLp q x‖ ≤ B → | |
| ∃ i, δ < |x i| := by | |
| let A := a ^ p.toReal | |
| let D := B ^ q.toReal | |
| have hA : 0 < A := Real.rpow_pos_of_pos ha _ | |
| have hD : 0 < D := Real.rpow_pos_of_pos hB _ | |
| have hs : 0 < p.toReal - q.toReal := sub_pos.mpr hqp | |
| let δ := (A / (2 * D)) ^ (1 / (p.toReal - q.toReal)) | |
| have hδ : 0 < δ := Real.rpow_pos_of_pos (div_pos hA (mul_pos (by norm_num) hD)) _ | |
| have hpow : δ ^ (p.toReal - q.toReal) = A / (2 * D) := by | |
| rw [show δ = (A / (2 * D)) ^ (1 / (p.toReal - q.toReal)) from rfl, | |
| ← Real.rpow_mul (by positivity), one_div_mul_cancel hs.ne', Real.rpow_one] | |
| refine ⟨δ, hδ, ?_⟩ | |
| intro n x hlow hupp | |
| by_contra! hnone | |
| have hint := finite_lp_interpolation p q hp hq hqp x δ hnone | |
| have hlu : A ≤ ‖WithLp.toLp p x‖ ^ p.toReal := Real.rpow_le_rpow ha.le hlow hp.le | |
| have huu : ‖WithLp.toLp q x‖ ^ q.toReal ≤ D := | |
| Real.rpow_le_rpow (norm_nonneg _) hupp hq.le | |
| have hb := mul_le_mul_of_nonneg_left huu (Real.rpow_nonneg hδ.le (p.toReal - q.toReal)) | |
| rw [hpow] at hint hb | |
| have heq : A / (2 * D) * D = A / 2 := by field_simp [ne_of_gt hD] | |
| rw [heq] at hb | |
| linarith | |
| theorem tendsto_of_dense_lipschitz {A X Y : Type*} [PseudoMetricSpace X] [PseudoMetricSpace Y] | |
| (d : A → X) (hd : DenseRange d) (f : ℕ → X → Y) (g : X → Y) (K : ℝ≥0) | |
| (hf : ∀ n, LipschitzWith K (f n)) (hg : LipschitzWith K g) | |
| (h : ∀ a, Filter.Tendsto (fun n => f n (d a)) Filter.atTop (nhds (g (d a)))) | |
| (x : X) : Filter.Tendsto (fun n => f n x) Filter.atTop (nhds (g x)) := by | |
| apply Metric.tendsto_nhds.mpr | |
| intro ε hε | |
| have hK : 0 < 3 * ((K : ℝ) + 1) := by positivity | |
| obtain ⟨a, ha⟩ := hd.exists_dist_lt x (div_pos hε hK) | |
| have hδ : (K : ℝ) * dist x (d a) < ε / 3 := by | |
| have hr := (lt_div_iff₀ hK).mp ha | |
| have hn := dist_nonneg (x := x) (y := d a) | |
| nlinarith | |
| filter_upwards [Metric.tendsto_nhds.mp (h a) (ε / 3) (by positivity)] with n hn | |
| have h₁ := (hf n).dist_le_mul x (d a) | |
| have h₂ := hg.dist_le_mul (d a) x | |
| rw [dist_comm (d a) x] at h₂ | |
| have ht := dist_triangle4 (f n x) (f n (d a)) (g (d a)) (g x) | |
| linarith | |
| end InterpolationAndDenseLimits | |
| end | |
| end C0Absorption | |
| end OAI | |