| import Mathlib |
|
|
| namespace OAI |
|
|
| open scoped BigOperators Topology NNReal ENNReal |
| open MeasureTheory ProbabilityTheory Filter Real |
|
|
| noncomputable section |
|
|
| namespace SquareRootDegree |
| namespace SmoothSelector |
|
|
| def clip (x : ℝ) : ℝ := max 0 (min 1 x) |
|
|
| @[fun_prop] theorem clip_continuous : Continuous clip := by unfold clip; fun_prop |
|
|
| theorem clip_nonneg (x : ℝ) : 0 ≤ clip x := le_max_left _ _ |
| theorem clip_le_one (x : ℝ) : clip x ≤ 1 := max_le zero_le_one (min_le_left _ _) |
| theorem clip_mono : Monotone clip := fun _ _ h => max_le_max le_rfl (min_le_min le_rfl h) |
| theorem clip_of_nonpos {x : ℝ} (hx : x ≤ 0) : clip x = 0 := by |
| unfold clip; rw [max_eq_left (le_trans (min_le_right _ _) hx)] |
| theorem clip_of_one_le {x : ℝ} (hx : 1 ≤ x) : clip x = 1 := by |
| unfold clip; rw [min_eq_left hx, max_eq_right zero_le_one] |
|
|
| / |
| def hat (N : ℕ) (δ : ℝ) (i : Fin (2*N+1)) (t : ℝ) : ℝ := |
| clip (t/δ + N - i + 1) - clip (t/δ + N - i) |
|
|
| @[fun_prop] theorem hat_continuous (N : ℕ) (δ : ℝ) (i : Fin (2*N+1)) : |
| Continuous (hat N δ i) := by unfold hat; fun_prop |
|
|
| theorem hat_nonneg (N : ℕ) (δ : ℝ) (i : Fin (2*N+1)) (t : ℝ) : |
| 0 ≤ hat N δ i t := by |
| unfold hat |
| exact sub_nonneg.mpr (clip_mono (by linarith)) |
|
|
| theorem hats_sum (N : ℕ) (δ t : ℝ) : |
| ∑ i : Fin (2*N+1), hat N δ i t = clip (t/δ+N+1)-clip (t/δ-N) := by |
| unfold hat |
| rw [Fin.sum_univ_eq_sum_range (fun i : ℕ => |
| clip (t/δ+N-i+1)-clip (t/δ+N-i)) (2*N+1)] |
| have he (i : ℕ) : clip (t/δ+N-i+1)-clip (t/δ+N-i) = |
| clip (t/δ+N-i+1)-clip (t/δ+N-(i+1:ℕ)+1) := by push_cast; ring_nf |
| simp_rw [he] |
| rw [Finset.sum_range_sub'] |
| push_cast |
| congr 1 <;> congr 1 <;> ring |
|
|
| theorem hats_sum_le_one (N : ℕ) (δ t : ℝ) : |
| ∑ i : Fin (2*N+1), hat N δ i t ≤ 1 := by |
| rw [hats_sum] |
| linarith [clip_le_one (t/δ+N+1),clip_nonneg (t/δ-N)] |
|
|
| theorem hats_sum_eq_one {N : ℕ} {δ t : ℝ} (hδ : 0 < δ) (ht : |t| ≤ N*δ) : |
| ∑ i : Fin (2*N+1), hat N δ i t = 1 := by |
| rw [hats_sum] |
| have ht' := abs_le.mp ht |
| have hp : t/δ-N ≤ 0 := by |
| have := (div_le_iff₀ hδ).mpr ht'.2 |
| linarith |
| have hn : 1 ≤ t/δ+N+1 := by |
| have : -(N:ℝ) ≤ t/δ := (le_div_iff₀ hδ).mpr (by linarith [ht'.1]) |
| linarith |
| rw [clip_of_one_le hn,clip_of_nonpos hp,sub_zero] |
|
|
| def middle (N : ℕ) : Fin (2*N+1) := ⟨N, by omega⟩ |
|
|
| def weight (N : ℕ) (δ : ℝ) (i : Fin (2*N+1)) (t : ℝ) : ℝ := |
| hat N δ i t + if i = middle N then 1-∑ j, hat N δ j t else 0 |
|
|
| @[fun_prop] theorem weight_continuous (N : ℕ) (δ : ℝ) (i : Fin (2*N+1)) : |
| Continuous (weight N δ i) := by |
| unfold weight |
| split_ifs <;> fun_prop |
|
|
| theorem weight_nonneg (N : ℕ) (δ : ℝ) (i : Fin (2*N+1)) (t : ℝ) : |
| 0 ≤ weight N δ i t := by |
| unfold weight |
| split_ifs <;> linarith [hat_nonneg N δ i t, hats_sum_le_one N δ t] |
|
|
| @[simp] theorem weight_sum (N : ℕ) (δ t : ℝ) : ∑ i, weight N δ i t = 1 := by |
| simp [weight, Finset.sum_add_distrib] |
|
|
| def center (N : ℕ) (δ : ℝ) (i : Fin (2*N+1)) : ℝ := 1+δ*(i-N) |
|
|
| @[simp] theorem center_middle (N : ℕ) (δ : ℝ) : center N δ (middle N) = 1 := by |
| simp [center,middle] |
|
|
| theorem hat_local {N : ℕ} {δ t : ℝ} {i : Fin (2*N+1)} (hδ : 0 < δ) |
| (hi : hat N δ i t ≠ 0) : |center N δ i-(1+t)| < δ := by |
| have hlo : -1 < t/δ+N-i := by |
| by_contra hn |
| have h : t/δ+N-i+1 ≤ 0 := by linarith |
| have h' : t/δ+N-i ≤ 0 := by linarith |
| exact hi (by simp [hat,clip_of_nonpos h,clip_of_nonpos h']) |
| have hhi : t/δ+N-i < 1 := by |
| by_contra hn |
| have h : 1 ≤ t/δ+N-i := le_of_not_gt hn |
| have h' : 1 ≤ t/δ+N-i+1 := by linarith |
| exact hi (by simp [hat,clip_of_one_le h,clip_of_one_le h']) |
| have hcancel : t/δ*δ = t := div_mul_cancel₀ _ hδ.ne' |
| rw [abs_lt] |
| dsimp [center] |
| constructor <;> nlinarith [mul_pos hδ (sub_pos.mpr hlo),mul_pos hδ (sub_pos.mpr hhi)] |
|
|
| theorem hat_support {N : ℕ} {δ t : ℝ} {i : Fin (2*N+1)} (hδ : 0 < δ) |
| (hi : hat N δ i t ≠ 0) : |t| ≤ (N+1)*δ := by |
| have hh := abs_lt.mp (hat_local hδ hi) |
| have hi0 : 0 ≤ (i:ℝ) := Nat.cast_nonneg _ |
| have hiN : (i:ℝ) ≤ 2*N := by exact_mod_cast (Nat.le_of_lt_succ i.isLt) |
| have h1 := mul_nonneg hδ.le hi0 |
| have h2 := mul_nonneg hδ.le (sub_nonneg.mpr hiN) |
| rw [abs_le] |
| dsimp [center] at hh |
| constructor <;> nlinarith |
|
|
| theorem hat_compactSupport {N : ℕ} {δ : ℝ} (hδ : 0 < δ) (i : Fin (2*N+1)) : |
| HasCompactSupport (hat N δ i) := by |
| apply HasCompactSupport.intro (isCompact_Icc (a := -(N+1)*δ) (b := (N+1)*δ)) |
| intro x hx |
| by_contra hn |
| have hh := abs_le.mp (hat_support hδ hn) |
| exact hx ⟨by linarith [hh.1],hh.2⟩ |
|
|
| end SmoothSelector |
| end SquareRootDegree |
|
|
| end |
|
|
| end OAI |
|
|
