File size: 7,380 Bytes
37bcf52 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 | import OAI.MathematicalPhysics.NavierStokes.ForcedComputation.Programs.NonperiodicForceEvaluation
import OAI.MathematicalPhysics.NavierStokes.ForcedComputation.Flow.PlanarPulseExpressions
import OAI.MathematicalPhysics.NavierStokes.ForcedComputation.Detector.TriangularLift
namespace OAI
/-! The balanced compiler uses the existing nonperiodic finite syntax.
Periodic time pulses are replaced, on a rational time window, by the finite
set of translates which can meet that window. Spatial cutoffs remain exact
on the whole plane, including their collars. -/
noncomputable section
namespace ForcedComputation.BalancedExpressions
open ShearFlows PlanarHamiltonian VelocityDetector Set
open scoped ContDiff BigOperators
def coordinate (j : Fin 2) : NonperiodicExpr := .coord j.castSucc.succ
theorem coordinate_val (j : Fin 2) (y : SpaceTime) :
(coordinate j).val y = horizontal y.2 j := by
fin_cases j <;> rfl
def cutoffCode (R : RationalBox 2) (δ : ℚ) : NonperiodicExpr :=
.mul (NonperiodicExpr.composeProfile (.cutoff (R.lower 0-2*δ) (R.lower 0-δ)
(R.upper 0+δ) (R.upper 0+2*δ)) (coordinate 0))
(NonperiodicExpr.composeProfile (.cutoff (R.lower 1-2*δ) (R.lower 1-δ)
(R.upper 1+δ) (R.upper 1+2*δ)) (coordinate 1))
theorem cutoffCode_val (R : RationalBox 2) (δ : ℚ) (y : SpaceTime) :
(cutoffCode R δ).val y = rectangleCutoff R δ (horizontal y.2) := by
simp only [cutoffCode, NonperiodicExpr.val, NonperiodicExpr.val_composeProfile,
ProfileExpr.val_cutoff, coordinate_val, rectangleCutoff, Rat.cast_sub,
Rat.cast_add, Rat.cast_mul, Rat.cast_ofNat]
def primitiveCode : Primitive → NonperiodicExpr
| .translation v => .sub (.mul (.const (v 0)) (coordinate 1))
(.mul (.const (v 1)) (coordinate 0))
| .horizontal c a => .mul (.const (a/2))
(.mul (.sub (coordinate 1) (.const (c 1))) (.sub (coordinate 1) (.const (c 1))))
| .vertical c a => .mul (.const (-a/2))
(.mul (.sub (coordinate 0) (.const (c 0))) (.sub (coordinate 0) (.const (c 0))))
theorem primitiveCode_val (p : Primitive) (y : SpaceTime) :
(primitiveCode p).val y = p.potential (horizontal y.2) := by
cases p <;> simp only [primitiveCode, Primitive.potential, NonperiodicExpr.sub,
NonperiodicExpr.val, coordinate_val, translationPotential, horizontalPotential,
verticalPotential, Rat.cast_div, Rat.cast_neg, Rat.cast_ofNat] <;> ring
def potentialCode (p : Pulse) : NonperiodicExpr :=
.mul (cutoffCode p.rectangle p.collar) (primitiveCode p.primitive)
theorem potentialCode_val (p : Pulse) (y : SpaceTime) :
(potentialCode p).val y = p.hamiltonian (horizontal y.2) := by
rw [potentialCode, NonperiodicExpr.val, cutoffCode_val, primitiveCode_val]
rfl
def translateIndices (p : Pulse) (u v : ℚ) : Finset ℤ :=
Finset.Icc ⌊u-p.finish⌋ ⌈v-p.start⌉
def translatePulse (p : Pulse) (k : ℤ) : NonperiodicExpr :=
NonperiodicExpr.composeProfile (ProfileExpr.ramp p.start p.finish).diff
(.sub (.coord 0) (.const k))
theorem translatePulse_val (p : Pulse) (k : ℤ) (y : SpaceTime) :
(translatePulse p k).val y = smoothPulse p.start p.finish (y.1-k) := by
simp only [translatePulse, NonperiodicExpr.val_composeProfile, NonperiodicExpr.sub,
NonperiodicExpr.val, ProfileExpr.val_diff, ProfileExpr.val_ramp,
timeSpaceCoord, Rat.cast_intCast, Rat.cast_neg, Rat.cast_one, neg_one_mul]
rfl
def pulseCode (p : Pulse) (u v : ℚ) : NonperiodicExpr :=
NonperiodicExpr.sum ((translateIndices p u v).sort (· ≤ ·) |>.map (translatePulse p))
theorem pulseCode_val {p : Pulse} (hp : p.Valid) (u v : ℚ) {y : SpaceTime}
(hy : y.1 ∈ Icc (u : ℝ) v) :
(pulseCode p u v).val y = (PeriodicExpr.intervalPulse p.start p.finish).val y.1 := by
rw [pulseCode, NonperiodicExpr.sum_val, List.map_map]
change (((translateIndices p u v).sort (· ≤ ·)).map
(fun k => (translatePulse p k).val y)).sum = _
rw [((Finset.sort_perm_toList (translateIndices p u v) (· ≤ ·)).map
(fun k => (translatePulse p k).val y)).sum_eq, Finset.sum_map_toList]
have hs : Function.support (smoothPulse (p.start : ℝ) p.finish) ⊆
Icc (p.start : ℝ) p.finish :=
(smoothPulse_support (by exact_mod_cast hp.2)).trans Ioo_subset_Icc_self
have h := periodize_eq_finite (by norm_num : (0 : ℝ) < 1) hs hy
simpa only [translatePulse_val, PeriodicExpr.val, PeriodicExpr.intervalPulse, Rat.cast_one,
ProfileExpr.val_diff, ProfileExpr.val_ramp, smoothPulse, one_mul, div_one, translateIndices,
← Rat.cast_sub, Rat.floor_cast, Rat.ceil_cast] using h.symm
def hamiltonianCode {n : ℕ} (p : Fin n → Pulse) (u v : ℚ) : NonperiodicExpr :=
NonperiodicExpr.sum (List.ofFn fun i => .mul (pulseCode (p i) u v) (potentialCode (p i)))
theorem hamiltonianCode_val {n : ℕ} {p : Fin n → Pulse} (hp : ∀ i, (p i).Valid)
(u v : ℚ) {y : SpaceTime} (hy : y.1 ∈ Icc (u : ℝ) v) :
(hamiltonianCode p u v).val y = periodicHamiltonian p y.1 (horizontal y.2) := by
rw [hamiltonianCode, NonperiodicExpr.sum_ofFn_val]
apply Finset.sum_congr rfl
intro i _
exact congrArg₂ (· * ·) (pulseCode_val (hp i) u v hy) (potentialCode_val (p i) y)
def hamiltonianField (e : NonperiodicExpr) : NonperiodicVector :=
![e.diff 2, .mul (.const (-1)) (e.diff 1), .const 0]
private theorem horizontal_derivative {e : NonperiodicExpr} {H : Plane → ℝ}
{t : ℝ} (hH : ContDiff ℝ ∞ H)
(he : ∀ x : Space, e.val (t,x) = H (horizontal x)) (j : Fin 2) (x : Space) :
(e.diff j.castSucc.succ).val (t,x) = spatialD j H (horizontal x) := by
have hs : (fun z : Space => e.val (t,z)) = H ∘ horizontalLinear := by
funext z
simpa only [Function.comp_apply, horizontalLinear_eq] using he z
have heq : fderiv ℝ (fun z : Space => e.val (t,z)) x (ShearFlows.basis j.castSucc) =
fderiv ℝ e.val (t,x) (spaceTimeDirection j.castSucc.succ) := by
have hf := (e.smooth.differentiable (by simp) (t,x)).hasFDerivAt.comp x
((hasFDerivAt_const (c := t) x).prodMk (hasFDerivAt_id x))
have hff : fderiv ℝ (fun z : Space => e.val (t,z)) x =
(fderiv ℝ e.val (t,x)).comp
((0 : Space →L[ℝ] ℝ).prod (ContinuousLinearMap.id ℝ Space)) := hf.fderiv
rw [hff]
rfl
rw [e.val_diff, ← heq, hs]
rw [fderiv_comp x (hH.differentiable (by simp) _) horizontalLinear.differentiableAt,
horizontalLinear.fderiv]
change fderiv ℝ H (horizontalLinear x) (horizontalLinear (ShearFlows.basis j.castSucc)) = _
rw [VelocityDetector.horizontalLinear_basis, horizontalLinear_eq]
rfl
theorem hamiltonianField_val {e : NonperiodicExpr} {H : Plane → ℝ} {t : ℝ}
(hH : ContDiff ℝ ∞ H) (he : ∀ x : Space, e.val (t,x) = H (horizontal x)) (x : Space) :
(hamiltonianField e).val (t,x) = planeInclusion (field H (horizontal x)) := by
have h₀ := horizontal_derivative hH he 0 x
have h₁ := horizontal_derivative hH he 1 x
ext j
fin_cases j
· simpa [hamiltonianField, NonperiodicVector.val, planeInclusion, field,
PlanarHamiltonian.basis] using h₁
· simpa [hamiltonianField, NonperiodicVector.val, planeInclusion, field,
PlanarHamiltonian.basis, NonperiodicExpr.val] using congrArg Neg.neg h₀
· simp [hamiltonianField, NonperiodicVector.val, planeInclusion, field,
PlanarHamiltonian.basis, NonperiodicExpr.val]
end ForcedComputation.BalancedExpressions
end
end OAI
|