import Mathlib
import OAI.Computability.MinUncut.Search.ArithmeticExpression

namespace OAI

section
noncomputable section
namespace MinUncut.Preprocess.Syntax
open MinUncut.Costed MinUncut.CodeEffective Turing.ToPartrec
lemma p_dropCode : Primrec dropCode := by
  have hh := Primrec.nat_rec₁ Code.id
    (primrec_comp.comp (Primrec.const Code.tail) Primrec.snd).to₂
  exact hh.of_eq (by intro n; induction n <;> simp_all only [Nat.rec_zero,dropCode])
lemma p_constCode : Primrec constCode := by
  have hh := Primrec.nat_rec₁ Code.zero
    (primrec_comp.comp (Primrec.const Code.succ) Primrec.snd).to₂
  exact hh.of_eq (by intro n; induction n <;> simp_all only [Nat.rec_zero,constCode])
lemma p_atCode : Primrec atCode := primrec_comp.comp (Primrec.const Code.head) p_dropCode

def bin (op a b : Code) : Code := .comp op (.cons a (.cons b .nil))
def branch (e a b : Code) : Code := .comp (.case a (.comp b .tail)) (.cons e .id)
lemma p_bin (op : Code) : Primrec₂ (bin op) :=
  primrec_comp.comp (Primrec.const op) (primrec_cons.comp Primrec.fst (primrec_cons.comp Primrec.snd (Primrec.const Code.nil)))
lemma p_branch : Primrec (fun p : Code × Code × Code=>branch p.1 p.2.1 p.2.2) :=
  primrec_comp.comp (primrec_case.comp (Primrec.fst.comp Primrec.snd)
    (primrec_comp.comp (Primrec.snd.comp Primrec.snd) (Primrec.const Code.tail)))
    (primrec_cons.comp Primrec.fst (Primrec.const Code.id))

def C {P : Type} [Primcodable P] (f : P → AExpr) : Prop :=
  Computable (fun p=>(f p).program.code)
variable {P : Type} [Primcodable P]
lemma C.fixed (a : AExpr) : C (fun _ : P=>a) := Computable.const _
lemma C.const {f : P → ℕ} (hf : Computable f) : C (fun p=>.const (f p)) := p_constCode.to_comp.comp hf
lemma C.reg {f : P → ℕ} (hf : Computable f) : C (fun p=>.reg (f p)) := p_atCode.to_comp.comp hf
lemma C.add {a b : P → AExpr} (ha : C a) (hb : C b) : C (fun p=>.add (a p) (b p)) :=
  (p_bin PolyProgram.add.code).to_comp.comp ha hb
lemma C.sub {a b : P → AExpr} (ha : C a) (hb : C b) : C (fun p=>.sub (a p) (b p)) :=
  (p_bin PolyProgram.sub.code).to_comp.comp ha hb
lemma C.mul {a b : P → AExpr} (ha : C a) (hb : C b) : C (fun p=>.mul (a p) (b p)) :=
  (p_bin PolyProgram.mul.code).to_comp.comp ha hb
lemma C.div {a b : P → AExpr} (ha : C a) (hb : C b) : C (fun p=>.div (a p) (b p)) :=
  (p_bin Division.quotient.code).to_comp.comp ha hb
lemma C.mod {a b : P → AExpr} (ha : C a) (hb : C b) : C (fun p=>.mod (a p) (b p)) :=
  (p_bin Division.remainder.code).to_comp.comp ha hb
lemma cond_code (e a b : AExpr) :
    (.cond e a b : AExpr).program.code = branch e.program.code a.program.code b.program.code := rfl
lemma C.cond {e a b : P → AExpr} (he : C e) (ha : C a) (hb : C b) : C (fun p=>.cond (e p) (a p) (b p)) := by
  have hh := p_branch.to_comp.comp (he.pair (ha.pair hb))
  exact hh.of_eq (fun p=>(cond_code (e p) (a p) (b p)).symm)
attribute [local irreducible] PolyProgram.add PolyProgram.sub PolyProgram.mul
lemma eqOf_code {f g : List ℕ → List ℕ} (F : PolyProgram f) (G : PolyProgram g) :
    (PolyProgram.eqOf F G).code =
      branch (bin PolyProgram.add.code (bin PolyProgram.sub.code F.code G.code)
        (bin PolyProgram.sub.code G.code F.code)) (constCode 1) (constCode 0) := rfl
