| import Mathlib |
| import OAI.Analysis.BoxTransport.Motion |
| import OAI.Analysis.BoxTransport.Expressions |
|
|
| namespace OAI |
|
|
| /-! Effective realization of every balanced finite box instruction. -/ |
|
|
| noncomputable section |
| open scoped Topology |
| open scoped BigOperators ContDiff |
|
|
| open scoped BigOperators ContDiff |
| namespace BoxTransport.Routing.Computation |
|
|
| @[fun_prop] theorem representable_stageSwitch (j : Fin 5) : |
| Representable (fun p : SpaceTime => stageSwitch j p.1) := by |
| unfold stageSwitch |
| fun_prop |
|
|
| @[fun_prop] theorem representable_routeCenters {n : ℕ} (a b : Fin n → RationalSpace) (D : ℚ) |
| (i : Fin n) (j : Fin 3) : |
| Representable (fun p : SpaceTime => routeCenters a b (D : ℝ) i p.1 j) := by |
| fin_cases j <;> dsimp [routeCenters, routeCenterParameters] <;> fun_prop |
|
|
| @[fun_prop] theorem representable_linearBlend {n : ℕ} (h k : Fin n → RationalSpace) |
| (i : Fin n) (j : Fin 3) : Representable (fun p : SpaceTime => |
| 1 - stageSwitch 2 p.1 + stageSwitch 2 p.1 * scaleRatio h k i j) := by |
| unfold scaleRatio |
| fun_prop |
|
|
| @[fun_prop] theorem representable_routeScales {n : ℕ} {h k : Fin n → RationalSpace} |
| (hh : ∀ i j, 0 < h i j) (hk : ∀ i j, 0 < k i j) (i : Fin n) (j : Fin 3) : |
| Representable (fun p : SpaceTime => routeScales h k i p.1 j) := by |
| fin_cases j |
| · exact representable_linearBlend h k i 0 |
| · exact representable_linearBlend h k i 1 |
| · change Representable (fun p : SpaceTime => |
| ((1 - stageSwitch 2 p.1 + stageSwitch 2 p.1 * scaleRatio h k i 0) * |
| (1 - stageSwitch 2 p.1 + stageSwitch 2 p.1 * scaleRatio h k i 1))⁻¹) |
| apply ((representable_linearBlend h k i 0).mul (representable_linearBlend h k i 1)).inv |
| refine ⟨min 1 (scaleRatio h k i 0) * min 1 (scaleRatio h k i 1), |
| mul_pos (lt_min zero_lt_one (scaleRatio_pos hh hk i 0)) |
| (lt_min zero_lt_one (scaleRatio_pos hh hk i 1)), fun p => ?_⟩ |
| have hp (j : Fin 3) := linearBlend_pos (scaleRatio_pos hh hk i j) (stageSwitch_mem 2 p.1) |
| rw [abs_of_pos (mul_pos (hp 0) (hp 1))] |
| exact mul_le_mul (linearBlend_between (stageSwitch_mem 2 p.1)).1 |
| (linearBlend_between (stageSwitch_mem 2 p.1)).1 |
| (le_of_lt (lt_min zero_lt_one (scaleRatio_pos hh hk i 1))) (hp 0).le |
|
|
| theorem routeScales_separated_from_zero {n : ℕ} {h k : Fin n → RationalSpace} |
| (hh : ∀ i j, 0 < h i j) (hk : ∀ i j, 0 < k i j) (i : Fin n) (j : Fin 3) : |
| ∃ ε : ℝ, 0 < ε ∧ ∀ p : SpaceTime, ε ≤ |routeScales h k i p.1 j| := by |
| have hs := scaleRatio_pos hh hk i |
| fin_cases j <;> simp only [Fin.reduceFinMk] |
| · refine ⟨min 1 (scaleRatio h k i 0), lt_min zero_lt_one (hs 0), fun p => ?_⟩ |
| rw [abs_of_pos (routeScales_pos hh hk i p.1 0)] |
| exact (linearBlend_between (stageSwitch_mem 2 p.1)).1 |
| · refine ⟨min 1 (scaleRatio h k i 1), lt_min zero_lt_one (hs 1), fun p => ?_⟩ |
| rw [abs_of_pos (routeScales_pos hh hk i p.1 1)] |
| exact (linearBlend_between (stageSwitch_mem 2 p.1)).1 |
| · refine ⟨(max 1 (scaleRatio h k i 0) * max 1 (scaleRatio h k i 1))⁻¹, |
| inv_pos.mpr (mul_pos (lt_max_of_lt_left zero_lt_one) (lt_max_of_lt_left zero_lt_one)), fun p => ?_⟩ |
| rw [abs_of_pos (routeScales_pos hh hk i p.1 2)] |
| change _ ≤ ((1 - stageSwitch 2 p.1 + stageSwitch 2 p.1 * scaleRatio h k i 0) * |
| (1 - stageSwitch 2 p.1 + stageSwitch 2 p.1 * scaleRatio h k i 1))⁻¹ |
| have hp (j : Fin 3) := linearBlend_pos (hs j) (stageSwitch_mem 2 p.1) |
| apply inv_anti₀ (mul_pos (hp 0) (hp 1)) |
| exact mul_le_mul (linearBlend_between (stageSwitch_mem 2 p.1)).2 |
| (linearBlend_between (stageSwitch_mem 2 p.1)).2 (hp 1).le |
| (le_of_lt (lt_max_of_lt_left zero_lt_one)) |
|
|
| theorem time_partial_curve {c : ℝ → Space} (hc : ContDiff ℝ ∞ c) (p : SpaceTime) (j : Fin 3) : |
| fderiv ℝ (fun p : SpaceTime => c p.1 j) p (coordinateDirection none) = deriv c p.1 j := by |
| have hs : ContDiff ℝ ∞ (fun p : SpaceTime => c p.1) := hc.comp contDiff_fst |
| rw [fderiv_apply (hs.differentiable (by simp) p)] |
| have hd := ((hc.differentiable (by simp) p.1).hasFDerivAt.comp p hasFDerivAt_fst).fderiv |
| change fderiv ℝ (fun p : SpaceTime => c p.1) p = _ at hd |
| rw [hd] |
| rfl |
|
|
| @[fun_prop] theorem representable_curve_deriv {c : ℝ → Space} (hc : ContDiff ℝ ∞ c) |
| (hrep : ∀ j, Representable (fun p : SpaceTime => c p.1 j)) (j : Fin 3) : |
| Representable (fun p : SpaceTime => deriv c p.1 j) := by |
| have h := (hrep j).directional none |
| simpa only [time_partial_curve hc] using h |
|
|
| @[fun_prop] theorem representable_diagonalLogVelocity {n : ℕ} {h k : Fin n → RationalSpace} |
| (hh : ∀ i j, 0 < h i j) (hk : ∀ i j, 0 < k i j) (i : Fin n) (j : Fin 3) : |
| Representable (fun p : SpaceTime => diagonalLogVelocity (routeScales h k i) p.1 j) := by |
| exact (representable_curve_deriv (contDiff_routeScales hh hk i) (representable_routeScales hh hk i) j).div |
| (representable_routeScales hh hk i j) (routeScales_separated_from_zero hh hk i j) |
|
|
| @[fun_prop] theorem representable_movingAffinePotential {c v l : ℝ → Space} |
| (hc : ∀ j, Representable (fun p : SpaceTime => c p.1 j)) |
| (hv : ∀ j, Representable (fun p : SpaceTime => v p.1 j)) |
| (hl : ∀ j, Representable (fun p : SpaceTime => l p.1 j)) (j : Fin 3) : |
| Representable (fun p => movingAffinePotential c v l p j) := by |
| have hr (j : Fin 3) := (Representable.space j).sub (hc j) |
| have hcomp (i j : Fin 3) : Representable |
| (fun p : SpaceTime => potentialComponent (c p.1) (v p.1) (l p.1) i j p) := by |
| exact ((Representable.one.div_nat 2).mul (((hv i).mul (hr j)).sub ((hv j).mul (hr i)))).add |
| (((Representable.one.div_nat 3).mul ((hl i).sub (hl j))).mul ((hr i).mul (hr j))) |
| fin_cases j |
| · exact hcomp 1 2 |
| · exact hcomp 2 0 |
| · exact hcomp 0 1 |
|
|
| @[fun_prop] theorem representable_movingBoxCutoff {c r : ℝ → Space} |
| (hc : ∀ j, Representable (fun p : SpaceTime => c p.1 j)) |
| (hr : ∀ j, Representable (fun p : SpaceTime => r p.1 j)) (η : ℚ) : |
| Representable (movingBoxCutoff c r η) := by |
| unfold movingBoxCutoff |
| apply Representable.prod |
| intro j _ |
| have hrj := (hr j).add ((Representable.ofNat 2).mul (Representable.rational η)) |
| have hxj := (Representable.space j).sub (hc j) |
| exact ((hrj.add hxj).div_rat η).transition.mul ((hrj.sub hxj).div_rat η).transition |
|
|
| @[fun_prop] theorem representable_familyPotential {n : ℕ} {c v l r : Fin n → ℝ → Space} |
| (hc : ∀ i j, Representable (fun p : SpaceTime => c i p.1 j)) |
| (hv : ∀ i j, Representable (fun p : SpaceTime => v i p.1 j)) |
| (hl : ∀ i j, Representable (fun p : SpaceTime => l i p.1 j)) |
| (hr : ∀ i j, Representable (fun p : SpaceTime => r i p.1 j)) (η : ℚ) (j : Fin 3) : |
| Representable (fun p => familyPotential c v l r η p j) := by |
| simp only [familyPotential, Finset.sum_apply] |
| apply Representable.sum |
| intro i _ |
| change Representable (fun p => movingBoxCutoff (c i) (r i) η p * movingAffinePotential (c i) (v i) (l i) p j) |
| exact (representable_movingBoxCutoff (hc i) (hr i) η).mul |
| (representable_movingAffinePotential (hc i) (hv i) (hl i) j) |
|
|
| @[fun_prop] theorem representable_spatialCurl {A : Field} |
| (hrep : ∀ j, Representable (fun p => A p j)) (j : Fin 3) : |
| Representable (fun p => spatialCurl A p j) := by |
| have hA : ContDiff ℝ ∞ A := contDiff_pi.mpr (fun j => (hrep j).smooth) |
| have hd (d : Axis) (k : Fin 3) : Representable (fun p => fderiv ℝ A p (coordinateDirection d) k) := by |
| have hh := (hrep k).directional d |
| simpa only [fderiv_apply (hA.differentiable (by simp) _), ContinuousLinearMap.comp_apply, |
| ContinuousLinearMap.proj_apply] using hh |
| fin_cases j <;> simp only [spatialCurl, curlLinear_apply] |
| · exact (hd (some 1) 2).sub (hd (some 2) 1) |
| · exact (hd (some 2) 0).sub (hd (some 0) 2) |
| · exact (hd (some 0) 1).sub (hd (some 1) 0) |
|
|
| theorem representable_routedField {n : ℕ} (a b h k : Fin n → RationalSpace) |
| (hh : ∀ i j, 0 < h i j) (hk : ∀ i j, 0 < k i j) (η : ℚ) (j : Fin 3) : |
| Representable (fun p => routedField a b h k η p j) := by |
| have hc (i : Fin n) (j : Fin 3) : Representable (fun p : SpaceTime => |
| routeCenters a b (30 * (boxDataBound h k : ℝ)) i p.1 j) := by |
| simpa only [Rat.cast_mul, Rat.cast_ofNat] using representable_routeCenters a b (30 * boxDataBound h k) i j |
| apply representable_spatialCurl |
| apply representable_familyPotential |
| · exact hc |
| · intro i j |
| exact representable_curve_deriv (contDiff_routeCenters a b _ i) (hc i) j |
| · exact representable_diagonalLogVelocity hh hk |
| · intro i j |
| exact (representable_routeScales hh hk i j).mul (Representable.rational (h i j)) |
|
|
| theorem effective_routedField {n : ℕ} (a b h k : Fin n → RationalSpace) |
| (hh : ∀ i j, 0 < h i j) (hk : ∀ i j, 0 < k i j) (η : ℚ) |
| (hs : ContDiff ℝ ∞ (routedField a b h k η)) (hc : HasCompactSupport (routedField a b h k η)) : |
| Effective (routedField a b h k η) := by |
| choose es he hv using representable_routedField a b h k hh hk η |
| exact effective_of_expressions hs hc es he (fun p j => congrFun (hv j) p) |
|
|
| end BoxTransport.Routing.Computation |
|
|
| namespace BoxTransport.Routing |
|
|
| theorem balanced_box_routing |
| (n : ℕ) (a b h k : Fin n → RationalSpace) |
| (hh : ∀ i j, 0 < h i j) (hk : ∀ i j, 0 < k i j) |
| (ha : Pairwise fun i j => Disjoint (solidBox (a i) (h i)) (solidBox (a j) (h j))) |
| (hb : Pairwise fun i j => Disjoint (solidBox (b i) (k i)) (solidBox (b j) (k j))) |
| (hvol : ∀ i, ∏ j : Fin 3, k i j / h i j = 1) : |
| ∃ U : Field, ∃ Φ : ℝ → Space → Space, |
| AdmissibleField U ∧ IsGlobalFlow U Φ ∧ Delivers a b h k Φ := by |
| obtain ⟨η, _, hs, hc, hdiv, ht, Φ, hΦ, hdel⟩ := exists_routedField_realization n a b h k hh hk ha hb hvol |
| exact ⟨routedField a b h k η, Φ, ⟨hs, hc, Computation.effective_routedField a b h k hh hk η hs hc, |
| hdiv, ht⟩, hΦ, hdel⟩ |
|
|
| end BoxTransport.Routing |
|
|
| end |
|
|
| end OAI |
|
|
