import Mathlib
import OAI.Computability.MinUncut.Estimates.ExpressionOutput

namespace OAI

section
namespace MinUncut.SourceTemplate
open MinUncutGames.Foundations MinUncutGames.Foundations.Target
open PCP Hastad Hastad.SourceContexts Hastad.SourceOccurrences
open MinUncutGames.Reduction.CloneGap
open MinUncut.Costed
open scoped BigOperators

def keyTag {u : ℕ} : LocalKey u → ℕ
  | .inl _ => 0
  | .inr (.inl _) => 1
  | .inr (.inr _) => 2

def keyTable {u : ℕ} : LocalKey u → ℕ
  | .inl f => (((iEncoding u).function Encoding.bool).code f).val
  | .inr (.inl g) => (((jEncoding u).function Encoding.bool).code g).val
  | .inr (.inr _) => 0

def keyNumber {u : ℕ} (N M c v : ℕ) (x : LocalKey u) : ℕ :=
  if keyTag x=0 then keyTable x+2^(2^u)*v else
  if keyTag x=1 then N^u*2^(2^u)+(keyTable x+2^(8^u)*c) else
    N^u*2^(2^u)+M^u*2^(8^u)

lemma keyAddress_number (F : Formula) {u : ℕ} (c : ClauseContext F u)
    (v : VariableContext F u) (x : LocalKey u) :
    (keyAddress F c v x).val=keyNumber F.«variables» F.clauses.length
      ((clauseEncoding F u).code c).val ((variableEncoding F u).code v).val x := by
  cases x with
  | inl f => rfl
  | inr x =>
    cases x with
    | inl g => rfl
    | inr z => cases z; rfl

def signatureEquiv (u : ℕ) : Signature u ≃
    (Fin u → Slot → Bool) × ((Fin u × Slot) → (Fin u × Slot) → Bool) where
  toFun s := (s.positive,s.same)
  invFun p := ⟨p.1,p.2⟩
  left_inv _ := rfl
  right_inv _ := rfl

def coordinateEncoding (u : ℕ) : Encoding (Fin u × Slot) := (Encoding.fin u).prod slotEncoding

def signatureEncoding (u : ℕ) : Encoding (Signature u) :=
  let p := (Encoding.fin u).function (slotEncoding.function Encoding.bool)
  let s := (coordinateEncoding u).function ((coordinateEncoding u).function Encoding.bool)
  ⟨(p.prod s).size,(signatureEquiv u).trans (p.prod s).code⟩

def inputTuple (F : Formula) {u : ℕ} (c : ClauseContext F u) : List ℕ :=
  ((clauseEncoding F u).code c).val::Complexity.formulaWords F

def tupleDigit (i : ℕ) : AExpr := .mod (.div (.reg 0) ((AExpr.reg 2).pow i)) (.reg 2)
def slotWord (i : ℕ) (s : Slot) (p : ℕ) : AExpr :=
  .at (.add (.add (.const 3) (.mul (.const 6) (tupleDigit i)))
    (.const (2*(slotEncoding.code s).val+p)))

lemma tupleDigit_eval (F : Formula) {u : ℕ} (c : ClauseContext F u) (i : Fin u) :
    (tupleDigit i.val).eval (inputTuple F c)=(c i).val := by
  have h := congrArg Fin.val (congrFun (finFunctionFinEquiv.symm_apply_apply c) i)
  have he : (clauseEncoding F u).code c=finFunctionFinEquiv c := by
    apply congrArg finFunctionFinEquiv
    funext j
    rfl
  simp only [tupleDigit,AExpr.eval,AExpr.eval_pow,inputTuple,Complexity.formulaWords,
    List.cons_append,List.nil_append,List.drop_succ_cons,List.drop_zero,List.headI_cons,he]
  exact h

