| import OAI.MathematicalPhysics.RapidForcing.Collars |
|
|
| namespace OAI |
|
|
| open scoped BigOperators ENNReal Topology |
| open Set MeasureTheory |
| namespace RapidForcing |
|
|
| lemma curl_joint_smooth {v : Field Space} |
| (hv : ContDiff ℝ (⊤ : ℕ∞) (Function.uncurry v)) : |
| ContDiff ℝ (⊤ : ℕ∞) (fun p : ℝ × Space => curl (v p.1) p.2) := by |
| have h : ContDiff ℝ (⊤ : ℕ∞) |
| (fun p : (ℝ × Space) × Space => v p.1.1 p.2) := |
| hv.comp (contDiff_fst.fst.prodMk contDiff_snd) |
| have hD : ContDiff ℝ (⊤ : ℕ∞) |
| (fun p : ℝ × Space => fderiv ℝ (v p.1) p.2) := |
| h.fderiv contDiff_snd (by simp) |
| apply (contDiff_piLp 2).mpr |
| intro i |
| fin_cases i <;> dsimp [curl, vec] <;> fun_prop |
|
|
| lemma movingCurl_joint_smooth {c : ℝ → Space} |
| (hc : ContDiff ℝ (⊤ : ℕ∞) c) (δ : ℝ) : |
| ContDiff ℝ (⊤ : ℕ∞) (Function.uncurry (movingCurl c δ)) := by |
| change ContDiff ℝ (⊤ : ℕ∞) (fun p : ℝ × Space => curl (fun y => |
| ζ (δ⁻¹ • (y - c p.1)) • ((1 / 2 : ℝ) • cross (deriv c p.1) (y - c p.1))) p.2) |
| apply curl_joint_smooth (v := fun σ y => |
| ζ (δ⁻¹ • (y - c σ)) • ((1 / 2 : ℝ) • cross (deriv c σ) (y - c σ))) |
| have hdc : ContDiff ℝ (⊤ : ℕ∞) (deriv c) := |
| (contDiff_infty_iff_deriv.mp hc).2 |
| apply (contDiff_piLp 2).mpr |
| intro i |
| fin_cases i <;> dsimp [cross, vec, Function.uncurry] <;> unfold ζ <;> fun_prop |
|
|
| noncomputable def stepVelocity (M : Machine) (w : M.Input) (n : ℕ) : Field Space := |
| fun t x => ∑ m ∈ Finset.range ((M.scaleData w).D n + 1), |
| movingCurl (addressPath M (M.scaleData w) n m) ((M.scaleData w).δ n) |
| (t - 1 - (n : ℝ)) x |
|
|
| noncomputable def loadingVelocity (M : Machine) (w : M.Input) : Field Space := |
| movingCurl (fun s => θ s • vec (-1) ((M.scaleData w).δ 0 * (M.initialDigit w : ℝ)) 0) 1 |
|
|
| lemma stepVelocity_smooth (M : Machine) (w : M.Input) (n : ℕ) : |
| ContDiff ℝ (⊤ : ℕ∞) (Function.uncurry (stepVelocity M w n)) := by |
| unfold stepVelocity Function.uncurry |
| apply ContDiff.sum |
| intro m _ |
| have hc : ContDiff ℝ (⊤ : ℕ∞) (addressPath M (M.scaleData w) n m) := by |
| unfold addressPath |
| exact contDiff_const.add (theta_smooth.smul contDiff_const) |
| have hsh : ContDiff ℝ (⊤ : ℕ∞) (fun p : ℝ × Space => (p.1 - 1 - (n : ℝ), p.2)) := by |
| fun_prop |
| simpa only [Function.comp_def, Function.uncurry] using |
| (movingCurl_joint_smooth hc ((M.scaleData w).δ n)).comp hsh |
|
|
| lemma loadingVelocity_smooth (M : Machine) (w : M.Input) : |
| ContDiff ℝ (⊤ : ℕ∞) (Function.uncurry (loadingVelocity M w)) := |
| movingCurl_joint_smooth (theta_smooth.smul contDiff_const) 1 |
|
|
| lemma stepVelocity_left_collar (M : Machine) (w : M.Input) (n : ℕ) {t : ℝ} |
| (ht : t < 1 + (n : ℝ) + 1 / 4) : stepVelocity M w n t = 0 := by |
| funext x |
| apply Finset.sum_eq_zero |
| intro m _ |
| exact congrFun (movingCurl_left_collar (addressCenter (M.scaleData w) n m) |
| (addressDisplacement M (M.scaleData w) n m) _ (by linarith)) x |
|
|
| lemma stepVelocity_right_collar (M : Machine) (w : M.Input) (n : ℕ) {t : ℝ} |
| (ht : 1 + (n : ℝ) + 3 / 4 < t) : stepVelocity M w n t = 0 := by |
| funext x |
| apply Finset.sum_eq_zero |
| intro m _ |
| exact congrFun (movingCurl_right_collar (addressCenter (M.scaleData w) n m) |
| (addressDisplacement M (M.scaleData w) n m) _ (by linarith)) x |
|
|
| lemma loadingVelocity_right_collar (M : Machine) (w : M.Input) {t : ℝ} |
| (ht : 3 / 4 < t) : loadingVelocity M w t = 0 := by |
| have h := movingCurl_right_collar 0 |
| (vec (-1) ((M.scaleData w).δ 0 * (M.initialDigit w : ℝ)) 0) 1 ht |
| funext x |
| change movingCurl (fun s => θ s • vec (-1) ((M.scaleData w).δ 0 * (M.initialDigit w : ℝ)) 0) |
| 1 t x = 0 |
| simpa only [zero_add] using congrFun h x |
|
|
| lemma addressedVelocity_eq_finite (M : Machine) (w : M.Input) (N : ℕ) |
| {t : ℝ} (ht : t < (N : ℝ) + 1) : |
| addressedVelocity M w t = loadingVelocity M w t + ∑ n ∈ Finset.range N, |
| stepVelocity M w n t := by |
| by_cases h : t ≤ 1 |
| · have hz : ∑ n ∈ Finset.range N, stepVelocity M w n t = 0 := by |
| apply Finset.sum_eq_zero |
| intro n _ |
| apply stepVelocity_left_collar |
| have : 0 ≤ (n : ℝ) := Nat.cast_nonneg n |
| linarith |
| rw [hz, add_zero] |
| exact funext fun x => by simp [addressedVelocity, loadingVelocity, h] |
| · have ht1 : 1 < t := lt_of_not_ge h |
| let n := Nat.floor (t - 1) |
| have hn : (n : ℝ) ≤ t - 1 := Nat.floor_le (by linarith) |
| have hn' : t - 1 < (n : ℝ) + 1 := Nat.lt_floor_add_one _ |
| have hnN : n < N := by |
| exact_mod_cast (by linarith : (n : ℝ) < (N : ℝ)) |
| have hs : (∑ j ∈ Finset.range N, stepVelocity M w j t) = stepVelocity M w n t := by |
| apply Finset.sum_eq_single n |
| · intro j _ hj |
| rcases lt_or_gt_of_ne hj with hj | hj |
| · apply stepVelocity_right_collar |
| have : (j : ℝ) + 1 ≤ (n : ℝ) := by exact_mod_cast hj |
| linarith |
| · apply stepVelocity_left_collar |
| have : (n : ℝ) + 1 ≤ (j : ℝ) := by exact_mod_cast hj |
| linarith |
| · intro hnnot |
| exact (hnnot (Finset.mem_range.mpr hnN)).elim |
| rw [hs, loadingVelocity_right_collar M w (by linarith), zero_add] |
| exact funext fun x => by simp [addressedVelocity, stepVelocity, h, n] |
| |
| theorem addressedVelocity_joint_smooth (M : Machine) (w : M.Input) : |
| ContDiff ℝ (⊤ : ℕ∞) (Function.uncurry (addressedVelocity M w)) := by |
| rw [contDiff_iff_contDiffAt] |
| intro p |
| obtain ⟨N, hN⟩ := exists_nat_gt p.1 |
| have hs : ContDiff ℝ (⊤ : ℕ∞) (fun q : ℝ × Space => |
| loadingVelocity M w q.1 q.2 + ∑ n ∈ Finset.range N, stepVelocity M w n q.1 q.2) := |
| (loadingVelocity_smooth M w).add <| ContDiff.sum fun n _ => stepVelocity_smooth M w n |
| apply hs.contDiffAt.congr_of_eventuallyEq |
| have ho : IsOpen {q : ℝ × Space | q.1 < (N : ℝ) + 1} := |
| isOpen_lt continuous_fst continuous_const |
| have he : ∀ᶠ q : ℝ × Space in 𝓝 p, q.1 < (N : ℝ) + 1 := |
| ho.mem_nhds (by change p.1 < (N : ℝ) + 1; linarith) |
| filter_upwards [he] with q hq |
| simpa only [Function.uncurry, Pi.add_apply, Finset.sum_apply] using |
| congrFun (addressedVelocity_eq_finite M w N hq) q.2 |
| |
| |
| section JointDerivatives |
| variable {E : Type} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| {v : Field E} |
| |
| lemma spatialD_joint_smooth (hv : ContDiff ℝ (⊤ : ℕ∞) (Function.uncurry v)) |
| (i : Fin 3) : ContDiff ℝ (⊤ : ℕ∞) (Function.uncurry (spatialD i v)) := by |
| have h : ContDiff ℝ (⊤ : ℕ∞) |
| (fun p : (ℝ × Space) × Space => v p.1.1 p.2) := |
| hv.comp (contDiff_fst.fst.prodMk contDiff_snd) |
| have hD : ContDiff ℝ (⊤ : ℕ∞) |
| (fun p : ℝ × Space => fderiv ℝ (v p.1) p.2) := |
| h.fderiv contDiff_snd (by simp) |
| exact hD.clm_apply contDiff_const |
| |
| lemma ordinaryTimeD_joint_smooth (hv : ContDiff ℝ (⊤ : ℕ∞) (Function.uncurry v)) : |
| ContDiff ℝ (⊤ : ℕ∞) (fun p : ℝ × Space => deriv (fun s => v s p.2) p.1) := by |
| have h : ContDiff ℝ (⊤ : ℕ∞) |
| (fun p : (ℝ × Space) × ℝ => v p.2 p.1.2) := |
| hv.comp (contDiff_snd.prodMk contDiff_fst.snd) |
| have hD : ContDiff ℝ (⊤ : ℕ∞) |
| (fun p : ℝ × Space => fderiv ℝ (fun s => v s p.2) p.1) := |
| h.fderiv contDiff_fst (by simp) |
| exact hD.clm_apply contDiff_const |
| |
| lemma timeD_eq_ordinary (hv : ContDiff ℝ (⊤ : ℕ∞) (Function.uncurry v)) |
| {t : ℝ} (ht : 0 ≤ t) (x : Space) : timeD v t x = deriv (fun s => v s x) t := by |
| have h : ContDiff ℝ (⊤ : ℕ∞) (fun s => v s x) := |
| hv.comp (contDiff_id.prodMk contDiff_const) |
| exact (h.differentiable (by simp) t).derivWithin (uniqueDiffOn_Ici 0 t ht) |
| |
| end JointDerivatives |
| |
| lemma advection_joint_smooth {v : Field Space} |
| (hv : ContDiff ℝ (⊤ : ℕ∞) (Function.uncurry v)) : |
| ContDiff ℝ (⊤ : ℕ∞) (Function.uncurry (advection v)) := by |
| change ContDiff ℝ (⊤ : ℕ∞) (fun p : ℝ × Space => ∑ i, (v p.1 p.2 i) • spatialD i v p.1 p.2) |
| apply ContDiff.sum |
| intro i _ |
| exact ((EuclideanSpace.proj i).contDiff.comp hv).smul (spatialD_joint_smooth hv i) |
| |
| lemma laplace_joint_smooth {v : Field Space} |
| (hv : ContDiff ℝ (⊤ : ℕ∞) (Function.uncurry v)) : |
| ContDiff ℝ (⊤ : ℕ∞) (Function.uncurry (laplace v)) := by |
| change ContDiff ℝ (⊤ : ℕ∞) (fun p : ℝ × Space => ∑ i, spatialD i (spatialD i v) p.1 p.2) |
| apply ContDiff.sum |
| intro i _ |
| exact spatialD_joint_smooth (spatialD_joint_smooth hv i) i |
| |
| lemma residual_smooth_of_joint_smooth {v : Field Space} |
| (hv : ContDiff ℝ (⊤ : ℕ∞) (Function.uncurry v)) (ν : ℝ) : Smooth (residual ν v) := by |
| have hr : ContDiff ℝ (⊤ : ℕ∞) (fun p : ℝ × Space => |
| deriv (fun s => v s p.2) p.1 + advection v p.1 p.2 - ν • laplace v p.1 p.2) := |
| ((ordinaryTimeD_joint_smooth hv).add (advection_joint_smooth hv)).sub |
| ((laplace_joint_smooth hv).const_smul ν) |
| apply hr.contDiffOn.congr |
| intro p hp |
| change timeD v p.1 p.2 + advection v p.1 p.2 - ν • laplace v p.1 p.2 = _ |
| rw [timeD_eq_ordinary hv hp.1] |
| |
| theorem addressed_fields_smooth (ν : ℝ) (M : Machine) (w : M.Input) : |
| Smooth (addressedVelocity M w) ∧ Smooth (addressedForce ν M w) := |
| ⟨(addressedVelocity_joint_smooth M w).contDiffOn, |
| residual_smooth_of_joint_smooth (addressedVelocity_joint_smooth M w) ν⟩ |
| |
| end RapidForcing |
| |
| end OAI |
| |
