import OAI.Computability.RationalHitting.UnaryArithmetic

namespace OAI

namespace RationalHitting.StackLanguage
open Function

def chooseClean : Program (Fin 18) := .seq Binomial.choose (.seq (clear 14) (clear 15))

lemma eval_chooseClean (n k : ℕ) : ∃ t≤4000000*(n+k+1)^10,
    Eval chooseClean (both (14 : Fin 18) 15 (unaryCode n) (unaryCode k))
      (single 0 (n.choose k).bits) t := by
  obtain ⟨t,ht,he⟩ := Binomial.eval_choose_polynomial n k
  have hin : Binomial.input n k=both (14:Fin 18) 15 (unaryCode n) (unaryCode k) := rfl
  let s := update (Binomial.input n k) 0 (n.choose k).bits
  have e1 := eval_clear (14:Fin 18) s
  have e2 := eval_clear (15:Fin 18) (update s 14 [])
  have hout : update (update s 14 []) 15 []=single 0 (n.choose k).bits := by
    funext j;fin_cases j <;> simp [s,Binomial.input,single]
  rw [hout] at e2
  have hcat := Eval.seq he (Eval.seq e1 e2)
  have hn : (s 14).length=n := by simp [s,Binomial.input]
  have hk : ((update s 14 []) 15).length=k := by simp [s,Binomial.input]
  rw [hn] at e1
  rw [hk] at e2
  refine ⟨1+t+(1+(2*n+1)+(2*k+1)),?_,?_⟩
  · have hp : n+k+1≤(n+k+1)^10 := Nat.le_self_pow (by omega) _
    omega
  · simpa only [chooseClean,hin,hn,hk] using hcat

namespace Procedure

def choose : Procedure (pairCode unaryCode unaryCode) Nat.bits (fun a => a.1.choose a.2) :=
  fromBinary chooseClean 14 15 0 (by decide) (4000000*TimeBound.variable^10)
    (by intro a b;simpa using eval_chooseClean a b)
    (by
      intro n k
      have h := nat_bits_mono (Nat.choose_le_two_pow n k)
      simp only [Nat.size_eq_bits_len,Nat.size_pow] at h
      have hp : n+k+1≤(n+k+1)^10 := Nat.le_self_pow (by omega) _
      simp only [TimeBound.eval_mul,TimeBound.eval_numeral,TimeBound.eval_pow,
        TimeBound.eval_variable,unaryCode_length,Nat.size_eq_bits_len]
      omega)

end Procedure
namespace Poly
@[fun_prop] theorem choose : Poly (fun a : Unary×Unary => a.1.val.choose a.2.val) :=
  (show Feasible (pairCode unaryCode unaryCode) Nat.bits (fun a : ℕ×ℕ => a.1.choose a.2) from
    ⟨Procedure.choose⟩).recode _ _ _ (fun a => (a.1.val,a.2.val))
      (by intro a;rfl) (by intro a;rfl)
end Poly
end RationalHitting.StackLanguage


namespace RationalHitting.StackLanguage
open Function

variable {K : Type} [DecidableEq K]

def unpackInt (a sg : K) : Program K := .seq (.drop a) (.seq (.transfer a sg) (.drop a))

lemma eval_unpackInt {a sg : K} (has : a≠sg) (s : Store K) (z : ℤ) (hz : s a=intCode z) :
    Eval (unpackInt a sg) s (update (update s a z.natAbs.bits) sg (decide (z<0)::s sg)) 5 := by
  have h : s a=false::decide (z<0)::true::z.natAbs.bits := hz
  let u := update s a (decide (z<0)::true::z.natAbs.bits)
  let v := update (update s a (true::z.natAbs.bits)) sg (decide (z<0)::s sg)
  have e1 : Eval (.drop a) s u 1 := by simpa [u,h] using Eval.drop a s
  have e2 : Eval (.transfer a sg) u v 1 := by
    simpa [transfer_cons has u (decide (z<0)) (true::z.natAbs.bits) (by simp [u]),u,v,has.symm] using
      Eval.transfer a sg u
  have e3 : Eval (.drop a) v (update (update s a z.natAbs.bits) sg (decide (z<0)::s sg)) 1 := by
    have he := Eval.drop a v
    convert he using 1
    funext k;by_cases ha : k=a <;> by_cases hs : k=sg <;> simp_all [v]
  exact Eval.seq e1 (Eval.seq e2 e3)

def rationalClean : Program (Fin 16) := .seq (unpackInt 0 12) (.seq (unpackInt 5 13)
  (.seq rationalEncode (.seq (clear 12) (clear 13))))

