import Mathlib

namespace OAI

namespace Alternating

open scoped BigOperators
open MeasureTheory

abbrev Instruction := ℕ × ℕ × Fin 3

abbrev Machine := ℕ × ℕ × Finset ℕ × List (List (Option Instruction))

abbrev MachineInput := Machine × List ℕ

def Machine.stateCount (M : Machine) : ℕ := M.1 + 1

def Machine.symbolCount (M : Machine) : ℕ := M.2.1 + 1

def Machine.haltingStates (M : Machine) : Finset ℕ := M.2.2.1

def Machine.table (M : Machine) : List (List (Option Instruction)) := M.2.2.2

def Machine.WellFormed (M : Machine) : Prop :=
  M.table.length = M.stateCount ∧
  (∀ q ∈ M.haltingStates, q < M.stateCount) ∧
  ∀ row ∈ M.table,
    row.length = M.symbolCount ∧
    ∀ i : Instruction, some i ∈ row →
      i.1 < M.stateCount ∧ i.2.1 < M.symbolCount

def ValidInput (I : MachineInput) : Prop :=
  I.1.WellFormed ∧ ∀ a ∈ I.2, a < I.1.symbolCount

theorem ValidInput.machine_wellFormed {I : MachineInput} (hI : ValidInput I) :
    I.1.WellFormed := hI.1

structure Configuration where
  state : ℕ
  head : ℤ
  tape : ℤ → ℕ

def Machine.isHalting (M : Machine) (q : ℕ) : Bool :=
  decide (q = M.stateCount ∨ q ∈ M.haltingStates)

def Machine.instruction (M : Machine) (q a : ℕ) : Option Instruction :=
  ((M.table[q]?).bind fun row => row[a]?).join

def Machine.step (M : Machine) (c : Configuration) : Configuration :=
  if M.isHalting c.state then c
  else match M.instruction c.state (c.tape c.head) with
    | none => { c with state := M.stateCount }
    | some i =>
      { state := i.1
        head := c.head + (i.2.2.val : ℤ) - 1
        tape := Function.update c.tape c.head i.2.1 }

def initialConfiguration (w : List ℕ) : Configuration :=
  { state := 0
    head := 0
    tape := fun j => if j < 0 then 0 else (w[j.toNat]?).getD 0 }

def configurationAt (I : MachineInput) (n : ℕ) : Configuration :=
  I.1.step^[n] (initialConfiguration I.2)

def Halts (I : MachineInput) : Prop :=
  ∃ n : ℕ, I.1.isHalting (configurationAt I n).state = true

abbrev Space := EuclideanSpace ℝ (Fin 3)
abbrev Field := ℝ → Space → Space
abbrev Pressure := ℝ → Space → ℝ
abbrev MultiIndex := Fin 3 → ℕ

noncomputable section

def basisVector (i : Fin 3) : Space := EuclideanSpace.single i 1

def multiOrder (α : MultiIndex) : ℕ := ∑ i, α i

