| import Mathlib |
|
|
| namespace OAI |
|
|
| open scoped BigOperators ENNReal Topology |
| open Set MeasureTheory |
| namespace RapidForcing |
|
|
| abbrev Space := EuclideanSpace ℝ (Fin 3) |
| abbrev Field (E : Type) := ℝ → Space → E |
| abbrev MultiIndex := Fin 3 → ℕ |
|
|
| theorem twoAtLeastTwo : Nat.AtLeastTwo 2 := ⟨Nat.le_refl 2⟩ |
|
|
| theorem neZeroThree : NeZero 3 := ⟨Nat.succ_ne_zero 2⟩ |
|
|
| noncomputable def vec (x y z : ℝ) : Space := |
| letI := twoAtLeastTwo |
| WithLp.toLp 2 ![x, y, z] |
|
|
| noncomputable def basis (i : Fin 3) : Space := EuclideanSpace.single i 1 |
|
|
| def K : Set Space := |
| letI := twoAtLeastTwo |
| letI := neZeroThree |
| {x | -2 ≤ x 0 ∧ x 0 ≤ 1 ∧ |
| -1 ≤ x 1 ∧ x 1 ≤ 2 ∧ -1 ≤ x 2 ∧ x 2 ≤ 1} |
|
|
| noncomputable def spatialD {E : Type} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| (i : Fin 3) (f : Field E) : Field E := |
| fun t x => fderiv ℝ (f t) x (basis i) |
|
|
| noncomputable def timeD {E : Type} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| (f : Field E) : Field E := |
| fun t x => derivWithin (fun s => f s x) (Ici 0) t |
|
|
| noncomputable def spatialMulti {E : Type} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| (α : MultiIndex) (f : Field E) : Field E := |
| letI := neZeroThree |
| (spatialD 0)^[α 0] ((spatialD 1)^[α 1] ((spatialD 2)^[α 2] f)) |
|
|
| noncomputable def mixedD {E : Type} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| (l : ℕ) (α : MultiIndex) (f : Field E) : Field E := |
| timeD^[l] (spatialMulti α f) |
|
|
| def order (α : MultiIndex) : ℕ := ∑ i, α i |
|
|
| def Smooth {E : Type} [NormedAddCommGroup E] [NormedSpace ℝ E] (f : Field E) : Prop := |
| ContDiffOn ℝ (⊤ : ℕ∞) (Function.uncurry f) (Ici (0 : ℝ) ×ˢ univ) |
|
|
| def Supported {E : Type} [Zero E] (f : Field E) : Prop := |
| ∀ t : ℝ, 0 ≤ t → tsupport (f t) ⊆ K |
|
|
| def Rapid {E : Type} [NormedAddCommGroup E] [NormedSpace ℝ E] (f : Field E) : Prop := |
| ∀ (J l : ℕ) (α : MultiIndex), ∃ C : ℝ, 0 ≤ C ∧ |
| ∀ (t : ℝ), 0 ≤ t → ∀ x : Space, |
| (1 + t) ^ J * ‖mixedD l α f t x‖ ≤ C |
|
|
| def RapidSpaceTime {E : Type} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| (f : Field E) : Prop := |
| ∀ (J l : ℕ) (α : MultiIndex), ∃ C : ℝ, 0 ≤ C ∧ |
| ∀ (t : ℝ), 0 ≤ t → ∀ x : Space, |
| (1 + t + ‖x‖) ^ J * ‖mixedD l α f t x‖ ≤ C |
|
|
| noncomputable def advection (u : Field Space) : Field Space := |
| fun t x => ∑ i, (u t x i) • spatialD i u t x |
|
|
| noncomputable def laplace (u : Field Space) : Field Space := |
| fun t x => ∑ i, spatialD i (spatialD i u) t x |
|
|
| noncomputable def divergence (u : Field Space) : Field ℝ := |
| fun t x => ∑ i, (spatialD i u t x) i |
|
|
| noncomputable def gradient (p : Field ℝ) : Field Space := |
| fun t x => ∑ i, (spatialD i p t x) • basis i |
|
|
| noncomputable def residual (ν : ℝ) (u : Field Space) : Field Space := |
| fun t x => timeD u t x + advection u t x - ν • laplace u t x |
|
|
| def NavierStokes (ν : ℝ) (f u : Field Space) (p : Field ℝ) : Prop := |
| (∀ (t : ℝ), 0 ≤ t → ∀ x : Space, |
| timeD u t x + advection u t x = |
| -gradient p t x + ν • laplace u t x + f t x) ∧ |
| (∀ (t : ℝ), 0 ≤ t → ∀ x : Space, divergence u t x = 0) ∧ |
| (∀ x : Space, u 0 x = 0) |
|
|
| def Classical (u : Field Space) (p : Field ℝ) : Prop := |
| letI := twoAtLeastTwo |
| (∀ t : ℝ, 0 ≤ t → ContDiff ℝ 2 (u t) ∧ ContDiff ℝ 1 (p t)) ∧ |
| (∀ x : Space, DifferentiableOn ℝ (fun t => u t x) (Ici 0)) ∧ |
| ∀ T : ℝ, 0 ≤ T → |
| let cylinder := Icc (0 : ℝ) T ×ˢ (univ : Set Space) |
| ContinuousOn (Function.uncurry u) cylinder ∧ |
| ContinuousOn (Function.uncurry (timeD u)) cylinder ∧ |
| (∀ i, ContinuousOn (Function.uncurry (spatialD i u)) cylinder) ∧ |
| (∀ i j, ContinuousOn (Function.uncurry (spatialD i (spatialD j u))) cylinder) ∧ |
| ContinuousOn (Function.uncurry p) cylinder ∧ |
| (∀ i, ContinuousOn (Function.uncurry (spatialD i p)) cylinder) |
|
|
| def L2ContinuousOn {E : Type} [NormedAddCommGroup E] |
| (f : Field E) (T : ℝ) : Prop := |
| letI := twoAtLeastTwo |
| ∃ v : ℝ → Lp E 2 (volume : Measure Space), |
| ContinuousOn v (Icc 0 T) ∧ |
| ∀ t ∈ Icc 0 T, (v t : Space → E) =ᵐ[volume] f t |
|
|
| def L2C1On (u : Field Space) (T : ℝ) : Prop := |
| letI := twoAtLeastTwo |
| ∃ v v' : ℝ → Lp Space 2 (volume : Measure Space), |
| ContinuousOn v (Icc 0 T) ∧ ContinuousOn v' (Icc 0 T) ∧ |
| (∀ t ∈ Icc 0 T, (v t : Space → Space) =ᵐ[volume] u t) ∧ |
| (∀ t ∈ Icc 0 T, (v' t : Space → Space) =ᵐ[volume] timeD u t) ∧ |
| ∀ t ∈ Icc 0 T, HasDerivWithinAt v (v' t) (Icc 0 T) t |
|
|
| def EnergyRegularity (u : Field Space) (p : Field ℝ) : Prop := |
| ∀ T : ℝ, 0 ≤ T → |
| (∀ α : MultiIndex, order α ≤ 2 → L2ContinuousOn (spatialMulti α u) T) ∧ |
| L2C1On u T ∧ |
| (∀ α : MultiIndex, order α ≤ 1 → L2ContinuousOn (spatialMulti α p) T) |
|
|
| def EnergyClass (u : Field Space) (p : Field ℝ) : Prop := |
| EnergyRegularity u p ∧ |
| ∀ T : ℝ, 0 ≤ T → ∃ C : ℝ, ∀ t ∈ Icc 0 T, ∀ x : Space, |
| ‖u t x‖ + ‖fderiv ℝ (u t) x‖ ≤ C |
|
|
| def EnergyCompetitor (u : Field Space) (p : Field ℝ) : Prop := |
| EnergyRegularity u p ∧ |
| ∀ T : ℝ, 0 ≤ T → ∃ C : ℝ, ∀ t ∈ Icc 0 T, ∀ x : Space, ‖u t x‖ ≤ C |
|
|
| def UniqueEnergySolution (ν : ℝ) (f u : Field Space) (p : Field ℝ) : Prop := |
| Classical u p ∧ EnergyClass u p ∧ NavierStokes ν f u p ∧ |
| ∀ (v : Field Space) (q : Field ℝ), |
| Classical v q → EnergyCompetitor v q → NavierStokes ν f v q → |
| ∀ (t : ℝ), 0 ≤ t → ∀ x : Space, v t x = u t x ∧ q t x = p t x |
|
|
| def TrajectoryOn (u : Field Space) (a : Space) (T : ℝ) (γ : ℝ → Space) : Prop := |
| γ 0 = a ∧ ∀ t ∈ Icc 0 T, |
| HasDerivWithinAt γ (u t (γ t)) (Icc 0 T) t |
|
|
| def MaterialFlow (u : Field Space) (X : ℝ → Space → Space) : Prop := |
| (∀ a : Space, X 0 a = a) ∧ |
| (∀ (a : Space) (t : ℝ), 0 ≤ t → |
| HasDerivWithinAt (fun s => X s a) (u t (X t a)) (Ici 0) t) ∧ |
| (∀ (T : ℝ), 0 < T → ∀ (a : Space) (γ : ℝ → Space), |
| TrajectoryOn u a T γ → ∀ t ∈ Icc 0 T, γ t = X t a) |
|
|
| abbrev Move := Fin 3 |
|
|
| structure Machine where |
| states : ℕ |
| symbols : ℕ |
| states_pos : 0 < states |
| symbols_pos : 0 < symbols |
| initial : Fin states |
| transition : Fin states → Fin symbols → Option (Fin states × Fin symbols × Move) |
|
|
| namespace Machine |
|
|
| abbrev Input (M : Machine) := List (Fin M.symbols) |
|
|
| def blank (M : Machine) : Fin M.symbols := ⟨0, M.symbols_pos⟩ |
|
|
| def description (M : Machine) : ℕ × ℕ × ℕ × List (Option (ℕ × ℕ × Move)) := |
| (M.states, M.symbols, M.initial.val, |
| (List.finRange M.states).flatMap fun q => |
| (List.finRange M.symbols).map fun z => |
| (M.transition q z).map fun v => (v.1.val, v.2.1.val, v.2.2)) |
|
|
| def inputDescription (M : Machine) (w : M.Input) : ℕ := |
| Encodable.encode (M.description, w.map Fin.val) |
|
|
| structure Config (M : Machine) where |
| state : Fin (M.states + 1) |
| head : ℤ |
| tape : ℤ → Fin M.symbols |
|
|
| def initialConfig (M : Machine) (w : M.Input) : M.Config := |
| ⟨⟨M.initial.val, Nat.lt_succ_of_lt M.initial.isLt⟩, 0, |
| fun i => if 0 ≤ i then w[i.toNat]?.getD M.blank else M.blank⟩ |
|
|
| def nextConfig (M : Machine) (c : M.Config) : M.Config := |
| if h : c.state.val < M.states then |
| match M.transition ⟨c.state.val, h⟩ (c.tape c.head) with |
| | none => ⟨⟨M.states, Nat.lt_succ_self _⟩, c.head, c.tape⟩ |
| | some (q', z', d) => |
| ⟨⟨q'.val, Nat.lt_succ_of_lt q'.isLt⟩, c.head + (d.val : ℤ) - 1, |
| Function.update c.tape c.head z'⟩ |
| else c |
|
|
| def run (M : Machine) (w : M.Input) (n : ℕ) : M.Config := |
| M.nextConfig^[n] (M.initialConfig w) |
|
|
| def Halts (M : Machine) (w : M.Input) : Prop := |
| ∃ n : ℕ, (M.run w n).state.val = M.states |
|
|
| end Machine |
|
|
| structure ScaleData where |
| rA : ℕ |
| rQ : ℕ |
| B : ℕ |
|
|
| namespace ScaleData |
|
|
| def A (d : ScaleData) : ℕ := 2 ^ d.rA |
| def S (d : ScaleData) : ℕ := 2 ^ d.rQ |
| def P (_d : ScaleData) (n : ℕ) : ℕ := 2 ^ (n + 2) |
| def L (d : ScaleData) (n : ℕ) : ℕ := d.rQ + n + 2 + d.rA * (2 * n + d.B + 1) |
| def capacity (d : ScaleData) (n : ℕ) : ℕ := 2 ^ d.L n |
| def C (d : ScaleData) : ℕ := max 1 (max (d.L 0) (1 + 2 * d.rA)) |
| def s (d : ScaleData) (n : ℕ) : ℕ := d.C * 2 ^ ((n + 2) ^ 2) |
| def D (d : ScaleData) (n : ℕ) : ℕ := 2 ^ d.s n |
| noncomputable def δ (d : ScaleData) (n : ℕ) : ℝ := |
| letI := twoAtLeastTwo |
| (1 / 2 : ℝ) ^ d.s n |
| noncomputable def b (d : ScaleData) (n : ℕ) : ℝ := d.δ (n + 1) * (d.capacity (n + 1) : ℝ) |
|
|
| end ScaleData |
|
|
| namespace Machine |
|
|
| def scaleData (M : Machine) (w : M.Input) : ScaleData := |
| ⟨M.symbols + 1, M.states + 1, w.length⟩ |
|
|
| def instruction (M : Machine) (q z : ℕ) : ℕ × ℕ × Move := |
| letI := neZeroThree |
| if hq : q < M.states then |
| if hz : z < M.symbols then |
| match M.transition ⟨q, hq⟩ ⟨z, hz⟩ with |
| | none => (M.states, z, 1) |
| | some (q', z', d) => (q'.val, z'.val, d) |
| else (M.states, z, 1) |
| else (M.states, z, 1) |
|
|
| def terminalDigit (M : Machine) (d : ScaleData) (k : ℕ) : ℕ := |
| if k % d.S = M.states then 1 else 0 |
|
|
| def nextDigit (M : Machine) (d : ScaleData) (n k : ℕ) : ℕ := |
| let q := k % d.S |
| let j := (k / d.S) % d.P n |
| let T := k / (d.S * d.P n) |
| let z := (T / d.A ^ j) % d.A |
| if q < M.states ∧ j ≤ 2 * n ∧ z < M.symbols then |
| let inst := M.instruction q z |
| inst.1 + d.S * (j + inst.2.2.val + |
| d.P (n + 1) * d.A * (T - z * d.A ^ j + inst.2.1 * d.A ^ j)) |
| else 0 |
|
|
| def initialDigit (M : Machine) (w : M.Input) : ℕ := |
| let d := M.scaleData w |
| M.initial.val + d.S * (d.P 0 * |
| ((w.map Fin.val).zipIdx.map fun a => a.1 * d.A ^ a.2).sum) |
|
|
| end Machine |
|
|
| noncomputable def θ (t : ℝ) : ℝ := |
| letI := twoAtLeastTwo |
| Real.smoothTransition (2 * t - 1 / 2) |
|
|
| noncomputable def ζ (v : Space) : ℝ := |
| ∏ i, Real.smoothTransition (16 * (v i + 1 / 8)) * |
| Real.smoothTransition (16 * (1 / 8 - v i)) |
|
|
| noncomputable def cross (a b : Space) : Space := |
| letI := neZeroThree |
| vec (a 1 * b 2 - a 2 * b 1) (a 2 * b 0 - a 0 * b 2) (a 0 * b 1 - a 1 * b 0) |
|
|
| noncomputable def curl (v : Space → Space) (x : Space) : Space := |
| letI := neZeroThree |
| vec ((fderiv ℝ v x (basis 1)) 2 - (fderiv ℝ v x (basis 2)) 1) |
| ((fderiv ℝ v x (basis 2)) 0 - (fderiv ℝ v x (basis 0)) 2) |
| ((fderiv ℝ v x (basis 0)) 1 - (fderiv ℝ v x (basis 1)) 0) |
|
|
| noncomputable def movingCurl (c : ℝ → Space) (δ : ℝ) : Field Space := |
| letI := twoAtLeastTwo |
| fun σ x => curl (fun y => |
| ζ (δ⁻¹ • (y - c σ)) • ((1 / 2 : ℝ) • cross (deriv c σ) (y - c σ))) x |
|
|
| noncomputable def addressCenter (d : ScaleData) (n m : ℕ) : Space := |
| vec (-1) ((m : ℝ) * d.δ n) 0 |
|
|
| noncomputable def addressDisplacement (M : Machine) (d : ScaleData) (n m : ℕ) : Space := |
| let k := m % d.capacity n |
| vec (-d.b n * (M.terminalDigit d k : ℝ)) |
| (d.δ (n + 1) * (M.nextDigit d n k : ℝ)) 0 |
|
|
| noncomputable def addressPath (M : Machine) (d : ScaleData) (n m : ℕ) (σ : ℝ) : Space := |
| addressCenter d n m + θ σ • addressDisplacement M d n m |
|
|
| noncomputable def addressedVelocity (M : Machine) (w : M.Input) : Field Space := |
| let d := M.scaleData w |
| let y₀ := d.δ 0 * (M.initialDigit w : ℝ) |
| fun t x => if t ≤ 1 then |
| movingCurl (fun s => θ s • vec (-1) y₀ 0) 1 t x |
| else |
| let n := Nat.floor (t - 1) |
| ∑ m ∈ Finset.range (d.D n + 1), |
| movingCurl (addressPath M d n m) (d.δ n) (t - 1 - (n : ℝ)) x |
|
|
| noncomputable def addressedForce (ν : ℝ) (M : Machine) (w : M.Input) : Field Space := |
| residual ν (addressedVelocity M w) |
|
|
| abbrev Program := Nat.Partrec.Code |
| abbrev RationalVector := ℚ × ℚ × ℚ |
| abbrev RationalPoint := ℚ × RationalVector |
|
|
| noncomputable def rationalVector (q : RationalVector) : Space := |
| vec q.1 q.2.1 q.2.2 |
|
|
| noncomputable def accuracy (n : ℕ) : ℝ := |
| letI := twoAtLeastTwo |
| (1 / 2 : ℝ) ^ n |
|
|
| def NamesReal (c : Program) (x : ℝ) : Prop := |
| ∀ n : ℕ, ∃ q : ℚ, Encodable.encode q ∈ c.eval n ∧ |(q : ℝ) - x| ≤ accuracy n |
|
|
| def ComputableReal (x : ℝ) : Prop := ∃ c : Program, NamesReal c x |
|
|
| def NamesPoint (c : Program) (t : ℝ) (x : Space) : Prop := |
| ∀ n : ℕ, ∃ q : RationalPoint, Encodable.encode q ∈ c.eval n ∧ |
| |(q.1 : ℝ) - t| ≤ accuracy n ∧ ‖rationalVector q.2 - x‖ ≤ accuracy n |
|
|
| def evalQuery (l : ℕ) (α : MultiIndex) (name : Program) (precision : ℕ) : ℕ := |
| letI := neZeroThree |
| Encodable.encode (l, α 0, α 1, α 2, Encodable.encode name, precision) |
|
|
| def boundQuery (J l : ℕ) (α : MultiIndex) : ℕ := |
| letI := neZeroThree |
| Encodable.encode (J, l, α 0, α 1, α 2) |
|
|
| def EvaluatesMixed (c : Program) (f : Field Space) : Prop := |
| ∀ (l : ℕ) (α : MultiIndex) (name : Program) (t : ℝ) (x : Space), |
| 0 ≤ t → NamesPoint name t x → ∀ n : ℕ, ∃ q : RationalVector, |
| Encodable.encode q ∈ c.eval (evalQuery l α name n) ∧ |
| ‖rationalVector q - mixedD l α f t x‖ ≤ accuracy n |
|
|
| def BoundsMixed (c : Program) (f : Field Space) : Prop := |
| ∀ (J l : ℕ) (α : MultiIndex), ∃ C : ℕ, |
| C ∈ c.eval (boundQuery J l α) ∧ |
| ∀ (t : ℝ), 0 ≤ t → ∀ x : Space, |
| (1 + t + ‖x‖) ^ J * ‖mixedD l α f t x‖ ≤ (C : ℝ) |
|
|
| def ForceProgram (codes : ℕ × ℕ) (f : Field Space) : Prop := |
| EvaluatesMixed (Nat.Partrec.Code.ofNatCode codes.1) f ∧ |
| BoundsMixed (Nat.Partrec.Code.ofNatCode codes.2) f |
|
|
| end RapidForcing |
|
|
| end OAI |
|
|
