import Mathlib
import OAI.Combinatorics.IndependentSets.PCP.BoundedIteration
import OAI.Combinatorics.IndependentSets.Reduction.StoredFloyd

namespace OAI

namespace LargeIndependentSets.FiniteScan
open IndependentSetsCut.CounterMachine
open IndependentSetsGames.Foundations.Complexity
open Turing
open scoped BigOperators

structure State (m : ℕ) where
  input : List Bool
  k : ℕ
  history : ℕ → Fin m

def State.value {m : ℕ} (s : State m) (w : ℕ) : ℕ :=
  if w=0 then s.input.length else if w=1 then s.k else
    if w<2+s.input.length then Expr.bitValue s.input (w-2)
    else (s.history (w-(2+s.input.length))).val

def State.bits {m : ℕ} (s : State m) : List Bool :=
  UnaryTables.words s.value (3+2*s.input.length)

def initial {m : ℕ} (q : Fin m) (input : List Bool) : State m := ⟨input,0,fun _ => q⟩

def step {m : ℕ} (δ : Fin m → Bool → Fin m) (s : State m) : State m where
  input := s.input
  k := s.k+1
  history := if h : s.k<s.input.length then
    Function.update s.history (s.k+1) (δ (s.history s.k) s.input[s.k]) else s.history

@[simp] lemma read_n {m : ℕ} (s : State m) : Expr.wordValue s.bits 0 = s.input.length := by
  rw [State.bits,UnaryTables.wordValue_words _ _ _ (by omega)]
  simp [State.value]
@[simp] lemma read_k {m : ℕ} (s : State m) : Expr.wordValue s.bits 1 = s.k := by
  rw [State.bits,UnaryTables.wordValue_words _ _ _ (by omega)]
  simp [State.value]

lemma read_input {m : ℕ} (s : State m) (i : ℕ) (hi : i<s.input.length) :
    Expr.wordValue s.bits (2+i) = Expr.bitValue s.input i := by
  rw [State.bits,UnaryTables.wordValue_words _ _ _ (by omega)]
  simp [State.value,show 2+i≠1 by omega,show 2+i<2+s.input.length by omega]

lemma read_history {m : ℕ} (s : State m) (i : ℕ) (hi : i ≤ s.input.length) :
    Expr.wordValue s.bits (2+s.input.length+i) = (s.history i).val := by
  rw [State.bits,UnaryTables.wordValue_words _ _ _ (by omega)]
  simp [State.value,
    show 2+s.input.length+i≠1 by omega,show ¬2+s.input.length+i<2+s.input.length by omega]

def nExpr : Expr := .word (.const 0)
def kExpr : Expr := .word (.const 1)
def inputExpr (i : Expr) : Expr := .word (.add (.const 2) i)
def historyExpr (i : Expr) : Expr := .word (.add (.add (.const 2) nExpr) i)

def transitionExpr {m : ℕ} (δ : Fin m → Bool → Fin m) (q b : Expr) : Expr :=
  Expr.listSum (List.finRange m) (fun i => .mul (Expr.equal q (.const i.val))
    (Expr.cond b (.const (δ i true).val) (.const (δ i false).val)))

lemma transitionExpr_eval {m : ℕ} (δ : Fin m → Bool → Fin m) (q b : Expr)
    (s : List Bool) (args : ℕ → ℕ) (i : Fin m) (c : Bool)
    (hq : q.eval s args=i.val) (hb : b.eval s args=if c then 1 else 0) :
    (transitionExpr δ q b).eval s args = (δ i c).val := by
  simp only [transitionExpr,Expr.listSum_eval,Expr.eval,Expr.equal_eval,Expr.cond_eval,hq,hb]
  cases c <;> simp only [Bool.false_eq_true, ↓reduceIte, ne_eq, not_true_eq_false,
    one_ne_zero, not_false_eq_true]
  all_goals
    rw [← List.ofFn_eq_map, List.sum_ofFn]
    simp [Fin.val_inj]

@[simp] lemma nExpr_eval {m : ℕ} (s : State m) (args : ℕ → ℕ) :
    nExpr.eval s.bits args = s.input.length := by simp [nExpr,Expr.eval]
@[simp] lemma kExpr_eval {m : ℕ} (s : State m) (args : ℕ → ℕ) :
    kExpr.eval s.bits args = s.k := by simp [kExpr,Expr.eval]

