import OAI.Computability.WLIdentification.GraphEnumeration

namespace OAI

namespace WLIdentification

namespace NumericWL
open NumericKernel

def left (t a : ℕ) : Bool := decide (a<t)
def code (t a : ℕ) : ℕ := if a<t then a else a-t

def pairTable (N : ℕ) (p : ℕ → ℕ → Bool) : Word :=
  (List.range (Nat.pair N N+1)).map (fun x => p x.unpair.1 x.unpair.2)

def transTable (N width branch : ℕ) (p : ℕ → ℕ → ℕ → ℕ → Bool) : Word :=
  (List.range (Nat.pair N (Nat.pair branch (Nat.pair width N))+1)).map (fun x =>
    p x.unpair.1 x.unpair.2.unpair.1 x.unpair.2.unpair.2.unpair.1 x.unpair.2.unpair.2.unpair.2)

def equalCounts (t : ℕ) (W : Word) : Bool :=
  (List.range (t+t)).all (fun a => decide (
    ((List.range t).map (fun b => if lookup W b a then 1 else 0)).sum =
    ((List.range t).map (fun b => if lookup W (t+b) a then 1 else 0)).sum))

def selectedEdge (n t : ℕ) (W V : Word) (a i j : ℕ) : Bool :=
  if left t a then NumericGraph.edge n W i j else NumericGraph.edge n V i j

def neighborActive (n : ℕ) (W V : Word) (a z : ℕ) : Bool :=
  selectedEdge n n W V a (code n a) z

def neighborTrans (n a z _i y : ℕ) : Bool :=
  decide (left n a = left n y) && decide (code n y = z)

def neighbor (n cap : ℕ) (W V : Word) : Bool :=
  let N := n+n
  equalCounts n (table N 1 n cap (pairTable N (neighborActive n W V))
    (transTable N 1 n (neighborTrans n)) (pairTable N (fun _ _ => true)) (N*N))

def tupleInitial (n k t : ℕ) (W V : Word) (a b : ℕ) : Bool :=
  (List.range k).all (fun i => (List.range k).all (fun j =>
    decide ((digit n (code t a) i = digit n (code t a) j) =
      (digit n (code t b) i = digit n (code t b) j)) &&
    decide (selectedEdge n t W V a (digit n (code t a) i) (digit n (code t a) j) =
      selectedEdge n t W V b (digit n (code t b) i) (digit n (code t b) j))))

def tupleTrans (n k t a z i y : ℕ) : Bool :=
  decide (left t a = left t y) && (List.range k).all (fun j =>
    decide (digit n (code t y) j = if j=i then z else digit n (code t a) j))

def tuple (n k cap : ℕ) (W V : Word) : Bool :=
  let t := min (n^k) cap
  let N := t+t
  equalCounts t (table N k n cap (pairTable N (fun _ _ => true))
    (transTable N k n (tupleTrans n k t)) (pairTable N (tupleInitial n k t W V)) (N*N))

def equivalent (n k cap : ℕ) (W V : Word) : Bool :=
  if k=1 then neighbor n cap W V else tuple n k cap W V

end NumericWL

namespace NumericWL
open WordExpressions

theorem left_poly {m} {t a : (Fin m → Word) → ℕ} (ht : NatPoly t) (ha : NatPoly a) :
    BoolPoly (fun S => left (t S) (a S)) := NatPoly.lt ha ht

theorem code_poly {m} {t a : (Fin m → Word) → ℕ} (ht : NatPoly t) (ha : NatPoly a) :
    NatPoly (fun S => code (t S) (a S)) := NatPoly.iteProp (NatPoly.lt ha ht) ha (NatPoly.sub ha ht)

theorem selectedEdge_poly {m} {n t a i j : (Fin m → Word) → ℕ}
    {W V : (Fin m → Word) → Word} (hn : NatPoly n) (ht : NatPoly t) (hW : Poly W) (hV : Poly V)
    (ha : NatPoly a) (hi : NatPoly i) (hj : NatPoly j) :
    BoolPoly (fun S => selectedEdge (n S) (t S) (W S) (V S) (a S) (i S) (j S)) :=
  BoolPoly.ite (left_poly ht ha) (NumericGraph.edge_poly hn hW hi hj) (NumericGraph.edge_poly hn hV hi hj)

