import OAI.Combinatorics.LowSpaceSubsetSum.Word.WordTuple

namespace OAI

/-! # Finite fair-word streams realize the sequential operational law -/

noncomputable section
namespace LowSpaceSubsetSum.WordProgram

open scoped BigOperators
variable {w : ℕ} {α : Type}

def finiteStream {N : ℕ} (words : Fin N → Fin (2^w)) (i : ℕ) : Fin (2^w) :=
  if h : i < N then words ⟨i,h⟩ else 0

theorem run_shift (stream : ℕ → Fin (2^w)) (p : Program w α) (offset k : ℕ) :
    run stream p (offset+k) =
      let out := run (fun i => stream (i+k)) p offset
      (out.1,out.2+k) := by
  induction p generalizing offset with
  | pure a => rfl
  | draw branch ih =>
    simp only [run]
    simpa only [Nat.add_assoc, Nat.add_comm k 1, Nat.add_left_comm] using
      ih (stream (offset+k)) (offset+1)

theorem finiteStream_cons (x : Fin (2^w)) {N : ℕ} (xs : Fin N → Fin (2^w)) :
    (fun i => finiteStream (Fin.cons x xs) (i+1)) = finiteStream xs := by
  funext i
  unfold finiteStream
  by_cases h : i < N
  · simp only [show i+1 < N+1 by omega, ↓reduceDIte, h]
    change Fin.cons (n := N) (α := fun _ => Fin (2^w)) x xs (Fin.succ ⟨i,h⟩) = xs ⟨i,h⟩
    rfl
  · simp only [show ¬i+1 < N+1 by omega, ↓reduceDIte, h]

theorem draw_cons_value (branch : Fin (2^w) → Program w α) {N : ℕ}
    (x : Fin (2^w)) (xs : Fin N → Fin (2^w)) :
    (run (finiteStream (Fin.cons x xs)) (.draw branch) 0).1 =
      (run (finiteStream xs) (branch x) 0).1 := by
  have hzero : finiteStream (Fin.cons x xs) 0 = x := by
    simp [finiteStream]
  simp only [run, hzero, Nat.zero_add]
  have h := congrArg Prod.fst (run_shift (finiteStream (Fin.cons x xs)) (branch x) 0 1)
  simpa only [Nat.zero_add, finiteStream_cons] using h

theorem run_expectation (p : Program w α) (N : ℕ) (hp : Bounded p N) (f : α → ℝ) :
    expectation p f = (FiniteLaw.uniform : FiniteLaw (Fin N → Fin (2^w))).expectation
      (fun words => f (run (finiteStream words) p 0).1) := by
  induction hp with
  | pure a N =>
    simp only [expectation, run, FiniteLaw.expectation, ← Finset.sum_mul,
      FiniteLaw.total, one_mul]
  | draw branch N hb ih =>
    rw [WordTuple.cons_expectation]
    simp only [expectation, draw_cons_value, ih]

theorem run_probability (p : Program w α) (N : ℕ) (hp : Bounded p N) (P : α → Prop) :
    probability p P = (FiniteLaw.uniform : FiniteLaw (Fin N → Fin (2^w))).probability
      (fun words => P (run (finiteStream words) p 0).1) := by
  rw [probability, run_expectation p N hp, FiniteLaw.probability_eq_expectation]

end LowSpaceSubsetSum.WordProgram

end

end OAI