lean/OAI/MathematicalPhysics/AlternatingFlow/Construction.lean

import OAI.MathematicalPhysics.AlternatingFlow.LocalRules
import OAI.MathematicalPhysics.AlternatingFlow.SpatialCurls
import OAI.MathematicalPhysics.AlternatingFlow.TimeGlue

namespace OAI

open scoped BigOperators ENNReal NNReal Topology ContDiff
open MeasureTheory
namespace AlternatingNS
namespace Construction

def donorIndex (n : ℕ) : Fin 3 :=
  letI := neZeroThree
  if n % 2 = 0 then 1 else 2

def receiverIndex (n : ℕ) : Fin 3 :=
  letI := neZeroThree
  if n % 2 = 0 then 2 else 1

lemma indices_distinct (n : ℕ) : receiverIndex n ≠ 0 ∧ donorIndex n ≠ receiverIndex n ∧
    donorIndex n ≠ 0 := by
  unfold donorIndex receiverIndex
  split_ifs <;> decide

noncomputable def slot (M : Machine) (N n : ℕ) : Space → Space :=
  letI := neZeroThree
  Spatial.localizedShear (donorIndex n) (receiverIndex n) 0
    (LocalRule.write M N n) (LocalRule.signal M N n)

noncomputable def loading (M : Machine) (w : List ℕ) : Space → Space :=
  letI := neZeroThree
  Spatial.localizedShear 2 1 0
    (fun _ => Scales.ε M.base w.length 0 * M.recordedBlock w 0)
    (fun _ => 1 - Scales.ε M.base w.length 0)

noncomputable def piece (M : Machine) (w : List ℕ) : ℕ → Space → Space :=
  fun n => Nat.casesOn n (loading M w) (fun k => slot M w.length k)

noncomputable def velocity (M : Machine) (w : List ℕ) : Velocity :=
  TimeGlue.glue Profiles.pulse (piece M w)

lemma slot_smooth (M : Machine) (N n : ℕ) : ContDiff ℝ ∞ (slot M N n) :=
  Spatial.localizedShear_smooth _ _ _ _ _ (LocalRule.write_smooth M N n) (LocalRule.signal_smooth M N n)

lemma loading_smooth (M : Machine) (w : List ℕ) : ContDiff ℝ ∞ (loading M w) :=
  Spatial.localizedShear_smooth _ _ _ _ _ contDiff_const contDiff_const

lemma piece_smooth (M : Machine) (w : List ℕ) (n : ℕ) : ContDiff ℝ ∞ (piece M w n) := by
  cases n with
  | zero => exact loading_smooth M w
  | succ n => exact slot_smooth M w.length n

lemma piece_support (M : Machine) (w : List ℕ) (n : ℕ) :
    tsupport (piece M w n) ⊆ Spatial.box := by
  cases n <;> exact Spatial.localizedShear_support _ _ _ _ _

lemma piece_div (M : Machine) (w : List ℕ) (n : ℕ) (x : Space) :
    (∑ i : Fin 3, Spatial.d i (piece M w n) x i) = 0 := by
  cases n with
  | zero => exact Spatial.localizedShear_div _ _ _ _ _ contDiff_const contDiff_const x
  | succ n =>
    exact Spatial.localizedShear_div _ _ _ _ _ (LocalRule.write_smooth M w.length n)
      (LocalRule.signal_smooth M w.length n) x

lemma velocity_smooth (M : Machine) (w : List ℕ) :
    ContDiff ℝ ∞ (Function.uncurry (velocity M w)) :=
  TimeGlue.smooth Profiles.pulse Profiles.pulse_zero_left Profiles.pulse_smooth
    (piece M w) (piece_smooth M w)

lemma velocity_supported (M : Machine) (w : List ℕ) (t : ℝ) :
    Function.support (velocity M w t) ⊆ Spatial.box := by
  intro x hx
  by_contra hn
  have hz (k : ℕ) : piece M w k x = 0 := by
    by_contra hk
    exact hn (piece_support M w k (subset_closure hk))
  exact hx (by simp [velocity, TimeGlue.glue, hz])

lemma velocity_rest (M : Machine) (w : List ℕ) (x : Space) : velocity M w 0 x = 0 := by
  rw [velocity, TimeGlue.pulse_slot _ 0 0 (by norm_num) x]
  simp [Profiles.pulse_zero_left]