theorem equalCounts_poly : BoolPoly (fun S : Fin 2 → Word => equalCounts (S 0).length (S 1)) := by
  unfold equalCounts
  apply BoolPoly.allRange
  · word_poly
  · apply NatPoly.eqtest <;> apply NatPoly.sumRange
    · word_poly
    · apply NatPoly.ite
      · unfold NumericKernel.lookup
        word_poly
      · word_poly
      · word_poly
    · word_poly
    · apply NatPoly.ite
      · unfold NumericKernel.lookup
        word_poly
      · word_poly
      · word_poly

theorem neighborActive_poly : BoolPoly (fun S : Fin 5 → Word =>
    neighborActive (S 0).length (S 1) (S 2) (S 3).length (S 4).length) := by
  unfold neighborActive
  apply selectedEdge_poly <;> first | apply code_poly <;> word_poly | word_poly

theorem neighborTrans_poly : BoolPoly (fun S : Fin 5 → Word =>
    neighborTrans (S 0).length (S 1).length (S 2).length (S 3).length (S 4).length) := by
  unfold neighborTrans
  apply BoolPoly.and
  · apply BoolPoly.eqtest <;> apply left_poly <;> word_poly
  · apply NatPoly.eqtest
    · apply code_poly <;> word_poly
    · word_poly

theorem tupleInitial_poly : BoolPoly (fun S : Fin 7 → Word => tupleInitial
    (S 0).length (S 1).length (S 2).length (S 3) (S 4) (S 5).length (S 6).length) := by
  unfold tupleInitial
  apply BoolPoly.allRange (NatPoly.var 1)
  apply BoolPoly.allRange (NatPoly.var 1)
  apply BoolPoly.and
  · apply BoolPoly.propEq <;> apply NatPoly.eqtest <;> apply NatPoly.digit
    all_goals first | apply code_poly <;> word_poly | word_poly
  · apply BoolPoly.eqtest <;> apply selectedEdge_poly
    all_goals repeat' first | apply NatPoly.digit | apply code_poly | solve | word_poly

theorem tupleTrans_poly : BoolPoly (fun S : Fin 7 → Word => tupleTrans
    (S 0).length (S 1).length (S 2).length (S 3).length (S 4).length (S 5).length (S 6).length) := by
  unfold tupleTrans
  apply BoolPoly.and
  · apply BoolPoly.eqtest <;> apply left_poly <;> word_poly
  · apply BoolPoly.allRange (NatPoly.var 1)
    apply NatPoly.eqtest
    · apply NatPoly.digit
      · word_poly
      · apply code_poly <;> word_poly
      · word_poly
    · apply NatPoly.iteProp
      · word_poly
      · word_poly
      · apply NatPoly.digit
        · word_poly
        · apply code_poly <;> word_poly
        · word_poly

end NumericWL

namespace NumericKernel
open WordExpressions

theorem table_poly_of {m} {N : (Fin m → Word) → ℕ} {w : (Fin m → Word) → ℕ} {b : (Fin m → Word) → ℕ} {c : (Fin m → Word) → ℕ} {ac : (Fin m → Word) → Word} {tr : (Fin m → Word) → Word} {ini : (Fin m → Word) → Word} {r : (Fin m → Word) → ℕ}
    (h_N : NatPoly N)    (h_w : NatPoly w)    (h_b : NatPoly b)    (h_c : NatPoly c)    (h_ac : Poly ac)    (h_tr : Poly tr)    (h_ini : Poly ini)    (h_r : NatPoly r) :
    Poly (fun S => table (N S) (w S) (b S) (c S) (ac S) (tr S) (ini S) (r S)) := by
  have h := table_poly.subst (g := ![fun S => unary (N S),fun S => unary (w S),fun S => unary (b S),fun S => unary (c S),ac,tr,ini,fun S => unary (r S)])
    (by intro i; fin_cases i; exacts [h_N,h_w,h_b,h_c,h_ac,h_tr,h_ini,h_r])
  simpa [unary] using h

end NumericKernel
namespace NumericWL
open WordExpressions