lemma formula_name_word (F : Formula) (i : Fin F.clauses.length) (s : Slot) :
    ((Complexity.formulaWords F).drop (2+6*i.val+2*(slotEncoding.code s).val)).headI=
      (nameAt (clauseAt F i) s).val := by
  have h : ∀ (xs : List (Clause F.«variables»)) (j : ℕ) (hj : j<xs.length),
      ((xs.flatMap Complexity.clauseWords).drop (6*j+2*(slotEncoding.code s).val)).headI=
        (nameAt xs[j] s).val := by
    intro xs
    induction xs with
    | nil => intro j hj; simp at hj
    | cons e es ih =>
      intro j hj
      cases j with
      | zero => cases s <;> rfl
      | succ j =>
        have he : 6*(j+1)+2*(slotEncoding.code s).val=
            ((((((6*j+2*(slotEncoding.code s).val)+1)+1)+1)+1)+1)+1 := by omega
        rw [he]
        simpa only [List.flatMap_cons,Complexity.clauseWords,Complexity.literalWords,
          List.cons_append,List.nil_append,List.drop_succ_cons,List.getElem_cons_succ] using
          ih j (by simpa using hj)
  have he : 2+6*i.val+2*(slotEncoding.code s).val=(6*i.val+2*(slotEncoding.code s).val)+1+1 := by omega
  rw [he]
  exact h F.clauses i.val i.isLt

lemma formula_positive_word (F : Formula) (i : Fin F.clauses.length) (s : Slot) :
    ((Complexity.formulaWords F).drop (2+6*i.val+(2*(slotEncoding.code s).val+1))).headI=
      (positiveAt (clauseAt F i) s).toNat := by
  have h : ∀ (xs : List (Clause F.«variables»)) (j : ℕ) (hj : j<xs.length),
      ((xs.flatMap Complexity.clauseWords).drop (6*j+(2*(slotEncoding.code s).val+1))).headI=
        (positiveAt xs[j] s).toNat := by
    intro xs
    induction xs with
    | nil => intro j hj; simp at hj
    | cons e es ih =>
      intro j hj
      cases j with
      | zero =>
        cases s with
        | first => change (if e[0].positive then 1 else 0)=e[0].positive.toNat
                   cases e[0].positive <;> rfl
        | second => change (if e[1].positive then 1 else 0)=e[1].positive.toNat
                    cases e[1].positive <;> rfl
        | third => change (if e[2].positive then 1 else 0)=e[2].positive.toNat
                   cases e[2].positive <;> rfl
      | succ j =>
        have he : 6*(j+1)+(2*(slotEncoding.code s).val+1)=
            ((((((6*j+(2*(slotEncoding.code s).val+1))+1)+1)+1)+1)+1)+1 := by omega
        rw [he]
        simpa only [List.flatMap_cons,Complexity.clauseWords,Complexity.literalWords,
          List.cons_append,List.nil_append,List.drop_succ_cons,List.getElem_cons_succ] using
          ih j (by simpa using hj)
  have he : 2+6*i.val+(2*(slotEncoding.code s).val+1)=
      (6*i.val+(2*(slotEncoding.code s).val+1))+1+1 := by omega
  rw [he]
  exact h F.clauses i.val i.isLt

lemma slotWord_name (F : Formula) {u : ℕ} (c : ClauseContext F u) (i : Fin u) (s : Slot) :
    (slotWord i.val s 0).eval (inputTuple F c)=(nameAt (clauseAt F (c i)) s).val := by
  simp only [slotWord,AExpr.eval,tupleDigit_eval,Nat.add_zero]
  have he : 3+6*(c i).val+2*(slotEncoding.code s).val=
      (2+6*(c i).val+2*(slotEncoding.code s).val)+1 := by omega
  rw [he]
  exact formula_name_word F (c i) s

lemma slotWord_positive (F : Formula) {u : ℕ} (c : ClauseContext F u) (i : Fin u) (s : Slot) :
    (slotWord i.val s 1).eval (inputTuple F c)=(positiveAt (clauseAt F (c i)) s).toNat := by
  simp only [slotWord,AExpr.eval,tupleDigit_eval]
  have he : 3+6*(c i).val+(2*(slotEncoding.code s).val+1)=
      (2+6*(c i).val+(2*(slotEncoding.code s).val+1))+1 := by omega
  rw [he]
  exact formula_positive_word F (c i) s

end MinUncut.SourceTemplate

end

end OAI