| import OAI.Analysis.C0Absorption.Core |
| import Mathlib |
|
|
| namespace OAI |
|
|
| namespace C0Absorption |
|
|
| open scoped BigOperators NNReal ENNReal |
| noncomputable section |
| open Finset |
|
|
| section Molecules |
|
|
| variable (S : Type*) |
|
|
| def MoleculeSpace : Submodule ℝ (S →₀ ℝ) := |
| (Finsupp.linearCombination ℝ (fun _ : S => (1 : ℝ))).ker |
|
|
| abbrev Molecule := MoleculeSpace S |
|
|
| noncomputable def pairing (f : S → ℝ) : Molecule S →ₗ[ℝ] ℝ := |
| (Finsupp.linearCombination ℝ f).comp (MoleculeSpace S).subtype |
|
|
| variable {S} |
|
|
| noncomputable def molecule (s t : S) : Molecule S := |
| ⟨Finsupp.single s 1 - Finsupp.single t 1, by |
| simp [MoleculeSpace, LinearMap.mem_ker]⟩ |
|
|
| @[simp] theorem pairing_molecule (f : S → ℝ) (s t : S) : |
| pairing S f (molecule s t) = f s - f t := by |
| simp [pairing, molecule] |
|
|
| @[simp] theorem pairing_const (c : ℝ) (m : Molecule S) : |
| pairing S (fun _ => c) m = 0 := by |
| have hm := m.property |
| change (Finsupp.linearCombination ℝ (fun _ : S => (1 : ℝ))) m.val = 0 at hm |
| simp only [Finsupp.linearCombination_apply, smul_eq_mul, mul_one] at hm |
| simp only [pairing, LinearMap.comp_apply, Submodule.subtype_apply, |
| Finsupp.linearCombination_apply, smul_eq_mul] |
| rw [← Finsupp.sum_mul, hm, zero_mul] |
|
|
| theorem molecule_decomposition (m : Molecule S) (o : S) : |
| m = ∑ s ∈ m.val.support, m.val s • molecule s o := by |
| classical |
| have hm := m.property |
| change (Finsupp.linearCombination ℝ (fun _ : S => (1 : ℝ))) m.val = 0 at hm |
| simp only [Finsupp.linearCombination_apply, smul_eq_mul, mul_one, |
| Finsupp.sum] at hm |
| apply Subtype.ext |
| simp only [Submodule.coe_sum, Submodule.coe_smul, molecule, smul_sub] |
| rw [Finset.sum_sub_distrib, ← Finset.sum_smul, hm, zero_smul, sub_zero] |
| simpa only [Finsupp.smul_single, smul_eq_mul, mul_one, Finsupp.sum] using (Finsupp.sum_single m.val).symm |
|
|
| @[simp] theorem molecule_self (s : S) : molecule s s = 0 := by |
| apply Subtype.ext |
| simp [molecule] |
|
|
| theorem molecule_sub_molecule (s t o : S) : molecule s o - molecule t o = molecule s t := by |
| apply Subtype.ext |
| change (Finsupp.single s 1 - Finsupp.single o 1) - |
| (Finsupp.single t 1 - Finsupp.single o 1) = Finsupp.single s 1 - Finsupp.single t 1 |
| abel |
|
|
| end Molecules |
|
|
| section TestLists |
|
|
| variable {S : Type*} [MetricSpace S] |
|
|
| structure AdmissibleList (L : Set (S → ℝ)) (C : ℝ≥0) where |
| length : ℕ |
| test : Fin length → S → ℝ |
| mem : ∀ i, test i ∈ L |
| signed_lipschitz : ∀ ε : Fin length → ℝ, (∀ i, |ε i| = 1) → |
| LipschitzWith C (fun s => ∑ i, ε i * test i s) |
|
|
| def AdmissibleList.empty (L : Set (S → ℝ)) (C : ℝ≥0) : AdmissibleList L C where |
| length := 0 |
| test := Fin.elim0 |
| mem i := Fin.elim0 i |
| signed_lipschitz ε hε := by |
| apply LipschitzWith.of_dist_le_mul |
| intro s t |
| simp only [Fin.sum_univ_zero, dist_self] |
| positivity |
|
|
| instance (L : Set (S → ℝ)) (C : ℝ≥0) : Nonempty (AdmissibleList L C) := |
| ⟨AdmissibleList.empty L C⟩ |
|
|
| theorem AdmissibleList.sum_abs_sub_le {L : Set (S → ℝ)} {C : ℝ≥0} |
| (l : AdmissibleList L C) (s t : S) : |
| ∑ i, |l.test i s - l.test i t| ≤ C * dist s t := by |
| classical |
| let ε : Fin l.length → ℝ := fun i => if 0 ≤ l.test i s - l.test i t then 1 else -1 |
| have hε : ∀ i, |ε i| = 1 := by |
| intro i |
| dsimp [ε] |
| split <;> norm_num |
| have heq : ∀ i, ε i * (l.test i s - l.test i t) = |
| |l.test i s - l.test i t| := by |
| intro i |
| dsimp [ε] |
| split |
| · simp [abs_of_nonneg, *] |
| · simp [abs_of_neg (lt_of_not_ge ‹¬ 0 ≤ l.test i s - l.test i t›)] |
| have h := (l.signed_lipschitz ε hε).dist_le_mul s t |
| rw [Real.dist_eq, ← Finset.sum_sub_distrib] at h |
| simp_rw [← mul_sub, heq] at h |
| rwa [abs_of_nonneg (Finset.sum_nonneg fun _ _ => abs_nonneg _)] at h |
|
|
| theorem finite_lp_norm_le_sum {ι : Type*} [Fintype ι] (p : ℝ≥0∞) [Fact (1 ≤ p)] |
| (f : PiLp p (fun _ : ι => ℝ)) : ‖f‖ ≤ ∑ i, |f i| := by |
| classical |
| have heq : f = ∑ i, PiLp.single p (β := fun _ : ι => ℝ) i (f i) := by |
| apply PiLp.ext |
| intro j |
| simp [← WithLp.toLp_sum, PiLp.single, Function.update, Pi.single] |
| calc |
| ‖f‖ = ‖∑ i, PiLp.single p (β := fun _ : ι => ℝ) i (f i)‖ := congrArg norm heq |
| _ ≤ ∑ i, ‖PiLp.single p (β := fun _ : ι => ℝ) i (f i)‖ := norm_sum_le _ _ |
| _ = ∑ i, |f i| := by simp [PiLp.norm_single, Real.norm_eq_abs] |
|
|
| def AdmissibleList.eval {L : Set (S → ℝ)} {C : ℝ≥0} |
| (l : AdmissibleList L C) (p : ℝ≥0∞) : |
| Molecule S →ₗ[ℝ] PiLp p (fun _ : Fin l.length => ℝ) := |
| (WithLp.linearEquiv p ℝ _).symm.toLinearMap.comp |
| (LinearMap.pi fun i => pairing S (l.test i)) |
|
|
| @[simp] theorem AdmissibleList.eval_apply {L : Set (S → ℝ)} {C : ℝ≥0} |
| (l : AdmissibleList L C) (p : ℝ≥0∞) (m : Molecule S) (i : Fin l.length) : |
| (l.eval p m) i = pairing S (l.test i) m := rfl |
|
|
| def AdmissibleList.seminorm {L : Set (S → ℝ)} {C : ℝ≥0} |
| (l : AdmissibleList L C) (p : ℝ≥0∞) [Fact (1 ≤ p)] : Seminorm ℝ (Molecule S) := |
| (normSeminorm ℝ (PiLp p (fun _ : Fin l.length => ℝ))).comp (l.eval p) |
|
|
| @[simp] theorem AdmissibleList.seminorm_apply {L : Set (S → ℝ)} {C : ℝ≥0} |
| (l : AdmissibleList L C) (p : ℝ≥0∞) [Fact (1 ≤ p)] (m : Molecule S) : |
| l.seminorm p m = ‖l.eval p m‖ := rfl |
|
|
| theorem AdmissibleList.seminorm_molecule_le {L : Set (S → ℝ)} {C : ℝ≥0} |
| (l : AdmissibleList L C) (p : ℝ≥0∞) [Fact (1 ≤ p)] (s t : S) : |
| l.seminorm p (molecule s t) ≤ C * dist s t := by |
| calc |
| l.seminorm p (molecule s t) ≤ ∑ i, |(l.eval p (molecule s t)) i| := |
| finite_lp_norm_le_sum p _ |
| _ = ∑ i, |l.test i s - l.test i t| := by simp |
| _ ≤ C * dist s t := l.sum_abs_sub_le s t |
|
|
| theorem AdmissibleList.seminorm_le {L : Set (S → ℝ)} {C : ℝ≥0} |
| (l : AdmissibleList L C) (p : ℝ≥0∞) [Fact (1 ≤ p)] (o : S) (m : Molecule S) : |
| l.seminorm p m ≤ C * ∑ s ∈ m.val.support, |m.val s| * dist s o := by |
| classical |
| conv_lhs => rw [molecule_decomposition m o] |
| simp only [AdmissibleList.seminorm_apply, map_sum, map_smul] |
| calc |
| ‖∑ s ∈ m.val.support, m.val s • l.eval p (molecule s o)‖ |
| ≤ ∑ s ∈ m.val.support, |m.val s| * ‖l.eval p (molecule s o)‖ := by |
| simpa only [norm_smul, Real.norm_eq_abs] using |
| norm_sum_le m.val.support (fun s => m.val s • l.eval p (molecule s o)) |
| _ ≤ ∑ s ∈ m.val.support, |m.val s| * (C * dist s o) := by |
| apply Finset.sum_le_sum |
| intro s hs |
| exact mul_le_mul_of_nonneg_left (l.seminorm_molecule_le p s o) (abs_nonneg _) |
| _ = C * ∑ s ∈ m.val.support, |m.val s| * dist s o := by |
| rw [Finset.mul_sum] |
| apply Finset.sum_congr rfl |
| intro s hs |
| ring |
|
|
| def sigma (L : Set (S → ℝ)) (C : ℝ≥0) (p : ℝ≥0∞) [Fact (1 ≤ p)] : |
| Seminorm ℝ (Molecule S) := |
| ⨆ l : AdmissibleList L C, l.seminorm p |
|
|
| theorem list_seminorms_bddAbove (L : Set (S → ℝ)) (C : ℝ≥0) |
| (p : ℝ≥0∞) [Fact (1 ≤ p)] (o : S) : |
| BddAbove (Set.range fun l : AdmissibleList L C => l.seminorm p) := by |
| rw [Seminorm.bddAbove_range_iff] |
| intro m |
| refine ⟨C * ∑ s ∈ m.val.support, |m.val s| * dist s o, ?_⟩ |
| rintro _ ⟨l, rfl⟩ |
| exact l.seminorm_le p o m |
|
|
| theorem sigma_apply (L : Set (S → ℝ)) (C : ℝ≥0) |
| (p : ℝ≥0∞) [Fact (1 ≤ p)] (o : S) (m : Molecule S) : |
| sigma L C p m = ⨆ l : AdmissibleList L C, ‖l.eval p m‖ := by |
| exact Seminorm.iSup_apply (list_seminorms_bddAbove L C p o) |
|
|
| theorem sigma_molecule_le (L : Set (S → ℝ)) (C : ℝ≥0) |
| (p : ℝ≥0∞) [Fact (1 ≤ p)] (s t : S) : |
| sigma L C p (molecule s t) ≤ C * dist s t := by |
| rw [sigma_apply L C p s] |
| exact ciSup_le fun l => l.seminorm_molecule_le p s t |
|
|
| theorem list_le_sigma (L : Set (S → ℝ)) (C : ℝ≥0) |
| (p : ℝ≥0∞) [Fact (1 ≤ p)] (o : S) (l : AdmissibleList L C) : |
| l.seminorm p ≤ sigma L C p := |
| le_ciSup (list_seminorms_bddAbove L C p o) l |
|
|
| theorem sigma_le (L : Set (S → ℝ)) (C : ℝ≥0) |
| (p : ℝ≥0∞) [Fact (1 ≤ p)] (o : S) (m : Molecule S) : |
| sigma L C p m ≤ C * ∑ s ∈ m.val.support, |m.val s| * dist s o := by |
| rw [sigma_apply L C p o] |
| exact ciSup_le fun l => l.seminorm_le p o m |
|
|
| end TestLists |
|
|
| section SquareSum |
|
|
| variable {M : Type*} [AddCommGroup M] [Module ℝ M] |
| variable (q : ℕ → Seminorm ℝ M) |
| variable (hq : ∀ x, Summable (fun n => (q n x) ^ 2)) |
|
|
| def squareVector (x : M) : lp (fun _ : ℕ => ℝ) 2 := |
| ⟨fun n => q n x, memℓp_gen (by |
| simpa only [ENNReal.toReal_ofNat, Real.rpow_two, Real.norm_eq_abs, sq_abs] |
| using hq x)⟩ |
|
|
| @[simp] theorem squareVector_apply (x : M) (n : ℕ) : |
| squareVector q hq x n = q n x := rfl |
|
|
| def squareSeminorm : Seminorm ℝ M := |
| Seminorm.of (fun x => ‖squareVector q hq x‖) |
| (by |
| intro x y |
| calc |
| ‖squareVector q hq (x + y)‖ ≤ ‖squareVector q hq x + squareVector q hq y‖ := by |
| apply lp.norm_mono (by norm_num : (2 : ℝ≥0∞) ≠ 0) |
| intro n |
| change ‖q n (x + y)‖ ≤ ‖q n x + q n y‖ |
| rw [Real.norm_of_nonneg (apply_nonneg _ _), |
| Real.norm_of_nonneg (add_nonneg (apply_nonneg _ _) (apply_nonneg _ _))] |
| exact map_add_le_add _ _ _ |
| _ ≤ ‖squareVector q hq x‖ + ‖squareVector q hq y‖ := norm_add_le _ _) |
| (by |
| intro a x |
| have h : squareVector q hq (a • x) = ‖a‖ • squareVector q hq x := by |
| apply lp.ext |
| funext n |
| change q n (a • x) = ‖a‖ * q n x |
| exact map_smul_eq_mul _ _ _ |
| rw [h, norm_smul, norm_norm]) |
|
|
| @[simp] theorem squareSeminorm_apply (x : M) : |
| squareSeminorm q hq x = ‖squareVector q hq x‖ := rfl |
|
|
| theorem squareSeminorm_sq (x : M) : |
| (squareSeminorm q hq x) ^ 2 = ∑' n, (q n x) ^ 2 := by |
| simpa only [squareSeminorm_apply, ENNReal.toReal_ofNat, Real.rpow_two, |
| Real.norm_eq_abs, sq_abs, squareVector_apply] using |
| lp.norm_rpow_eq_tsum (by norm_num : 0 < (2 : ℝ≥0∞).toReal) (squareVector q hq x) |
| |
| theorem coordinate_le_squareSeminorm (n : ℕ) (x : M) : |
| q n x ≤ squareSeminorm q hq x := by |
| simpa only [squareSeminorm_apply, squareVector_apply, |
| Real.norm_of_nonneg (apply_nonneg _ _)] using |
| lp.norm_apply_le_norm (by norm_num : (2 : ℝ≥0∞) ≠ 0) (squareVector q hq x) n |
| |
| theorem seminorm_abs_sub_le (r : Seminorm ℝ M) (x y : M) : |
| |r x - r y| ≤ r (x - y) := by |
| have hxy := map_add_le_add r (x - y) y |
| have hyx := map_add_le_add r (y - x) x |
| rw [sub_add_cancel] at hxy hyx |
| have hn : r (y - x) = r (x - y) := by rw [← neg_sub x y, map_neg_eq_map] |
| rw [hn] at hyx |
| apply abs_le.mpr |
| constructor <;> linarith |
| |
| theorem squareVector_sub_norm_le (x y : M) : |
| ‖squareVector q hq x - squareVector q hq y‖ ≤ squareSeminorm q hq (x - y) := by |
| apply lp.norm_mono (by norm_num : (2 : ℝ≥0∞) ≠ 0) |
| intro n |
| change ‖q n x - q n y‖ ≤ ‖q n (x - y)‖ |
| rw [Real.norm_eq_abs, Real.norm_of_nonneg (apply_nonneg _ _)] |
| exact seminorm_abs_sub_le _ _ _ |
| |
| end SquareSum |
| |
| end |
| end C0Absorption |
| |
| end OAI |
| |