theorem equalCounts_poly_of {m} {t : (Fin m → Word) → ℕ} {W : (Fin m → Word) → Word}
    (h_t : NatPoly t)    (h_W : Poly W) :
    BoolPoly (fun S => equalCounts (t S) (W S)) := by
  have h := equalCounts_poly.subst (g := ![fun S => unary (t S),W])
    (by intro i; fin_cases i; exacts [h_t,h_W])
  simpa [unary] using h

end NumericWL
namespace NumericWL
open WordExpressions

theorem neighborActive_poly_of {m} {n : (Fin m → Word) → ℕ} {W : (Fin m → Word) → Word} {V : (Fin m → Word) → Word} {a : (Fin m → Word) → ℕ} {z : (Fin m → Word) → ℕ}
    (h_n : NatPoly n)    (h_W : Poly W)    (h_V : Poly V)    (h_a : NatPoly a)    (h_z : NatPoly z) :
    BoolPoly (fun S => neighborActive (n S) (W S) (V S) (a S) (z S)) := by
  have h := neighborActive_poly.subst (g := ![fun S => unary (n S),W,V,fun S => unary (a S),fun S => unary (z S)])
    (by intro i; fin_cases i; exacts [h_n,h_W,h_V,h_a,h_z])
  simpa [unary] using h

end NumericWL
namespace NumericWL
open WordExpressions

theorem neighborTrans_poly_of {m} {n : (Fin m → Word) → ℕ} {a : (Fin m → Word) → ℕ} {z : (Fin m → Word) → ℕ} {i : (Fin m → Word) → ℕ} {y : (Fin m → Word) → ℕ}
    (h_n : NatPoly n)    (h_a : NatPoly a)    (h_z : NatPoly z)    (h_i : NatPoly i)    (h_y : NatPoly y) :
    BoolPoly (fun S => neighborTrans (n S) (a S) (z S) (i S) (y S)) := by
  have h := neighborTrans_poly.subst (g := ![fun S => unary (n S),fun S => unary (a S),fun S => unary (z S),fun S => unary (i S),fun S => unary (y S)])
    (by intro i; fin_cases i; exacts [h_n,h_a,h_z,h_i,h_y])
  simpa [unary] using h

end NumericWL
namespace NumericWL
open WordExpressions

theorem tupleInitial_poly_of {m} {n : (Fin m → Word) → ℕ} {k : (Fin m → Word) → ℕ} {t : (Fin m → Word) → ℕ} {W : (Fin m → Word) → Word} {V : (Fin m → Word) → Word} {a : (Fin m → Word) → ℕ} {b : (Fin m → Word) → ℕ}
    (h_n : NatPoly n)    (h_k : NatPoly k)    (h_t : NatPoly t)    (h_W : Poly W)    (h_V : Poly V)    (h_a : NatPoly a)    (h_b : NatPoly b) :
    BoolPoly (fun S => tupleInitial (n S) (k S) (t S) (W S) (V S) (a S) (b S)) := by
  have h := tupleInitial_poly.subst (g := ![fun S => unary (n S),fun S => unary (k S),fun S => unary (t S),W,V,fun S => unary (a S),fun S => unary (b S)])
    (by intro i; fin_cases i; exacts [h_n,h_k,h_t,h_W,h_V,h_a,h_b])
  simpa [unary] using h

end NumericWL
namespace NumericWL
open WordExpressions

theorem tupleTrans_poly_of {m} {n : (Fin m → Word) → ℕ} {k : (Fin m → Word) → ℕ} {t : (Fin m → Word) → ℕ} {a : (Fin m → Word) → ℕ} {z : (Fin m → Word) → ℕ} {i : (Fin m → Word) → ℕ} {y : (Fin m → Word) → ℕ}
    (h_n : NatPoly n)    (h_k : NatPoly k)    (h_t : NatPoly t)    (h_a : NatPoly a)    (h_z : NatPoly z)    (h_i : NatPoly i)    (h_y : NatPoly y) :
    BoolPoly (fun S => tupleTrans (n S) (k S) (t S) (a S) (z S) (i S) (y S)) := by
  have h := tupleTrans_poly.subst (g := ![fun S => unary (n S),fun S => unary (k S),fun S => unary (t S),fun S => unary (a S),fun S => unary (z S),fun S => unary (i S),fun S => unary (y S)])
    (by intro i; fin_cases i; exacts [h_n,h_k,h_t,h_a,h_z,h_i,h_y])
  simpa [unary] using h

