| import Mathlib |
| import OAI.GroupTheory.SimpleAmenable.RandomFields.CovarianceLimit |
| import OAI.GroupTheory.SimpleAmenable.RandomFields.CompactSignalEnergy |
|
|
| namespace OAI |
|
|
| section |
| section |
| open scoped symmDiff |
| namespace SimpleAmenable |
| open scoped commutatorElement |
| open scoped commutatorElement |
| section SourceSignalRemainder |
| open Classical Filter |
| open scoped Topology |
|
|
| noncomputable def sourceSignalDelta (D : ℕ) (η : ℝ) (n : ℕ) : ℝ := |
| 38880/((D:ℝ)*Real.sqrt ((2:ℝ)^n*η)) |
|
|
| noncomputable def sourceSignalError (A B Cv Ca Cr η κ : ℝ) (D n : ℕ) : ℝ := |
| Real.sqrt A*(Cv*η*(1+sourceSignalDelta D η n)+Ca*sourceSignalDelta D η n)+ |
| Real.sqrt B*Real.sqrt (κ+(1/4:ℝ)^n)*(Cr*Ca) |
|
|
| theorem sourceSignalDelta_nonneg (D n : ℕ) (η : ℝ) : 0 ≤ sourceSignalDelta D η n := by |
| unfold sourceSignalDelta; positivity |
|
|
| theorem sourceSignalDelta_tendsto {D : ℕ} (hD : 0<D) {η : ℝ} (hη : 0<η) : |
| Tendsto (sourceSignalDelta D η) atTop (nhds 0) := by |
| have ht := (tendsto_pow_atTop_atTop_of_one_lt (show (1:ℝ)<2 by norm_num)).atTop_mul_const hη |
| have hd : (0:ℝ)<D := by exact_mod_cast hD |
| have ht' := (Real.tendsto_sqrt_atTop.comp ht).const_mul_atTop hd |
| have hh := ht'.inv_tendsto_atTop.const_mul 38880 |
| change Tendsto (fun n => 38880/((D:ℝ)*Real.sqrt ((2:ℝ)^n*η))) atTop (nhds 0) |
| simpa only [div_eq_mul_inv,mul_zero,Function.comp_apply,Pi.inv_apply] using hh |
|
|
| theorem sourceSignalDelta_bound {D n i : ℕ} {η : ℝ} (hD : 0<D) (hη : 0<η) |
| (hi : n ≤ i) : 38880/((D:ℝ)*Real.sqrt ((2:ℝ)^i*η)) ≤ sourceSignalDelta D η n := by |
| have hd : (0:ℝ)<D := by exact_mod_cast hD |
| apply div_le_div_of_nonneg_left (by norm_num) (by positivity) |
| exact mul_le_mul_of_nonneg_left (Real.sqrt_le_sqrt |
| (mul_le_mul_of_nonneg_right (pow_le_pow_right₀ (by norm_num) hi) hη.le)) hd.le |
|
|
| theorem sourceSignalError_nonneg {A B Cv Ca Cr η κ : ℝ} (hCv : 0≤Cv) (hCa : 0≤Ca) |
| (hCr : 0≤Cr) (hη : 0≤η) (D n : ℕ) : 0 ≤ sourceSignalError A B Cv Ca Cr η κ D n := by |
| unfold sourceSignalError |
| positivity [sourceSignalDelta_nonneg D n η] |
|
|
| theorem sourceSignalError_tendsto {D : ℕ} (hD : 0<D) (A B Cv Ca Cr κ : ℝ) |
| {η : ℝ} (hη : 0<η) : |
| Tendsto (sourceSignalError A B Cv Ca Cr η κ D) atTop |
| (nhds (Real.sqrt A*Cv*η+Real.sqrt B*Cr*Ca*Real.sqrt κ)) := by |
| have hδ := sourceSignalDelta_tendsto hD hη |
| have hs : Tendsto (fun n : ℕ => (1/4:ℝ)^n) atTop (nhds 0) := |
| tendsto_pow_atTop_nhds_zero_of_lt_one (by norm_num) (by norm_num) |
| have hh := ((hδ.const_add 1).const_mul (Cv*η) |>.add (hδ.const_mul Ca) |>.const_mul (Real.sqrt A)).add |
| (((hs.const_add κ).sqrt.const_mul (Real.sqrt B)).mul_const (Cr*Ca)) |
| change Tendsto (fun n => Real.sqrt A*(Cv*η*(1+sourceSignalDelta D η n)+Ca*sourceSignalDelta D η n)+ |
| Real.sqrt B*Real.sqrt (κ+(1/4:ℝ)^n)*(Cr*Ca)) atTop _ |
| simpa only [mul_zero,add_zero,mul_one,mul_assoc,mul_left_comm,mul_comm] using hh |
|
|
| theorem sourceSignalBound_tendsto {D : ℕ} (hD : 0<D) (A B Cv Ca Cr C κ : ℝ) |
| {η : ℝ} (hη : 0<η) : |
| Tendsto (fun n => C/(1+sourceDyadicMass n)+sourceSignalError A B Cv Ca Cr η κ D n) |
| atTop (nhds (Real.sqrt A*Cv*η+Real.sqrt B*Cr*Ca*Real.sqrt κ)) := by |
| have hm : Tendsto (fun n => 1+sourceDyadicMass n) atTop atTop := |
| tendsto_atTop_mono (fun n => by linarith : ∀n,sourceDyadicMass n ≤ 1+sourceDyadicMass n) sourceDyadicMass_tendsto |
| have ht := hm.inv_tendsto_atTop.const_mul C |
| have ht' : Tendsto (fun n => C/(1+sourceDyadicMass n)) atTop (nhds 0) := by |
| simpa only [div_eq_mul_inv,mul_zero,Pi.inv_apply] using ht |
| simpa only [zero_add] using ht'.add (sourceSignalError_tendsto hD A B Cv Ca Cr κ hη) |
|
|
| end SourceSignalRemainder |
|
|
| section PolygonSignalInverse |
| open Classical Filter Matrix |
| open scoped Topology |
|
|
| theorem sourceFlagMatrix_inverse_signal {a m D : ℕ} {v : ℝ×ℝ} (hD : 0<D) |
| (g : polygonFullGroup a m) (ψ χ : (ℝ×ℝ) → ℝ) |
| (hψ : ContDiff ℝ 2 ψ) (hsψ : HasCompactSupport ψ) (q K L : ℝ) |
| (hL : 0<L) (hKL : K+2 ≤ L) |
| (hcompact : ∀x,K ≤ ‖x‖ → ψ x=0) |
| (hχ : ∀x,χ x∈Set.Icc (0:ℝ) 1) |
| (hχ₁ : ∀x,‖x‖ ≤ K+2 → χ x=1) |
| (hχc : ∀x,L ≤ ‖x‖ → χ x=0) : |
| ∃C₁ C₂ : ℝ,0≤C₁ ∧ 0≤C₂ ∧ ∀η : ℝ,0<η → η≤1 → ∀κ : ℝ,0<κ → |
| ∀ε : ℝ,0<ε → ∀ᶠn : ℕ in atTop, |
| ∀T : Finset (FlagSite a m D v), |
| flagBoxFinset hD (mul_pos (sourceDyadicN_pos n) hL)⊆T → |
| finiteL2Norm (((1 : Matrix T T ℝ)+(Matrix.of (fun (z w : T) => sourceFlagMatrix (v:=v) χ ((D:ℝ)^4/5) η κ n z.val w.val)))⁻¹*ᵥ |
| (fun z : T => flagSignalDifference (v:=v) hD g (fun x => q+ψ x) (sourceDyadicN n) z.val)) ≤ |
| C₁*η+C₂*Real.sqrt κ+ε := by |
| obtain ⟨R,Q,Cv,Ca,hR,hQ,hCv,hCa,happrox⟩ := |
| polygon_signal_approx_identity (v:=v) hD g ψ χ hψ hsψ q K L hL hKL hcompact hχ hχ₁ hχc |
| obtain ⟨C,hC,henergy⟩ := compactSignal_energy (v:=v) hD g ψ hψ hsψ q |
| let A := flagVolumeConstant m D L |
| let B := flagExceptionalConstant a m D L |
| let Cr := flagRowSumConstant D |
| have hA : 0≤A := by dsimp [A,flagVolumeConstant]; positivity |
| have hB : 0≤B := by dsimp [B,flagExceptionalConstant]; positivity |
| have hCr : 0≤Cr := by dsimp [Cr,flagRowSumConstant]; positivity |
| refine ⟨Real.sqrt A*Cv,Real.sqrt B*Cr*Ca,by positivity,by positivity, |
| fun η hη hη₁ κ hκ ε hε => ?_⟩ |
| have ht := sourceSignalBound_tendsto hD A B Cv Ca Cr C κ hη |
| have ht' := ht.eventually_lt_const |
| (show Real.sqrt A*Cv*η+Real.sqrt B*Cr*Ca*Real.sqrt κ < |
| (Real.sqrt A*Cv)*η+(Real.sqrt B*Cr*Ca)*Real.sqrt κ+ε by linarith) |
| filter_upwards [ht',sourceDyadic_radius_eventually Q,sourceDyadic_radius_eventually (36/η), |
| sourceDyadic_fine_eventually (max R 1) hκ] with n hn hQN hrad hf |
| intro T hJT |
| let N := sourceDyadicN n |
| have hN : 0<N := sourceDyadicN_pos n |
| have hN₁ : 1≤N := sourceDyadicN_one_le n |
| have h2N : (2:ℝ)^n≤N := by |
| unfold N sourceDyadicN |
| exact pow_le_pow_right₀ (by norm_num) (by omega) |
| have hQN' : Q≤N := hQN.trans h2N |
| let J := flagBoxFinset (a:=a) (m:=m) (v:=v) hD (mul_pos hN hL) |
| let h := flagSignalDifference (v:=v) hD g (fun x => q+ψ x) N |
| let M : ℕ → Matrix T T ℝ := fun i => (fun (z w : T) => flagAveragingMatrix (a:=a) (m:=m) (D:=D) (v:=v) χ ((D:ℝ)^4/5) N ((2:ℝ)^i) η κ z.val w.val) |
| have hd : (0:ℝ)<D := by exact_mod_cast hD |
| have hρ : 0<(D:ℝ)^4/5 := by positivity |
| have hM (i : ℕ) (hi : i∈sourceDyadicIndices n) : (M i).PosSemidef := |
| (flagAveragingMatrix_posSemidef χ hρ hN (by positivity) hκ).submatrix (fun z : T => z.val) |
| have he (i : ℕ) (hi : i∈sourceDyadicIndices n) : |
| finiteL2Norm (M i*ᵥ(fun z : T => h z)-(fun z : T => h z)) ≤ |
| sourceSignalError A B Cv Ca Cr η κ D n := by |
| have his := sourceDyadic_scale_bounds hi |
| have hiv := (Finset.mem_Icc.mp hi).1 |
| have hri : 36≤(2:ℝ)^i*η := by |
| apply (div_le_iff₀ hη).mp |
| exact hrad.trans (pow_le_pow_right₀ (by norm_num) hiv) |
| have hfR := (le_max_left R 1).trans (hf i hi) |
| have hf1 := (le_max_right R 1).trans (hf i hi) |
| have hline : 1≤2*κ/((2:ℝ)^i/N) := by |
| rw [mul_div_assoc] |
| linarith |
| obtain ⟨hesupp,herr⟩ := happrox N ((2:ℝ)^i) η κ hN₁ hQN' his.1 his.2.1 hη hη₁ hκ hri hline hfR |
| let ei := fun z => (∑w∈J,flagAveragingMatrix χ ((D:ℝ)^4/5) N ((2:ℝ)^i) η κ z w*h w)-h z |
| have hee := finite_support_error_energy J T hJT |
| (flagAveragingMatrix χ ((D:ℝ)^4/5) N ((2:ℝ)^i) η κ) h |
| (by |
| intro z w hw |
| rw [flagAveragingMatrix_box_support hD χ hL hN hχc _ _ _ _ z w (Or.inr hw),zero_mul]) |
| ei (fun _ => rfl) hesupp |
| let δ := 38880/((D:ℝ)*Real.sqrt ((2:ℝ)^i*η)) |
| have hc : 0≤Cv*η*(1+δ)+Ca*δ := by dsimp [δ]; positivity |
| have hκs : 0≤κ+(2:ℝ)^i/N := by positivity |
| have hb : finiteL2Norm (M i*ᵥ(fun z : T => h z)-(fun z : T => h z)) ≤ |
| Real.sqrt A*(Cv*η*(1+δ)+Ca*δ)+Real.sqrt (B*(κ+(2:ℝ)^i/N))*(Cr*Ca) := by |
| apply finiteL2Norm_le_of_energy hA (mul_nonneg hB hκs) hc (mul_nonneg hCr hCa) |
| rw [hee] |
| exact herr |
| rw [Real.sqrt_mul hB] at hb |
| refine hb.trans ?_ |
| have hd := sourceSignalDelta_bound hD hη hiv |
| change δ ≤ sourceSignalDelta D η n at hd |
| dsimp only [sourceSignalError] |
| gcongr |
| exact his.2.2 |
| have hs := finite_weighted_resolvent (sourceDyadicIndices n) M hM |
| (sourceDyadicWeight_nonneg n) (sourceSignalError_nonneg hCv hCa hCr hη.le D n) |
| (fun z : T => h z) he |
| have hnorm : finiteL2Norm (fun z : T => h z) ≤ C := by |
| apply (sq_le_sq₀ (finiteL2Norm_nonneg _) hC).mp |
| rw [finiteL2Norm_sq] |
| rw [show (∑i : T,h i.val^2) = ∑i∈T,h i^2 from Finset.sum_coe_sort T (fun i => h i^2)] |
| exact henergy N hN₁ T |
| have hmatrix : (sourceDyadicWeight n • ∑i∈sourceDyadicIndices n,M i)= |
| (fun (z w : T) => sourceFlagMatrix (v:=v) χ ((D:ℝ)^4/5) η κ n z.val w.val) := by |
| ext z w |
| simp only [Matrix.smul_apply,smul_eq_mul,Matrix.sum_apply] |
| simp only [M,N,sourceFlagMatrix] |
| dsimp only at hs |
| rw [hmatrix] at hs |
| change _ ≤ finiteL2Norm (fun z : T => h z)/(1+sourceDyadicMass n)+_ at hs |
| refine hs.trans ((add_le_add ?_ le_rfl).trans hn.le) |
| apply div_le_div_of_nonneg_right hnorm |
| linarith [sourceDyadicMass_nonneg n] |
|
|
| end PolygonSignalInverse |
|
|
| end SimpleAmenable |
| end |
| end |
|
|
| end OAI |
|
|
