| import OAI.MathematicalPhysics.RapidForcing.ScaleBounds | |
| import OAI.MathematicalPhysics.RapidForcing.Rapid | |
| namespace OAI | |
| section | |
| open scoped BigOperators ENNReal Topology SchwartzMap ContDiff | |
| open Set MeasureTheory | |
| namespace RapidForcing | |
| lemma joint_tsupport_subset {E : Type} [NormedAddCommGroup E] | |
| {v : Field E} {a b : ℝ} | |
| (ht : ∀ t, t < a ∨ b < t → v t = 0) | |
| (hx : ∀ t, tsupport (v t) ⊆ K) : | |
| tsupport (Function.uncurry v) ⊆ Icc a b ×ˢ K := by | |
| apply closure_minimal _ (isClosed_Icc.prod K_closed) | |
| intro p hp | |
| refine ⟨?_, hx p.1 (subset_closure hp)⟩ | |
| by_contra h | |
| have hor : p.1 < a ∨ b < p.1 := by | |
| by_cases ha : a ≤ p.1 | |
| · exact Or.inr (lt_of_not_ge (fun hb => h ⟨ha, hb⟩)) | |
| · exact Or.inl (lt_of_not_ge ha) | |
| exact hp (congrFun (ht p.1 hor) p.2) | |
| lemma stepVelocity_joint_tsupport (M : Machine) (w : M.Input) (n : ℕ) : | |
| tsupport (Function.uncurry (stepVelocity M w n)) ⊆ | |
| Icc ((n : ℝ) + 1) ((n : ℝ) + 2) ×ˢ K := by | |
| apply joint_tsupport_subset | |
| · intro t ht | |
| rcases ht with ht | ht | |
| · exact stepVelocity_left_collar M w n (by linarith) | |
| · exact stepVelocity_right_collar M w n (by linarith) | |
| · intro t | |
| apply closure_minimal _ K_closed | |
| intro x hx | |
| by_contra hK | |
| apply hx | |
| apply Finset.sum_eq_zero | |
| intro m hm | |
| exact image_eq_zero_of_notMem_tsupport (fun h => hK | |
| (addressCurl_tsupport_subset_K M w n m | |
| (Nat.le_of_lt_succ (Finset.mem_range.mp hm)) _ h)) | |
| lemma loadingVelocity_joint_tsupport (M : Machine) (w : M.Input) : | |
| tsupport (Function.uncurry (loadingVelocity M w)) ⊆ Icc (0 : ℝ) 1 ×ˢ K := by | |
| apply joint_tsupport_subset | |
| · intro t ht | |
| rcases ht with ht | ht | |
| · have hh := movingCurl_left_collar 0 | |
| (vec (-1) ((M.scaleData w).δ 0 * (M.initialDigit w : ℝ)) 0) 1 | |
| (by linarith : t < 1 / 4) | |
| funext x | |
| simpa only [loadingVelocity, zero_add, Pi.zero_apply] using congrFun hh x | |
| · exact loadingVelocity_right_collar M w (by linarith) | |
| · exact loadingCurl_tsupport_subset_K M w | |
| lemma norm_le_slot {n : ℕ} {p : ℝ × Space} | |
| (hp : p ∈ Icc ((n : ℝ) + 1) ((n : ℝ) + 2) ×ˢ K) : | |
| ‖p‖ ≤ (n : ℝ) + 3 := by | |
| have hn : (0 : ℝ) ≤ n := Nat.cast_nonneg _ | |
| change max ‖p.1‖ ‖p.2‖ ≤ _ | |
| apply max_le | |
| · rw [Real.norm_eq_abs, abs_of_nonneg (by linarith [hp.1.1])] | |
| linarith [hp.1.2] | |
| · have hx := norm_le_three_of_mem_K hp.2 | |
| linarith | |
| lemma stepVelocity_weighted_derivative_bound (M : Machine) (w : M.Input) (J k : ℕ) : | |
| ∃ C : ℝ, 0 ≤ C ∧ ∀ n : ℕ, ∀ p : ℝ × Space, | |
| ‖p‖ ^ J * ‖iteratedFDeriv ℝ k (Function.uncurry (stepVelocity M w n)) p‖ ≤ | |
| C * (((n : ℝ) + 3) ^ J * | |
| ((M.scaleData w).b n / (M.scaleData w).δ n ^ (k + 1))) := by | |
| obtain ⟨C, hC, hB⟩ := stepVelocity_derivative_bound M w k | |
| refine ⟨C, hC, ?_⟩ | |
| intro n p | |
| by_cases hp : p ∈ tsupport (Function.uncurry (stepVelocity M w n)) | |
| · calc | |
| _ ≤ ((n : ℝ) + 3) ^ J * | |
| (C * ((M.scaleData w).b n / (M.scaleData w).δ n ^ (k + 1))) := | |
| mul_le_mul (pow_le_pow_left₀ (norm_nonneg _) (norm_le_slot | |
| (stepVelocity_joint_tsupport M w n hp)) _) (hB n p) | |
| (norm_nonneg _) (by positivity) | |
| _ = _ := by ring | |
| · have hz : iteratedFDeriv ℝ k (Function.uncurry (stepVelocity M w n)) p = 0 := | |
| image_eq_zero_of_notMem_tsupport (fun h => hp (tsupport_iteratedFDeriv_subset k h)) | |
| rw [hz, norm_zero, mul_zero] | |
| exact mul_nonneg hC (mul_nonneg (by positivity) | |
| (div_nonneg ((M.scaleData w).b_pos _).le (pow_nonneg ((M.scaleData w).delta_nonneg _) _))) | |
| lemma addressedVelocity_schwartz_decay (M : Machine) (w : M.Input) (J k : ℕ) : | |
| ∃ C : ℝ, ∀ p : ℝ × Space, | |
| ‖p‖ ^ J * ‖iteratedFDeriv ℝ k (Function.uncurry (addressedVelocity M w)) p‖ ≤ C := by | |
| have hc : HasCompactSupport (Function.uncurry (loadingVelocity M w)) := | |
| (isCompact_Icc.prod K_compact).of_isClosed_subset (isClosed_tsupport _) | |
| (loadingVelocity_joint_tsupport M w) | |
| let load : 𝓢(ℝ × Space, Space) := hc.toSchwartzMap (loadingVelocity_smooth M w) | |
| obtain ⟨B, hBpos, hB⟩ := load.decay J k | |
| obtain ⟨C, hC, hbound⟩ := stepVelocity_weighted_derivative_bound M w J k | |
| let d := M.scaleData w | |
| let a : ℕ → ℝ := fun n => ((n : ℝ) + 3) ^ J * (d.b n / d.δ n ^ (k + 1)) | |
| have ha : ∀ n, 0 ≤ a n := fun n => mul_nonneg (by positivity) | |
| (div_nonneg (d.b_pos n).le (pow_nonneg (d.delta_nonneg n) _)) | |
| have hsum : Summable a := d.velocity_coefficient_summable J (k + 1) | |
| refine ⟨B + C * ∑' n, a n, ?_⟩ | |
| intro p | |
| obtain ⟨N, hN⟩ := exists_nat_gt p.1 | |
| have he : Function.uncurry (addressedVelocity M w) =ᶠ[𝓝 p] | |
| fun q : ℝ × Space => loadingVelocity M w q.1 q.2 + | |
| ∑ n ∈ Finset.range N, stepVelocity M w n q.1 q.2 := by | |
| have hopen : IsOpen {q : ℝ × Space | q.1 < (N : ℝ) + 1} := | |
| isOpen_lt continuous_fst continuous_const | |
| have ho : ∀ᶠ q : ℝ × Space in 𝓝 p, q.1 < (N : ℝ) + 1 := | |
| hopen.mem_nhds (by change p.1 < (N : ℝ) + 1; linarith) | |
| filter_upwards [ho] with q hq | |
| simpa only [Function.uncurry, Pi.add_apply, Finset.sum_apply] using | |
| congrFun (addressedVelocity_eq_finite M w N hq) q.2 | |
| have hk : (k : ℕ∞ω) ≤ (⊤ : ℕ∞) := by exact_mod_cast (le_top : (k : ℕ∞) ≤ ⊤) | |
| have hload : ContDiffAt ℝ k (Function.uncurry (loadingVelocity M w)) p := | |
| ((loadingVelocity_smooth M w).of_le hk).contDiffAt | |
| have hstep (n : ℕ) : ContDiffAt ℝ k (Function.uncurry (stepVelocity M w n)) p := | |
| ((stepVelocity_smooth M w n).of_le hk).contDiffAt | |
| have hsplit : iteratedFDeriv ℝ k | |
| (fun q : ℝ × Space => loadingVelocity M w q.1 q.2 + | |
| ∑ n ∈ Finset.range N, stepVelocity M w n q.1 q.2) p = | |
| iteratedFDeriv ℝ k (Function.uncurry (loadingVelocity M w)) p + | |
| ∑ n ∈ Finset.range N, | |
| iteratedFDeriv ℝ k (Function.uncurry (stepVelocity M w n)) p := by | |
| calc | |
| _ = iteratedFDeriv ℝ k (Function.uncurry (loadingVelocity M w)) p + | |
| iteratedFDeriv ℝ k (fun q : ℝ × Space => | |
| ∑ n ∈ Finset.range N, stepVelocity M w n q.1 q.2) p := by | |
| exact fun_iteratedFDeriv_add_apply hload | |
| (ContDiffAt.sum (s := Finset.range N) (fun n _ => hstep n)) | |
| _ = _ := congrArg (_ + ·) (iteratedFDeriv_fun_sum_apply (fun n _ => hstep n)) | |
| rw [(he.iteratedFDeriv ℝ k).eq_of_nhds, hsplit] | |
| calc | |
| _ ≤ ‖p‖ ^ J * (‖iteratedFDeriv ℝ k (Function.uncurry (loadingVelocity M w)) p‖ + | |
| ∑ n ∈ Finset.range N, ‖iteratedFDeriv ℝ k (Function.uncurry (stepVelocity M w n)) p‖) := by | |
| apply mul_le_mul_of_nonneg_left _ (by positivity) | |
| exact (norm_add_le _ _).trans (add_le_add le_rfl (norm_sum_le _ _)) | |
| _ = ‖p‖ ^ J * ‖iteratedFDeriv ℝ k (Function.uncurry (loadingVelocity M w)) p‖ + | |
| ∑ n ∈ Finset.range N, ‖p‖ ^ J * | |
| ‖iteratedFDeriv ℝ k (Function.uncurry (stepVelocity M w n)) p‖ := by | |
| rw [mul_add, Finset.mul_sum] | |
| _ ≤ B + ∑ n ∈ Finset.range N, C * a n := by | |
| exact add_le_add (hB p) (Finset.sum_le_sum (fun n _ => hbound n p)) | |
| _ = B + C * ∑ n ∈ Finset.range N, a n := by rw [Finset.mul_sum] | |
| _ ≤ B + C * ∑' n, a n := add_le_add le_rfl | |
| (mul_le_mul_of_nonneg_left (hsum.sum_le_tsum _ (fun n _ => ha n)) hC) | |
| noncomputable def addressedSchwartz (M : Machine) (w : M.Input) : 𝓢(ℝ × Space, Space) where | |
| toFun := Function.uncurry (addressedVelocity M w) | |
| smooth' := addressedVelocity_joint_smooth M w | |
| decay' := addressedVelocity_schwartz_decay M w | |
| end RapidForcing | |
| end | |
| end OAI | |