lean/OAI/MathematicalPhysics/AlternatingFlow/LocalRules.lean

import OAI.MathematicalPhysics.AlternatingFlow.Detector
import OAI.MathematicalPhysics.AlternatingFlow.MachineProfiles

namespace OAI

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

noncomputable def readC (M : Machine) (N n : ℕ) (D : ℝ) : ℝ :=
  Profiles.decoder M.base ((M.base : ℝ) ^ Scales.s N n * D)
noncomputable def readB (M : Machine) (N n : ℕ) (D : ℝ) : ℝ :=
  Profiles.decoder M.base ((M.base : ℝ) ^ (Scales.s N n + 1 + Scales.K N n) * D)
noncomputable def readA (M : Machine) (N n : ℕ) (D : ℝ) : ℝ :=
  Profiles.decoder M.base ((M.base : ℝ) ^ (Scales.s N n + 1) * D) -
    ((M.base : ℝ) ^ Scales.K N n)⁻¹ * readB M N n D

noncomputable def updateLeft (b _a l : ℕ) (r : Rule) (A _B : ℝ) : ℝ :=
  letI := neZeroThree
  letI := twoAtLeastTwo
  if r.2.2 = 0 then (b : ℝ) * A - 2 * l
  else if r.2.2 = 1 then A else ((2 * r.2.1 : ℕ) + A) / b

noncomputable def updateRight (b a l : ℕ) (r : Rule) (_A B : ℝ) : ℝ :=
  letI := neZeroThree
  letI := twoAtLeastTwo
  let R := (b : ℝ) * B - 2 * a
  if r.2.2 = 0 then ((2 * l : ℕ) + ((2 * r.2.1 : ℕ) + R) / b) / b
  else if r.2.2 = 1 then ((2 * r.2.1 : ℕ) + R) / b else R

noncomputable def branchNumerator (b K a l : ℕ) (r : Rule) (A B : ℝ) : ℝ :=
  (2 * r.1 : ℕ) + updateLeft b a l r A B +
    ((b : ℝ) ^ K)⁻¹ * updateRight b a l r A B

noncomputable def branch (M : Machine) (N n q a : ℕ) (A B : ℝ) : ℝ :=
  letI := neZeroThree
  let r := M.command q a
  if r.2.2 = 0 then ∑ l ∈ Finset.range M.alphabet,
    Profiles.selector M.base l A * branchNumerator M.base (Scales.K N (n + 1)) a l r A B
  else branchNumerator M.base (Scales.K N (n + 1)) a 0 r A B

noncomputable def write (M : Machine) (N n : ℕ) (D : ℝ) : ℝ :=
  Scales.ε M.base N (n + 1) / M.base *
    ∑ q ∈ Finset.range (M.states + 1), ∑ a ∈ Finset.range M.alphabet,
      Profiles.selector M.base q (readC M N n D) *
        Profiles.selector M.base a (readB M N n D) *
          branch M N n q a (readA M N n D) (readB M N n D)

noncomputable def haltWeight (M : Machine) (N n : ℕ) (D : ℝ) : ℝ :=
  ∑ q ∈ Finset.range (M.states + 1),
    if q = M.states ∨ q ∈ M.haltingStates then Profiles.selector M.base q (readC M N n D) else 0

noncomputable def signal (M : Machine) (N n : ℕ) (D : ℝ) : ℝ :=
  letI := twoAtLeastTwo
  Scales.ε M.base N n - Scales.ε M.base N (n + 1) +
    2 * Scales.ε M.base N (n + 1) * haltWeight M N n D

lemma readC_smooth (M : Machine) (N n : ℕ) : ContDiff ℝ ∞ (readC M N n) := by
  exact (Profiles.decoder_smooth M.base (by have := M.base_ge_four; omega)).comp
    (contDiff_const.mul contDiff_id)

lemma readB_smooth (M : Machine) (N n : ℕ) : ContDiff ℝ ∞ (readB M N n) := by
  exact (Profiles.decoder_smooth M.base (by have := M.base_ge_four; omega)).comp
    (contDiff_const.mul contDiff_id)

lemma readA_smooth (M : Machine) (N n : ℕ) : ContDiff ℝ ∞ (readA M N n) := by
  exact ((Profiles.decoder_smooth M.base (by have := M.base_ge_four; omega)).comp
    (contDiff_const.mul contDiff_id)).sub (contDiff_const.mul (readB_smooth M N n))

