File size: 7,308 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
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
import Mathlib

noncomputable section
namespace OAI.Analysis.Fourier.WavePackets

open Set
open scoped ContDiff

/-- A smooth cardinal partition function, supported on `[-1,1]`.
Its translates telescope, so normalization introduces no scale-dependent
denominator. -/
def angularGridBump (x : ℝ) : ℝ :=
  Real.smoothTransition (x + 1) - Real.smoothTransition x

theorem contDiff_angularGridBump : ContDiff ℝ ∞ angularGridBump :=
  (Real.smoothTransition.contDiff.comp (contDiff_id.add contDiff_const)).sub
    Real.smoothTransition.contDiff

theorem angularGridBump_nonneg (x : ℝ) : 0 ≤ angularGridBump x := by
  exact sub_nonneg.mpr (Real.smoothTransition.monotone (by linarith))

theorem angularGridBump_le_one (x : ℝ) : angularGridBump x ≤ 1 := by
  have := Real.smoothTransition.le_one (x + 1)
  have := Real.smoothTransition.nonneg x
  dsimp [angularGridBump]
  linarith

theorem angularGridBump_eq_zero {x : ℝ} (hx : x ≤ -1 ∨ 1 ≤ x) :
    angularGridBump x = 0 := by
  rcases hx with hx | hx
  · simp only [angularGridBump,
      Real.smoothTransition.zero_of_nonpos (show x + 1 ≤ 0 by linarith),
      Real.smoothTransition.zero_of_nonpos (show x ≤ 0 by linarith), sub_self]
  · simp only [angularGridBump,
      Real.smoothTransition.one_of_one_le (show 1 ≤ x + 1 by linarith),
      Real.smoothTransition.one_of_one_le hx, sub_self]

theorem angularGridBump_ne_zero {x : ℝ} (hx : angularGridBump x ≠ 0) :
    |x| < 1 := by
  by_contra hn
  have hn := le_of_not_gt hn
  exact hx (angularGridBump_eq_zero (by
    rcases le_abs.mp hn with h | h
    · exact Or.inr h
    · exact Or.inl (by linarith)))

theorem sum_angularGridBump_range (N : ℕ) (x : ℝ) :
    ∑ j ∈ Finset.range N, angularGridBump (x - j) =
      Real.smoothTransition (x + 1) - Real.smoothTransition (x - N + 1) := by
  induction N with
  | zero => simp
  | succ N ih =>
    rw [Finset.sum_range_succ, ih, angularGridBump]
    have he : x - (↑(N + 1) : ℝ) + 1 = x - N := by push_cast; ring
    rw [he]
    ring

/-- The finite interval of translates already sums to one throughout
`[-M,M]`. -/
theorem sum_angularGridBump_fin (M : ℕ) {x : ℝ} (hx : |x| ≤ M) :
    ∑ j : Fin (2 * M + 1), angularGridBump (x - ((j : ℕ) - (M : ℝ))) = 1 := by
  have he (j : ℕ) : x - (j - (M : ℝ)) = (x + M) - j := by ring
  simp_rw [he]
  rw [← Finset.sum_range (fun j : ℕ => angularGridBump (x + M - j)),
    sum_angularGridBump_range]
  have hlo : 1 ≤ x + M + 1 := by have := (abs_le.mp hx).1; linarith
  have hhi : x + M - (↑(2 * M + 1) : ℝ) + 1 ≤ 0 := by
    have := (abs_le.mp hx).2
    push_cast
    linarith
  rw [Real.smoothTransition.one_of_one_le hlo, Real.smoothTransition.zero_of_nonpos hhi]
  norm_num

/-- Tensor-product grid bump. We keep the coordinates as a finite real
product so that chart rescalings can be inserted by composition. -/
def angularGridProduct {d : ℕ} (x : Fin d → ℝ) : ℝ :=
  ∏ i, angularGridBump (x i)

theorem contDiff_angularGridProduct (d : ℕ) :
    ContDiff ℝ ∞ (angularGridProduct (d := d)) := by
  apply contDiff_prod
  intro i _
  exact contDiff_angularGridBump.comp (contDiff_apply ℝ ℝ i)

theorem angularGridProduct_nonneg {d : ℕ} (x : Fin d → ℝ) :
    0 ≤ angularGridProduct x := Finset.prod_nonneg (fun _ _ => angularGridBump_nonneg _)

theorem angularGridProduct_ne_zero {d : ℕ} {x : Fin d → ℝ}
    (hx : angularGridProduct x ≠ 0) (i : Fin d) : |x i| < 1 := by
  apply angularGridBump_ne_zero
  intro hz
  exact hx (Finset.prod_eq_zero (Finset.mem_univ i) hz)

theorem sum_angularGridProduct (d M : ℕ) {x : Fin d → ℝ}
    (hx : ∀ i, |x i| ≤ M) :
    ∑ k : Fin d → Fin (2 * M + 1),
      angularGridProduct (fun i => x i - ((k i : ℕ) - (M : ℝ))) = 1 := by
  unfold angularGridProduct
  dsimp only
  rw [← Fintype.prod_sum (fun i (j : Fin (2 * M + 1)) =>
    angularGridBump (x i - ((j : ℕ) - (M : ℝ))))]
  simp_rw [sum_angularGridBump_fin M (hx _)]
  simp

