import Mathlib
import OAI.Combinatorics.IndependentSets.Geometry.Witness
import OAI.Combinatorics.IndependentSets.Machines.ExprTables
import OAI.Combinatorics.IndependentSets.PCP.GeometryPointTable

namespace OAI

namespace LargeIndependentSets.GeometryNames
open IndependentSetsCut.CounterMachine UniformLC PhaseTest Coefficient
open scoped Classical BigOperators
noncomputable section
attribute [-instance] mixedTupleComputableFintype mixedTupleDecidableEq

variable (L R : Type) [Fintype L] [Fintype R] (p : SamplerParameters)

abbrev Outcome := (p.law L R).Expanded
abbrev outcomeCount := Fintype.card (Outcome L R p)
abbrev vertexCount (t : Table L R) := t.ne^p.n*outcomeCount L R p

lemma vertexCount_pos (t : Table L R) : 0<vertexCount L R p t :=
  Nat.mul_pos (pow_pos t.he _) Fintype.card_pos

def vertexEquiv (t : Table L R) : p.Vertices L R (Fin t.ne) ≃ Fin (vertexCount L R p t) :=
  (Equiv.prodCongr finFunctionFinEquiv (Fintype.equivFin (Outcome L R p))).trans finProdFinEquiv

def scheduleLC (f : Fin p.n → L → R) : LabelCoverData Unit Unit L R (Fin p.n) :=
  ⟨fun _ => (),fun _ => (),f⟩

def samplePoint (f : Fin p.n → L → R) (o : Outcome L R p) : StaticPoint L R p.n (p.m*2^p.k) :=
  ⟨(p.location (scheduleLC L R p f) (id,o)).1.1,
    (p.location (scheduleLC L R p f) (id,o)).2⟩

lemma samplePoint_decode (t : Table L R) (v : p.Vertices L R (Fin t.ne)) :
    decode (fun k => t.left (v.1 k)) (fun k => t.right (v.1 k))
      (samplePoint L R p (fun k => t.project (v.1 k)) v.2)=p.location t.lc v := by
  rfl

def locationName (t : Table L R) (v : p.Vertices L R (Fin t.ne)) : Fin (size L R p.n (p.m*2^p.k) t) :=
  nodeEquiv L R p.n (p.m*2^p.k) t.nu t.nv
    ((fun k => t.left (v.1 k),fun k => t.right (v.1 k)),
      samplePoint L R p (fun k => t.project (v.1 k)) v.2)

lemma locationName_exact (t : Table L R) (v : p.Vertices L R (Fin t.ne)) :
    names L R p.n (p.m*2^p.k) t.nu t.nv (locationName L R p t v)=p.location t.lc v := by
  rw [names,locationName,Equiv.symm_apply_apply]
  exact samplePoint_decode L R p t v

def vertexCountExpr : Expr := .mul (Expr.power neExpr p.n) (.const (outcomeCount L R p))
def outcomeExpr (x : Expr) : Expr := Expr.remainder x (.const (outcomeCount L R p))
def chainExpr (x : Expr) (k : Fin p.n) : Expr :=
  Expr.remainder (Expr.quotient (Expr.quotient x (.const (outcomeCount L R p)))
    (Expr.power neExpr k.val)) neExpr

@[simp] lemma vertexCountExpr_eval (t : Table L R) (a : ℕ → ℕ) :
    (vertexCountExpr L R p).eval t.bits a=vertexCount L R p t := by
  simp [vertexCountExpr,Expr.eval,vertexCount]

lemma chainExpr_eval (t : Table L R) (x : Expr) (a : ℕ → ℕ) (i : Fin (vertexCount L R p t))
    (hi : x.eval t.bits a=i.val) (k : Fin p.n) :
    (chainExpr L R p x k).eval t.bits a=(((vertexEquiv L R p t).symm i).1 k).val := by
  simp only [chainExpr,Expr.remainder_eval,Expr.quotient_eval,Expr.power_eval,neExpr_eval,Expr.eval,hi]
  rfl

lemma outcomeExpr_eval (t : Table L R) (x : Expr) (a : ℕ → ℕ) (i : Fin (vertexCount L R p t))
    (hi : x.eval t.bits a=i.val) :
    (outcomeExpr L R p x).eval t.bits a=
      (Fintype.equivFin (Outcome L R p) ((vertexEquiv L R p t).symm i).2).val := by
  simp only [outcomeExpr,Expr.remainder_eval,Expr.eval,hi]
  change _=(Fintype.equivFin _ ((Fintype.equivFin _).symm _)).val
  rw [Equiv.apply_symm_apply]
  rfl

def scheduleTest (x : Expr) (f : Fin p.n → L → R) : Expr :=
  Expr.listAll (List.finRange p.n) fun k =>
    Expr.equal (fieldExpr (chainExpr L R p x k) 2) (.const (projectCode (f k)))

