File size: 7,889 Bytes
4a56cd6
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
import OAI.Analysis.Fourier.WavePackets.AngularAtlas
import OAI.Analysis.PDE.Concentration.FrequencyParameters

open OAI.Analysis.Fourier.Wave

noncomputable section
namespace OAI.Analysis.Fourier.WavePackets

open Set OAI.Analysis.Calculus.Current OAI.Analysis.PDE.Concentration
open scoped RealInnerProductSpace

def angularChartAxis {d : ℕ} (c : Fin d → ℝ) : Space (d + 1) :=
  WithLp.toLp 2 (Fin.cases 1 c)

@[simp] theorem angularChartAxis_zero {d : ℕ} (c : Fin d → ℝ) :
    angularChartAxis c 0 = 1 := rfl

@[simp] theorem angularChartAxis_succ {d : ℕ} (c : Fin d → ℝ) (i : Fin d) :
    angularChartAxis c i.succ = c i := by simp [angularChartAxis]

theorem angularChartAxis_norm_ge_one {d : ℕ} (c : Fin d → ℝ) :
    1 ≤ ‖angularChartAxis c‖ := by
  simpa using PiLp.norm_apply_le (angularChartAxis c) 0

def angularChartRotation {d : ℕ} (c : Fin d → ℝ) :
    Space (d + 1) ≃ₗᵢ[ℝ] Space (d + 1) :=
  Submodule.reflection (ℝ ∙ (angularChartAxis c -
    ‖angularChartAxis c‖ • EuclideanSpace.single 0 1))ᗮ

theorem angularChartRotation_axis {d : ℕ} (c : Fin d → ℝ) :
    angularChartRotation c (angularChartAxis c) =
      ‖angularChartAxis c‖ • EuclideanSpace.single 0 1 := by
  apply Submodule.reflection_sub
  simp [norm_smul]

theorem euclidean_norm_le_sum_abs {ι : Type*} [Fintype ι] [DecidableEq ι]
    (x : EuclideanSpace ℝ ι) : ‖x‖ ≤ ∑ i, |x i| := by
  have he : (∑ i, EuclideanSpace.single i (x i)) = x := by
    ext j
    simp
  calc
    ‖x‖ = ‖∑ i, EuclideanSpace.single i (x i)‖ := congrArg norm he.symm
    _ ≤ ∑ i, ‖EuclideanSpace.single i (x i)‖ := norm_sum_le _ _
    _ = ∑ i, |x i| := by simp

theorem angular_chart_residual_bound {d : ℕ} {γ : ℝ} (_ : 0 ≤ γ)
    (c : Fin d → ℝ) {ξ : Space (d + 1)} (_ : 0 ≤ ξ 0)
    (hw : ∀ i : Fin d, |ξ i.succ - c i * ξ 0| ≤ γ * ξ 0) :
    ‖ξ - ξ 0 • angularChartAxis c‖ ≤ (d : ℝ) * γ * ξ 0 := by
  calc
    ‖ξ - ξ 0 • angularChartAxis c‖ ≤
        ∑ i : Fin (d + 1), |(ξ - ξ 0 • angularChartAxis c) i| :=
      euclidean_norm_le_sum_abs _
    _ = ∑ i : Fin d, |ξ i.succ - c i * ξ 0| := by
      rw [Fin.sum_univ_succ]
      simp [mul_comm]
    _ ≤ ∑ _ : Fin d, γ * ξ 0 := Finset.sum_le_sum (fun i _ => hw i)
    _ = (d : ℝ) * γ * ξ 0 := by simp; ring

theorem angular_chart_rotated_residual_bound {d : ℕ} {γ : ℝ} (hγ : 0 ≤ γ)
    (c : Fin d → ℝ) {ξ : Space (d + 1)} (hξ : 0 ≤ ξ 0)
    (hw : ∀ i : Fin d, |ξ i.succ - c i * ξ 0| ≤ γ * ξ 0) :
    ‖angularChartRotation c ξ -
      (ξ 0 * ‖angularChartAxis c‖) • EuclideanSpace.single 0 1‖ ≤
        (d : ℝ) * γ * ξ 0 := by
  have he : angularChartRotation c (ξ - ξ 0 • angularChartAxis c) =
      angularChartRotation c ξ -
        (ξ 0 * ‖angularChartAxis c‖) • EuclideanSpace.single 0 1 := by
    rw [map_sub, map_smul, angularChartRotation_axis, smul_smul]
  rw [← he, (angularChartRotation c).norm_map]
  exact angular_chart_residual_bound hγ c hξ hw

