import Mathlib
import OAI.Combinatorics.IndependentSets.PCP.TargetLC
import OAI.Combinatorics.IndependentSets.Reduction.TargetRead

namespace OAI

namespace LargeIndependentSets.TargetLC
open IndependentSetsGames.Foundations IndependentSetsGames.Foundations.Complexity
open IndependentSetsCut.CounterMachine
open Target PCP Hastad.SourceContexts Hastad.SourceGame UniformLC
open TargetRead TargetRepair
open scoped Classical BigOperators
noncomputable section
variable (u : ℕ)

def eventExpr (x : Expr) (k : Fin u) : Expr :=
  Expr.remainder (Expr.quotient x (Expr.power (.mul clausesExpr (.const 3)) k.val))
    (.mul clausesExpr (.const 3))
def clauseExpr (x : Expr) (k : Fin u) : Expr := Expr.quotient (eventExpr u x k) (.const 3)
def slotExpr (x : Expr) (k : Fin u) : Expr := Expr.remainder (eventExpr u x k) (.const 3)

lemma clauseExpr_eval (F : Input) (x : Expr) (a : ℕ → ℕ) (i : Fin (table u F).ne)
    (hi : x.eval (Complexity.formulaBits F.val) a=i.val) (k : Fin u) :
    (clauseExpr u x k).eval (Complexity.formulaBits F.val) a=
      (((eventEquiv u F.val).symm i k).1).val := by
  simp only [clauseExpr,eventExpr,Expr.remainder_eval,Expr.quotient_eval,Expr.power_eval,
    Expr.eval,clausesExpr_eval,hi]
  rfl

lemma slotExpr_eval (F : Input) (x : Expr) (a : ℕ → ℕ) (i : Fin (table u F).ne)
    (hi : x.eval (Complexity.formulaBits F.val) a=i.val) (k : Fin u) :
    (slotExpr u x k).eval (Complexity.formulaBits F.val) a=
      (RawInitialTables.slotOrder (((eventEquiv u F.val).symm i k).2)).val := by
  simp only [slotExpr,eventExpr,Expr.remainder_eval,Expr.quotient_eval,Expr.power_eval,
    Expr.eval,clausesExpr_eval,hi]
  change _=(RawInitialTables.slotOrder (RawInitialTables.slotOrder.symm _)).val
  rw [Equiv.apply_symm_apply]
  rfl

def sampledNameExpr (x : Expr) (k : Fin u) : Expr :=
  selectSlot (slotExpr u x k) (nameExpr (clauseExpr u x k))
def projectedBitExpr (x : Expr) (j : J u) (k : Fin u) : Expr :=
  selectSlot (slotExpr u x k) (repairExpr (clauseExpr u x k) (j k))

lemma sampledNameExpr_eval (F : Input) (x : Expr) (a : ℕ → ℕ) (i : Fin (table u F).ne)
    (hi : x.eval (Complexity.formulaBits F.val) a=i.val) (k : Fin u) :
    (sampledNameExpr u x k).eval (Complexity.formulaBits F.val) a=
      (nameAt (clauseAt F.val (((eventEquiv u F.val).symm i k).1))
        (((eventEquiv u F.val).symm i k).2)).val := by
  rw [sampledNameExpr,selectSlot_eval _ _ _ _ _ (slotExpr_eval u F x a i hi k)]
  exact nameExpr_eval F.val _ a _ (clauseExpr_eval u F x a i hi k) _

lemma projectedBitExpr_eval (F : Input) (x : Expr) (a : ℕ → ℕ) (i : Fin (table u F).ne)
    (hi : x.eval (Complexity.formulaBits F.val) a=i.val) (j : J u) (k : Fin u) :
    (projectedBitExpr u x j k).eval (Complexity.formulaBits F.val) a=
      bit ((table u F).project i j k) := by
  rw [projectedBitExpr,selectSlot_eval _ _ _ _ _ (slotExpr_eval u F x a i hi k)]
  rw [repairExpr_eval _ _ _ _ (clauseExpr_eval u F x a i hi k)]
  congr 1
  exact (project_apply u F.val _ j k).symm

def rankExpr (base : Expr) (f : Fin u → Expr) : Expr :=
  Expr.listSum (List.finRange u) (fun k => .mul (f k) (Expr.power base k.val))
lemma rankExpr_eval (s : List Bool) (a : ℕ → ℕ) (base : Expr) (f : Fin u → Expr)
    {m : ℕ} (v : Fin u → Fin m) (hb : base.eval s a=m) (hf : ∀ k, (f k).eval s a=(v k).val) :
    (rankExpr u base f).eval s a=(finFunctionFinEquiv v).val := by
  simp only [rankExpr,Expr.listSum_eval,Expr.eval,Expr.power_eval,hb,hf,finFunctionFinEquiv_apply]
  rw [← List.ofFn_eq_map,List.sum_ofFn]

def leftExpr (x : Expr) : Expr := rankExpr u clausesExpr (clauseExpr u x)
def rightExpr (x : Expr) : Expr := rankExpr u varsExpr (sampledNameExpr u x)
lemma leftExpr_eval (F : Input) (x : Expr) (a : ℕ → ℕ) (i : Fin (table u F).ne)
    (hi : x.eval (Complexity.formulaBits F.val) a=i.val) :
    (leftExpr u x).eval (Complexity.formulaBits F.val) a=((table u F).left i).val := by
  exact rankExpr_eval u _ _ _ _ _ (clausesExpr_eval F.val a) (clauseExpr_eval u F x a i hi)
lemma rightExpr_eval (F : Input) (x : Expr) (a : ℕ → ℕ) (i : Fin (table u F).ne)
    (hi : x.eval (Complexity.formulaBits F.val) a=i.val) :
    (rightExpr u x).eval (Complexity.formulaBits F.val) a=((table u F).right i).val := by
  exact rankExpr_eval u _ _ _ _ _ (varsExpr_eval F.val a) (sampledNameExpr_eval u F x a i hi)

def projectionTest (x : Expr) (f : J u → I u) : Expr :=
  Expr.listAll (List.finRange (Fintype.card (J u))) fun i =>
    Expr.listAll (List.finRange u) fun k =>
      Expr.equal (projectedBitExpr u x ((Fintype.equivFin (J u)).symm i) k)
        (.const (bit (f ((Fintype.equivFin (J u)).symm i) k)))
lemma projectionTest_nonzero (F : Input) (x : Expr) (a : ℕ → ℕ) (i : Fin (table u F).ne)
    (hi : x.eval (Complexity.formulaBits F.val) a=i.val) (f : J u → I u) :
    (projectionTest u x f).eval (Complexity.formulaBits F.val) a≠0 ↔ f=(table u F).project i := by
  simp only [projectionTest,Expr.listAll_eval,List.mem_finRange,forall_true_left,
    Expr.equal_eval,projectedBitExpr_eval u F x a i hi,Expr.eval,indicator_ne,bit_eq]
  constructor
  · intro h
    funext j k
    simpa using (h (Fintype.equivFin (J u) j) k).symm
  · rintro rfl
    exact fun _ _ => rfl

def projectExpr (x : Expr) : Expr := Expr.pick projectCode (projectionTest u x)
lemma projectExpr_eval (F : Input) (x : Expr) (a : ℕ → ℕ) (i : Fin (table u F).ne)
    (hi : x.eval (Complexity.formulaBits F.val) a=i.val) :
    (projectExpr u x).eval (Complexity.formulaBits F.val) a=projectCode ((table u F).project i) := by
  apply Expr.pick_eval
  exact projectionTest_nonzero u F x a i hi

end
end LargeIndependentSets.TargetLC

end OAI