end NumericWL

namespace NumericGraph
open WordExpressions

theorem simple_poly_of {m} {n : (Fin m → Word) → ℕ} {W : (Fin m → Word) → Word}
    (h_n : NatPoly n)    (h_W : Poly W) :
    BoolPoly (fun S => simple (n S) (W S)) := by
  have h := simple_poly.subst (g := ![fun S => unary (n S),W])
    (by intro i; fin_cases i; exacts [h_n,h_W])
  simpa [unary] using h

end NumericGraph
namespace NumericGraph
open WordExpressions

theorem iso_poly_of {m} {n : (Fin m → Word) → ℕ} {c : (Fin m → Word) → ℕ} {W : (Fin m → Word) → Word} {V : (Fin m → Word) → Word}
    (h_n : NatPoly n)    (h_c : NatPoly c)    (h_W : Poly W)    (h_V : Poly V) :
    BoolPoly (fun S => iso (n S) (c S) (W S) (V S)) := by
  have h := iso_poly.subst (g := ![fun S => unary (n S),fun S => unary (c S),W,V])
    (by intro i; fin_cases i; exacts [h_n,h_c,h_W,h_V])
  simpa [unary] using h

end NumericGraph
namespace NumericGraph
open WordExpressions

theorem mate_poly_of {m} {n : (Fin m → Word) → ℕ} {mask : (Fin m → Word) → ℕ}
    (h_n : NatPoly n)    (h_mask : NatPoly mask) :
    Poly (fun S => mate (n S) (mask S)) := by
  have h := mate_poly.subst (g := ![fun S => unary (n S),fun S => unary (mask S)])
    (by intro i; fin_cases i; exacts [h_n,h_mask])
  simpa [unary] using h

end NumericGraph

namespace NumericWL
open WordExpressions

theorem neighborActiveTable_poly : Poly (fun S : Fin 3 → Word =>
    pairTable ((S 0).length+(S 0).length) (neighborActive (S 0).length (S 1) (S 2))) := by
  unfold pairTable
  apply Poly.tabulateRange
  · word_poly
  · apply neighborActive_poly_of <;> word_poly

theorem neighborTransTable_poly : Poly (fun S : Fin 1 → Word =>
    transTable ((S 0).length+(S 0).length) 1 (S 0).length (neighborTrans (S 0).length)) := by
  unfold transTable
  apply Poly.tabulateRange
  · word_poly
  · exact neighborTrans_poly_of (NatPoly.var 0) ((NatPoly.var 1).unpair_fst)
      ((NatPoly.var 1).unpair_snd.unpair_fst) ((NatPoly.var 1).unpair_snd.unpair_snd.unpair_fst)
      ((NatPoly.var 1).unpair_snd.unpair_snd.unpair_snd)

theorem trueTable_poly {m} {N : (Fin m → Word) → ℕ} (hN : NatPoly N) :
    Poly (fun S => pairTable (N S) (fun _ _ => true)) := by
  unfold pairTable
  exact Poly.tabulateRange (NatPoly.succ (NatPoly.pair hN hN)) (BoolPoly.const true)

theorem tupleInitialTable_poly : Poly (fun S : Fin 5 → Word =>
    pairTable ((S 2).length+(S 2).length)
      (tupleInitial (S 0).length (S 1).length (S 2).length (S 3) (S 4))) := by
  unfold pairTable
  apply Poly.tabulateRange
  · word_poly
  · apply tupleInitial_poly_of <;> word_poly

theorem tupleTransTable_poly : Poly (fun S : Fin 3 → Word =>
    transTable ((S 2).length+(S 2).length) (S 1).length (S 0).length
      (tupleTrans (S 0).length (S 1).length (S 2).length)) := by
  unfold transTable
  apply Poly.tabulateRange
  · word_poly
  · exact tupleTrans_poly_of (NatPoly.var 0) (NatPoly.var 1) (NatPoly.var 2)
      ((NatPoly.var 3).unpair_fst) ((NatPoly.var 3).unpair_snd.unpair_fst)
      ((NatPoly.var 3).unpair_snd.unpair_snd.unpair_fst) ((NatPoly.var 3).unpair_snd.unpair_snd.unpair_snd)