lemma branchNumerator_smooth (b K a l : ℕ) (r : Rule) (A B : ℝ → ℝ)
    (hA : ContDiff ℝ ∞ A) (hB : ContDiff ℝ ∞ B) :
    ContDiff ℝ ∞ (fun D => branchNumerator b K a l r (A D) (B D)) := by
  unfold branchNumerator updateLeft updateRight
  split_ifs <;> fun_prop

lemma branch_smooth (M : Machine) (N n q a : ℕ) (A B : ℝ → ℝ)
    (hA : ContDiff ℝ ∞ A) (hB : ContDiff ℝ ∞ B) :
    ContDiff ℝ ∞ (fun D => branch M N n q a (A D) (B D)) := by
  unfold branch
  dsimp only
  split_ifs
  · apply ContDiff.sum
    intro l _
    exact ((Profiles.selector_smooth M.base l).comp hA).mul
      (branchNumerator_smooth _ _ _ _ _ _ _ hA hB)
  · exact branchNumerator_smooth _ _ _ _ _ _ _ hA hB

lemma write_smooth (M : Machine) (N n : ℕ) : ContDiff ℝ ∞ (write M N n) := by
  unfold write
  apply ContDiff.mul contDiff_const
  apply ContDiff.sum
  intro q _
  apply ContDiff.sum
  intro a _
  exact (((Profiles.selector_smooth M.base q).comp (readC_smooth M N n)).mul
    ((Profiles.selector_smooth M.base a).comp (readB_smooth M N n))).mul
    (branch_smooth M N n q a _ _ (readA_smooth M N n) (readB_smooth M N n))

lemma haltWeight_smooth (M : Machine) (N n : ℕ) : ContDiff ℝ ∞ (haltWeight M N n) := by
  unfold haltWeight
  apply ContDiff.sum
  intro q _
  split_ifs
  · exact (Profiles.selector_smooth M.base q).comp (readC_smooth M N n)
  · exact contDiff_const

lemma signal_smooth (M : Machine) (N n : ℕ) : ContDiff ℝ ∞ (signal M N n) := by
  exact contDiff_const.add (contDiff_const.mul (haltWeight_smooth M N n))

lemma readC_run (M : Machine) (hM : M.WellFormed) (w : List ℕ) (hw : M.ValidInput w) (n : ℕ) :
    readC M w.length n (Encoding.donor M.base w.length (M.recordedBlock w) n) =
      M.recordedBlock w n := (M.read_run hM w hw n).1

lemma readB_run (M : Machine) (hM : M.WellFormed) (w : List ℕ) (hw : M.ValidInput w) (n : ℕ) :
    readB M w.length n (Encoding.donor M.base w.length (M.recordedBlock w) n) =
      Machine.rightCode M.base w.length n (M.run w n) := (M.read_run hM w hw n).2.1

lemma readA_run (M : Machine) (hM : M.WellFormed) (w : List ℕ) (hw : M.ValidInput w) (n : ℕ) :
    readA M w.length n (Encoding.donor M.base w.length (M.recordedBlock w) n) =
      Machine.leftCode M.base w.length n (M.run w n) := (M.read_run hM w hw n).2.2

end LocalRule
end AlternatingNS

namespace AlternatingNS
namespace LocalRule

lemma branchNumerator_execute (b N n : ℕ) (hb : 0 < b) (c : Machine.Configuration)
    (hc : Machine.Window N n c) (r : Rule) :
    branchNumerator b (Scales.K N (n + 1)) (c.tape c.head) (c.tape (c.head - 1)) r
      (Machine.leftCode b N n c) (Machine.rightCode b N n c) =
    (2 * r.1 : ℕ) + Machine.leftCode b N (n + 1) (Machine.execute c r) +
      ((b : ℝ) ^ Scales.K N (n + 1))⁻¹ * Machine.rightCode b N (n + 1) (Machine.execute c r) := by
  by_cases h₀ : r.2.2 = 0
  · obtain ⟨hL, hR⟩ := Machine.code_execute_left b N n hb c hc r h₀
    rw [hL, hR]
    simp [branchNumerator, updateLeft, updateRight, h₀, Machine.leftDigits, Machine.rightDigits]
  · by_cases h₁ : r.2.2 = 1
    · obtain ⟨hL, hR⟩ := Machine.code_execute_stay b N n hb c hc r h₁
      rw [hL, hR]
      simp [branchNumerator, updateLeft, updateRight, h₁, Machine.rightDigits]
    · have h₂ : r.2.2 = 2 := by omega
      obtain ⟨hL, hR⟩ := Machine.code_execute_right b N n hb c hc r h₂
      rw [hL, hR]
      simp [branchNumerator, updateLeft, updateRight, h₀, h₁, Machine.rightDigits]