lemma eq_code (a b : AExpr) :
    (.eq a b : AExpr).program.code =
      branch (bin PolyProgram.add.code (bin PolyProgram.sub.code a.program.code b.program.code)
        (bin PolyProgram.sub.code b.program.code a.program.code)) (constCode 1) (constCode 0) :=
  eqOf_code a.program b.program
lemma le_code (a b : AExpr) :
    (.le a b : AExpr).program.code =
      branch (bin PolyProgram.sub.code a.program.code b.program.code) (constCode 1) (constCode 0) := rfl
lemma at_code (a : AExpr) : (.at a : AExpr).program.code =
    Code.comp PolyProgram.dynamic.code (Code.cons a.program.code Code.id) := rfl
lemma C.eq {a b : P → AExpr} (ha : C a) (hb : C b) : C (fun p=>.eq (a p) (b p)) := by
  have hh := p_branch.to_comp.comp
    (((p_bin PolyProgram.add.code).to_comp.comp
      ((p_bin PolyProgram.sub.code).to_comp.comp ha hb)
      ((p_bin PolyProgram.sub.code).to_comp.comp hb ha)).pair
      ((Computable.const (constCode 1)).pair (Computable.const (constCode 0))))
  exact hh.of_eq (fun p=>(eq_code (a p) (b p)).symm)
lemma C.le {a b : P → AExpr} (ha : C a) (hb : C b) : C (fun p=>.le (a p) (b p)) := by
  have hh := p_branch.to_comp.comp
    (((p_bin PolyProgram.sub.code).to_comp.comp ha hb).pair
      ((Computable.const (constCode 1)).pair (Computable.const (constCode 0))))
  exact hh.of_eq (fun p=>(le_code (a p) (b p)).symm)
lemma C.at {a : P → AExpr} (ha : C a) : C (fun p=>.at (a p)) := by
  have hh := computable_comp.comp (Computable.const PolyProgram.dynamic.code)
    (computable_cons.comp ha (Computable.const Code.id))
  exact hh.of_eq (fun p=>(at_code (a p)).symm)
lemma powCode_eq (a : AExpr) (n : ℕ) :
    Nat.rec (AExpr.const 1).program.code (fun _ ih=>bin PolyProgram.mul.code ih a.program.code) n =
      (a.pow n).program.code := by
  induction n with
  | zero => rfl
  | succ n ih =>
    change bin _ (Nat.rec _ _ n) _ = _
    rw [ih]; rfl
lemma C.pow {a : P → AExpr} {n : P → ℕ} (ha : C a) (hn : Computable n) : C (fun p=>(a p).pow (n p)) := by
  have hh := Computable.nat_rec (σ:=Code) hn (Computable.const (AExpr.const 1).program.code)
    ((p_bin PolyProgram.mul.code).to_comp.comp (Computable.snd.comp Computable.snd)
      (ha.comp Computable.fst)).to₂
  exact hh.of_eq (fun p=>powCode_eq (a p) (n p))

def sumCode (cs : List Code) : Code := cs.foldr (bin PolyProgram.add.code) (AExpr.const 0).program.code
lemma p_sumCode : Primrec sumCode :=
  Primrec.list_foldr Primrec.id (Primrec.const _) ((p_bin _).comp (Primrec.fst.comp Primrec.snd) (Primrec.snd.comp Primrec.snd)).to₂
lemma sumCode_eq (as : List AExpr) : sumCode (as.map (fun a=>a.program.code))=(AExpr.sum as).program.code := by
  induction as with
  | nil => rfl
  | cons a as ih => simp only [sumCode,List.map_cons,List.foldr_cons] at *; rw [ih]; rfl
lemma C.sum {as : P → List AExpr} (h : Computable (fun p=>(as p).map (fun a=>a.program.code))) : C (fun p=>AExpr.sum (as p)) :=
  (p_sumCode.to_comp.comp h).of_eq (fun p=>sumCode_eq (as p))
end MinUncut.Preprocess.Syntax

end
end

end OAI