def spatialD {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    (i : Fin 3) (g : Space → E) : Space → E :=
  fun x => fderiv ℝ g x (basisVector i)

def spatialPartial {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    (α : MultiIndex) (g : Space → E) : Space → E :=
  (spatialD 2)^[α 2] ((spatialD 1)^[α 1] ((spatialD 0)^[α 0] g))

def timeD {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    (g : ℝ → E) : ℝ → E := fun t => derivWithin g (Set.Ici 0) t

def mixedPartial (u : Field) (l : ℕ) (α : MultiIndex) (t : ℝ) (x : Space) : Space :=
  timeD^[l] (fun s => spatialPartial α (u s) x) t

def timeDerivative (u : Field) (t : ℝ) (x : Space) : Space :=
  timeD (fun s => u s x) t

def divergence (u : Space → Space) (x : Space) : ℝ :=
  ∑ i : Fin 3, spatialD i u x i

def gradient (p : Space → ℝ) (x : Space) : Space :=
  (EuclideanSpace.equiv (Fin 3) ℝ).symm (fun i => spatialD i p x)

def laplacian (u : Space → Space) (x : Space) : Space :=
  ∑ i : Fin 3, spatialD i (spatialD i u) x

def convection (u : Space → Space) (x : Space) : Space :=
  ∑ i : Fin 3, (u x i) • spatialD i u x

def residual (ν : ℝ) (u : Field) : Field :=
  fun t x => timeDerivative u t x + convection (u t) x - ν • laplacian (u t) x

def timeSpace : Set (ℝ × Space) := Set.Ici 0 ×ˢ Set.univ

def SmoothUpToZero (u : Field) : Prop :=
  ContDiffOn ℝ (⊤ : ℕ∞) (Function.uncurry u) timeSpace

def SupportedIn (K : Set Space) (u : Field) : Prop :=
  ∀ t : ℝ, 0 ≤ t → ∀ x : Space, x ∉ K → u t x = 0

def RapidDecay (u : Field) : Prop :=
  ∀ (J l : ℕ) (α : MultiIndex), ∃ C : ℝ, 0 ≤ C ∧
    ∀ (t : ℝ), 0 ≤ t → ∀ x : Space,
      (1 + t + ‖x‖) ^ J * ‖mixedPartial u l α t x‖ ≤ C

def ClassicalRegularity (u : Field) (p : Pressure) : Prop :=
  (∀ t : ℝ, 0 ≤ t → ContDiff ℝ 2 (u t) ∧ ContDiff ℝ 1 (p t)) ∧
  (∀ x : Space, DifferentiableOn ℝ (fun t => u t x) (Set.Ici 0)) ∧
  ∀ T : ℝ, 0 ≤ T →
    ContinuousOn (Function.uncurry (timeDerivative u)) (Set.Icc 0 T ×ˢ Set.univ) ∧
    (∀ α : MultiIndex, multiOrder α ≤ 2 →
      ContinuousOn (fun tx : ℝ × Space => spatialPartial α (u tx.1) tx.2)
        (Set.Icc 0 T ×ˢ Set.univ)) ∧
    (∀ α : MultiIndex, multiOrder α ≤ 1 →
      ContinuousOn (fun tx : ℝ × Space => spatialPartial α (p tx.1) tx.2)
        (Set.Icc 0 T ×ˢ Set.univ))

def NSSolution (ν : ℝ) (f u : Field) (p : Pressure) : Prop :=
  ClassicalRegularity u p ∧
  (∀ x : Space, u 0 x = 0) ∧
  ∀ t : ℝ, 0 ≤ t → ∀ x : Space,
    divergence (u t) x = 0 ∧
    timeDerivative u t x + convection (u t) x =
      -gradient (p t) x + ν • laplacian (u t) x + f t x

abbrev SpatialL2 (E : Type*) [NormedAddCommGroup E] :=
  MeasureTheory.Lp E 2 (MeasureTheory.volume : MeasureTheory.Measure Space)

def ContinuousInSobolev {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    (k : ℕ) (g : ℝ → Space → E) (T : ℝ) : Prop :=
  ∀ α : MultiIndex, multiOrder α ≤ k →
    ∃ G : ℝ → SpatialL2 E,
      ContinuousOn G (Set.Icc 0 T) ∧
      ∀ t ∈ Set.Icc (0 : ℝ) T,
        (fun x : Space => (G t) x) =ᵐ[volume] spatialPartial α (g t)

def C1InL2 (u : Field) (T : ℝ) : Prop :=
  ∃ U W : ℝ → SpatialL2 Space,
    ContinuousOn U (Set.Icc 0 T) ∧ ContinuousOn W (Set.Icc 0 T) ∧
    ∀ t ∈ Set.Icc (0 : ℝ) T,
      ((fun x : Space => (U t) x) =ᵐ[volume] u t) ∧
      ((fun x : Space => (W t) x) =ᵐ[volume] timeDerivative u t) ∧
      HasDerivWithinAt U (W t) (Set.Icc 0 T) t

def EnergyClass (u : Field) (p : Pressure) : Prop :=
  ∀ T : ℝ, 0 ≤ T →
    ContinuousInSobolev 2 u T ∧ C1InL2 u T ∧ ContinuousInSobolev 1 p T ∧
    ∃ C : ℝ, ∀ t ∈ Set.Icc (0 : ℝ) T, ∀ x : Space,
      ‖u t x‖ + ‖fderiv ℝ (u t) x‖ ≤ C

def CompetitorEnergyClass (u : Field) (p : Pressure) : Prop :=
  ∀ T : ℝ, 0 ≤ T →
    ContinuousInSobolev 2 u T ∧ C1InL2 u T ∧ ContinuousInSobolev 1 p T ∧
    ∃ C : ℝ, ∀ t ∈ Set.Icc (0 : ℝ) T, ∀ x : Space, ‖u t x‖ ≤ C

def SolvesParticle (u : Field) (a : Space) (γ : ℝ → Space) : Prop :=
  γ 0 = a ∧ ∀ t : ℝ, 0 ≤ t →
    HasDerivWithinAt γ (u t (γ t)) (Set.Ici 0) t

def GlobalMaterialFlow (u : Field) (X : ℝ → Space → Space) : Prop :=
  (∀ a : Space, SolvesParticle u a (fun t => X t a)) ∧
  ∀ (a : Space) (γ : ℝ → Space), SolvesParticle u a γ →
    ∀ t : ℝ, 0 ≤ t → γ t = X t a

def observedParticle : Space := -basisVector 0

abbrev Program := Nat.Partrec.Code
abbrev RationalPoint := ℚ × ℚ × ℚ

def rationalPoint (q : RationalPoint) : Space :=
  (EuclideanSpace.equiv (Fin 3) ℝ).symm ![(q.1 : ℝ), (q.2.1 : ℝ), (q.2.2 : ℝ)]

def error (k : ℕ) : ℝ := (2 : ℝ)⁻¹ ^ k

def ComputableReal (x : ℝ) : Prop :=
  ∃ c : Program, ∀ k : ℕ, ∃ q : ℚ,
    Encodable.encode q ∈ c.eval k ∧ |x - (q : ℝ)| ≤ error k

abbrev FieldProgram := Program × Program × Program

def EvaluatesField (c : FieldProgram) (u : Field) : Prop :=
  (∀ (l : ℕ) (α : MultiIndex) (t : ℚ), 0 ≤ t →
    ∀ (x : RationalPoint) (k : ℕ), ∃ q : RationalPoint,
      Encodable.encode q ∈ c.1.eval (Encodable.encode (l, α, t, x, k)) ∧
      ‖mixedPartial u l α (t : ℝ) (rationalPoint x) - rationalPoint q‖ ≤ error k) ∧
  (∀ (l : ℕ) (α : MultiIndex) (k : ℕ), ∃ m : ℕ,
    m ∈ c.2.1.eval (Encodable.encode (l, α, k)) ∧
    ∀ (t s : ℝ), 0 ≤ t → 0 ≤ s → ∀ x y : Space,
      |t - s| + ‖x - y‖ ≤ error m →
      ‖mixedPartial u l α t x - mixedPartial u l α s y‖ ≤ error k) ∧
  (∀ (J l : ℕ) (α : MultiIndex), ∃ C : ℚ,
    Encodable.encode C ∈ c.2.2.eval (Encodable.encode (J, l, α)) ∧ 0 ≤ C ∧
    ∀ t : ℝ, 0 ≤ t → ∀ x : Space,
      (1 + t + ‖x‖) ^ J * ‖mixedPartial u l α t x‖ ≤ (C : ℝ))

def AlternatingOutput (ν : ℝ) (K : Set Space) (I : MachineInput)
    (velocityProgram forceProgram : FieldProgram) : Prop :=
  ∃ (u f : Field) (X : ℝ → Space → Space),
    EvaluatesField velocityProgram u ∧ EvaluatesField forceProgram f ∧
    SmoothUpToZero u ∧ SmoothUpToZero f ∧
    SupportedIn K u ∧ SupportedIn K f ∧ RapidDecay u ∧ RapidDecay f ∧
    f = residual ν u ∧
    NSSolution ν f u (fun _ _ => 0) ∧ EnergyClass u (fun _ _ => 0) ∧
    (∀ (v : Field) (p : Pressure), NSSolution ν f v p → CompetitorEnergyClass v p →
      ∀ t : ℝ, 0 ≤ t → ∀ x : Space, v t x = u t x ∧ p t x = 0) ∧
    GlobalMaterialFlow u X ∧
    ((∃ t : ℝ, 0 ≤ t ∧ 0 < X t observedParticle 0) ↔ Halts I)

end

end Alternating

end OAI