openAI-math-dataset / lean /OAI /MathematicalPhysics /NavierStokes /ForcedComputation /Programs /ClockedExpressions.lean
| import OAI.MathematicalPhysics.NavierStokes.ShearFlows.FieldExpressions | |
| namespace OAI | |
| /-! Finite expressions for the prescribed detector clock. Differentiation | |
| keeps the smooth clock separate from the periodic field it samples. -/ | |
| namespace ForcedComputation | |
| open ShearFlows | |
| open scoped ContDiff | |
| noncomputable def clockedPoint (q : ProfileExpr) (y : SpaceTime) : SpaceTime := | |
| (q.val y.1, y.2) | |
| theorem clockedPoint_smooth (q : ProfileExpr) : ContDiff ℝ ∞ (clockedPoint q) := | |
| (q.smooth.comp contDiff_fst).prodMk contDiff_snd | |
| theorem clockedPoint_direction (q : ProfileExpr) (y : SpaceTime) (j : Fin 4) : | |
| fderiv ℝ (clockedPoint q) y (spaceTimeDirection j) = | |
| if j = 0 then q.diff.val y.1 • spaceTimeDirection 0 else spaceTimeDirection j := by | |
| have hq := (q.hasDerivAt y.1).comp_hasFDerivAt y | |
| (ContinuousLinearMap.fst ℝ ℝ Space).hasFDerivAt | |
| have hd := hq.prodMk (ContinuousLinearMap.snd ℝ ℝ Space).hasFDerivAt | |
| change HasFDerivAt (clockedPoint q) _ y at hd | |
| rw [hd.fderiv] | |
| cases j using Fin.cases with | |
| | zero => simp [spaceTimeDirection, Prod.smul_mk] | |
| | succ k => simp [spaceTimeDirection] | |
| inductive ClockedExpr | |
| | const (r : ℚ) | |
| | profile (q : ProfileExpr) | |
| | field (q : ProfileExpr) (e : FieldExpr) | |
| | add (e f : ClockedExpr) | |
| | mul (e f : ClockedExpr) | |
| deriving DecidableEq | |
| namespace ClockedExpr | |
| noncomputable def val : ClockedExpr → SpaceTime → ℝ | |
| | .const r, _ => r | |
| | .profile q, y => q.val y.1 | |
| | .field q e, y => e.val (clockedPoint q y) | |
| | .add e f, y => e.val y + f.val y | |
| | .mul e f, y => e.val y * f.val y | |
| def Valid : ClockedExpr → Prop | |
| | .const _ => True | |
| | .profile _ => True | |
| | .field _ e => e.Valid | |
| | .add e f => e.Valid ∧ f.Valid | |
| | .mul e f => e.Valid ∧ f.Valid | |
| def diff (j : Fin 4) : ClockedExpr → ClockedExpr | |
| | .const _ => .const 0 | |
| | .profile q => if j = 0 then .profile q.diff else .const 0 | |
| | .field q e => if j = 0 then .mul (.profile q.diff) (.field q (e.diff 0)) | |
| else .field q (e.diff j) | |
| | .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 valid_diff {e : ClockedExpr} (he : e.Valid) (j : Fin 4) : (e.diff j).Valid := by | |
| induction e with | |
| | const => trivial | |
| | profile => simp only [diff]; split_ifs <;> trivial | |
| | field q e => | |
| by_cases hj : j = 0 | |
| · simp only [diff, hj, ite_true, Valid] | |
| exact ⟨trivial, e.valid_diff he 0⟩ | |
| · simpa only [diff, hj, ite_false, Valid] using e.valid_diff he j | |
| | add e f ih₁ ih₂ => exact ⟨ih₁ he.1, ih₂ he.2⟩ | |
| | mul e f ih₁ ih₂ => exact ⟨⟨ih₁ he.1, he.2⟩, ⟨he.1, ih₂ he.2⟩⟩ | |
| theorem smooth {e : ClockedExpr} (he : e.Valid) : ContDiff ℝ ∞ e.val := by | |
| induction e with | |
| | const => exact contDiff_const | |
| | profile q => exact q.smooth.comp contDiff_fst | |
| | field q e => exact (e.smooth he).comp (clockedPoint_smooth q) | |
| | add e f ih₁ ih₂ => exact (ih₁ he.1).add (ih₂ he.2) | |
| | mul e f ih₁ ih₂ => exact (ih₁ he.1).mul (ih₂ he.2) | |
| theorem val_diff {e : ClockedExpr} (he : e.Valid) (j : Fin 4) (y : SpaceTime) : | |
| (e.diff j).val y = fderiv ℝ e.val y (spaceTimeDirection j) := by | |
| induction e with | |
| | const r => simp [diff, val] | |
| | profile q => | |
| have hd := (q.hasDerivAt y.1).comp_hasFDerivAt y | |
| (ContinuousLinearMap.fst ℝ ℝ Space).hasFDerivAt | |
| change _ = fderiv ℝ (q.val ∘ Prod.fst) y (spaceTimeDirection j) | |
| rw [hd.fderiv] | |
| cases j using Fin.cases with | |
| | zero => simp [diff, val, spaceTimeDirection] | |
| | succ k => simp [diff, val, spaceTimeDirection] | |
| | field q e => | |
| have hd := ((e.smooth he).differentiable (by simp) (clockedPoint q y)).hasFDerivAt.comp y | |
| ((clockedPoint_smooth q).differentiable (by simp) y).hasFDerivAt | |
| change _ = fderiv ℝ (e.val ∘ clockedPoint q) y (spaceTimeDirection j) | |
| rw [hd.fderiv, ContinuousLinearMap.comp_apply, clockedPoint_direction] | |
| by_cases hj : j = 0 | |
| · subst j | |
| simp only [diff, ite_true, val, map_smul, smul_eq_mul] | |
| rw [e.val_diff he 0] | |
| · simp only [diff, hj, ite_false, val] | |
| exact e.val_diff he j _ | |
| | add e f ih₁ ih₂ => | |
| rw [show ClockedExpr.val (.add e f) = e.val + f.val from rfl, | |
| fderiv_add ((smooth he.1).differentiable (by simp) y) | |
| ((smooth he.2).differentiable (by simp) y)] | |
| exact congrArg₂ (· + ·) (ih₁ he.1) (ih₂ he.2) | |
| | mul e f ih₁ ih₂ => | |
| have hd := ((smooth he.1).differentiable (by simp) y).hasFDerivAt.mul | |
| ((smooth he.2).differentiable (by simp) y).hasFDerivAt | |
| change _ = fderiv ℝ (e.val * f.val) y (spaceTimeDirection j) | |
| rw [hd.fderiv] | |
| simp only [diff, val, add_apply, smul_apply, smul_eq_mul] | |
| rw [ih₁ he.1, ih₂ he.2] | |
| ring | |
| end ClockedExpr | |
| end ForcedComputation | |
| end OAI | |