lemma velocity_div (M : Machine) (w : List ℕ) (t : ℝ) (ht : 0 ≤ t) (x : Space) :
    div (velocity M w) t x = 0 := by
  let k := ⌊t⌋₊
  have hk : t ∈ Set.Icc (k : ℝ) (k + 1) := ⟨Nat.floor_le ht, (Nat.lt_floor_add_one t).le⟩
  have heq : velocity M w t = (fun x => Profiles.pulse (t - k) • piece M w k x) :=
    funext (TimeGlue.pulse_slot _ k t hk)
  unfold div dx
  rw [heq]
  have hd := (piece_smooth M w k).differentiable (by simp) x
  change (∑ i : Fin 3, (fderiv ℝ (Profiles.pulse (t - k) • piece M w k) x (e i)) i) = 0
  simp only [fderiv_const_smul hd, smul_apply, PiLp.smul_apply, smul_eq_mul]
  rw [← Finset.mul_sum]
  change Profiles.pulse (t - k) * (∑ i : Fin 3, Spatial.d i (piece M w k) x i) = 0
  rw [piece_div, mul_zero]

lemma slot_plateau (M : Machine) (N n : ℕ) (x : Space) (hx : x ∈ Spatial.plateau) :
    slot M N n x = LocalRule.write M N n (x (donorIndex n)) • e (receiverIndex n) +
      LocalRule.signal M N n (x (donorIndex n)) • e 0 :=
  Spatial.localizedShear_plateau _ _ _ (indices_distinct n).1 (indices_distinct n).2.1
    (indices_distinct n).2.2 _ _ (LocalRule.write_smooth M N n) (LocalRule.signal_smooth M N n) x hx

lemma loading_plateau (M : Machine) (w : List ℕ) (x : Space) (hx : x ∈ Spatial.plateau) :
    loading M w x = (Scales.ε M.base w.length 0 * M.recordedBlock w 0) • e 1 +
      (1 - Scales.ε M.base w.length 0) • e 0 :=
  Spatial.localizedShear_plateau 2 1 0 (by decide) (by decide) (by decide)
    _ _ contDiff_const contDiff_const x hx

end Construction
end AlternatingNS

namespace AlternatingNS
namespace Construction

lemma donorIndex_succ (n : ℕ) : donorIndex (n + 1) = receiverIndex n := by
  unfold donorIndex receiverIndex
  split_ifs <;> omega

lemma donorIndex_eq (j n : ℕ) : donorIndex j = donorIndex n ↔ j % 2 = n % 2 := by
  unfold donorIndex
  split_ifs <;> norm_num <;> omega

noncomputable def memory (M : Machine) (w : List ℕ) (n : ℕ) : Space :=
  ∑ j ∈ Finset.range (n + 1),
    (Scales.ε M.base w.length j * M.recordedBlock w j) • e (donorIndex j)

noncomputable def history (M : Machine) (w : List ℕ) (n : ℕ) : Space :=
  memory M w n + Detector.signal M.base w.length (fun j => M.isHalting (M.run w j)) n • e 0

noncomputable def displacement (M : Machine) (w : List ℕ) : ℕ → Space
  | 0 => (Scales.ε M.base w.length 0 * M.recordedBlock w 0) • e 1 +
      (1 - Scales.ε M.base w.length 0) • e 0
  | n + 1 => (Scales.ε M.base w.length (n + 1) * M.recordedBlock w (n + 1)) •
      e (receiverIndex n) +
      Detector.increment M.base w.length (fun j => M.isHalting (M.run w j)) n • e 0

noncomputable def node (M : Machine) (w : List ℕ) : ℕ → Space
  | 0 => observedParticle
  | n + 1 => history M w n

noncomputable def path (M : Machine) (w : List ℕ) (t : ℝ) : Space :=
  observedParticle + TimeGlue.glue Profiles.clock (fun k (_ : Unit) => displacement M w k) t ()

lemma memory_zero_coord (M : Machine) (w : List ℕ) (n : ℕ) : memory M w n 0 = 0 := by
  have h0 (j : ℕ) : (0 : Fin 3) ≠ donorIndex j := (indices_distinct j).2.2.symm
  simp [memory, WithLp.ofLp_sum, Finset.sum_apply, Spatial.e_apply, h0]

lemma memory_donor (M : Machine) (w : List ℕ) (n : ℕ) :
    memory M w n (donorIndex n) = Encoding.donor M.base w.length (M.recordedBlock w) n := by
  simp only [memory, Encoding.donor, WithLp.ofLp_sum, Finset.sum_apply, PiLp.smul_apply, smul_eq_mul, Spatial.e_apply]
  apply Finset.sum_congr rfl
  intro j _
  simp only [donorIndex_eq, eq_comm (a := n % 2) (b := j % 2), mul_ite, mul_one, mul_zero]

