introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
13.4 kB
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