@[simp] lemma inputExpr_eval (i : Expr) (s : List Bool) (args : ℕ → ℕ) :
    (inputExpr i).eval s args = Expr.wordValue s (2+i.eval s args) := by simp [inputExpr,Expr.eval]
@[simp] lemma historyExpr_eval (i : Expr) (s : List Bool) (args : ℕ → ℕ) :
    (historyExpr i).eval s args = Expr.wordValue s (2+nExpr.eval s args+i.eval s args) := by
  simp [historyExpr,Expr.eval]

def countExpr : Expr := .add (.const 3) (.mul (.const 2) nExpr)
def valueExpr {m : ℕ} (δ : Fin m → Bool → Fin m) : Expr :=
  Expr.cond (Expr.equal (.arg 0) (.const 1)) (.add kExpr (.const 1))
    (Expr.cond (.mul (Expr.lt kExpr nExpr)
      (Expr.equal (.arg 0) (.add (.add (.const 3) nExpr) kExpr)))
      (transitionExpr δ (historyExpr kExpr) (inputExpr kExpr)) (.word (.arg 0)))

lemma valueExpr_eval {m : ℕ} (δ : Fin m → Bool → Fin m) (s : State m)
    (w : ℕ) (hw : w<3+2*s.input.length) :
    (valueExpr δ).eval s.bits (fun _ => w) = (step δ s).value w := by
  have old := UnaryTables.wordValue_words s.value (3+2*s.input.length) w hw
  change Expr.wordValue s.bits w = s.value w at old
  by_cases hw1 : w=1
  · subst w
    simp [valueExpr,Expr.eval,State.value,step]
  by_cases hk : s.k<s.input.length
  · have ht : (transitionExpr δ (historyExpr kExpr) (inputExpr kExpr)).eval s.bits (fun _ => w) =
        (δ (s.history s.k) s.input[s.k]).val := by
      apply transitionExpr_eval
      · simp [read_history s s.k hk.le]
      · simp [read_input s s.k hk,Expr.bitValue,List.getElem?_eq_getElem hk]
    simp only [valueExpr,Expr.cond_eval,Expr.equal_eval,Expr.eval,hw1,ite_false,
      ne_eq,not_true_eq_false,ite_true,nExpr_eval,kExpr_eval,Expr.lt_eval,Expr.word_eval,
      hk,one_mul,ht,old]
    simp only [step,dite_eq_left hk,State.value]
    by_cases hw0 : w=0
    · subst w; simp [show ¬0=3+s.input.length+s.k by omega]
    by_cases hwl : w<2+s.input.length
    · have hne : w≠3+s.input.length+s.k := by omega
      simp [hw0,hw1,hwl,hne]
    · have he : w=3+s.input.length+s.k ↔ w-(2+s.input.length)=s.k+1 := by omega
      simp only [hw0,hw1,hwl,ite_false,Function.update_apply]
      by_cases hwe : w=3+s.input.length+s.k
      · rw [ite_eq_left hwe,ite_eq_left (he.mp hwe)]; simp
      · rw [ite_eq_right hwe,ite_eq_right (mt he.mpr hwe)]; simp
  · simp [valueExpr,Expr.eval,hk,hw1,old,step,State.value]

lemma body_spec {m : ℕ} (δ : Fin m → Bool → Fin m) (s : State m) :
    UnaryTables.words (fun j => (valueExpr δ).eval s.bits (fun _ => j))
      (countExpr.eval s.bits (fun _ => 0)) = (step δ s).bits := by
  have hn : countExpr.eval s.bits (fun _ => 0) = 3+2*s.input.length := by
    simp [countExpr,Expr.eval]
  rw [hn]
  exact UnaryTables.words_congr (valueExpr_eval δ s)

noncomputable def body {m : ℕ} (δ : Fin m → Bool → Fin m) :
    TM2ComputableInPolyTime State.bits State.bits (step δ) :=
  UnaryTables.encodedComputer State.bits State.bits (step δ) countExpr (valueExpr δ) (body_spec δ)

lemma body_finiteAlphabet {m : ℕ} (δ : Fin m → Bool → Fin m) :
    MachineFiniteAlphabet.FiniteAlphabet (body δ).tm :=
  UnaryTables.encodedComputer_finiteAlphabet _ _ _ _ _ _