lemma memory_succ (M : Machine) (w : List ℕ) (n : ℕ) :
    memory M w (n + 1) = memory M w n +
      (Scales.ε M.base w.length (n + 1) * M.recordedBlock w (n + 1)) • e (receiverIndex n) := by
  simp only [memory, Finset.sum_range_succ (n := n + 1), donorIndex_succ]

lemma history_zero_coord (M : Machine) (w : List ℕ) (n : ℕ) :
    history M w n 0 = Detector.signal M.base w.length (fun j => M.isHalting (M.run w j)) n := by
  simp [history, PiLp.add_apply, memory_zero_coord, PiLp.smul_apply, Spatial.e_apply]

lemma history_donor (M : Machine) (w : List ℕ) (n : ℕ) :
    history M w n (donorIndex n) = Encoding.donor M.base w.length (M.recordedBlock w) n := by
  simp [history, PiLp.add_apply, memory_donor, PiLp.smul_apply, Spatial.e_apply, (indices_distinct n).2.2]

lemma history_succ (M : Machine) (w : List ℕ) (n : ℕ) :
    history M w (n + 1) = history M w n + displacement M w (n + 1) := by
  simp only [history, memory_succ, Detector.signal, displacement, add_smul]
  abel

lemma observedParticle_eq : observedParticle = -e 0 := by
  ext i
  fin_cases i <;> norm_num [observedParticle, e, PiLp.single_apply, PiLp.neg_apply,
    EuclideanSpace.single, EuclideanSpace.equiv]

lemma node_succ (M : Machine) (w : List ℕ) (k : ℕ) :
    node M w (k + 1) = node M w k + displacement M w k := by
  cases k with
  | zero =>
    simp only [node, history, memory, Nat.zero_add, Finset.sum_range_one, donorIndex, Nat.zero_mod,
      ite_true, Detector.signal, displacement, observedParticle_eq, sub_smul, one_smul, neg_smul]
    abel
  | succ n => exact history_succ M w n

lemma node_sum (M : Machine) (w : List ℕ) (k : ℕ) :
    node M w k = observedParticle + ∑ j ∈ Finset.range k, displacement M w j := by
  induction k with
  | zero => simp [node]
  | succ k ih => rw [node_succ, ih, Finset.sum_range_succ, add_assoc]

lemma path_slot (M : Machine) (w : List ℕ) (k : ℕ) (t : ℝ)
    (ht : t ∈ Set.Icc (k : ℝ) (k + 1)) :
    path M w t = node M w k + Profiles.clock (t - k) • displacement M w k := by
  rw [path, TimeGlue.clock_slot _ k t ht (), ← add_assoc, ← node_sum]

lemma path_node (M : Machine) (w : List ℕ) (k : ℕ) : path M w k = node M w k := by
  rw [path_slot M w k k (by constructor <;> linarith)]
  simp [Profiles.clock_zero]

lemma memory_bound (M : Machine) (hM : M.WellFormed) (w : List ℕ) (hw : M.ValidInput w)
    (n : ℕ) (i : Fin 3) : 0 ≤ memory M w n i ∧ memory M w n i < 1 / 4 := by
  have hb := M.base_ge_four
  have he (j : ℕ) := Scales.ε_nonneg M.base w.length j (by omega)
  have hC (j : ℕ) := M.recordedBlock_mem hM w hw j
  have hm := Encoding.tailMax_lt_one M.base (by omega)
  have hterm (j : ℕ) : 0 ≤ ((Scales.ε M.base w.length j * M.recordedBlock w j) •
      e (donorIndex j)) i ∧
      ((Scales.ε M.base w.length j * M.recordedBlock w j) • e (donorIndex j)) i ≤
        Scales.ε M.base w.length j := by
    simp only [PiLp.smul_apply, Spatial.e_apply, smul_eq_mul]
    split_ifs
    · rw [mul_one]
      exact ⟨mul_nonneg (he j) (hC j).1, mul_le_of_le_one_right (he j) ((hC j).2.trans hm.le)⟩
    · simp only [mul_zero]
      exact ⟨le_rfl, he j⟩
  simp only [memory, WithLp.ofLp_sum, Finset.sum_apply]
  refine ⟨Finset.sum_nonneg (fun j _ => (hterm j).1), ?_⟩
  calc
    _ ≤ ∑ j ∈ Finset.range (n + 1), Scales.ε M.base w.length j :=
      Finset.sum_le_sum (fun j _ => (hterm j).2)
    _ ≤ ∑' j, Scales.ε M.base w.length j :=
      (Scales.summable_ε M.base w.length (by omega)).sum_le_tsum _ (fun j _ => he j)
    _ ≤ 2 * Scales.ε M.base w.length 0 := Scales.total_memory_le _ _ (by omega)
    _ < 1 / 4 := Scales.initial_memory_small _ _ hb

