openAI-math-dataset / lean /OAI /MathematicalPhysics /NavierStokes /ForcedComputation /Programs /FastVectorArithmetic.lean
| import OAI.MathematicalPhysics.NavierStokes.ForcedComputation.Programs.FinitePhaseEvaluation | |
| import OAI.MathematicalPhysics.NavierStokes.ForcedComputation.Programs.LogarithmName | |
| namespace OAI | |
| /-! Finite rational interval arithmetic for vector-valued derivative formulas. | |
| The stopping test is rational and finite; convergence proves its termination. -/ | |
| namespace ForcedComputation | |
| open ShearFlows Filter | |
| open scoped Topology | |
| def realNameBall (a : ℕ → ℚ) (n : ℕ) : QBall := | |
| ⟨a n, (2 : ℚ) ^ (-(n : ℤ))⟩ | |
| def vectorNameBall (a : ℕ → RationalVector) (n : ℕ) (j : Fin 3) : QBall := | |
| realNameBall (fun k => a k j) n | |
| theorem realNameBall_contains {a : ℕ → ℚ} {x : ℝ} | |
| (ha : IsFastRealName a x) (n : ℕ) : (realNameBall a n).Contains x := by | |
| simpa [realNameBall, QBall.Contains, errorTolerance] using ha n | |
| theorem realNameBall_converges {a : ℕ → ℚ} {x : ℝ} | |
| (ha : IsFastRealName a x) : QBall.Converges (realNameBall a) x := by | |
| refine ⟨fastRealName_tendsto ha, ?_⟩ | |
| have he : (fun n => ((realNameBall a n).radius : ℝ)) = errorTolerance := by | |
| funext n | |
| simp [realNameBall, errorTolerance] | |
| rw [he] | |
| exact errorTolerance_tendsto | |
| theorem vectorNameBall_contains {a : ℕ → RationalVector} {v : Space} | |
| (ha : IsFastVectorName a v) (n : ℕ) (j : Fin 3) : | |
| (vectorNameBall a n j).Contains (v j) := by | |
| apply realNameBall_contains | |
| intro k | |
| exact (show |v j - (a k j : ℝ)| ≤ ‖v - rationalVector (a k)‖ from | |
| norm_le_pi_norm (v - rationalVector (a k)) j).trans (ha k) | |
| theorem vectorNameBall_converges {a : ℕ → RationalVector} {v : Space} | |
| (ha : IsFastVectorName a v) (j : Fin 3) : | |
| QBall.Converges (fun n => vectorNameBall a n j) (v j) := by | |
| apply realNameBall_converges | |
| intro k | |
| exact (show |v j - (a k j : ℝ)| ≤ ‖v - rationalVector (a k)‖ from | |
| norm_le_pi_norm (v - rationalVector (a k)) j).trans (ha k) | |
| def vectorBallReady (b : ℕ → Fin 3 → QBall) (ε : ℚ) (n : ℕ) : Prop := | |
| ∀ j, (b n j).radius ≤ ε | |
| instance (b : ℕ → Fin 3 → QBall) (ε : ℚ) (n : ℕ) : | |
| Decidable (vectorBallReady b ε n) := | |
| inferInstanceAs (Decidable (∀ j, (b n j).radius ≤ ε)) | |
| theorem vectorBallReady_exists {b : ℕ → Fin 3 → QBall} {v : Space} | |
| (hb : ∀ j, QBall.Converges (fun n => b n j) (v j)) | |
| {ε : ℚ} (hε : 0 < ε) : ∃ n, vectorBallReady b ε n := by | |
| have he : (0 : ℝ) < ε := by exact_mod_cast hε | |
| have h : ∀ j, ∀ᶠ n in atTop, ((b n j).radius : ℝ) < ε := fun j => | |
| (hb j).2.eventually_lt_const he | |
| obtain ⟨n, hn⟩ := (eventually_all.mpr h).exists | |
| exact ⟨n, fun j => by exact_mod_cast (hn j).le⟩ | |
| def evaluateVectorBalls (b : ℕ → Fin 3 → QBall) (ε : ℚ) | |
| (h : ∃ n, vectorBallReady b ε n) : RationalVector := | |
| fun j => (b (Nat.find h) j).center | |
| theorem evaluateVectorBalls_spec {v : Space} (b : ℕ → Fin 3 → QBall) | |
| (hb : ∀ j, QBall.Converges (fun n => b n j) (v j)) | |
| (hc : ∀ n j, (b n j).Contains (v j)) (ε : ℚ) (hε : 0 < ε) : | |
| ‖v - rationalVector (evaluateVectorBalls b ε (vectorBallReady_exists hb hε))‖ ≤ (ε : ℝ) := by | |
| apply (pi_norm_le_iff_of_nonneg (by exact_mod_cast hε.le)).mpr | |
| intro j | |
| change |v j - ((b (Nat.find (vectorBallReady_exists hb hε)) j).center : ℝ)| ≤ ε | |
| exact (hc _ j).trans (by exact_mod_cast (Nat.find_spec (vectorBallReady_exists hb hε) j)) | |
| end ForcedComputation | |
| end OAI | |