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

namespace OAI

namespace LargeIndependentSets.UniformLC
open IndependentSetsCut.CounterMachine
open scoped Classical BigOperators
noncomputable section

structure Table (L R : Type) where
  nu : ℕ
  nv : ℕ
  ne : ℕ
  hu : 0 < nu
  hv : 0 < nv
  he : 0 < ne
  left : Fin ne → Fin nu
  right : Fin ne → Fin nv
  project : Fin ne → L → R

def Table.lc {L R : Type} (t : Table L R) : LabelCoverData (Fin t.nu) (Fin t.nv) L R (Fin t.ne) :=
  ⟨t.left,t.right,t.project⟩

instance {L R : Type} (t : Table L R) : Nonempty (Fin t.ne) := ⟨⟨0,t.he⟩⟩

variable {L R : Type} [Fintype L] [Fintype R]

def projectCode (f : L → R) : ℕ := (Fintype.equivFin (L → R) f).val

def Table.value (t : Table L R) (w : ℕ) : ℕ :=
  if w=0 then t.nu else if w=1 then t.nv else if w=2 then t.ne else
    if h : (w-3)/3 < t.ne then
      if (w-3)%3=0 then (t.left ⟨(w-3)/3,h⟩).val
      else if (w-3)%3=1 then (t.right ⟨(w-3)/3,h⟩).val
      else projectCode (t.project ⟨(w-3)/3,h⟩)
    else 0

def Table.bits (t : Table L R) := UnaryTables.words t.value (3+3*t.ne)

@[simp] lemma read_nu (t : Table L R) : Expr.wordValue t.bits 0=t.nu := by
  rw [Table.bits,UnaryTables.wordValue_words _ _ _ (by omega)]
  simp [Table.value]
@[simp] lemma read_nv (t : Table L R) : Expr.wordValue t.bits 1=t.nv := by
  rw [Table.bits,UnaryTables.wordValue_words _ _ _ (by omega)]
  simp [Table.value]
@[simp] lemma read_ne (t : Table L R) : Expr.wordValue t.bits 2=t.ne := by
  rw [Table.bits,UnaryTables.wordValue_words _ _ _ (by omega)]
  simp [Table.value]

lemma read_field (t : Table L R) (c : Fin t.ne) (j : Fin 3) :
    Expr.wordValue t.bits (3+3*c.val+j.val) =
      if j.val=0 then (t.left c).val else if j.val=1 then (t.right c).val else projectCode (t.project c) := by
  rw [Table.bits,UnaryTables.wordValue_words _ _ _ (by have := c.isLt; have := j.isLt; omega)]
  have hsub : 3+3*c.val+j.val-3=3*c.val+j.val := by omega
  have hdiv : (3*c.val+j.val)/3=c.val := by omega
  have hmod : (3*c.val+j.val)%3=j.val := by omega
  simp [Table.value,show 3+3*c.val+j.val≠1 by omega,
    show 3+3*c.val+j.val≠2 by omega,hsub,hdiv,hmod,c.isLt]

def nuExpr : Expr := Expr.word (.const 0)
def nvExpr : Expr := Expr.word (.const 1)
def neExpr : Expr := Expr.word (.const 2)
def fieldExpr (c : Expr) (j : ℕ) : Expr := Expr.word (.add (.add (.const 3) (.mul (.const 3) c)) (.const j))

@[simp] lemma nuExpr_eval (t : Table L R) (a : ℕ → ℕ) : nuExpr.eval t.bits a=t.nu := by simp [nuExpr,Expr.eval]
@[simp] lemma nvExpr_eval (t : Table L R) (a : ℕ → ℕ) : nvExpr.eval t.bits a=t.nv := by simp [nvExpr,Expr.eval]
@[simp] lemma neExpr_eval (t : Table L R) (a : ℕ → ℕ) : neExpr.eval t.bits a=t.ne := by simp [neExpr,Expr.eval]

lemma fieldExpr_eval (t : Table L R) (a : ℕ → ℕ) (c : Expr) (e : Fin t.ne)
    (hc : c.eval t.bits a=e.val) (j : Fin 3) :
    (fieldExpr c j.val).eval t.bits a =
      if j.val=0 then (t.left e).val else if j.val=1 then (t.right e).val else projectCode (t.project e) := by
  simp only [fieldExpr,Expr.word_eval,Expr.eval,hc,read_field]

end
end LargeIndependentSets.UniformLC

namespace IndependentSetsCut.CounterMachine.Expr
open scoped BigOperators

def finLookup {m : ℕ} (f : Fin m → ℕ) (x : Expr) : Expr :=
  listSum (List.finRange m) (fun i => .mul (equal x (.const i.val)) (.const (f i)))

lemma finLookup_eval {m : ℕ} (f : Fin m → ℕ) (x : Expr) (s : List Bool) (a : ℕ → ℕ)
    (i : Fin m) (hi : x.eval s a=i.val) :
    (finLookup f x).eval s a=f i := by
  simp only [finLookup,listSum_eval,eval,equal_eval,hi,ite_mul,one_mul,zero_mul]
  rw [← List.ofFn_eq_map,List.sum_ofFn]
  simp [Fin.val_inj]

noncomputable def staticLookup {α : Type} [Fintype α] (f : α → ℕ) (x : Expr) : Expr :=
  finLookup (fun i => f ((Fintype.equivFin α).symm i)) x

lemma staticLookup_eval {α : Type} [Fintype α] (f : α → ℕ) (x : Expr)
    (s : List Bool) (a : ℕ → ℕ) (v : α) (hv : x.eval s a=(Fintype.equivFin α v).val) :
    (staticLookup f x).eval s a=f v := by
  rw [staticLookup,finLookup_eval _ _ _ _ _ hv,Equiv.symm_apply_apply]

def listAll {α : Type} (xs : List α) (f : α → Expr) : Expr :=
  .zero (listSum xs (fun a => .zero (f a)))

lemma listAll_eval {α : Type} (xs : List α) (f : α → Expr) (s : List Bool) (a : ℕ → ℕ) :
    (listAll xs f).eval s a = if ∀ x ∈ xs, (f x).eval s a≠0 then 1 else 0 := by
  simp only [listAll,eval,listSum_eval]
  congr 1
  simp only [List.sum_eq_zero_iff,List.mem_map,forall_exists_index,and_imp]
  simp

end IndependentSetsCut.CounterMachine.Expr

end OAI