theorem angular_chart_positive_rotated_axis {d : ℕ} {γ : ℝ} (hγ : 0 ≤ γ)
    (hsmall : (d : ℝ) * γ ≤ 1 / 2)
    (c : Fin d → ℝ) {ξ : Space (d + 1)} (hξ : 0 ≤ ξ 0)
    (hw : ∀ i : Fin d, |ξ i.succ - c i * ξ 0| ≤ γ * ξ 0) :
    ξ 0 / 2 ≤ angularChartRotation c ξ 0 := by
  have hr := angular_chart_rotated_residual_bound hγ c hξ hw
  have hc := PiLp.norm_apply_le (angularChartRotation c ξ -
      (ξ 0 * ‖angularChartAxis c‖) • EuclideanSpace.single 0 1) 0
  have hc' : |angularChartRotation c ξ 0 - ξ 0 * ‖angularChartAxis c‖| ≤
      (d : ℝ) * γ * ξ 0 := by
    simpa using hc.trans hr
  have haxis := mul_le_mul_of_nonneg_left (angularChartAxis_norm_ge_one c) hξ
  have hsize := mul_le_mul_of_nonneg_right hsmall hξ
  have hlo := (abs_le.mp hc').1
  nlinarith

/-- Dropping the real longitudinal coordinate is a contraction into the
complex transverse space. -/
theorem norm_transverseFrequency_le {d : ℕ} (η : OAI.Analysis.Calculus.Current.SpatialSpace d) :
    ‖OAI.Analysis.PDE.Concentration.transverseFrequency η‖ ≤ ‖η‖ := by
  have ht : ‖OAI.Analysis.PDE.Concentration.transverseFrequency η‖ ^ 2 = ∑ i : Fin d, η (some i) ^ 2 := by
    rw [EuclideanSpace.norm_sq_eq]
    apply Finset.sum_congr rfl
    intro i hi
    simp [OAI.Analysis.PDE.Concentration.transverseFrequency, Complex.norm_real]
  have hη : ‖η‖ ^ 2 = η none ^ 2 + ∑ i : Fin d, η (some i) ^ 2 := by
    rw [EuclideanSpace.norm_sq_eq, Fintype.sum_option]
    simp
  nlinarith [sq_nonneg (η none), norm_nonneg η, norm_nonneg (OAI.Analysis.PDE.Concentration.transverseFrequency η)]

theorem norm_transverse_rotated_chart_le {d : ℕ} {γ : ℝ} (hγ : 0 ≤ γ)
    (c : Fin d → ℝ) {ξ : Space (d + 1)} (hξ : 0 ≤ ξ 0)
    (hw : ∀ i : Fin d, |ξ i.succ - c i * ξ 0| ≤ γ * ξ 0) :
    ‖OAI.Analysis.PDE.Concentration.transverseFrequency ((OAI.Analysis.PDE.Concentration.spatialFinIsometry d).symm (angularChartRotation c ξ))‖ ≤
      (d : ℝ) * γ * ξ 0 := by
  let v := angularChartRotation c ξ -
      (ξ 0 * ‖angularChartAxis c‖) • EuclideanSpace.single 0 1
  have he : OAI.Analysis.PDE.Concentration.transverseFrequency ((OAI.Analysis.PDE.Concentration.spatialFinIsometry d).symm v) =
      OAI.Analysis.PDE.Concentration.transverseFrequency ((OAI.Analysis.PDE.Concentration.spatialFinIsometry d).symm (angularChartRotation c ξ)) := by
    ext i
    simp [OAI.Analysis.PDE.Concentration.transverseFrequency, OAI.Analysis.PDE.Concentration.spatialFinIsometry_symm_apply, v]
  rw [← he]
  exact (norm_transverseFrequency_le _).trans
    (by rw [(OAI.Analysis.PDE.Concentration.spatialFinIsometry d).symm.norm_map];
        exact angular_chart_rotated_residual_bound hγ c hξ hw)

/-- The projective-grid width gives the genuine Gaussian velocity
bound in the orthogonal packet frame. -/
theorem angular_chart_gaussian_velocity_bound {d : ℕ} {γ : ℝ} (hγ : 0 ≤ γ)
    (hsmall : (d : ℝ) * γ ≤ 1 / 2)
    (c : Fin d → ℝ) {ξ : Space (d + 1)} (hξ : 0 < ξ 0)
    (hw : ∀ i : Fin d, |ξ i.succ - c i * ξ 0| ≤ γ * ξ 0) :
    let η := (OAI.Analysis.PDE.Concentration.spatialFinIsometry d).symm (angularChartRotation c ξ)
    0 < OAI.Analysis.PDE.Concentration.gaussianFrequencyK η ∧ ‖OAI.Analysis.PDE.Concentration.gaussianVelocity η‖ ≤ 4 * d * γ := by
  dsimp only
  let η := (OAI.Analysis.PDE.Concentration.spatialFinIsometry d).symm (angularChartRotation c ξ)
  have hη0 : ξ 0 / 2 ≤ η none := by
    simpa [η, OAI.Analysis.PDE.Concentration.spatialFinIsometry_symm_apply] using
      angular_chart_positive_rotated_axis hγ hsmall c hξ.le hw
  have hsqrt0 : 0 < Real.sqrt 2 := by positivity
  have hsqrt2 : Real.sqrt 2 ≤ 2 := by nlinarith [Real.sq_sqrt (by norm_num : (0 : ℝ) ≤ 2)]
  have hk : ξ 0 / 4 ≤ OAI.Analysis.PDE.Concentration.gaussianFrequencyK η := by
    rw [OAI.Analysis.PDE.Concentration.gaussianFrequencyK, le_div_iff₀ hsqrt0]
    have hh := mul_le_mul_of_nonneg_left hsqrt2 (show 0 ≤ ξ 0 / 4 by positivity)
    nlinarith [norm_nonneg η]
  have hk0 : 0 < OAI.Analysis.PDE.Concentration.gaussianFrequencyK η := lt_of_lt_of_le (by positivity) hk
  refine ⟨hk0, ?_⟩
  change ‖(OAI.Analysis.PDE.Concentration.gaussianFrequencyK η)⁻¹ • OAI.Analysis.PDE.Concentration.transverseFrequency η‖ ≤ _
  rw [norm_smul, Real.norm_eq_abs, abs_of_pos (inv_pos.mpr hk0), ← div_eq_inv_mul]
  apply (div_le_iff₀ hk0).mpr
  have ht := norm_transverse_rotated_chart_le hγ c hξ.le hw
  change ‖OAI.Analysis.PDE.Concentration.transverseFrequency η‖ ≤ (d : ℝ) * γ * ξ 0 at ht
  have hh := mul_le_mul_of_nonneg_left hk (show 0 ≤ 4 * (d : ℝ) * γ by positivity)
  nlinarith

end OAI.Analysis.Fourier.WavePackets