| import Mathlib |
| import OAI.MathematicalPhysics.SheetFlows.ScheduledForce |
| import OAI.MathematicalPhysics.SheetFlows.JetProfiles |
|
|
| namespace OAI |
|
|
| /-! SheetFlows box jets. -/ |
|
|
| noncomputable section |
| open Set MeasureTheory Filter |
| open scoped BigOperators Topology |
| namespace Solenoidal |
|
|
| def coordinateLinear : Fin 4 → SpaceTime →L[ℝ] ℝ := |
| ![ContinuousLinearMap.fst ℝ ℝ Space, |
| (ContinuousLinearMap.proj 0).comp (ContinuousLinearMap.snd ℝ ℝ Space), |
| (ContinuousLinearMap.proj 1).comp (ContinuousLinearMap.snd ℝ ℝ Space), |
| (ContinuousLinearMap.proj 2).comp (ContinuousLinearMap.snd ℝ ℝ Space)] |
|
|
| @[simp] theorem coordinateLinear_eq (j : Fin 4) (z : SpaceTime) : |
| coordinateLinear j z = flatten z j := by |
| fin_cases j <;> rfl |
|
|
| @[simp] theorem coordinateLinear_basis (i j : Fin 4) : |
| coordinateLinear i (spacetimeBasis j) = if i=j then 1 else 0 := by |
| fin_cases i <;> fin_cases j <;> simp [coordinateLinear, spacetimeBasis, basis] |
|
|
| inductive BoxExpr where |
| | const : ℚ → BoxExpr |
| | coord : Fin 4 → JetExpr → BoxExpr |
| | add : BoxExpr → BoxExpr → BoxExpr |
| | mul : BoxExpr → BoxExpr → BoxExpr |
|
|
| namespace BoxExpr |
|
|
| def eval : BoxExpr → SpaceTime → ℝ |
| | .const q => fun _ => q |
| | .coord j e => fun z => e.eval (coordinateLinear j z) |
| | .add e f => fun z => e.eval z + f.eval z |
| | .mul e f => fun z => e.eval z * f.eval z |
|
|
| theorem smooth (e : BoxExpr) : ContDiff ℝ (⊤ : ℕ∞) e.eval := by |
| induction e with |
| | const q => exact contDiff_const |
| | coord j e => exact e.smooth.comp (coordinateLinear j).contDiff |
| | add e f he hf => exact he.add hf |
| | mul e f he hf => exact he.mul hf |
|
|
| def diff (j : Fin 4) : BoxExpr → BoxExpr |
| | .const _ => .const 0 |
| | .coord i e => if i=j then .coord i e.diff else .const 0 |
| | .add e f => .add (e.diff j) (f.diff j) |
| | .mul e f => .add (.mul (e.diff j) f) (.mul e (f.diff j)) |
|
|
| theorem diff_correct (e : BoxExpr) (j : Fin 4) (z : SpaceTime) : |
| (e.diff j).eval z = fderiv ℝ e.eval z (spacetimeBasis j) := by |
| induction e with |
| | const q => simp [diff,eval] |
| | coord i e => |
| have h := HasDerivAt.comp_hasFDerivAt z (e.diff_correct (coordinateLinear i z)) |
| (coordinateLinear i).hasFDerivAt |
| have he : (.coord i e : BoxExpr).eval = e.eval ∘ coordinateLinear i := rfl |
| rw [he, h.fderiv] |
| by_cases hij : i=j |
| · subst j |
| simp only [diff, ↓reduceIte, eval, smul_apply, coordinateLinear_basis, |
| smul_eq_mul, mul_one] |
| · simp only [diff, eval, Rat.cast_zero, smul_apply, |
| coordinateLinear_basis, ite_eq_right hij, smul_eq_mul, mul_zero] |
| | add e f he hf => |
| simp only [diff, eval, fderiv_fun_add (e.smooth.differentiable (by simp) z) |
| (f.smooth.differentiable (by simp) z), add_apply, he, hf] |
| | mul e f he hf => |
| simp only [diff, eval, fderiv_fun_mul (e.smooth.differentiable (by simp) z) |
| (f.smooth.differentiable (by simp) z), add_apply, |
| smul_apply, smul_eq_mul, he, hf] |
| ring |
|
|
| def mixed (e : BoxExpr) : List (Fin 4) → BoxExpr |
| | [] => e |
| | j::α => (e.mixed α).diff j |
|
|
| def bound : BoxExpr → ℚ → ℚ |
| | .const q, _ => |q| |
| | .coord _ e, R => e.bound R |
| | .add e f, R => e.bound R + f.bound R |
| | .mul e f, R => e.bound R * f.bound R |
|
|
| theorem bound_nonneg (e : BoxExpr) (R : ℚ) : 0 ≤ e.bound R := by |
| induction e with |
| | const q => exact abs_nonneg q |
| | coord i e => exact e.bound_nonneg R |
| | add e f he hf => exact add_nonneg he hf |
| | mul e f he hf => exact mul_nonneg he hf |
|
|
| theorem bound_correct (e : BoxExpr) (R : ℚ) (z : SpaceTime) |
| (hz : ∀ j, |flatten z j| ≤ |(R:ℝ)|) : |e.eval z| ≤ (e.bound R:ℝ) := by |
| induction e with |
| | const q => simp [eval,bound] |
| | coord i e => exact e.bound_correct R (coordinateLinear i z) (by simpa using hz i) |
| | add e f he hf => |
| simpa only [eval,bound,Rat.cast_add] using (abs_add_le _ _).trans (add_le_add he hf) |
| | mul e f he hf => |
| simpa only [eval,bound,Rat.cast_mul,abs_mul] using |
| mul_le_mul he hf (abs_nonneg _) (by exact_mod_cast e.bound_nonneg R) |
|
|
| end BoxExpr |
|
|
| def expressionField (e : Fin 3 → BoxExpr) : Field := fun t x j => (e j).eval (t,x) |
|
|
| theorem expressionField_smooth (e : Fin 3 → BoxExpr) : Smooth (expressionField e) := |
| contDiff_pi.mpr (fun j => (e j).smooth) |
|
|
| theorem mixedDerivative_expressionField (e : Fin 3 → BoxExpr) (α : List (Fin 4)) : |
| mixedDerivative (expressionField e) α = fun z j => ((e j).mixed α).eval z := by |
| induction α with |
| | nil => rfl |
| | cons k α ih => |
| ext z j |
| rw [mixedDerivative,ih] |
| change (fderiv ℝ (fun z j => ((e j).mixed α).eval z) z (spacetimeBasis k)) j = _ |
| rw [fderiv_pi (fun i => ((e i).mixed α).smooth.differentiable (by simp) z)] |
| exact (((e j).mixed α).diff_correct k z).symm |
|
|
| def expressionBound (e : Fin 3 → BoxExpr) (α : List (Fin 4)) (R : ℚ) : ℚ := |
| ∑ j, ((e j).mixed α).bound R |
|
|
| theorem expressionBound_nonneg (e : Fin 3 → BoxExpr) (α : List (Fin 4)) (R : ℚ) : |
| 0 ≤ expressionBound e α R := |
| Finset.sum_nonneg (fun j _ => BoxExpr.bound_nonneg ((e j).mixed α) R) |
|
|
| theorem expressionBound_correct (e : Fin 3 → BoxExpr) (α : List (Fin 4)) (R : ℚ) |
| (z : SpaceTime) (hz : ∀ j, |flatten z j| ≤ |(R:ℝ)|) : |
| ‖mixedDerivative (expressionField e) α z‖ ≤ (expressionBound e α R : ℝ) := by |
| apply (pi_norm_le_iff_of_nonneg (by exact_mod_cast expressionBound_nonneg e α R)).mpr |
| intro j |
| rw [mixedDerivative_expressionField] |
| change |((e j).mixed α).eval z| ≤ _ |
| apply (BoxExpr.bound_correct _ R z hz).trans |
| exact_mod_cast Finset.single_le_sum (fun i _ => BoxExpr.bound_nonneg _ _) (Finset.mem_univ j) |
|
|
| def closedPeriodCell : Set SpaceTime := Set.Icc (0,0) (1,fun _ => 10) |
|
|
| theorem mixedDerivative_eqOn_open {u v : Field} {S : Set SpaceTime} (hS : IsOpen S) |
| (h : Set.EqOn (fun z => u z.1 z.2) (fun z => v z.1 z.2) S) (α : List (Fin 4)) : |
| Set.EqOn (mixedDerivative u α) (mixedDerivative v α) S := by |
| induction α with |
| | nil => exact h |
| | cons j α ih => |
| intro z hz |
| change fderiv ℝ (mixedDerivative u α) z (spacetimeBasis j) = _ |
| rw [(ih.eventuallyEq_of_mem (hS.mem_nhds hz)).fderiv_eq] |
| rfl |
|
|
| theorem mixedDerivative_eqOn_cell {u v : Field} (hu : Smooth u) (hv : Smooth v) |
| (h : Set.EqOn (fun z => u z.1 z.2) (fun z => v z.1 z.2) closedPeriodCell) |
| (α : List (Fin 4)) : |
| Set.EqOn (mixedDerivative u α) (mixedDerivative v α) closedPeriodCell := by |
| have hc : Convex ℝ closedPeriodCell := convex_Icc _ _ |
| have hn : (interior closedPeriodCell).Nonempty := by |
| have he : interior closedPeriodCell = |
| (Set.Ioo (0:ℝ) 1) ×ˢ (Set.pi Set.univ (fun _ : Fin 3 => Set.Ioo (0:ℝ) 10)) := by |
| simp [closedPeriodCell, Set.Icc_prod_eq, interior_prod_eq, interior_Icc, |
| ← Set.pi_univ_Icc, interior_pi_set] |
| rw [he] |
| exact ⟨(1/2,fun _ => 5), by norm_num [Set.mem_pi]⟩ |
| have hi : Set.EqOn (mixedDerivative u α) (mixedDerivative v α) (interior closedPeriodCell) := |
| mixedDerivative_eqOn_open isOpen_interior (h.mono interior_subset) α |
| have hh := hi.closure (mixedDerivative_contDiff hu α).continuous (mixedDerivative_contDiff hv α).continuous |
| have hclosure : closure (interior closedPeriodCell) = closedPeriodCell := |
| hc.closure_interior_eq_closure_of_nonempty_interior hn |>.trans isClosed_Icc.closure_eq |
| rwa [hclosure] at hh |
|
|
| theorem periodic_expression_mixed_bound {u : Field} (hu : Smooth u) |
| (hs : SpatiallyPeriodic u) (ht : OnePeriodic u) (e : Fin 3 → BoxExpr) |
| (he : Set.EqOn (fun z => u z.1 z.2) (fun z => expressionField e z.1 z.2) closedPeriodCell) |
| (α : List (Fin 4)) (z : SpaceTime) : |
| ‖mixedDerivative u α z‖ ≤ (expressionBound e α 10 : ℝ) := by |
| have hp := periodic_field_reduction |
| (mixedDerivative_spatially_periodic hu hs α) (mixedDerivative_onePeriodic hu ht α) z.1 z.2 |
| change mixedDerivative u α z = mixedDerivative u α (Int.fract z.1,wrapSpace z.2) at hp |
| rw [hp] |
| have hx : (Int.fract z.1,wrapSpace z.2) ∈ closedPeriodCell := |
| ⟨⟨Int.fract_nonneg _, (wrapSpace_mem z.2).1⟩, |
| ⟨(Int.fract_lt_one _).le, (wrapSpace_mem z.2).2⟩⟩ |
| rw [mixedDerivative_eqOn_cell hu (expressionField_smooth e) he α hx] |
| apply expressionBound_correct |
| intro j |
| fin_cases j |
| · simp only [flatten, Rat.cast_ofNat, abs_of_pos (by norm_num : (0:ℝ)<10)] |
| rw [abs_of_nonneg (Int.fract_nonneg _)] |
| exact (Int.fract_lt_one _).le.trans (by norm_num) |
| all_goals |
| change |wrapSpace z.2 _| ≤ |(10:ℝ)| |
| rw [abs_of_nonneg ((wrapSpace_mem z.2).1 _)] |
| simpa using (wrapSpace_mem z.2).2 _ |
|
|
| end Solenoidal |
| end |
|
|
| end OAI |
|
|
