import Mathlib
import OAI.Computability.MinUncut.Estimates.UniformGrid

namespace OAI

noncomputable section
namespace MinUncut.Costed.SourceWords
open MinUncut.Inner MinUncut.Outer MinUncut.Outer.LocalTemplate
open MinUncutGames.Reduction MinUncut.SourceBridge

variable {t : ℕ} {h : Fin t → Bool}

def secondAddress (h : Fin t → Bool) (pos : Fin t → Fin 3) : AExpr :=
  .add ((AExpr.mul ((AExpr.reg 1).pow 3) (.const 2)).pow t) (secondExpr h pos)
def leftExpr (T : Query h) (pos : Fin t → Fin 3) : AExpr :=
  .add (signatureLookup (fun s=>tableNumber (T.leftTable pos s)))
    (.mul (.const (2^((2^3)^t))) (if T.first then firstExpr t else secondAddress h pos))
def rightExpr (T : Query h) (pos : Fin t → Fin 3) : AExpr :=
  .add (.const (tableNumber T.rightTable)) (.mul (.const (2^((2^3)^t))) (secondAddress h pos))
def signExpr (T : Query h) (pos : Fin t → Fin 3) : AExpr :=
  signatureLookup (fun s=>(T.localSign pos s).toNat)

lemma secondAddress_eval (input : SourceEncoding.Input) (u : Fin t → Fin input.equations.length)
    (h : Fin t → Bool) (pos : Fin t → Fin 3) :
    (secondAddress h pos).eval (inputTuple input u)=
      (input.«variables»^3*2)^t+secondNumber (fun j=>equations input (u j)) h pos := by
  simp only [secondAddress,AExpr.eval,AExpr.eval_pow,inputTuple_reg1,secondExpr_eval]
lemma leftExpr_eval (input : SourceEncoding.Input) (u : Fin t → Fin input.equations.length)
    (T : Query h) (pos : Fin t → Fin 3) :
    (leftExpr T pos).eval (inputTuple input u)=T.leftNumber (fun j=>equations input (u j)) pos := by
  simp only [leftExpr,AExpr.eval,signatureLookup_eval,Query.leftNumber]
  cases T.first <;> simp only [Bool.false_eq_true,ite_false,ite_true,firstExpr_eval,secondAddress_eval]
lemma rightExpr_eval (input : SourceEncoding.Input) (u : Fin t → Fin input.equations.length)
    (T : Query h) (pos : Fin t → Fin 3) :
    (rightExpr T pos).eval (inputTuple input u)=T.rightNumber (fun j=>equations input (u j)) pos := by
  simp only [rightExpr,AExpr.eval,secondAddress_eval,Query.rightNumber]
lemma signExpr_eval (input : SourceEncoding.Input) (u : Fin t → Fin input.equations.length)
    (T : Query h) (pos : Fin t → Fin 3) :
    (signExpr T pos).eval (inputTuple input u)=
      ((T.realize (fun j=>equations input (u j)) pos).signed familyBase).equal.toNat := by
  rw [Query.signed_equal]
  exact signatureLookup_eval input u _

def queryWords (T : Query h) (pos : Fin t → Fin 3) (v : List ℕ) : List ℕ :=
  [(leftExpr T pos).eval v,(rightExpr T pos).eval v,(signExpr T pos).eval v]
def queryProgram (T : Query h) (pos : Fin t → Fin 3) : PolyProgram (queryWords T pos) :=
  ((leftExpr T pos).program.cons ((rightExpr T pos).program.cons
    ((signExpr T pos).program.cons PolyProgram.nil))).ofEq (by intro v; rfl)

lemma queryWords_eq (input : SourceEncoding.Input) (u : Fin t → Fin input.equations.length)
    (T : Query h) (pos : Fin t → Fin 3) :
    queryWords T pos (inputTuple input u)=
      [(variableCode ((T.realize (fun j=>equations input (u j)) pos).signed familyBase).left).val,
       (variableCode ((T.realize (fun j=>equations input (u j)) pos).signed familyBase).right).val,
       ((T.realize (fun j=>equations input (u j)) pos).signed familyBase).equal.toNat] := by
  simp only [queryWords,leftExpr_eval,rightExpr_eval,signExpr_eval,Query.left_number,Query.right_number]

end MinUncut.Costed.SourceWords

namespace MinUncut.Preprocess.Syntax
open MinUncut.Costed MinUncut.Costed.SourceWords
open MinUncut.Outer MinUncut.Outer.LocalTemplate UEncoding
variable {P : Type} [Primcodable P] {A : P → Type} {c : UEncoding P A}
lemma O.demandDigit {i : ∀p,A p → ℕ} (hi : c.Out i) :
    O c (fun p x=>MinUncut.Costed.SourceWords.tupleDigit (i p x)) :=
  ((O.fixed (.reg 0)).div ((O.fixed (.reg 2)).pow hi)).mod (O.fixed (.reg 2))
