openAI-math-dataset / lean /OAI /MathematicalPhysics /NavierStokes /ForcedComputation /Programs /FinitePhaseEvaluation.lean
| import OAI.MathematicalPhysics.NavierStokes.ForcedComputation.Programs.InitializedVelocityEvaluation | |
| import OAI.MathematicalPhysics.NavierStokes.ForcedComputation.Programs.LogarithmicBounds | |
| namespace OAI | |
| /-! Finite recursive evaluation of the Euler derivative polynomials that | |
| occur in the logarithmic slowdown. -/ | |
| namespace ForcedComputation | |
| open ShearFlows | |
| open scoped ContDiff | |
| def IsFastVectorName (a : ℕ → RationalVector) (v : Space) : Prop := | |
| ∀ n, ‖v - rationalVector (a n)‖ ≤ errorTolerance n | |
| theorem initializedVelocityTolerance_pos (n : ℕ) : | |
| 0 < (2 : ℚ) ^ (-(n : ℤ)) := by positivity | |
| def initializedVelocityName (loader body : Input) | |
| (hl : ValidInput loader) (hb : ValidInput body) (α : List (Fin 4)) | |
| (b : ℕ → RationalSpaceTime) : ℕ → RationalVector := fun n => | |
| evaluateInitializedVelocity loader body hl hb α b ((2 : ℚ) ^ (-(n : ℤ))) (initializedVelocityTolerance_pos n) | |
| theorem initializedVelocityName_spec {loader body : Input} | |
| (hl : ValidInput loader) (hb : ValidInput body) (α : List (Fin 4)) | |
| {b : ℕ → RationalSpaceTime} {y : SpaceTime} (hy : IsFastName b y) : | |
| IsFastVectorName (initializedVelocityName loader body hl hb α b) | |
| (mixedDerivative (initializedProgram loader body) α y) := by | |
| intro n | |
| have h := evaluateInitializedVelocity_spec hl hb α hy | |
| ((2 : ℚ) ^ (-(n : ℤ))) (by positivity) | |
| simpa [initializedVelocityName, errorTolerance] using h | |
| def subtractNatName (c : ℕ) (a b : ℕ → RationalVector) : ℕ → RationalVector := | |
| fun n => a (n + c + 1) - (c : ℚ) • b (n + c + 1) | |
| theorem subtractNatName_spec {a b : ℕ → RationalVector} {x y : Space} | |
| (ha : IsFastVectorName a x) (hb : IsFastVectorName b y) (c : ℕ) : | |
| IsFastVectorName (subtractNatName c a b) (x - (c : ℝ) • y) := by | |
| intro n | |
| have hcast (m : ℕ) : rationalVector (a m - (c : ℚ) • b m) = | |
| rationalVector (a m) - (c : ℝ) • rationalVector (b m) := by | |
| ext j | |
| simp only [rationalVector, Pi.sub_apply, Pi.smul_apply, smul_eq_mul, | |
| Rat.cast_sub, Rat.cast_mul, Rat.cast_natCast] | |
| have hsize : (1 + (c : ℝ)) ≤ (2 : ℝ) ^ (c + 1) := by | |
| have h := Nat.lt_two_pow_self (n := c + 1) | |
| rw [add_comm 1] | |
| exact_mod_cast h.le | |
| have ht : (1 + (c : ℝ)) * errorTolerance (n + c + 1) ≤ errorTolerance n := by | |
| calc | |
| _ ≤ (2 : ℝ) ^ (c + 1) * errorTolerance (n + c + 1) := | |
| mul_le_mul_of_nonneg_right hsize (by dsimp [errorTolerance]; positivity) | |
| _ = errorTolerance n := by | |
| simp only [errorTolerance, show n + c + 1 = n + (c + 1) by omega, | |
| pow_add, mul_inv_rev] | |
| field_simp | |
| rw [subtractNatName, hcast] | |
| have he : x - (c : ℝ) • y - (rationalVector (a (n + c + 1)) - | |
| (c : ℝ) • rationalVector (b (n + c + 1))) = | |
| (x - rationalVector (a (n + c + 1))) - | |
| (c : ℝ) • (y - rationalVector (b (n + c + 1))) := by module | |
| rw [he] | |
| calc | |
| _ ≤ ‖x - rationalVector (a (n + c + 1))‖ + | |
| ‖(c : ℝ) • (y - rationalVector (b (n + c + 1)))‖ := norm_sub_le _ _ | |
| _ ≤ errorTolerance (n + c + 1) + (c : ℝ) * errorTolerance (n + c + 1) := by | |
| rw [norm_smul, Real.norm_of_nonneg (Nat.cast_nonneg c)] | |
| exact add_le_add (ha _) (mul_le_mul_of_nonneg_left (hb _) (Nat.cast_nonneg c)) | |
| _ = (1 + (c : ℝ)) * errorTolerance (n + c + 1) := by ring | |
| _ ≤ _ := ht | |
| def phaseName (r : ℕ) (a : ℕ → ℕ → RationalVector) : ℕ → ℕ → ℕ → RationalVector | |
| | 0, k => a k | |
| | n + 1, k => subtractNatName (r + n) (phaseName r a n (k + 1)) (phaseName r a n k) | |
| theorem phaseName_spec (r : ℕ) {A : ℝ → Space} (hA : ContDiff ℝ ∞ A) (s : ℝ) | |
| {a : ℕ → ℕ → RationalVector} | |
| (ha : ∀ k, IsFastVectorName (a k) (iteratedDeriv k A s)) (n k : ℕ) : | |
| IsFastVectorName (phaseName r a n k) (iteratedDeriv k (phaseIter r A n) s) := by | |
| induction n generalizing k with | |
| | zero => exact ha k | |
| | succ n ih => | |
| rw [show phaseIter r A (n + 1) = | |
| phaseDerivative (r + n) (phaseIter r A n) from rfl, | |
| iteratedDeriv_phaseDerivative (r + n) k (phaseIter_smooth r hA n)] | |
| exact subtractNatName_spec (ih (k + 1)) (ih k) (r + n) | |
| end ForcedComputation | |
| end OAI | |