lemma node_plateau (M : Machine) (hM : M.WellFormed) (w : List ℕ) (hw : M.ValidInput w)
    (k : ℕ) : node M w k ∈ Spatial.plateau := by
  have hb := M.base_ge_four
  intro i
  cases k with
  | zero =>
    simp only [node, observedParticle_eq, PiLp.neg_apply, Spatial.e_apply]
    split_ifs <;> norm_num
  | succ n =>
    change |history M w n i| < 2
    by_cases hi : i = 0
    · rw [hi, history_zero_coord]
      have hp := Detector.signal_in_plateau M.base w.length hb
        (fun j => M.isHalting (M.run w j)) n
      exact (abs_lt.2 hp).trans (by norm_num)
    · simp only [history, PiLp.add_apply, PiLp.smul_apply, Spatial.e_apply,
        ite_eq_right hi, smul_eq_mul, mul_zero, add_zero]
      rw [abs_of_nonneg (memory_bound M hM w hw n i).1]
      exact (memory_bound M hM w hw n i).2.trans (by norm_num)

lemma segment_plateau (a b : Space) (ha : a ∈ Spatial.plateau) (hb : b ∈ Spatial.plateau)
    (θ : ℝ) (hθ : θ ∈ Set.Icc 0 1) : (1 - θ) • a + θ • b ∈ Spatial.plateau := by
  intro i
  have hai := abs_lt.mp (ha i)
  have hbi := abs_lt.mp (hb i)
  simp only [PiLp.add_apply, PiLp.smul_apply, smul_eq_mul]
  apply abs_lt.mpr
  constructor <;> nlinarith [mul_nonneg (sub_nonneg.mpr hθ.2) (le_of_lt (sub_pos.mpr hai.2)),
    mul_nonneg hθ.1 (le_of_lt (sub_pos.mpr hbi.2)),
    mul_nonneg (sub_nonneg.mpr hθ.2) (le_of_lt (sub_pos.mpr hai.1)),
    mul_nonneg hθ.1 (le_of_lt (sub_pos.mpr hbi.1))]

lemma path_plateau (M : Machine) (hM : M.WellFormed) (w : List ℕ) (hw : M.ValidInput w)
    (t : ℝ) (ht : 0 ≤ t) : path M w t ∈ Spatial.plateau := by
  let k := ⌊t⌋₊
  have hk : t ∈ Set.Icc (k : ℝ) (k + 1) := ⟨Nat.floor_le ht, (Nat.lt_floor_add_one t).le⟩
  rw [path_slot M w k t hk]
  have heq : node M w k + Profiles.clock (t - k) • displacement M w k =
      (1 - Profiles.clock (t - k)) • node M w k + Profiles.clock (t - k) • node M w (k + 1) := by
    rw [node_succ, smul_add, sub_smul, one_smul]
    abel
  rw [heq]
  exact segment_plateau _ _ (node_plateau M hM w hw k) (node_plateau M hM w hw (k + 1))
    _ (Profiles.clock_mem _)

end Construction
end AlternatingNS

namespace AlternatingNS
namespace Construction