theorem tsupport_angularGridProduct_subset (d : ℕ) :
    tsupport (angularGridProduct (d := d)) ⊆ Set.Icc (fun _ => -1) (fun _ => 1) := by
  apply closure_minimal _ isClosed_Icc
  intro x hx
  constructor <;> intro i
  · exact (abs_lt.mp (angularGridProduct_ne_zero hx i)).1.le
  · exact (abs_lt.mp (angularGridProduct_ne_zero hx i)).2.le

theorem hasCompactSupport_angularGridProduct (d : ℕ) :
    HasCompactSupport (angularGridProduct (d := d)) :=
  isCompact_Icc.of_isClosed_subset (isClosed_tsupport _)
    (tsupport_angularGridProduct_subset d)

def angularGridSize (R γ : ℝ) : ℕ := ⌈R / γ⌉₊

def angularGridCenter {d : ℕ} (R γ : ℝ)
    (k : Fin d → Fin (2 * angularGridSize R γ + 1)) (i : Fin d) : ℝ :=
  γ * ((k i : ℕ) - (angularGridSize R γ : ℝ))

/-- A grid in a fixed `d`-dimensional chart has the sharp `γ⁻ᵈ`
cardinality, including the endpoint and rounding costs. -/
theorem angularGrid_card_bound (d : ℕ) {R γ : ℝ} (hR : 0 ≤ R)
    (hγ : 0 < γ) (hγ1 : γ ≤ 1) :
    (Fintype.card (Fin d → Fin (2 * angularGridSize R γ + 1)) : ℝ) ≤
      ((2 * R + 3) / γ) ^ d := by
  have hM := (Nat.ceil_lt_add_one (div_nonneg hR hγ.le)).le
  change (angularGridSize R γ : ℝ) ≤ R / γ + 1 at hM
  have hb : (2 * angularGridSize R γ + 1 : ℝ) ≤ (2 * R + 3) / γ := by
    apply (le_div_iff₀ hγ).mpr
    have hm := (mul_le_mul_of_nonneg_right hM hγ.le)
    rw [add_mul, div_mul_cancel₀ _ hγ.ne'] at hm
    nlinarith
  simp only [Fintype.card_fun, Fintype.card_fin, Nat.cast_pow, Nat.cast_add, Nat.cast_mul,
    Nat.cast_ofNat, Nat.cast_one]
  exact pow_le_pow_left₀ (by positivity) hb d

theorem angularGridCenter_bound {d : ℕ} {R γ : ℝ} (hR : 0 ≤ R)
    (hγ : 0 < γ) (hγ1 : γ ≤ 1)
    (k : Fin d → Fin (2 * angularGridSize R γ + 1)) (i : Fin d) :
    |angularGridCenter R γ k i| ≤ R + 1 := by
  have hk : (k i : ℕ) ≤ 2 * angularGridSize R γ := Nat.le_of_lt_succ (k i).isLt
  have hk' : ((k i : ℕ) : ℝ) ≤ 2 * (angularGridSize R γ : ℝ) := by exact_mod_cast hk
  have hk0 : 0 ≤ ((k i : ℕ) : ℝ) := by positivity
  have hd : |((k i : ℕ) : ℝ) - angularGridSize R γ| ≤ angularGridSize R γ :=
    abs_le.mpr ⟨by linarith, by linarith⟩
  have hM := (Nat.ceil_lt_add_one (div_nonneg hR hγ.le)).le
  change (angularGridSize R γ : ℝ) ≤ R / γ + 1 at hM
  have hm := mul_le_mul_of_nonneg_left hM hγ.le
  rw [mul_add, mul_div_cancel₀ _ hγ.ne', mul_one] at hm
  dsimp [angularGridCenter]
  rw [abs_mul, abs_of_pos hγ]
  exact (mul_le_mul_of_nonneg_left hd hγ.le).trans (by linarith)

theorem sum_scaled_angularGridProduct {d : ℕ} {R γ : ℝ} (hγ : 0 < γ)
    {x : Fin d → ℝ} (hx : ∀ i, |x i| ≤ R) :
    ∑ k : Fin d → Fin (2 * angularGridSize R γ + 1),
      angularGridProduct (fun i => (x i - angularGridCenter R γ k i) / γ) = 1 := by
  have he (k : Fin d → Fin (2 * angularGridSize R γ + 1)) (i : Fin d) :
      (x i - angularGridCenter R γ k i) / γ =
        x i / γ - ((k i : ℕ) - (angularGridSize R γ : ℝ)) := by
    dsimp [angularGridCenter]
    field_simp
  simp_rw [he]
  apply sum_angularGridProduct
  intro i
  rw [abs_div, abs_of_pos hγ]
  exact (div_le_div_of_nonneg_right (hx i) hγ.le).trans (Nat.le_ceil _)

end OAI.Analysis.Fourier.WavePackets