lemma iterate_input {m : ℕ} (δ : Fin m → Bool → Fin m) (q : Fin m) (s : List Bool) (i : ℕ) :
    ((step δ)^[i] (initial q s)).input = s := by
  induction i with
  | zero => rfl
  | succ i ih => simpa [Function.iterate_succ_apply',step] using ih

lemma iterate_k {m : ℕ} (δ : Fin m → Bool → Fin m) (q : Fin m) (s : List Bool) (i : ℕ) :
    ((step δ)^[i] (initial q s)).k = i := by
  induction i with
  | zero => rfl
  | succ i ih => simp [Function.iterate_succ_apply',step,ih]

lemma history_prefix {m : ℕ} (δ : Fin m → Bool → Fin m) (q : Fin m) (s : List Bool)
    (i : ℕ) (hi : i ≤ s.length) (j : ℕ) (hj : j ≤ i) :
    ((step δ)^[i] (initial q s)).history j = (s.take j).foldl δ q := by
  induction i generalizing j with
  | zero =>
    have : j=0 := by omega
    subst j
    rfl
  | succ i ih =>
    have hk : i<s.length := hi
    rw [Function.iterate_succ_apply']
    simp only [step,iterate_k,iterate_input,dite_eq_left hk,Function.update_apply]
    by_cases he : j=i+1
    · rw [ite_eq_left he]
      subst j
      rw [ih hk.le i le_rfl,List.take_succ_eq_append_getElem hk,List.foldl_append]
      rfl
    · rw [ite_eq_right he]
      exact ih hk.le j (by omega)

def output {m : ℕ} (δ : Fin m → Bool → Fin m) (q : Fin m) (s : List Bool) : State m :=
  (step δ)^[s.length] (initial q s)

lemma output_history {m : ℕ} (δ : Fin m → Bool → Fin m) (q : Fin m) (s : List Bool)
    (j : ℕ) (hj : j ≤ s.length) :
    (output δ q s).history j = (s.take j).foldl δ q := history_prefix δ q s _ le_rfl j hj

lemma value_le {m : ℕ} (s : State m) (w : ℕ) : s.value w ≤ s.input.length+s.k+m+1 := by
  unfold State.value
  split
  · omega
  · split
    · omega
    · split
      · unfold Expr.bitValue; split <;> omega
      · have := (s.history (w-(2+s.input.length))).isLt; omega

lemma bits_length_le {m : ℕ} (s : State m) :
    s.bits.length ≤ (3+2*s.input.length)*(s.input.length+s.k+m+2) := by
  rw [State.bits,UnaryTables.words_length]
  unfold UnaryTables.offset
  calc
    _ ≤ ∑ _ ∈ Finset.range (3+2*s.input.length), (s.input.length+s.k+m+2) := by
      apply Finset.sum_le_sum
      intro w _hw
      have := value_le s w
      omega
    _ = _ := by simp

noncomputable def lengthPolynomial (m : ℕ) : Polynomial ℕ :=
  (3+2*Polynomial.X)*(2*Polynomial.X+Polynomial.C (m+2))

lemma lengthPolynomial_eval (m N : ℕ) :
    (lengthPolynomial m).eval N = (3+2*N)*(2*N+m+2) := by
  simp [lengthPolynomial,Nat.add_assoc]

def countedInput {m : ℕ} (q : Fin m) (s : List Bool) : List Bool :=
  BoundedIteration.counted List.length State.bits (initial q) s

lemma intermediate_bound {m : ℕ} (δ : Fin m → Bool → Fin m) (q : Fin m) (s : List Bool)
    (i : ℕ) (hi : i ≤ s.length) :
    ((step δ)^[i] (initial q s)).bits.length ≤ (lengthPolynomial m).eval (countedInput q s).length := by
  rw [lengthPolynomial_eval]
  apply (bits_length_le _).trans
  rw [iterate_input,iterate_k]
  have hn : s.length ≤ (countedInput q s).length :=
    BoundedIteration.count_le List.length State.bits (initial q) s
  gcongr; omega

noncomputable def countedCertificate {m : ℕ} (δ : Fin m → Bool → Fin m) (q : Fin m) :
    TM2ComputableInPolyTime (countedInput q) State.bits (output δ q) :=
  BoundedIteration.certificate State.bits (step δ) (initial q) List.length (body δ)
    (lengthPolynomial m) (intermediate_bound δ q)

lemma countedCertificate_finiteAlphabet {m : ℕ} (δ : Fin m → Bool → Fin m) (q : Fin m) :
    MachineFiniteAlphabet.FiniteAlphabet (countedCertificate δ q).tm :=
  BoundedIteration.certificate_finiteAlphabet _ _ _ _ _ _ _ (body_finiteAlphabet δ)

lemma words_cons (f : ℕ → ℕ) (n : ℕ) :
    UnaryTables.words f (n+1) = (List.replicate (f 0) true ++ [false]) ++
      UnaryTables.words (fun j => f (j+1)) n := by
  simp [UnaryTables.words,List.range_succ_eq_map,List.flatMap_map,Function.comp_def]

def initialCount : Expr := .add (.const 4) (.mul (.const 2) .length)
def initialValue {m : ℕ} (q : Fin m) : Expr :=
  Expr.cond (Expr.le (.arg 0) (.const 1)) .length
    (Expr.cond (Expr.equal (.arg 0) (.const 2)) (.const 0)
      (Expr.cond (Expr.lt (.arg 0) (.add (.const 3) .length))
        (.bit (.sub (.arg 0) (.const 3))) (.const q.val)))

lemma initialValue_zero {m : ℕ} (q : Fin m) (s : List Bool) :
    (initialValue q).eval s (fun _ => 0) = s.length := by simp [initialValue,Expr.eval]

lemma initialValue_succ {m : ℕ} (q : Fin m) (s : List Bool) (w : ℕ) :
    (initialValue q).eval s (fun _ => w+1) = (initial q s).value w := by
  simp only [initialValue,Expr.cond_eval,Expr.le_eval,Expr.equal_eval,Expr.lt_eval,Expr.eval]
  have h1 : w+1≤1 ↔ w=0 := by omega
  have h2 : w+1=2 ↔ w=1 := by omega
  have h3 : w+1<3+s.length ↔ w<2+s.length := by omega
  simp only [h1,h2,h3]
  by_cases hw0 : w=0
  · simp [hw0,initial,State.value]
  by_cases hw1 : w=1
  · simp [hw1,initial,State.value]
  have ht : w+1-3=w-2 := by omega
  simp [hw0,hw1,ht,initial,State.value,Expr.bitValue]
  rfl

lemma initial_spec {m : ℕ} (q : Fin m) (s : List Bool) :
    UnaryTables.words (fun j => (initialValue q).eval s (fun _ => j))
      (initialCount.eval s (fun _ => 0)) = countedInput q s := by
  have hc : initialCount.eval s (fun _ => 0) = (3+2*s.length)+1 := by
    simp [initialCount,Expr.eval]; omega
  rw [hc,words_cons,initialValue_zero]
  unfold countedInput BoundedIteration.counted State.bits
  congr 1
  exact UnaryTables.words_congr (fun j _hj => initialValue_succ q s j)

noncomputable def initialCertificate {m : ℕ} (q : Fin m) :
    TM2ComputableInPolyTime (id : List Bool → List Bool) (countedInput q) id :=
  UnaryTables.encodedComputer id (countedInput q) id initialCount (initialValue q) (initial_spec q)

lemma initialCertificate_finiteAlphabet {m : ℕ} (q : Fin m) :
    MachineFiniteAlphabet.FiniteAlphabet (initialCertificate q).tm :=
  UnaryTables.encodedComputer_finiteAlphabet _ _ _ _ _ _

noncomputable def certificate {m : ℕ} (δ : Fin m → Bool → Fin m) (q : Fin m) :
    TM2ComputableInPolyTime (id : List Bool → List Bool) State.bits (output δ q) :=
  MachineSequential.composeBits (initialCertificate q) (countedCertificate δ q)

lemma finiteAlphabet {m : ℕ} (δ : Fin m → Bool → Fin m) (q : Fin m) :
    MachineFiniteAlphabet.FiniteAlphabet (certificate δ q).tm :=
  MachineFiniteAlphabet.composeBits _ _ (initialCertificate_finiteAlphabet q)
    (countedCertificate_finiteAlphabet δ q)
end LargeIndependentSets.FiniteScan

end OAI