import Mathlib
import OAI.Computability.MinUncut.Estimates.CodeComputability

namespace OAI

section
namespace MinUncut.Costed
open Turing.ToPartrec

def addCode : Code := .prec .head (.comp .succ .tail)
def subCode : Code := .prec .head (.comp .pred .tail)

lemma run_add (n a : ℕ) (v : List ℕ) :
    Runs addCode (n::a::v) [a+n] (100000*(magnitude (n::a::v)+2)^2) := by
  let M := magnitude (n::a::v)
  have hn : n≤M := by dsimp [M]; omega
  have ha : a≤M := by dsimp [M]; omega
  have hv : magnitude (a::v)≤M := by dsimp [M]; omega
  have hr : ∀i≤n,a+i≤M := by intro i hi; dsimp [M]; omega
  have hg : ∀i<n, Runs (.comp .succ .tail) (i::(a+i)::a::v) [a+(i+1)] (200*(M+1)) := by
    intro i hi
    have hh := run_comp (run_tail (i::(a+i)::a::v)) (run_succ ((a+i)::a::v))
    have hri := hr i (by omega)
    apply hh.mono
    simp only [magnitude_cons] at *
    omega
  have hh := run_prec .head (.comp .succ .tail) n (fun i=>a+i) (a::v) M
    (300*(M+1)) (200*(M+1)) hn hr hv ((run_head (a::v)).mono (by gcongr)) hg
  apply hh.mono
  dsimp [M] at *
  nlinarith

lemma run_sub (n a : ℕ) (v : List ℕ) :
    Runs subCode (n::a::v) [a-n] (100000*(magnitude (n::a::v)+2)^2) := by
  let M := magnitude (n::a::v)
  have hn : n≤M := by dsimp [M]; omega
  have ha : a≤M := by dsimp [M]; omega
  have hv : magnitude (a::v)≤M := by dsimp [M]; omega
  have hr : ∀i≤n,a-i≤M := by intro i _; omega
  have hg : ∀i<n, Runs (.comp .pred .tail) (i::(a-i)::a::v) [a-(i+1)] (1000*(M+1)) := by
    intro i hi
    have hh := run_comp (run_tail (i::(a-i)::a::v)) (run_pred ((a-i)::a::v))
    have he : a-i-1=a-(i+1) := by omega
    simp only [List.headI_cons,he] at hh
    apply hh.mono
    simp only [magnitude_cons] at *
    omega
  have hh := run_prec .head (.comp .pred .tail) n (fun i=>a-i) (a::v) M
    (300*(M+1)) (1000*(M+1)) hn hr hv ((run_head (a::v)).mono (by gcongr)) hg
  apply hh.mono
  dsimp [M] at *
  nlinarith

def mulCode : Code := .prec .zero (.comp addCode .tail)

lemma run_mul (n a : ℕ) (v : List ℕ) :
    Runs mulCode (n::a::v) [a*n] (10000000*(magnitude (n::a::v)+2)^6) := by
  let S := magnitude (n::a::v)
  let M := (S+2)^2
  have hnS : n≤S := by dsimp [S]; omega
  have haS : a≤S := by dsimp [S]; omega
  have hvS : magnitude (a::v)≤S := by dsimp [S]; omega
  have hSM : S≤M := by dsimp [M]; nlinarith
  have hr : ∀i≤n,a*i≤M := by
    intro i hi
    have hh : a*i≤S*S := Nat.mul_le_mul haS (hi.trans hnS)
    dsimp [M]; nlinarith
  have hg : ∀i<n,Runs (.comp addCode .tail) (i::(a*i)::a::v) [a*(i+1)]
      (1000000*(M+2)^2) := by
    intro i hi
    have hh := run_comp (run_tail (i::(a*i)::a::v)) (run_add (a*i) a v)
    have he : a+a*i=a*(i+1) := by ring
    rw [he] at hh
    apply hh.mono
    have hri := hr i (by omega)
    simp only [magnitude_cons] at *
    have hinput : a*i+1+(a+1+magnitude v)≤M+1+S := by omega
    have hiM : i≤M := (Nat.le_of_lt hi).trans (hnS.trans hSM)
    calc
      _ ≤ 32*(M+1+(2*M+1)+1)+100000*(2*M+3)^2+1 := by
        have ht : i+1+(a*i+1+(a+1+magnitude v))+1 ≤
            M+1+(2*M+1)+1 := by omega
        have hc : a*i+1+(a+1+magnitude v)+2 ≤ 2*M+3 := by omega
        exact Nat.add_le_add_right (Nat.add_le_add (Nat.mul_le_mul_left 32 ht)
          (Nat.mul_le_mul_left 100000 (Nat.pow_le_pow_left hc 2))) 1
      _ ≤ _ := by ring_nf; omega
  have hh := run_prec .zero (.comp addCode .tail) n (fun i=>a*i) (a::v) M
    (210*(M+1)) (1000000*(M+2)^2) (hnS.trans hSM) hr (hvS.trans hSM)
    ((run_const_zero (a::v)).mono (by gcongr; exact hvS.trans hSM)) hg
  apply hh.mono
  change 210*(M+1)+(n+2)*(1000000*(M+2)^2+50000*(M+1))≤10000000*(S+2)^6
  calc
    _ ≤ 210*(M+1)+(S+2)*(1000000*(M+2)^2+50000*(M+1)) := by gcongr
    _ ≤ _ := by dsimp [M]; ring_nf; omega

end MinUncut.Costed

end

end OAI