end NumericWL

namespace NumericWL
open WordExpressions

theorem neighborActiveTable_poly_of {m} {n : (Fin m → Word) → ℕ} {W V : (Fin m → Word) → Word}
    (hn : NatPoly n) (hW : Poly W) (hV : Poly V) :
    Poly (fun S => pairTable (n S+n S) (neighborActive (n S) (W S) (V S))) := by
  have h := neighborActiveTable_poly.subst (g := ![fun S => unary (n S),W,V])
    (by intro i; fin_cases i; exacts [hn,hW,hV])
  simpa [unary] using h

theorem neighborTransTable_poly_of {m} {n : (Fin m → Word) → ℕ} (hn : NatPoly n) :
    Poly (fun S => transTable (n S+n S) 1 (n S) (neighborTrans (n S))) := by
  have h := neighborTransTable_poly.subst (g := ![fun S => unary (n S)])
    (by intro i; fin_cases i; exact hn)
  simpa [unary] using h

theorem tupleInitialTable_poly_of {m} {n k t : (Fin m → Word) → ℕ} {W V : (Fin m → Word) → Word}
    (hn : NatPoly n) (hk : NatPoly k) (ht : NatPoly t) (hW : Poly W) (hV : Poly V) :
    Poly (fun S => pairTable (t S+t S) (tupleInitial (n S) (k S) (t S) (W S) (V S))) := by
  have h := tupleInitialTable_poly.subst (g := ![fun S => unary (n S),fun S => unary (k S),
    fun S => unary (t S),W,V]) (by intro i; fin_cases i; exacts [hn,hk,ht,hW,hV])
  simpa [unary] using h

theorem tupleTransTable_poly_of {m} {n k t : (Fin m → Word) → ℕ}
    (hn : NatPoly n) (hk : NatPoly k) (ht : NatPoly t) :
    Poly (fun S => transTable (t S+t S) (k S) (n S) (tupleTrans (n S) (k S) (t S))) := by
  have h := tupleTransTable_poly.subst (g := ![fun S => unary (n S),fun S => unary (k S),
    fun S => unary (t S)]) (by intro i; fin_cases i; exacts [hn,hk,ht])
  simpa [unary] using h

theorem neighbor_poly_of {m} {n c : (Fin m → Word) → ℕ} {W V : (Fin m → Word) → Word}
    (hn : NatPoly n) (hc : NatPoly c) (hW : Poly W) (hV : Poly V) :
    BoolPoly (fun S => neighbor (n S) (c S) (W S) (V S)) := by
  exact equalCounts_poly_of hn (NumericKernel.table_poly_of (hn.add hn) (NatPoly.const 1) hn hc
    (neighborActiveTable_poly_of hn hW hV) (neighborTransTable_poly_of hn)
    (trueTable_poly (hn.add hn)) ((hn.add hn).mul (hn.add hn)))

theorem tuple_poly_of {m} {n k c : (Fin m → Word) → ℕ} {W V : (Fin m → Word) → Word}
    (hn : NatPoly n) (hk : NatPoly k) (hc : NatPoly c) (hW : Poly W) (hV : Poly V) :
    BoolPoly (fun S => tuple (n S) (k S) (c S) (W S) (V S)) := by
  have ht := NatPoly.cappedPow hn hk hc
  exact equalCounts_poly_of ht (NumericKernel.table_poly_of (ht.add ht) hk hn hc
    (trueTable_poly (ht.add ht)) (tupleTransTable_poly_of hn hk ht)
    (tupleInitialTable_poly_of hn hk ht hW hV) ((ht.add ht).mul (ht.add ht)))

theorem equivalent_poly_of {m} {n k c : (Fin m → Word) → ℕ} {W V : (Fin m → Word) → Word}
    (hn : NatPoly n) (hk : NatPoly k) (hc : NatPoly c) (hW : Poly W) (hV : Poly V) :
    BoolPoly (fun S => equivalent (n S) (k S) (c S) (W S) (V S)) :=
  BoolPoly.iteProp (NatPoly.eqtest hk (NatPoly.const 1))
    (neighbor_poly_of hn hc hW hV) (tuple_poly_of hn hk hc hW hV)

end NumericWL

end WLIdentification

end OAI