lemma O.slotExpr {i j : ∀p,A p → ℕ} (hi : c.Out i) (hj : c.Out j) :
    O c (fun p x=>MinUncut.Costed.SourceWords.slotExpr (i p x) (j p x)) :=
  ((O.fixed (.const 3)).add ((O.fixed (.const 4)).mul (O.demandDigit hi))).add (O.const hj) |>.at
lemma O.equationExpr {i : ∀p,A p → ℕ} (hi : c.Out i) :
    O c (fun p x=>MinUncut.Costed.SourceWords.equationExpr (i p x)) := by
  have hp : (c.prod (fin (fun _ : P=>3) (Computable.const 3))).Out (fun _ x=>x.2.val) :=
    (out_code (fin (P:=P) (fun _=>3) (Computable.const 3))).second
  have hw := (O.slotExpr hi.first hp).mul ((O.fixed (.reg 1)).pow hp)
  exact (O.slotExpr hi (out_const c (Computable.const 3))).add
    ((O.fixed (.const 2)).mul (hw.sum_fin (Computable.const 3)))
lemma c_firstExpr : C MinUncut.Costed.SourceWords.firstExpr := by
  let c := unitN.prod (fin id Computable.id)
  have hi : c.Out (fun _ x=>x.2.val) := (out_code (fin id Computable.id)).second
  have hbase : O c (fun _ _=>.mul ((AExpr.reg 1).pow 3) (.const 2)) := O.fixed _
  exact ((O.equationExpr hi).mul (hbase.pow hi) |>.sum_fin Computable.id).toC
lemma O.secondExpr {t : P → ℕ} (ht : Computable t) {h : ∀p,A p → Fin (t p) → Bool}
    {pos : ∀p,A p → Fin (t p) → Fin 3}
    (hh : c.Map ((fin t ht).function bool) h)
    (hp : c.Map (Alphabet.positionsList t ht) pos) :
    O c (fun p x=>MinUncut.Costed.SourceWords.secondExpr (h p x) (pos p x)) := by
  let d:=c.prod (fin t ht)
  have hi : d.Out (fun _ x=>x.2.val) := (out_code (fin t ht)).second
  have hj := map_apply hp.first (map_snd c (fin t ht))
  have hjn := (out_code (fin (fun _ : P=>3) (Computable.const 3))).comp hj
  have hb:=map_apply hh.first (map_snd c (fin t ht))
  have left:=O.slotExpr hi hjn
  have right:=(O.fixed (.reg 1)).add (O.equationExpr hi)
  have base : O d (fun _ _=>.add (.reg 1) (.mul ((AExpr.reg 1).pow 3) (.const 2))) := O.fixed _
  exact ((O.choose hb left right).mul (base.pow hi)).sum_fin ht

lemma c_demandSignatureExpr : C MinUncut.Costed.SourceWords.signatureExpr := by
  let axes:=fin (P:=ℕ) id Computable.id
  let pos:=fin (P:=ℕ) (fun _=>3) (Computable.const 3)
  let c:=unitN.prod axes
  let d:=c.prod pos
  let e:=d.prod pos
  have hi : e.Out (fun _ x=>x.1.1.2.val) := (out_code axes).second.first.first
  have hp : e.Out (fun _ x=>x.1.2.val) := (out_code pos).second.first
  have hq : e.Out (fun _ x=>x.2.val) := (out_code pos).second
  have eqs := (O.slotExpr hi hp).eq (O.slotExpr hi hq)
  have powq := hq.map (ca_pow (Computable.const 2) Computable.id)
  have inner := (eqs.mul (O.const powq)).sum_fin (Computable.const 3)
  have pcode : d.Out (fun _ x=>x.2.val) := (out_code pos).second
  have powp := pcode.map (ca_pow (Computable.const (2^3)) Computable.id)
  have mid := (inner.mul (O.const powp)).sum_fin (Computable.const 3)
  have ii : c.Out (fun _ x=>x.2.val) := (out_code axes).second
  have outer := (mid.mul (O.const (ii.map (ca_pow (Computable.const ((2^3)^3)) Computable.id)))).sum_fin Computable.id
  have rhs := ((O.slotExpr ii (out_const c (Computable.const 3))).mul
    (O.const (ii.map (ca_pow (Computable.const 2) Computable.id)))).sum_fin Computable.id
  have co := O.const (out_const unitN (ca_pow (Computable.const ((2^3)^3)) Computable.id))
  exact (outer.add (co.mul rhs)).toC
lemma O.demandLookup {t : P → ℕ} (ht : Computable t)
    {f : ∀p,A p × Signature (Fin (t p)) → ℕ}
    (hf : (c.prod (Alphabet.signatures t ht)).Out f) :
    O c (fun p x=>MinUncut.Costed.SourceWords.signatureLookup (fun s=>f p (x,s))) :=
  (O.fromC (c_demandSignatureExpr.precomp ht)).lookup (out_constantTable hf)
end MinUncut.Preprocess.Syntax

end

end OAI