lemma branch_on_configuration (M : Machine) (N n : ℕ) (c : Machine.Configuration)
    (ha : M.Admissible c) (hw : Machine.Window N n c) :
    branch M N n c.state (c.tape c.head)
      (Machine.leftCode M.base N n c) (Machine.rightCode M.base N n c) =
    (2 * (M.step c).state : ℕ) + Machine.leftCode M.base N (n + 1) (M.step c) +
      ((M.base : ℝ) ^ Scales.K N (n + 1))⁻¹ * Machine.rightCode M.base N (n + 1) (M.step c) := by
  have hb : 0 < M.base := by have := M.base_ge_four; omega
  have hnum := branchNumerator_execute M.base N n hb c hw (M.command c.state (c.tape c.head))
  rw [Machine.step_execute]
  unfold branch
  dsimp only
  split_ifs with h₀
  · rw [Finset.sum_eq_single_of_mem (c.tape (c.head - 1)) (Finset.mem_range.2 (ha.2 _))]
    · rw [Machine.selector_leftCode M c ha N n, ite_eq_left rfl, one_mul]
      exact hnum
    · intro l _ hl
      simp [Machine.selector_leftCode M c ha N n l, hl]
  · simpa only [branchNumerator, updateLeft, updateRight, h₀, ite_false, Machine.execute] using hnum

lemma write_run (M : Machine) (hM : M.WellFormed) (w : List ℕ) (hw : M.ValidInput w) (n : ℕ) :
    write M w.length n (Encoding.donor M.base w.length (M.recordedBlock w) n) =
      Scales.ε M.base w.length (n + 1) * M.recordedBlock w (n + 1) := by
  have hc := M.run_admissible hM w hw n
  have hq : (M.run w n).state ∈ Finset.range (M.states + 1) :=
    Finset.mem_range.2 (Nat.lt_succ_of_le hc.1)
  have ha : (M.run w n).tape (M.run w n).head ∈ Finset.range M.alphabet :=
    Finset.mem_range.2 (hc.2 _)
  unfold write
  rw [readC_run M hM w hw n, readB_run M hM w hw n, readA_run M hM w hw n]
  simp only [Machine.selector_recordedBlock M hM w hw n,
    Machine.selector_rightCode M (M.run w n) hc w.length n,
    ite_mul, one_mul, zero_mul, Finset.sum_ite_irrel, Finset.sum_const_zero,
    Finset.sum_ite_eq', ite_eq_left hq, ite_eq_left ha]
  rw [branch_on_configuration M w.length n (M.run w n) hc (M.run_window w n)]
  rw [Machine.recordedBlock_formula, Machine.run_succ]
  ring

lemma haltWeight_run (M : Machine) (hM : M.WellFormed) (w : List ℕ) (hw : M.ValidInput w) (n : ℕ) :
    haltWeight M w.length n (Encoding.donor M.base w.length (M.recordedBlock w) n) =
      if M.isHalting (M.run w n) then 1 else 0 := by
  have hc := (M.run_admissible hM w hw n).1
  unfold haltWeight
  rw [readC_run M hM w hw n,
    Finset.sum_eq_single_of_mem (M.run w n).state (Finset.mem_range.2 (by omega))]
  · simp [Machine.selector_recordedBlock M hM w hw n, Machine.isHalting]
  · intro q _ hq
    simp [Machine.selector_recordedBlock M hM w hw n q, hq]

lemma signal_run (M : Machine) (hM : M.WellFormed) (w : List ℕ) (hw : M.ValidInput w) (n : ℕ) :
    signal M w.length n (Encoding.donor M.base w.length (M.recordedBlock w) n) =
      Detector.increment M.base w.length (fun j => M.isHalting (M.run w j)) n := by
  rw [signal, haltWeight_run M hM w hw n]
  simp only [Detector.increment, mul_ite, mul_one, mul_zero]

end LocalRule
end AlternatingNS

end OAI