lemma path_donor (M : Machine) (w : List ℕ) (n : ℕ) (t : ℝ)
    (ht : t ∈ Set.Icc ((n : ℝ) + 1) (n + 1 + 1)) :
    path M w t (donorIndex n) = Encoding.donor M.base w.length (M.recordedBlock w) n := by
  have ht' : t ∈ Set.Icc ((n + 1 : ℕ) : ℝ) ((n + 1 : ℕ) + 1) := by
    simpa only [Nat.cast_add, Nat.cast_one] using ht
  rw [path_slot M w (n + 1) t ht']
  simp only [node, PiLp.add_apply, PiLp.smul_apply, history_donor, displacement,
    Spatial.e_apply, (indices_distinct n).2.1, (indices_distinct n).2.2,
    ite_false, smul_eq_mul, mul_zero, add_zero]

lemma piece_path (M : Machine) (hM : M.WellFormed) (w : List ℕ) (hw : M.ValidInput w)
    (k : ℕ) (t : ℝ) (ht : t ∈ Set.Icc (k : ℝ) (k + 1)) :
    piece M w k (path M w t) = displacement M w k := by
  have ht0 : 0 ≤ t := le_trans (Nat.cast_nonneg k) ht.1
  have hp := path_plateau M hM w hw t ht0
  cases k with
  | zero => exact loading_plateau M w _ hp
  | succ n =>
    change slot M w.length n (path M w t) = _
    rw [slot_plateau M w.length n _ hp,
      path_donor M w n t (by simpa only [Nat.cast_add, Nat.cast_one] using ht),
      LocalRule.write_run M hM w hw, LocalRule.signal_run M hM w hw]
    rfl

lemma velocity_path (M : Machine) (hM : M.WellFormed) (w : List ℕ) (hw : M.ValidInput w)
    (t : ℝ) (ht : 0 ≤ t) :
    velocity M w t (path M w t) =
      TimeGlue.glue Profiles.pulse (fun k (_ : Unit) => displacement M w k) t () := by
  let k := ⌊t⌋₊
  have hk : t ∈ Set.Icc (k : ℝ) (k + 1) := ⟨Nat.floor_le ht, (Nat.lt_floor_add_one t).le⟩
  rw [velocity, TimeGlue.pulse_slot _ k t hk, TimeGlue.pulse_slot _ k t hk,
    piece_path M hM w hw k t hk]

theorem path_isTrajectory (M : Machine) (hM : M.WellFormed) (w : List ℕ) (hw : M.ValidInput w) :
    IsTrajectory (velocity M w) observedParticle (path M w) := by
  refine ⟨by simpa only [Nat.cast_zero, node] using path_node M w 0, ?_⟩
  intro t ht
  rw [velocity_path M hM w hw t ht]
  exact ((TimeGlue.hasDerivAt Profiles.clock Profiles.pulse
    (fun s hs => Profiles.clock_zero s (by linarith)) Profiles.pulse_zero_left
    Profiles.clock_hasDeriv (fun k (_ : Unit) => displacement M w k) t ()).const_add
      observedParticle).hasDerivWithinAt

lemma path_loading_coord (M : Machine) (w : List ℕ) (t : ℝ) (ht : t ∈ Set.Icc 0 1) :
    path M w t 0 = Detector.loading M.base w.length (Profiles.clock t) := by
  rw [path_slot M w 0 t (by simpa using ht)]
  simp [node, observedParticle_eq, displacement, PiLp.add_apply, PiLp.smul_apply,
    PiLp.neg_apply, Spatial.e_apply, Detector.loading]

lemma path_slot_coord (M : Machine) (w : List ℕ) (n : ℕ) (t : ℝ)
    (ht : t ∈ Set.Icc ((n : ℝ) + 1) (n + 1 + 1)) :
    path M w t 0 = Detector.during M.base w.length (fun j => M.isHalting (M.run w j)) n
      (Profiles.clock (t - (n + 1))) := by
  rw [path_slot M w (n + 1) t (by simpa only [Nat.cast_add, Nat.cast_one] using ht)]
  simp [node, displacement, PiLp.add_apply, PiLp.smul_apply, Spatial.e_apply,
    (indices_distinct n).1.symm, Detector.during, history_zero_coord]

theorem path_reachability (M : Machine) (w : List ℕ) :
    (∃ t : ℝ, 0 ≤ t ∧ 0 < path M w t 0) ↔ M.Halts w := by
  have hb := M.base_ge_four
  constructor
  · rintro ⟨t, ht, hp⟩
    have hk : t ∈ Set.Icc (⌊t⌋₊ : ℝ) (⌊t⌋₊ + 1) := ⟨Nat.floor_le ht, (Nat.lt_floor_add_one t).le⟩
    generalize hfloor : ⌊t⌋₊ = k at hk
    cases k with
    | zero =>
      have ht' : t ∈ Set.Icc 0 1 := by simpa using hk
      rw [path_loading_coord M w t ht'] at hp
      exact False.elim ((Detector.loading_negative M.base w.length (by omega) _
        (Profiles.clock_mem t)).not_gt hp)
    | succ n =>
      rw [path_slot_coord M w n t (by simpa only [Nat.cast_add, Nat.cast_one] using hk)] at hp
      exact (Detector.machine_scalar_reachability M.base (by omega) M w).mp
        ⟨n, _, Profiles.clock_mem _, hp⟩
  · intro h
    let n := Nat.find h
    have hn : M.isHalting (M.run w n) = true := Nat.find_spec h
    have hprev : ∀ j < n, M.isHalting (M.run w j) = false :=
      fun j hj => Bool.eq_false_iff.2 (Nat.find_min h hj)
    refine ⟨((n + 1 + 1 : ℕ) : ℝ), Nat.cast_nonneg _, ?_⟩
    rw [path_node]
    change 0 < history M w (n + 1) 0
    rw [history_zero_coord, Detector.signal_first_halt M.base w.length _ n hprev hn]
    exact Scales.ε_pos M.base w.length (n + 1) (by omega)

end Construction
end AlternatingNS

end OAI