lemma scheduleTest_nonzero (t : Table L R) (x : Expr) (a : ℕ → ℕ) (i : Fin (vertexCount L R p t))
    (hi : x.eval t.bits a=i.val) (f : Fin p.n → L → R) :
    (scheduleTest L R p x f).eval t.bits a≠0 ↔
      f=fun k => t.project (((vertexEquiv L R p t).symm i).1 k) := by
  have hh (k : Fin p.n) : (fieldExpr (chainExpr L R p x k) 2).eval t.bits a=
      projectCode (t.project (((vertexEquiv L R p t).symm i).1 k)) := by
    simpa using fieldExpr_eval t a (chainExpr L R p x k)
      (((vertexEquiv L R p t).symm i).1 k) (chainExpr_eval L R p t x a i hi k) (2:Fin 3)
  simp only [scheduleTest,Expr.listAll_eval,List.mem_finRange,forall_true_left]
  split_ifs with h
  · simp only [ne_eq,one_ne_zero,not_false_eq_true,true_iff]
    funext k
    have hk := h k
    rw [Expr.equal_eval,hh,Expr.eval] at hk
    have hc : projectCode (t.project (((vertexEquiv L R p t).symm i).1 k))=projectCode (f k) := by
      split_ifs at hk with he
      · exact he
      · exact False.elim (hk rfl)
    exact ((Fintype.equivFin (L → R)).injective (Fin.ext hc)).symm
  · simp only [ne_eq,not_true_eq_false,false_iff]
    intro he
    apply h
    intro k
    rw [Expr.equal_eval,hh,Expr.eval,he]
    simp

def scheduleCodeExpr (x : Expr) : Expr :=
  Expr.pick (fun f : Fin p.n → L → R => (Fintype.equivFin _ f).val) (scheduleTest L R p x)

lemma scheduleCodeExpr_eval (t : Table L R) (x : Expr) (a : ℕ → ℕ) (i : Fin (vertexCount L R p t))
    (hi : x.eval t.bits a=i.val) :
    (scheduleCodeExpr L R p x).eval t.bits a=
      (Fintype.equivFin (Fin p.n → L → R) (fun k => t.project (((vertexEquiv L R p t).symm i).1 k))).val := by
  apply Expr.pick_eval
  exact scheduleTest_nonzero L R p t x a i hi

def samplePointExpr (x : Expr) : Expr :=
  Expr.static2 (fun f o => (pointEquiv L R p.n (p.m*2^p.k) (samplePoint L R p f o)).val)
    (scheduleCodeExpr L R p x) (outcomeExpr L R p x)

lemma samplePointExpr_eval (t : Table L R) (x : Expr) (a : ℕ → ℕ) (i : Fin (vertexCount L R p t))
    (hi : x.eval t.bits a=i.val) :
    (samplePointExpr L R p x).eval t.bits a=
      (pointEquiv L R p.n (p.m*2^p.k) (samplePoint L R p
        (fun k => t.project (((vertexEquiv L R p t).symm i).1 k)) ((vertexEquiv L R p t).symm i).2)).val := by
  apply Expr.static2_eval
  · exact scheduleCodeExpr_eval L R p t x a i hi
  · exact outcomeExpr_eval L R p t x a i hi

def tupleCodeExpr (base : Expr) (f : Fin p.n → Expr) : Expr :=
  Expr.listSum (List.finRange p.n) (fun k => .mul (f k) (Expr.power base k.val))

lemma tupleCodeExpr_eval (s : List Bool) (a : ℕ → ℕ) (base : Expr) (f : Fin p.n → Expr)
    {m : ℕ} (v : Fin p.n → Fin m) (hb : base.eval s a=m) (hf : ∀ k, (f k).eval s a=(v k).val) :
    (tupleCodeExpr p base f).eval s a=(finFunctionFinEquiv v).val := by
  simp only [tupleCodeExpr,Expr.listSum_eval,Expr.eval,Expr.power_eval,hb,hf,finFunctionFinEquiv_apply]
  rw [← List.ofFn_eq_map,List.sum_ofFn]

def locationExpr (x : Expr) : Expr :=
  .add (.mul (.add (.mul (tupleCodeExpr p nuExpr (fun k => fieldExpr (chainExpr L R p x k) 0))
        (Expr.power nvExpr p.n))
      (tupleCodeExpr p nvExpr (fun k => fieldExpr (chainExpr L R p x k) 1)))
      (.const (staticCount L R p.n (p.m*2^p.k)))) (samplePointExpr L R p x)

lemma locationExpr_eval (t : Table L R) (x : Expr) (a : ℕ → ℕ) (i : Fin (vertexCount L R p t))
    (hi : x.eval t.bits a=i.val) :
    (locationExpr L R p x).eval t.bits a=
      (locationName L R p t ((vertexEquiv L R p t).symm i)).val := by
  have hf (k : Fin p.n) (j : Fin 3) := fieldExpr_eval t a (chainExpr L R p x k)
    (((vertexEquiv L R p t).symm i).1 k) (chainExpr_eval L R p t x a i hi k) j
  have hu : ∀ k, (fieldExpr (chainExpr L R p x k) 0).eval t.bits a=
      (t.left (((vertexEquiv L R p t).symm i).1 k)).val := by
    intro k; simpa using hf k 0
  have hv : ∀ k, (fieldExpr (chainExpr L R p x k) 1).eval t.bits a=
      (t.right (((vertexEquiv L R p t).symm i).1 k)).val := by
    intro k; simpa using hf k 1
  simp only [locationExpr,Expr.eval,Expr.power_eval,nvExpr_eval,
    tupleCodeExpr_eval p _ _ _ _ _ (nuExpr_eval t a) hu,
    tupleCodeExpr_eval p _ _ _ _ _ (nvExpr_eval t a) hv,samplePointExpr_eval L R p t x a i hi]
  rw [locationName,nodeEquiv_val]
  ring

attribute [instance 1100] mixedTupleComputableFintype
attribute [instance] mixedTupleDecidableEq
end
end LargeIndependentSets.GeometryNames

end OAI