Download data/lean/OAI/Analysis/C0Absorption/Lists.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 9.29 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Analysis/C0Absorption/Lists.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Analysis/C0Absorption/Lists.lean
-
curl -L -o Lists.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Analysis/C0Absorption/Lists.lean
9.29 kB
| 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 | |