abbrev NZInt := {z : ℤ // z≠0}

lemma eval_rationalClean (a : ℤ) (b : NZInt) : ∃ t≤4000*(a.natAbs.bits.length+b.val.natAbs.bits.length+8)^3,
    Eval rationalClean (both (0:Fin 16) 5 (intCode a) (intCode b.val))
      (single 14 (encodeRat (Rat.divInt a b.val))) t := by
  let s := both (0:Fin 16) 5 (intCode a) (intCode b.val)
  let u := update (update s 0 a.natAbs.bits) 12 [decide (a<0)]
  let v := update (update u 5 b.val.natAbs.bits) 13 [decide (b.val<0)]
  have e1 : Eval (unpackInt 0 12) s u 5 := by
    simpa [s,u,both,single] using eval_unpackInt (a:=(0:Fin 16)) (sg:=12) (by decide) s a (by simp [s,both,single])
  have e2 : Eval (unpackInt 5 13) u v 5 := by
    simpa [v,u,s,both,single] using eval_unpackInt (a:=(5:Fin 16)) (sg:=13) (by decide) u b.val
      (by simp [u,s,both,single])
  obtain ⟨t,ht,he⟩ := eval_rationalEncode v a b.val b.property
    (by simp [v,u,s,both,single]) (by simp [v]) (by simp [v,u]) (by simp [v])
    (by simp [v,u,s,both,single])
    (by intro i hi h0 h5;simp [v,u,s,both,single,h0,h5,show i≠12 by omega,show i≠13 by omega])
    (a.natAbs.bits.length+b.val.natAbs.bits.length+1) (by omega) (by omega)
  let w := update (update (update v 0 []) 5 []) 14 (encodeRat (Rat.divInt a b.val))
  have e3 : Eval rationalEncode v w t := by simpa [w,v,u,s,both,single] using he
  have e4 : Eval (clear 12) w (update w 12 []) 3 := by simpa [w,v,u] using eval_clear (12:Fin 16) w
  have ho : update (update w 12 []) 13 []=single 14 (encodeRat (Rat.divInt a b.val)) := by
    funext k;fin_cases k <;> simp [w,v,u,s,both,single]
  have e5 : Eval (clear 13) (update w 12 []) (single 14 (encodeRat (Rat.divInt a b.val))) 3 := by
    have hh := eval_clear (13:Fin 16) (update w 12 [])
    rw [ho] at hh
    simpa [w,v] using hh
  refine ⟨1+5+(1+5+(1+t+(1+3+3))),?_,Eval.seq e1 (Eval.seq e2 (Eval.seq e3 (Eval.seq e4 e5)))⟩
  have hp : (a.natAbs.bits.length+b.val.natAbs.bits.length+2)^3≤
      (a.natAbs.bits.length+b.val.natAbs.bits.length+8)^3 := by gcongr ; omega
  have hp0 : 1≤(a.natAbs.bits.length+b.val.natAbs.bits.length+8)^3 := by
    have hpos : 0<(a.natAbs.bits.length+b.val.natAbs.bits.length+8)^3 := by positivity
    omega
  simp only [Nat.add_assoc,Nat.reduceAdd] at ht hp hp0 ⊢
  omega

namespace Procedure

def rationalEncode : Procedure (pairCode intCode (fun b : NZInt => intCode b.val)) _root_.id
    (fun a => encodeRat (Rat.divInt a.1 a.2.val)) :=
  fromBinary rationalClean 0 5 14 (by decide) (4000*(TimeBound.variable+1)^3)
    (by intro a b;simpa only [intCode_length,TimeBound.eval_mul,TimeBound.eval_numeral,
      TimeBound.eval_pow,TimeBound.eval_add,TimeBound.eval_variable,Nat.add_assoc,Nat.add_left_comm,Nat.add_comm,Nat.reduceAdd,id_eq] using eval_rationalClean a b)
    (by
      intro a b
      let L := a.natAbs.bits.length+b.val.natAbs.bits.length+1
      have ha : a.natAbs.size≤L := by rw [←Nat.size_eq_bits_len];dsimp [L];omega
      have hb : b.val.natAbs.size≤L := by rw [←Nat.size_eq_bits_len];dsimp [L];omega
      have hh := EncodingBounds.encodeRat_ratio_le a b.val b.property L (Nat.size_le.mp ha) (Nat.size_le.mp hb)
      have hp : L+7≤(L+7)^3 := Nat.le_self_pow (by decide) _
      simp only [intCode_length,TimeBound.eval_mul,TimeBound.eval_numeral,TimeBound.eval_pow,
        TimeBound.eval_add,TimeBound.eval_variable,id_eq]
      dsimp [L] at hh hp
      simp only [Nat.add_assoc,Nat.add_left_comm,Nat.add_comm,Nat.reduceAdd] at hp ⊢
      omega)
end Procedure
namespace Poly
@[fun_prop] theorem rationalEncodeNZ : Poly (fun a : ℤ×NZInt => BitWord.mk (encodeRat (Rat.divInt a.1 a.2.val))) :=
  (show Feasible (pairCode intCode (fun b : NZInt => intCode b.val)) _root_.id
    (fun a : ℤ×NZInt => encodeRat (Rat.divInt a.1 a.2.val)) from
      ⟨Procedure.rationalEncode⟩).recode _ _ _ _root_.id (by intro a;rfl) (by intro a;rfl)

@[fun_prop] theorem safeDen : Poly (fun b : ℤ => (⟨if b=0 then 1 else b,by split_ifs with h <;> simp_all⟩ : NZInt)) := by
  have hh := intZero.cond (const (1:ℤ)) (show Poly (fun b : ℤ => b) from id)
  have hh' : Poly (fun b : ℤ => if b=0 then 1 else b) := hh.of_eq (by intro b;simp)
  exact hh'.subtypeMk _

@[fun_prop] theorem rationalEncode : Poly (fun a : ℤ×ℤ => BitWord.mk (encodeRat (Rat.divInt a.1 a.2))) := by
  have hz := intZero.comp (show Poly (Prod.snd : ℤ×ℤ → ℤ) from snd)
  have hn := rationalEncodeNZ.comp ((show Poly (Prod.fst : ℤ×ℤ → ℤ) from fst).pair
    (safeDen.comp (show Poly (Prod.snd : ℤ×ℤ → ℤ) from snd)))
  exact (hz.cond (const (BitWord.mk (encodeRat 0))) hn).of_eq (by
    intro a
    by_cases h : a.2=0
    · simp [h,Rat.divInt_eq_div]
    · simp [h])
end Poly
end RationalHitting.StackLanguage


namespace RationalHitting.StackLanguage
namespace Poly
variable {A B : Type} [Coding A] [Coding B]

theorem unaryEta {f : A → Unary} (hf : Poly f) :
    Poly (fun a => Unary.mk (f a).val) := hf

theorem unaryAddFun {f g : A → ℕ}
    (hf : Poly (fun a => Unary.mk (f a))) (hg : Poly (fun a => Unary.mk (g a))) :
    Poly (fun a => Unary.mk (f a+g a)) := unaryAdd.comp (hf.pair hg)
theorem unarySubFun {f g : A → ℕ}
    (hf : Poly (fun a => Unary.mk (f a))) (hg : Poly (fun a => Unary.mk (g a))) :
    Poly (fun a => Unary.mk (f a-g a)) := unarySub.comp (hf.pair hg)
theorem unaryMulFun {f g : A → ℕ}
    (hf : Poly (fun a => Unary.mk (f a))) (hg : Poly (fun a => Unary.mk (g a))) :
    Poly (fun a => Unary.mk (f a*g a)) := unaryMul.comp (hf.pair hg)
theorem unaryDivFun {f g : A → ℕ}
    (hf : Poly (fun a => Unary.mk (f a))) (hg : Poly (fun a => Unary.mk (g a))) :
    Poly (fun a => Unary.mk (f a/g a)) := unaryDiv.comp (hf.pair hg)
theorem unaryModFun {f g : A → ℕ}
    (hf : Poly (fun a => Unary.mk (f a))) (hg : Poly (fun a => Unary.mk (g a))) :
    Poly (fun a => Unary.mk (f a%g a)) := unaryMod.comp (hf.pair hg)
theorem unaryPowFun {f : A → ℕ} (k : ℕ)
    (hf : Poly (fun a => Unary.mk (f a))) : Poly (fun a => Unary.mk (f a^k)) :=
  (unaryPow k).comp hf
@[fun_prop] theorem unaryCastInt : Poly (fun a : Unary => (a.val : ℤ)) :=
  natCastInt.comp unaryToNat

theorem unaryCastIntFun {f : A → ℕ}
    (hf : Poly (fun a => Unary.mk (f a))) : Poly (fun a => (f a : ℤ)) := unaryCastInt.comp hf
theorem unaryEqFun {f g : A → ℕ}
    (hf : Poly (fun a => Unary.mk (f a))) (hg : Poly (fun a => Unary.mk (g a))) :
    Poly (fun a => decide (f a=g a)) := unaryEq.comp (hf.pair hg)
theorem unaryLtFun {f g : A → ℕ}
    (hf : Poly (fun a => Unary.mk (f a))) (hg : Poly (fun a => Unary.mk (g a))) :
    Poly (fun a => decide (f a<g a)) := unaryLt.comp (hf.pair hg)
theorem chooseFun {f g : A → ℕ}
    (hf : Poly (fun a => Unary.mk (f a))) (hg : Poly (fun a => Unary.mk (g a))) :
    Poly (fun a => (f a).choose (g a)) := choose.comp (hf.pair hg)
theorem intPowFun {f : A → ℤ} {g : A → ℕ}
    (hf : Poly f) (hg : Poly (fun a => Unary.mk (g a))) :
    Poly (fun a => f a ^ g a) := intPow.comp (hf.pair hg)

 theorem ite {c : A → Prop} [DecidablePred c] {f g : A → B}
    (hc : Poly (fun a => decide (c a))) (hf : Poly f) (hg : Poly g) :
    Poly (fun a => if c a then f a else g a) :=
  (hc.cond hf hg).of_eq (by intro a;simp)

 theorem sumUp {n : A → ℕ} {f : A×Unary → ℤ}
    (hn : Poly (fun a => Unary.mk (n a))) (hf : Poly f) :
    Poly (fun a => ((List.range (n a)).map (fun i => f (a,⟨i⟩))).sum) :=
  hf.sumRange.comp (hn.pair (show Poly (fun a : A => a) from id))

end Poly

namespace Unary
instance (n : ℕ) : OfNat Unary n := ⟨⟨n⟩⟩
instance : Add Unary := ⟨fun a b => ⟨a.val+b.val⟩⟩
instance : Sub Unary := ⟨fun a b => ⟨a.val-b.val⟩⟩
instance : Mul Unary := ⟨fun a b => ⟨a.val*b.val⟩⟩
instance : Div Unary := ⟨fun a b => ⟨a.val/b.val⟩⟩
instance : Mod Unary := ⟨fun a b => ⟨a.val%b.val⟩⟩
instance : Pow Unary ℕ := ⟨fun a b => ⟨a.val^b⟩⟩
def toInt (a : Unary) : ℤ := a.val
def choose (a b : Unary) : ℤ := a.val.choose b.val
def powInt (a : ℤ) (b : Unary) : ℤ := a^b.val
def eqb (a b : Unary) : Bool := decide (a.val=b.val)
def ltb (a b : Unary) : Bool := decide (a.val<b.val)
end Unary

namespace Poly
@[fun_prop] theorem uAdd : Poly (fun a : Unary×Unary => a.1+a.2) := unaryAdd
@[fun_prop] theorem uSub : Poly (fun a : Unary×Unary => a.1-a.2) := unarySub
@[fun_prop] theorem uMul : Poly (fun a : Unary×Unary => a.1*a.2) := unaryMul
@[fun_prop] theorem uDiv : Poly (fun a : Unary×Unary => a.1/a.2) := unaryDiv
@[fun_prop] theorem uMod : Poly (fun a : Unary×Unary => a.1%a.2) := unaryMod
@[fun_prop] theorem uPow (k : ℕ) : Poly (fun a : Unary => a^k) := unaryPow k
@[fun_prop] theorem uInt : Poly Unary.toInt := unaryCastInt
@[fun_prop] theorem uChoose : Poly (fun a : Unary×Unary => Unary.choose a.1 a.2) :=
  natCastInt.comp choose
@[fun_prop] theorem uPowInt : Poly (fun a : ℤ×Unary => Unary.powInt a.1 a.2) := intPow
@[fun_prop] theorem uEq : Poly (fun a : Unary×Unary => Unary.eqb a.1 a.2) := unaryEq
@[fun_prop] theorem uLt : Poly (fun a : Unary×Unary => Unary.ltb a.1 a.2) := unaryLt

example : Poly (fun a : Unary×Unary => Unary.mk (2*(a.1.val+1)^3*(2*a.2.val+1))) := by
  change Poly (fun a : Unary×Unary => 2*(a.1+1)^3*(2*a.2+1))
  fun_prop
example : Poly (fun a : Unary×Unary => (a.1.val : ℤ)^a.2.val) := by
  change Poly (fun a : Unary×Unary => Unary.powInt a.1.toInt a.2)
  fun_prop
end Poly
end RationalHitting.StackLanguage

end OAI