import Mathlib
import OAI.Computability.SolenoidalRecorder.Scans

namespace OAI

/-! Recording cycles and finite simulation of machine prefixes. -/

namespace Solenoidal
namespace Recorder
variable {M : Machine}
def checkpoint (q : M.State) (k : ℤ) (W : ℤ → M.Symbol) (H : ℤ → History M) : Config M :=
  ⟨.S q, k, tracks W H (fun _ => false)⟩

 

theorem recording_cycle (r : M.Instruction) (W : ℤ → M.Symbol) (H : ℤ → History M)
    (k g : ℤ) (hH : Frontier H g) (hk : k ≠ g)
    (hnew : k + r.move.displacement < g) (hread : W k = r.read) :
    Steps (2 * (g - (k + r.move.displacement)).toNat + 4)
      (checkpoint r.oldState k W H)
      (checkpoint r.nextState (k + r.move.displacement)
        (Function.update W k r.write) (appendHistory H g r)) := by
  let k' := k + r.move.displacement
  change k' < g at hnew
  let W' := Function.update W k r.write
  let marked : ℤ → Bool := Function.update (fun _ => false) k' true
  let H₁ := Function.update H g (.record r)
  let H₂ := appendHistory H g r
  let n := (g - k' - 1).toNat
  have hn : (n : ℤ) = g - k' - 1 := Int.toNat_of_nonneg (by omega)
  have hnR : k' + 1 + (n : ℤ) = g := by omega
  have hnL : g - (↑(n + 1) : ℤ) = k' := by omega
  have hkF : H k ≠ .frontier := fun he => hk ((hH.1 k).mp he)
  have hk'F : H k' ≠ .frontier := by
    intro he
    have := (hH.1 k').mp he
    omega
  have hgMark : marked g = false := by
    have hne : g ≠ k' := by omega
    simp [marked, hne]
  have hg1Mark : marked (g + 1) = false := by
    have hne : g + 1 ≠ k' := by omega
    simp [marked, hne]
  have hg1Hist : H₁ (g + 1) = .empty := by
    simp [H₁, hH.2 (g + 1) (by omega)]
  have h1 : Step (checkpoint r.oldState k W H)
      ⟨.A r, k', tracks W' H (fun _ => false)⟩ := by
    have ht := tracks_step W H (fun _ => false) k (.S r.oldState) (.A r)
      r.write (H k) false r.move (by simpa only [hread] using Rule.work r (H k) hkF)
    simpa only [checkpoint, Function.update_eq_self] using ht
  have h2 : Step (⟨.A r, k', tracks W' H (fun _ => false)⟩ : Config M)
      ⟨.R r, k' + 1, tracks W' H marked⟩ := by
    have ht := tracks_step W' H (fun _ => false) k' (.A r) (.R r)
      (W' k') (H k') true .right (Rule.mark r (W' k') (H k') hk'F)
    simpa only [Move.displacement, Function.update_eq_self] using ht
  have hscanR : Steps n (⟨.R r, k' + 1, tracks W' H marked⟩ : Config M)
      ⟨.R r, g, tracks W' H marked⟩ := by
    rw [← hnR]
    apply scanRight_steps
    intro j hj
    change H (k' + 1 + j) ≠ .frontier ∧ marked (k' + 1 + j) = false
    constructor
    · intro he
      have := (hH.1 _).mp he
      omega
    · have hne : k' + 1 + (j : ℤ) ≠ k' := by omega
      simp [marked, hne]
  have h3 : Step (⟨.R r, g, tracks W' H marked⟩ : Config M)
      ⟨.F r.nextState, g + 1, tracks W' H₁ marked⟩ := by
    have ht := tracks_step W' H marked g (.R r) (.F r.nextState)
      (W' g) (.record r) false .right
        (by simpa [((hH.1 g).mpr rfl), hgMark] using Rule.record r (W' g))
    simpa only [Move.displacement, ← hgMark, Function.update_eq_self] using ht
  have h4 : Step (⟨.F r.nextState, g + 1, tracks W' H₁ marked⟩ : Config M)
      ⟨.L r.nextState, g, tracks W' H₂ marked⟩ := by
    have ht := tracks_step W' H₁ marked (g + 1) (.F r.nextState) (.L r.nextState)
      (W' (g + 1)) .frontier false .left
        (by simpa [hg1Hist, hg1Mark] using Rule.advance r.nextState (W' (g + 1)))
    simpa only [Move.displacement, Int.add_neg_cancel_right, ← hg1Mark,
      Function.update_eq_self, H₂, appendHistory, H₁] using ht
  have hH₂ : Frontier H₂ (g + 1) := frontier_append hH r
  have hscanL : Steps (n + 1) (⟨.L r.nextState, g, tracks W' H₂ marked⟩ : Config M)
      ⟨.L r.nextState, k', tracks W' H₂ marked⟩ := by
    rw [← hnL]
    apply scanLeft_steps
    intro j hj
    change H₂ (g - j) ≠ .frontier ∧ marked (g - j) = false
    constructor
    · intro he
      have := (hH₂.1 _).mp he
      omega
    · have hne : g - (j : ℤ) ≠ k' := by omega
      simp [marked, hne]
  have h6 : Step (⟨.L r.nextState, k', tracks W' H₂ marked⟩ : Config M)
      (checkpoint r.nextState k' W' H₂) := by
    have hk₂ : H₂ k' ≠ .frontier := by
      intro he
      have := (hH₂.1 k').mp he
      omega
    have ht := tracks_step W' H₂ marked k' (.L r.nextState) (.S r.nextState)
      (W' k') (H₂ k') false .stay
        (by simpa [marked] using Rule.finish r.nextState (W' k') (H₂ k') hk₂)
    simpa only [Move.displacement, add_zero, checkpoint, marked, Function.update_eq_self,
      Function.update_idem] using ht
  have hsteps := (((((Steps.one h1).tail h2).trans hscanR).tail h3).tail h4).trans hscanL
  have htotal := hsteps.tail h6
  have hcount : (1 + 1 + n + 1 + 1) + (n + 1) + 1 = 2 * (g - k').toNat + 4 := by
    omega
  simpa only [hcount] using htotal

 
theorem checkpoint_next (w : List M.Symbol) (n : ℕ) (r₀ : ℤ) (hr₀ : 2 ≤ r₀)
    (H : ℤ → History M) (hH : Frontier H (r₀ + n))
    (hRun : M.halt (M.run w n).state = false) :
    ∃ r : M.Instruction,
      Steps (2 * (r₀ + n - (M.run w (n + 1)).head).toNat + 4)
        (checkpoint (M.run w n).state (M.run w n).head (M.run w n).tape H)
        (checkpoint (M.run w (n + 1)).state (M.run w (n + 1)).head (M.run w (n + 1)).tape
          (appendHistory H (r₀ + n) r)) := by
  let c := M.run w n
  let r : M.Instruction := ⟨(c.state, c.tape c.head), hRun⟩
  refine ⟨r, ?_⟩
  have hhead : c.head ≤ (n : ℤ) := (le_abs_self c.head).trans (M.run_head_bound w n)
  have hd : r.move.displacement ≤ 1 := (le_abs_self _).trans r.move.abs_displacement_le
  have hcycle := recording_cycle r c.tape H c.head (r₀ + n) hH (by omega) (by omega) rfl
  have heq : M.run w (n + 1) =
      (⟨r.nextState, c.head + r.move.displacement, Function.update c.tape c.head r.write⟩ : M.Config) := by
    rw [M.run_succ]
    simp only [Machine.step, hRun, Bool.false_eq_true, ↓reduceIte]
    rfl
  simpa only [heq, Machine.Instruction.oldState, c, r] using hcycle

 
theorem checkpoint_count_ge_six (w : List M.Symbol) (n : ℕ) (r₀ : ℤ) (hr₀ : 2 ≤ r₀) :
    6 ≤ 2 * (r₀ + n - (M.run w (n + 1)).head).toNat + 4 := by
  have hh := (le_abs_self _).trans (M.run_head_bound w (n + 1))
  omega

def initial (w : List M.Symbol) (r₀ : ℤ) : Config M :=
  checkpoint M.initial 0 (M.inputTape w) (initialHistory r₀)

 

theorem simulate_prefix (w : List M.Symbol) (r₀ : ℤ) (hr₀ : 2 ≤ r₀) (n : ℕ) :
    (∀ j : ℕ, j < n → M.halt (M.run w j).state = false) →
    ∃ (N : ℕ) (H : ℤ → History M),
      6 * n ≤ N ∧ Frontier H (r₀ + n) ∧
      Steps N (initial w r₀)
        (checkpoint (M.run w n).state (M.run w n).head (M.run w n).tape H) := by
  induction n with
  | zero =>
    intro _
    refine ⟨0, initialHistory r₀, by omega, ?_, ?_⟩
    · simpa using frontier_initial (M := M) r₀
    · simpa [initial, Machine.run, Machine.initialConfig] using Steps.zero (initial w r₀)
  | succ n ih =>
    intro hrun
    obtain ⟨N, H, hN, hH, hsteps⟩ := ih (fun j hj => hrun j (by omega))
    obtain ⟨r, hcycle⟩ := checkpoint_next w n r₀ hr₀ H hH (hrun n (by omega))
    refine ⟨N + (2 * (r₀ + n - (M.run w (n + 1)).head).toNat + 4),
      appendHistory H (r₀ + n) r, ?_, ?_, hsteps.trans hcycle⟩
    · have := checkpoint_count_ge_six w n r₀ hr₀
      omega
    · simpa only [Nat.cast_add, Nat.cast_one, add_assoc] using frontier_append hH r
end Recorder
end Solenoidal

end OAI