| import Mathlib |
|
|
| namespace OAI |
|
|
| open scoped BigOperators ENNReal NNReal Topology ContDiff |
| open MeasureTheory |
| namespace AlternatingNS |
|
|
| theorem neZeroThree : NeZero 3 := ⟨Nat.succ_ne_zero 2⟩ |
|
|
| theorem twoAtLeastTwo : Nat.AtLeastTwo 2 := ⟨Nat.le_refl 2⟩ |
|
|
| theorem threeAtLeastTwo : Nat.AtLeastTwo 3 := ⟨Nat.le_succ 2⟩ |
|
|
| theorem eightAtLeastTwo : Nat.AtLeastTwo 8 := ⟨by decide⟩ |
|
|
| abbrev Rule := ℕ × ℕ × Fin 3 |
|
|
| abbrev Machine := ℕ × ℕ × ℕ × List ℕ × List (Option Rule) |
|
|
| namespace Machine |
|
|
| def states (M : Machine) : ℕ := M.1 + 1 |
|
|
| def alphabet (M : Machine) : ℕ := M.2.1 + 1 |
|
|
| def initialState (M : Machine) : ℕ := M.2.2.1 |
|
|
| def haltingStates (M : Machine) : List ℕ := M.2.2.2.1 |
|
|
| def table (M : Machine) : List (Option Rule) := M.2.2.2.2 |
|
|
| def instruction (M : Machine) (q a : ℕ) : Option Rule := |
| (M.table[q * M.alphabet + a]?).join |
|
|
| def WellFormed (M : Machine) : Prop := |
| M.initialState < M.states ∧ |
| (∀ q ∈ M.haltingStates, q < M.states) ∧ |
| ∀ q a r, q < M.states → a < M.alphabet → M.instruction q a = some r → |
| r.1 < M.states ∧ r.2.1 < M.alphabet |
|
|
| def ValidInput (M : Machine) (w : List ℕ) : Prop := |
| ∀ a ∈ w, a < M.alphabet |
|
|
| structure Configuration where |
| state : ℕ |
| head : ℤ |
| tape : ℤ → ℕ |
|
|
| def isHalting (M : Machine) (c : Configuration) : Bool := |
| decide (c.state = M.states ∨ c.state ∈ M.haltingStates) |
|
|
| def initial (M : Machine) (w : List ℕ) : Configuration where |
| state := M.initialState |
| head := 0 |
| tape := fun i => if 0 ≤ i then w[i.toNat]?.getD 0 else 0 |
|
|
| def step (M : Machine) (c : Configuration) : Configuration := |
| if M.isHalting c then c else |
| match M.instruction c.state (c.tape c.head) with |
| | none => { c with state := M.states } |
| | some r => |
| { state := r.1 |
| head := c.head + ((r.2.2.val : ℤ) - 1) |
| tape := Function.update c.tape c.head r.2.1 } |
|
|
| def run (M : Machine) (w : List ℕ) (n : ℕ) : Configuration := |
| (M.step)^[n] (M.initial w) |
|
|
| def Halts (M : Machine) (w : List ℕ) : Prop := |
| ∃ n : ℕ, M.isHalting (M.run w n) = true |
|
|
| end Machine |
|
|
| abbrev Space := EuclideanSpace ℝ (Fin 3) |
| abbrev Field (E : Type*) := ℝ → Space → E |
| abbrev Velocity := Field Space |
| abbrev Pressure := Field ℝ |
| abbrev MultiIndex := Fin 3 → ℕ |
|
|
| noncomputable section |
|
|
| def e (i : Fin 3) : Space := EuclideanSpace.single i 1 |
|
|
| def dx {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| (i : Fin 3) (F : Field E) : Field E := |
| fun t x => fderiv ℝ (F t) x (e i) |
|
|
| def dt {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| (F : Field E) : Field E := |
| fun t x => fderivWithin ℝ (fun s => F s x) (Set.Ici 0) t 1 |
|
|
| def spatial {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| (α : MultiIndex) (F : Field E) : Field E := |
| (dx 0)^[α 0] ((dx 1)^[α 1] ((dx 2)^[α 2] F)) |
|
|
| def mixed {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| (l : ℕ) (α : MultiIndex) (F : Field E) : Field E := |
| dt^[l] (spatial α F) |
|
|
| def div (u : Velocity) (t : ℝ) (x : Space) : ℝ := |
| ∑ i : Fin 3, dx i u t x i |
|
|
| def grad (p : Pressure) (t : ℝ) (x : Space) : Space := |
| (EuclideanSpace.equiv (Fin 3) ℝ).symm (fun i => dx i p t x) |
|
|
| def laplacian (u : Velocity) (t : ℝ) (x : Space) : Space := |
| ∑ i : Fin 3, dx i (dx i u) t x |
|
|
| def advection (u : Velocity) (t : ℝ) (x : Space) : Space := |
| fderiv ℝ (u t) x (u t x) |
|
|
| def residual (ν : ℝ) (u : Velocity) : Velocity := |
| fun t x => dt u t x + advection u t x - ν • laplacian u t x |
|
|
| def timeCylinder (T : ℝ) : Set (ℝ × Space) := Set.Icc 0 T ×ˢ Set.univ |
|
|
| def Smooth {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| (F : Field E) : Prop := |
| ContDiffOn ℝ (∞) (Function.uncurry F) (Set.Ici 0 ×ˢ Set.univ) |
|
|
| def ClassicalRegularity (u : Velocity) (p : Pressure) : Prop := |
| (∀ x, DifferentiableOn ℝ (fun t => u t x) (Set.Ici 0)) ∧ |
| (∀ t, 0 ≤ t → Differentiable ℝ (u t)) ∧ |
| (∀ t, 0 ≤ t → ∀ i, Differentiable ℝ (dx i u t)) ∧ |
| (∀ t, 0 ≤ t → Differentiable ℝ (p t)) ∧ |
| ∀ T, 0 ≤ T → |
| ContinuousOn (Function.uncurry u) (timeCylinder T) ∧ |
| ContinuousOn (Function.uncurry (dt u)) (timeCylinder T) ∧ |
| (∀ i, ContinuousOn (Function.uncurry (dx i u)) (timeCylinder T)) ∧ |
| (∀ i j, ContinuousOn (Function.uncurry (dx i (dx j u))) (timeCylinder T)) ∧ |
| ContinuousOn (Function.uncurry p) (timeCylinder T) ∧ |
| (∀ i, ContinuousOn (Function.uncurry (dx i p)) (timeCylinder T)) |
|
|
| def ContinuousInH {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| (k : ℕ) (F : Field E) (T : ℝ) : Prop := |
| ∀ α : MultiIndex, (∑ i, α i) ≤ k → |
| ∃ g : ℝ → Lp E 2 (volume : Measure Space), |
| ContinuousOn g (Set.Icc 0 T) ∧ |
| ∀ t ∈ Set.Icc 0 T, |
| ∀ᵐ x ∂(volume : Measure Space), (g t) x = spatial α F t x |
|
|
| def C1InL2 (u : Velocity) (T : ℝ) : Prop := |
| ∃ g g' : ℝ → Lp Space 2 (volume : Measure Space), |
| ContinuousOn g (Set.Icc 0 T) ∧ |
| ContinuousOn g' (Set.Icc 0 T) ∧ |
| (∀ t ∈ Set.Icc 0 T, HasDerivWithinAt g (g' t) (Set.Icc 0 T) t) ∧ |
| (∀ t ∈ Set.Icc 0 T, ∀ᵐ x ∂(volume : Measure Space), (g t) x = u t x) ∧ |
| (∀ t ∈ Set.Icc 0 T, ∀ᵐ x ∂(volume : Measure Space), (g' t) x = dt u t x) |
|
|
| def CompetitorEnergyClass (u : Velocity) (p : Pressure) : Prop := |
| ∀ T, 0 ≤ T → |
| ContinuousInH 2 u T ∧ C1InL2 u T ∧ ContinuousInH 1 p T ∧ |
| ∃ C : ℝ, ∀ t ∈ Set.Icc 0 T, ∀ x, ‖u t x‖ ≤ C |
|
|
| def EnergyClass (u : Velocity) (p : Pressure) : Prop := |
| CompetitorEnergyClass u p ∧ |
| ∀ T, 0 ≤ T → ∃ C : ℝ, ∀ t ∈ Set.Icc 0 T, ∀ x, |
| ‖u t x‖ + ‖fderiv ℝ (u t) x‖ ≤ C |
|
|
| def NavierStokes (ν : ℝ) (f u : Velocity) (p : Pressure) : Prop := |
| ClassicalRegularity u p ∧ |
| (∀ x, u 0 x = 0) ∧ |
| ∀ t, 0 ≤ t → ∀ x, |
| div u t x = 0 ∧ |
| dt u t x + advection u t x = -grad p t x + ν • laplacian u t x + f t x |
|
|
| def Rapid (F : Velocity) : Prop := |
| ∀ J l : ℕ, ∀ α : MultiIndex, ∃ C : ℝ, 0 ≤ C ∧ |
| ∀ t, 0 ≤ t → ∀ x, |
| (1 + t + ‖x‖) ^ J * ‖mixed l α F t x‖ ≤ C |
|
|
| def SupportedIn (F : Velocity) (K : Set Space) : Prop := |
| ∀ t, 0 ≤ t → Function.support (F t) ⊆ K |
|
|
| def IsTrajectory (u : Velocity) (a : Space) (γ : ℝ → Space) : Prop := |
| γ 0 = a ∧ ∀ t, 0 ≤ t → HasDerivWithinAt γ (u t (γ t)) (Set.Ici 0) t |
|
|
| def observedParticle : Space := (EuclideanSpace.equiv (Fin 3) ℝ).symm ![-1, 0, 0] |
|
|
| abbrev RationalPoint := ℚ × ℚ × ℚ × ℚ |
| abbrev RationalVector := ℚ × ℚ × ℚ |
| abbrev IndexCode := ℕ × ℕ × ℕ |
| abbrev Program := Nat.Partrec.Code |
| abbrev FieldProgram := Program × Program × Program |
|
|
| def Returns {A B : Type*} [Encodable A] [Encodable B] |
| (c : Program) (a : A) (b : B) : Prop := |
| Encodable.encode b ∈ c.eval (Encodable.encode a) |
|
|
| def index (α : IndexCode) : MultiIndex := ![α.1, α.2.1, α.2.2] |
|
|
| def rationalVector (q : RationalVector) : Space := |
| (EuclideanSpace.equiv (Fin 3) ℝ).symm ![(q.1 : ℝ), (q.2.1 : ℝ), (q.2.2 : ℝ)] |
|
|
| def rationalPoint (q : RationalPoint) : ℝ × Space := |
| ((q.1 : ℝ), rationalVector q.2) |
|
|
| def dyadicError (n : ℕ) : ℝ := (1 / 2 : ℝ) ^ n |
|
|
| def ComputableReal (r : ℝ) : Prop := |
| ∃ a : ℕ → ℚ, Computable (fun n => ((a n).num, (a n).den)) ∧ |
| ∀ n, |r - (a n : ℝ)| ≤ dyadicError n |
|
|
| def ProgramFor (c : FieldProgram) (F : Velocity) : Prop := |
| (∀ (l : ℕ) (α : IndexCode) (q : RationalPoint) (k : ℕ), |
| ∃ v : RationalVector, Returns c.1 (l, α, q, k) v ∧ |
| (0 ≤ q.1 → |
| ‖rationalVector v - mixed l (index α) F (rationalPoint q).1 (rationalPoint q).2‖ |
| ≤ dyadicError k)) ∧ |
| (∀ (l : ℕ) (α : IndexCode) (R k : ℕ), |
| ∃ m : ℕ, Returns c.2.1 (l, α, R, k) m ∧ |
| ∀ z z' : ℝ × Space, |
| 0 ≤ z.1 → 0 ≤ z'.1 → ‖z‖ ≤ R → ‖z'‖ ≤ R → |
| ‖z - z'‖ ≤ dyadicError m → |
| ‖mixed l (index α) F z.1 z.2 - mixed l (index α) F z'.1 z'.2‖ ≤ dyadicError k) ∧ |
| (∀ (J l : ℕ) (α : IndexCode), |
| ∃ B : ℕ, Returns c.2.2 (J, l, α) B ∧ |
| ∀ t, 0 ≤ t → ∀ x, |
| (1 + t + ‖x‖) ^ J * ‖mixed l (index α) F t x‖ ≤ B) |
|
|
| def AlternatingConclusion (ν : ℝ) : Prop := |
| ∃ (compileForce compileVelocity : Machine × List ℕ → FieldProgram), |
| Computable compileForce ∧ Computable compileVelocity ∧ |
| ∃ K : Set Space, IsCompact K ∧ |
| ∀ (M : Machine) (w : List ℕ), M.WellFormed → M.ValidInput w → |
| ∃ (f U : Velocity) (X : Space → ℝ → Space), |
| ProgramFor (compileForce (M, w)) f ∧ |
| ProgramFor (compileVelocity (M, w)) U ∧ |
| Smooth f ∧ Smooth U ∧ |
| SupportedIn f K ∧ SupportedIn U K ∧ Rapid f ∧ Rapid U ∧ |
| f = residual ν U ∧ |
| NavierStokes ν f U (fun _ _ => 0) ∧ EnergyClass U (fun _ _ => 0) ∧ |
| (∀ (v : Velocity) (p : Pressure), |
| NavierStokes ν f v p → CompetitorEnergyClass v p → |
| ∀ t, 0 ≤ t → ∀ x, v t x = U t x ∧ p t x = 0) ∧ |
| (∀ a, IsTrajectory U a (X a)) ∧ |
| (∀ a γ, IsTrajectory U a γ → ∀ t, 0 ≤ t → γ t = X a t) ∧ |
| ((∃ t : ℝ, 0 ≤ t ∧ 0 < X observedParticle t 0) ↔ M.Halts w) |
|
|
| end |
| end AlternatingNS |
|
|
| end OAI |
|
|
