| import Mathlib |
| import OAI.MathematicalPhysics.SheetFlows.Clocks |
| import OAI.MathematicalPhysics.SheetFlows.JetCalculus |
|
|
| namespace OAI |
|
|
| /-! SheetFlows jet profiles. -/ |
|
|
| noncomputable section |
| open Set MeasureTheory Filter |
| open scoped BigOperators Topology Polynomial |
| namespace Solenoidal |
| namespace JetExpr |
|
|
| def transition : JetExpr := .mul (.flat 1) .reciprocal |
|
|
| @[simp] theorem transition_eval (x : ℝ) : transition.eval x = Real.smoothTransition x := by |
| simp [transition, eval, flatJet, transitionReciprocal, Real.smoothTransition, div_eq_mul_inv] |
|
|
| def cutoff (h d : ℚ) : JetExpr := |
| .mul (.affine (2/d) (2*(h+d)/d) transition) |
| (.affine (-2/d) (2*(h+d)/d) transition) |
|
|
| def linearCutoff (h d : ℚ) : JetExpr := .mul .id (cutoff h d) |
|
|
| @[simp] theorem cutoff_eval (h d : ℚ) (x : ℝ) : |
| (cutoff h d).eval x = plateau h d x := by |
| simp only [cutoff, eval, transition_eval, plateau, Rat.cast_div, Rat.cast_mul, |
| Rat.cast_add, Rat.cast_neg, Rat.cast_ofNat] |
| congr 2 <;> ring |
|
|
| @[simp] theorem linearCutoff_eval (h d : ℚ) (x : ℝ) : |
| (linearCutoff h d).eval x = linearProfile h d x := by |
| simp [linearCutoff, eval, linearProfile] |
|
|
| def shiftedC (h d c : ℚ) : JetExpr := .affine 1 (-c) (cutoff h d) |
| def shiftedD (h d c : ℚ) : JetExpr := .affine 1 (-c) (linearCutoff h d) |
|
|
| def clock (a b : ℚ) : JetExpr := .affine (1/(b-a)) (-a/(b-a)) transition |
|
|
| def clockPulse (a b : ℚ) : JetExpr := (clock a b).diff |
|
|
| @[simp] theorem shiftedC_eval (h d c : ℚ) (x : ℝ) : |
| (shiftedC h d c).eval x = plateau h d (x-c) := by |
| simp [shiftedC, eval, sub_eq_add_neg] |
|
|
| @[simp] theorem shiftedD_eval (h d c : ℚ) (x : ℝ) : |
| (shiftedD h d c).eval x = linearProfile h d (x-c) := by |
| simp [shiftedD, eval, sub_eq_add_neg] |
|
|
| @[simp] theorem clock_eval (a b : ℚ) (x : ℝ) : |
| (clock a b).eval x = pulseClock a b x := by |
| simp only [clock, eval, transition_eval, pulseClock, Rat.cast_div, Rat.cast_one, |
| Rat.cast_neg, Rat.cast_sub] |
| congr 1 |
| ring |
|
|
| @[simp] theorem clockPulse_eval (a b : ℚ) (x : ℝ) : |
| (clockPulse a b).eval x = localPulse a b x := by |
| rw [clockPulse, ((clock a b).diff_correct x).deriv.symm] |
| congr 1 |
| ext t |
| exact clock_eval a b t |
|
|
| end JetExpr |
|
|
| theorem iteratedDeriv_eqOn_Icc {f g : ℝ → ℝ} {a b : ℝ} |
| (hf : ContDiff ℝ (⊤ : ℕ∞) f) (hg : ContDiff ℝ (⊤ : ℕ∞) g) |
| (hab : a < b) (he : Set.EqOn f g (Set.Icc a b)) (n : ℕ) : |
| Set.EqOn (iteratedDeriv n f) (iteratedDeriv n g) (Set.Icc a b) := by |
| induction n with |
| | zero => exact he |
| | succ n ih => |
| intro x hx |
| have hxs := uniqueDiffOn_Icc hab x hx |
| have hfn := (hf.differentiable_iteratedDeriv n (by exact WithTop.coe_lt_coe.mpr (ENat.natCast_lt_top n)) x).hasDerivAt.hasDerivWithinAt |
| (s := Set.Icc a b) |
| have hgn := (hg.differentiable_iteratedDeriv n (by exact WithTop.coe_lt_coe.mpr (ENat.natCast_lt_top n)) x).hasDerivAt.hasDerivWithinAt |
| (s := Set.Icc a b) |
| have hfn' := hfn.congr (fun y hy => (ih hy).symm) (ih hx).symm |
| rw [iteratedDeriv_succ, iteratedDeriv_succ] |
| exact (hfn'.derivWithin hxs).symm.trans (hgn.derivWithin hxs) |
|
|
| theorem iteratedDeriv_periodic {f : ℝ → ℝ} {T : ℝ} |
| (hf : ContDiff ℝ (⊤ : ℕ∞) f) (hp : Function.Periodic f T) (n : ℕ) : |
| Function.Periodic (iteratedDeriv n f) T := by |
| induction n with |
| | zero => exact hp |
| | succ n ih => |
| intro x |
| have hd := (hf.differentiable_iteratedDeriv n (by exact WithTop.coe_lt_coe.mpr (ENat.natCast_lt_top n)) (x+T)).hasDerivAt |
| have hc := hd.comp x ((hasDerivAt_id x).add_const T) |
| have he : (fun y => iteratedDeriv n f (y+T)) = iteratedDeriv n f := funext ih |
| change HasDerivAt (fun y => iteratedDeriv n f (y+T)) |
| (deriv (iteratedDeriv n f) (x+T)*1) x at hc |
| rw [he, mul_one] at hc |
| simpa only [iteratedDeriv_succ] using hc.deriv.symm |
|
|
| structure PeriodicJet (T : ℚ) (f : ℝ → ℝ) where |
| positive : 0 < T |
| smooth : ContDiff ℝ (⊤ : ℕ∞) f |
| periodic : Function.Periodic f T |
| expression : JetExpr |
| on_chart : Set.EqOn f expression.eval (Set.Icc 0 T) |
|
|
| namespace PeriodicJet |
|
|
| variable {T : ℚ} {f : ℝ → ℝ} |
|
|
| def bound (p : PeriodicJet T f) (n : ℕ) : ℚ := (p.expression.nth n).bound T |
|
|
| theorem bound_nonneg (p : PeriodicJet T f) (n : ℕ) : 0 ≤ p.bound n := |
| JetExpr.bound_nonneg _ _ |
|
|
| theorem derivative_on_chart (p : PeriodicJet T f) (n : ℕ) : |
| Set.EqOn (iteratedDeriv n f) (p.expression.nth n).eval (Set.Icc 0 T) := by |
| rw [JetExpr.nth_correct] |
| exact iteratedDeriv_eqOn_Icc p.smooth p.expression.smooth (by exact_mod_cast p.positive) |
| p.on_chart n |
|
|
| theorem bound_correct (p : PeriodicJet T f) (n : ℕ) (x : ℝ) : |
| |iteratedDeriv n f x| ≤ (p.bound n : ℝ) := by |
| have hT : (0:ℝ) < T := by exact_mod_cast p.positive |
| let r : ℝ := (T:ℝ) * Int.fract (x/T) |
| have hr : r ∈ Set.Icc (0:ℝ) (T:ℝ) := by |
| constructor |
| · exact mul_nonneg hT.le (Int.fract_nonneg _) |
| · exact (mul_le_mul_of_nonneg_left (Int.fract_lt_one _).le hT.le).trans_eq (mul_one _) |
| have he : r = x - (⌊x/(T:ℝ)⌋ : ℝ)*(T:ℝ) := by |
| change (T:ℝ) * Int.fract (x/(T:ℝ)) = _ |
| rw [Int.fract, mul_sub] |
| field_simp |
| have hp := ((iteratedDeriv_periodic p.smooth p.periodic n).int_mul ⌊x/(T:ℝ)⌋).sub_eq x |
| rw [← hp, ← he, p.derivative_on_chart n hr] |
| apply JetExpr.bound_correct |
| rw [abs_of_nonneg hr.1, abs_of_pos hT] |
| exact hr.2 |
|
|
| def ofPeriodize (T : ℚ) (hT : 0 < T) (e : JetExpr) |
| (hz : ∀ x : ℝ, x ≤ 0 ∨ (T:ℝ) ≤ x → e.eval x = 0) : |
| PeriodicJet T (periodize T e.eval) where |
| positive := hT |
| smooth := periodize_contDiff (by exact_mod_cast hT) (a := 0) (b := T) |
| (e.eval) |
| (by intro x hx; exact hz x (hx.elim (fun h => Or.inl h.le) (fun h => Or.inr h.le))) e.smooth |
| periodic := periodize_periodic _ _ |
| expression := e |
| on_chart := fun _ hx => periodize_on_chart (by exact_mod_cast hT) _ hz hx |
|
|
| def const (T : ℚ) (hT : 0 < T) (q : ℚ) : PeriodicJet T (fun _ => (q:ℝ)) where |
| positive := hT |
| smooth := contDiff_const |
| periodic := fun _ => rfl |
| expression := .const q |
| on_chart := fun _ _ => rfl |
|
|
| def add {g : ℝ → ℝ} (p : PeriodicJet T f) (q : PeriodicJet T g) : |
| PeriodicJet T (fun x => f x + g x) where |
| positive := p.positive |
| smooth := p.smooth.add q.smooth |
| periodic := p.periodic.add q.periodic |
| expression := .add p.expression q.expression |
| on_chart := by intro x hx; simp only [JetExpr.eval, p.on_chart hx, q.on_chart hx] |
|
|
| def mul {g : ℝ → ℝ} (p : PeriodicJet T f) (q : PeriodicJet T g) : |
| PeriodicJet T (fun x => f x * g x) where |
| positive := p.positive |
| smooth := p.smooth.mul q.smooth |
| periodic := p.periodic.mul q.periodic |
| expression := .mul p.expression q.expression |
| on_chart := by intro x hx; simp only [JetExpr.eval, p.on_chart hx, q.on_chart hx] |
|
|
| end PeriodicJet |
|
|
| def Cprofile_jet (h d c : ℚ) (hd : 0 < d) (hl : h+d ≤ c) (hu : c+(h+d) ≤ 10) : |
| PeriodicJet 10 (Cprofile h d c) where |
| positive := by norm_num |
| smooth := Cprofile_contDiff _ _ (by exact_mod_cast hd) |
| periodic := Cprofile_periodic _ _ _ |
| expression := JetExpr.shiftedC h d c |
| on_chart := by |
| intro x hx |
| rw [JetExpr.shiftedC_eval] |
| apply periodize_on_chart (by norm_num) _ _ hx |
| apply shifted_profile_zero_outside _ (fun s hs => plateau_zero (by exact_mod_cast hd) hs) |
| · exact_mod_cast hl |
| · exact_mod_cast hu |
|
|
| def Dprofile_jet (h d c : ℚ) (hd : 0 < d) (hl : h+d ≤ c) (hu : c+(h+d) ≤ 10) : |
| PeriodicJet 10 (Dprofile h d c) where |
| positive := by norm_num |
| smooth := Dprofile_contDiff _ _ (by exact_mod_cast hd) |
| periodic := Dprofile_periodic _ _ _ |
| expression := JetExpr.shiftedD h d c |
| on_chart := by |
| intro x hx |
| rw [JetExpr.shiftedD_eval] |
| apply periodize_on_chart (by norm_num) _ _ hx |
| apply shifted_profile_zero_outside _ (fun s hs => linearProfile_zero (by exact_mod_cast hd) hs) |
| · exact_mod_cast hl |
| · exact_mod_cast hu |
|
|
| def periodicPulse_jet (a b : ℚ) (hab : a < b) (ha : 0 ≤ a) (hb : b ≤ 1) : |
| PeriodicJet 1 (periodicPulse a b) where |
| positive := by norm_num |
| smooth := periodicPulse_contDiff (by exact_mod_cast hab) |
| periodic := by simpa using periodicPulse_periodic (a:ℝ) (b:ℝ) |
| expression := JetExpr.clockPulse a b |
| on_chart := by |
| intro x hx |
| rw [JetExpr.clockPulse_eval] |
| exact periodicPulse_on_chart (by exact_mod_cast hab) (by exact_mod_cast ha) |
| (by exact_mod_cast hb) (by simpa using hx) |
|
|
| end Solenoidal |
| end |
|
|
| end OAI |
|
|
