import OAI.Computability.WeisfeilerLeman.RAMSimulation

namespace OAI

universe uK uX

namespace WLTime.TypedStack.Code
variable {K : Type uK} {X : Type uX} [DecidableEq K]
abbrev HaltState (c : Code K X) := c.State ⊕ Unit
def haltTransition (c : Code K X) (answer : Tops K X → Bool) :
    HaltState c → Tops K X → Command K X (HaltState c)
  | .inl q,v => Command.redirect Sum.inl (.inr ()) (c.transition q v)
  | .inr _,v => .halt (answer v)
def haltMachine (c : Code K X) (input : K) (letter : Bool → X) (answer : Tops K X → Bool) :
    Machine K X (HaltState c) where
  inputStack := input
  inputLetter := letter
  initial := .inl c.entry
  transition := haltTransition c answer
 theorem haltMachine_run (c : Code K X) (input : K) (letter : Bool → X) (answer : Tops K X → Bool)
    (w : List Bool) {t out} (h : c.Exec (fun r => if r=input then w.map letter else []) t out) :
    ((haltMachine c input letter answer).run w (t+1)).state=.inl (answer (tops out)) := by
  have he := (exec_finite h).plug Sum.inl (.inr ()) (fun _ _ => rfl)
    (Execution.halt (tr:=haltTransition c answer) (q:=.inr ()) (s:=out) rfl)
  exact congrArg Config.state (he.iterate (haltMachine c input letter answer))
variable [Fintype K] [Fintype X]
noncomputable def haltOneTape (c : Code K X) (input : K) (letter : Bool → X) (answer : Tops K X → Bool) : OneTape :=
  (haltMachine c input letter answer).compile.oneTape
 theorem haltOneTape_correct (c : Code K X) (input : K) (letter : Bool → X) (answer : Tops K X → Bool)
    (w : List Bool) {t out} (h : c.Exec (fun r => if r=input then w.map letter else []) t out) :
    (haltOneTape c input letter answer).toTM.halts w ∧
    (haltOneTape c input letter answer).toTM.time w≤8*(Fintype.card K+1)*(w.length+t+2)^2 ∧
    ((haltOneTape c input letter answer).toTM.accepts w ↔ answer (tops out)=true) := by
  have hr := haltMachine_run c input letter answer w h
  have he := (haltMachine c input letter answer).oneTape_correct w (t+1) (answer (tops out)) hr
  simpa only [haltOneTape,show w.length+(t+1)+1=w.length+t+2 by omega] using he
end WLTime.TypedStack.Code

namespace WLTime.RAMAlphabet
open scoped Classical
noncomputable section
variable (A : RAM)
def budgetConstant : ℕ := 100*(A.registers+1)+constant A*depth A*(depth A+1)+A.locations+2
 theorem budget_bound (w len time : ℕ) :
    budget A w len time≤budgetConstant A*(w+1)^exponent A*(len+time+1)^2 := by
  let W := (w+1)^exponent A
  let X := len+time+1
  have he : 1≤exponent A := by unfold exponent; omega
  have hw : w+1≤W := by simpa only [pow_one] using Nat.pow_le_pow_right (by omega : 0<w+1) he
  have hW : 1≤W := by omega
  have hX : 1≤X := by dsimp [X]; omega
  have ht : time≤X := by dsimp [X]; omega
  have hl : len+1≤X := by dsimp [X]; omega
  have hXX : X≤X^2 := Nat.le_self_pow (by decide) X
  have hi : initBound A w len≤100*(A.registers+1)*W*X^2 := by
    exact (Nat.mul_le_mul (Nat.mul_le_mul_left _ hw) hl).trans (Nat.mul_le_mul_left _ hXX)
  have hc := unitCost_bound A w
  have hL : len+time*depth A+depth A+1≤(depth A+1)*X := by dsimp [X]; nlinarith
  have hs : stepBound A w (len+time*depth A)≤constant A*W*depth A*((depth A+1)*X)+A.locations := by
    unfold stepBound
    exact Nat.add_le_add_right (Nat.mul_le_mul (Nat.mul_le_mul_right _ hc) hL) _
  have hremain : (stepBound A w (len+time*depth A)+1)*time+1≤
      (constant A*depth A*(depth A+1)+A.locations+2)*W*X^2 := by
    have hz : stepBound A w (len+time*depth A)+1≤
        (constant A*depth A*(depth A+1)+A.locations+1)*W*X := by
      have hWX : 1≤W*X := Nat.mul_le_mul hW hX
      have hP := Nat.mul_le_mul_left (A.locations+1) hWX
      nlinarith only [hs,hP]
    have hmul := Nat.mul_le_mul hz ht
    have hWX2 : 1≤W*X^2 := Nat.mul_le_mul hW (one_le_pow₀ hX)
    nlinarith only [hmul,hWX2]
  dsimp only [budget,budgetConstant]
  change initBound A w len+(stepBound A w (len+time*depth A)+1)*time+1≤
    (100*(A.registers+1)+constant A*depth A*(depth A+1)+A.locations+2)*W*X^2
  nlinarith only [hi,hremain]
end
end WLTime.RAMAlphabet

namespace WLTime.TypedStack.Code
theorem Exec.of_decEq {K : Type uK} {X : Type uX} {i j : DecidableEq K} {c : Code K X} {s t out}
    (h : @Exec K X i c s t out) : @Exec K X j c s t out := by
  have he : i=j := Subsingleton.elim _ _
  cases he
  exact h
end WLTime.TypedStack.Code

namespace WLTime.RAMConsumer
open TypedStack
noncomputable section
variable {K : Type uK} [DecidableEq K] (A : RAM)
abbrev Reg (K : Type uK) := K ⊕ RAMAlphabet.Reg A
abbrev Letter := RAMAlphabet.Letter A
local instance : DecidableEq (RAMAlphabet.Reg A) := Classical.decEq _
local instance : DecidableEq (Letter A) := Classical.decEq _
def prelude (c : Code K Bool) (output : K) : Code (Reg A K) (Letter A) :=
  .seq ((c.mapLetters Sum.inl (RAMAlphabet.decode A)).relabel Sum.inl)
    (.transfer (.inl output) (.inr (.inl 0)) (.inl false))
def code (c : Code K Bool) (output : K) (w : ℕ) : Code (Reg A K) (Letter A) :=
  .seq (prelude A c output) ((RAMAlphabet.program A w).relabel Sum.inr)
def answer (v : Tops (Reg A K) (Letter A)) : Bool :=
  !((v (.inr (.inl 13))).map (RAMAlphabet.decode A)).getD false
 theorem prefix_exec (c : Code K Bool) (output : K) {s t out} (h : c.Exec s t out)
    (ys : List Bool) (ho : out output=ys.reverse) :
    (prelude A c output).Exec (Sum.elim (Code.listMap Sum.inl s) (fun _ => []))
      (t+(5*ys.length+1))
      (Sum.elim (Function.update (Code.listMap Sum.inl out) output []) (RAMAlphabet.inputState A ys)) := by
  have hc := Code.relabel_inl_exec
    (Code.mapLetters_exec Sum.inl (RAMAlphabet.decode A) (by intro b; rfl) h) (fun _ : RAMAlphabet.Reg A => [])
  have ht := Code.transfer_exec (Sum.inl output) (Sum.inr (.inl 0 : RAMAlphabet.Reg A)) (by simp)
    (.inl false : Letter A) (Sum.elim (Code.listMap Sum.inl out) (fun _ : RAMAlphabet.Reg A => []))
  have hf := Code.Exec.seq hc ht
  simp only [Sum.elim_inl,Sum.elim_inr] at hf
  have he : Function.update
      (Function.update (Sum.elim (Code.listMap Sum.inl out) (fun _ : RAMAlphabet.Reg A => [])) (.inl output) [])
        (.inr (.inl 0)) (((Code.listMap Sum.inl out) output).reverse++[])=
      Sum.elim (Function.update (Code.listMap Sum.inl out) output []) (RAMAlphabet.inputState A ys) := by
    funext r
    cases r with
    | inl r =>
      rw [Function.update_of_ne (show (Sum.inl r : Reg A K)≠.inr (.inl 0) from Sum.inl_ne_inr)]
      simp only [Function.update_apply,Sum.inl.injEq,Sum.elim_inl]
    | inr r =>
      simp only [Function.update_apply,Sum.inr.injEq,Sum.inr_ne_inl,ite_false,Sum.elim_inr,
        RAMAlphabet.inputState,Code.listMap,ho,List.map_reverse,List.reverse_reverse,List.append_nil]
      by_cases hr : r=(.inl 0 : RAMAlphabet.Reg A)
      · simp only [ite_eq_left hr]
      · simp only [ite_eq_right hr]
  rw [he] at hf
  simpa only [prelude,Code.listMap,Sum.elim_inl,Sum.elim_inr,ho,List.length_map,List.length_reverse] using hf
 theorem code_exec (c : Code K Bool) (input output : K) (n : ℕ) (w ys : List Bool)
    {t out} (he : c.Exec (fun r => if r=input then w else []) t out) (ho : out output=ys.reverse)
    (hfit : ys.length ≤ A.width.bits n*2^(A.width.bits n)) (hh : A.halts n ys) :
    ∃u  ≤ t+5*ys.length+RAMAlphabet.budget A (A.width.bits n) ys.length (A.time n ys)+1,∃last b,
      (code A c output (A.width.bits n)).Exec (fun r => if r=.inl input then w.map Sum.inl else []) u last ∧
      answer A (tops last)=(!b) ∧ (b=true ↔ A.accepts n ys) := by
  obtain ⟨v,hv,b,last,hg,ha,hb⟩ := RAMAlphabet.program_exec A n ys hfit hh
  have hg' : (RAMAlphabet.program A (A.width.bits n)).Exec (RAMAlphabet.inputState A ys) v last := Code.Exec.of_decEq hg
  have hf := Code.Exec.seq (prefix_exec A c output he ys ho)
    (Code.relabel_inr_exec hg'  (Function.update (Code.listMap Sum.inl out) output []))
  have hs : Sum.elim (Code.listMap (Sum.inl : Bool → Letter A) (fun r => if r=input then w else []))
      (fun _ : RAMAlphabet.Reg A => [])=(fun r => if r=.inl input then w.map Sum.inl else []) := by
    funext r
    cases r with
    | inl r =>
      by_cases hr : r=input
      · simp only [Code.listMap,Sum.elim_inl,Sum.inl.injEq,ite_eq_left hr]
      · simp only [Code.listMap,Sum.elim_inl,Sum.inl.injEq,ite_eq_right hr,List.map_nil]
    | inr r => simp only [Sum.elim_inr,Sum.inr_ne_inl,ite_false]
  rw [hs] at hf
  refine ⟨t+(5*ys.length+1)+v,by omega,_,b,hf,?_,hb⟩
  simp only [answer,tops,Sum.elim_inr,ha,List.head?_cons,Option.map_some,Option.getD_some,RAMAlphabet.decode]
variable [Fintype K]
def oneTape (c : Code K Bool) (input output : K) (n : ℕ) : OneTape :=
  (code A c output (A.width.bits n)).haltOneTape (.inl input) Sum.inl (answer A)
 theorem correct (c : Code K Bool) (input output : K) (n : ℕ) (w ys : List Bool)
    {t out} (he : c.Exec (fun r => if r=input then w else []) t out) (ho : out output=ys.reverse)
    (hfit : ys.length ≤ A.width.bits n*2^(A.width.bits n)) (hh : A.halts n ys) :
    (oneTape A c input output n).toTM.halts w ∧
    (oneTape A c input output n).toTM.time w ≤
      8*(Fintype.card K+Fintype.card (RAMAlphabet.Reg A)+1)*
        (w.length+t+5*ys.length+RAMAlphabet.budget A (A.width.bits n) ys.length (A.time n ys)+3)^2 ∧
    ((oneTape A c input output n).toTM.accepts w ↔ ¬A.accepts n ys) := by
  obtain ⟨u,hu,last,b,hc,ha,hb⟩ := code_exec A c input output n w ys he ho hfit hh
  obtain ⟨ht,htime,hans⟩ := Code.haltOneTape_correct (code A c output (A.width.bits n)) (.inl input) Sum.inl (answer A) w hc
  refine ⟨ht,htime.trans ?_,hans.trans ?_⟩
  · simp only [Reg,Fintype.card_sum]
    exact Nat.mul_le_mul_left _ (Nat.pow_le_pow_left (by omega) 2)
  · rw [ha]
    cases b <;> simp_all
 omit [DecidableEq K] [Fintype K] in
 theorem code_size (c : Code K Bool) (output : K) (w : ℕ) :
    (code A c output w).controlSize=c.controlSize+(RAMAlphabet.program A w).controlSize+5 := by
  simp only [code,prelude,Code.controlSize,Code.relabel_controlSize,Code.mapLetters_controlSize,Code.transfer]
  omega
end
end WLTime.RAMConsumer

namespace WLTime.OneTape.Symbolic.RAMWriter
open TypedStack
open scoped Classical
noncomputable section
variable (U : OneTape) (d q : ℕ) (A : RAM)
def consumer (n : ℕ) : OneTape :=
  RAMConsumer.oneTape A (FullWriter.program U d q n).code (.inr FullWriter.Reg.word) (.inr FullWriter.Reg.output) n
def consumerFactor : ℕ := 8*(FullWriter.scratchBound U d q+4+Fintype.card (RAMAlphabet.Reg A)+1)
 theorem correct (n : ℕ) (w : List Bool) (hm : 1 ≤ w.length) (hr : 2 ≤ d+q)
    (hn : baseOrder U d q w.length ≤ n)
    (ys : List Bool) (hys : ys=encodePair (pairGraph U d q hr w (n-baseOrder U d q w.length) 0)
      (pairGraph U d q hr w (n-baseOrder U d q w.length) 1))
    (hh : A.halts n ys) :
    (consumer U d q A n).toTM.halts w ∧
    (consumer U d q A n).toTM.time w ≤ consumerFactor U d q A*
      (w.length+FullWriter.budget U d q n w.length+5*ys.length+
        RAMAlphabet.budget A (A.width.bits n) ys.length (A.time n ys)+3)^2 ∧
    ((consumer U d q A n).toTM.accepts w ↔ ¬A.accepts n ys) := by
  have hgn : (listing U d q (d+q+2) w (n-baseOrder U d q w.length)).items.length=n := by
    rw [listing_length,Nat.add_sub_of_le hn]
  have hfit := A.input_fits _ (pairGraph U d q hr w (n-baseOrder U d q w.length) 0)
    (pairGraph U d q hr w (n-baseOrder U d q w.length) 1)
  have hfit' : ys.length ≤ A.width.bits n*2^(A.width.bits n) := by
    simpa only [hys,hgn] using hfit
  obtain ⟨t,ht,out,he,ho⟩ := FullWriter.code_correct U d q n w hm hr hn
  rw [←hys] at ho
  have hc := RAMConsumer.correct A (FullWriter.program U d q n).code (.inr FullWriter.Reg.word) (.inr FullWriter.Reg.output) n w ys he ho hfit' hh
  refine ⟨hc.1,hc.2.1.trans ?_,hc.2.2⟩
  have hs := FullWriter.scratch_le U d q n
  rw [Fintype.card_sum,Fintype.card_fin,FullWriter.card_reg]
  exact Nat.mul_le_mul (by unfold consumerFactor; omega) (Nat.pow_le_pow_left (by omega) 2)
 def tapesBound : ℕ := FullWriter.scratchBound U d q+4+Fintype.card (RAMAlphabet.Reg A)
 def alphabetBound : ℕ := 3+2*(3+Fintype.card (RAMAlphabet.Letter A))^tapesBound U d q A
 def ramSize : ℕ := Classical.choose (RAMAlphabet.program_linear A)
 theorem ramSize_spec (w : ℕ) : (RAMAlphabet.program A w).controlSize ≤ ramSize A*(w+1) :=
  Classical.choose_spec (RAMAlphabet.program_linear A) w
 def statesBound : ℕ := 3+14*(tapesBound U d q A+1)*(3+Fintype.card (RAMAlphabet.Letter A))*
    (FullWriter.syntaxBound U d q+ramSize A+7)*(3+Fintype.card (RAMAlphabet.Letter A))^tapesBound U d q A
 theorem consumer_alphabet (n : ℕ) : (consumer U d q A n).symbols ≤ alphabetBound U d q A := by
  unfold consumer RAMConsumer.oneTape Code.haltOneTape
  rw [StackMachine.Machine.compile_symbols]
  change 3+2*((2+Fintype.card (RAMAlphabet.Letter A))+1)^Fintype.card
    (RAMConsumer.Reg A (Fin (FullWriter.program U d q n).scratch ⊕ FullWriter.Reg)) ≤ _
  have hreg : Fintype.card (RAMConsumer.Reg A (Fin (FullWriter.program U d q n).scratch ⊕ FullWriter.Reg)) =
      (FullWriter.program U d q n).scratch+4+Fintype.card (RAMAlphabet.Reg A) := by
    rw [Fintype.card_sum,Fintype.card_sum,Fintype.card_fin,FullWriter.card_reg]
  rw [hreg]
  have hs := FullWriter.scratch_le U d q n
  unfold alphabetBound tapesBound
  apply Nat.add_le_add_left
  apply Nat.mul_le_mul_left
  rw [show 2+Fintype.card (RAMAlphabet.Letter A)+1=3+Fintype.card (RAMAlphabet.Letter A) by omega]
  exact Nat.pow_le_pow_right (by omega) (by omega)
 theorem consumer_states (n : ℕ) :
    (consumer U d q A n).states ≤ statesBound U d q A*((Nat.digits 2 n).length+A.width.bits n+2) := by
  have h := StackMachine.Machine.compile_states_bound
    (Code.haltMachine (RAMConsumer.code A (FullWriter.program U d q n).code (.inr FullWriter.Reg.output) (A.width.bits n))
      (.inl (.inr FullWriter.Reg.word)) Sum.inl (RAMConsumer.answer A)).compile
  change (consumer U d q A n).states ≤ 3+14*(Fintype.card
    (RAMConsumer.Reg A (Fin (FullWriter.program U d q n).scratch ⊕ FullWriter.Reg))+1)*
    (2+Fintype.card (RAMAlphabet.Letter A)+1)*
    (Fintype.card (Code.HaltState (RAMConsumer.code A (FullWriter.program U d q n).code (.inr FullWriter.Reg.output) (A.width.bits n)))+1)*
    (2+Fintype.card (RAMAlphabet.Letter A)+1)^Fintype.card
      (RAMConsumer.Reg A (Fin (FullWriter.program U d q n).scratch ⊕ FullWriter.Reg)) at h
  have hreg : Fintype.card (RAMConsumer.Reg A (Fin (FullWriter.program U d q n).scratch ⊕ FullWriter.Reg)) =
      (FullWriter.program U d q n).scratch+4+Fintype.card (RAMAlphabet.Reg A) := by
    rw [Fintype.card_sum,Fintype.card_sum,Fintype.card_fin,FullWriter.card_reg]
  rw [hreg] at h
  have hstate : Fintype.card (Code.HaltState (RAMConsumer.code A (FullWriter.program U d q n).code (.inr FullWriter.Reg.output) (A.width.bits n))) =
      (RAMConsumer.code A (FullWriter.program U d q n).code (.inr FullWriter.Reg.output) (A.width.bits n)).controlSize+1 := by
    rw [Fintype.card_sum,Code.card_state,Fintype.card_unit]
  rw [hstate,RAMConsumer.code_size] at h
  let Y := (Nat.digits 2 n).length+A.width.bits n+2
  let B := 3+Fintype.card (RAMAlphabet.Letter A)
  have hK : (FullWriter.program U d q n).scratch+4+Fintype.card (RAMAlphabet.Reg A) ≤ tapesBound U d q A := by
    have hs := FullWriter.scratch_le U d q n
    unfold tapesBound; omega
  have hq : (FullWriter.program U d q n).code.controlSize+(RAMAlphabet.program A (A.width.bits n)).controlSize+5+1+1 ≤
      (FullWriter.syntaxBound U d q+ramSize A+7)*Y := by
    have hs := FullWriter.syntax_le U d q n
    have hr := ramSize_spec A (A.width.bits n)
    dsimp only [Y]
    nlinarith only [hs,hr]
  have hp : B^((FullWriter.program U d q n).scratch+4+Fintype.card (RAMAlphabet.Reg A)) ≤ B^tapesBound U d q A :=
    Nat.pow_le_pow_right (by dsimp [B]; omega) hK
  rw [show 2+Fintype.card (RAMAlphabet.Letter A)+1=B by dsimp [B]; omega] at h
  have ht := Nat.mul_le_mul_right B (Nat.mul_le_mul_left 14 (Nat.add_le_add_right hK 1))
  have hz := Nat.add_le_add_left (Nat.mul_le_mul (Nat.mul_le_mul ht hq) hp) 3
  have hh := h.trans hz
  change (consumer U d q A n).states ≤ statesBound U d q A*Y
  unfold statesBound
  change (consumer U d q A n).states ≤ (3+14*(tapesBound U d q A+1)*B*(FullWriter.syntaxBound U d q+ramSize A+7)*B^tapesBound U d q A)*Y
  have hY : 1 ≤ Y := by dsimp [Y]; omega
  nlinarith only [hh,hY]
end
end WLTime.OneTape.Symbolic.RAMWriter

namespace WLTime.Numeric
 theorem ram_consumer_small (m a writer len time ram factor : ℕ) (hm : 8 ≤ m)
    (hb : writer ≤ m^2400) (hl : len ≤ m^20) (ht : time ≤ m^(8*a))
    (hr : ram ≤ m*(len+time+1)^2) (hf : factor ≤ m) :
    factor*(m+writer+5*len+ram+3)^2 ≤ m^(2*max 2400 (16*a+45)+3) := by
  let E := max 20 (8*a)
  let D := max 2400 (16*a+45)
  have hle : len ≤ m^E := hl.trans (pow_mono m 20 E (by omega) (le_max_left _ _))
  have hte : time ≤ m^E := ht.trans (pow_mono m (8*a) E (by omega) (le_max_right _ _))
  have hsum := sum_le_pow (by omega : 2 ≤ m) hle hte
  have hone : 1 ≤ m^(E+1) := one_le_pow₀ (by omega)
  have hsum' : len+time+1 ≤ m^(E+2) := by
    simpa only [show E+1+1=E+2 by omega] using sum_le_pow (by omega : 2 ≤ m) hsum hone
  have hram : ram ≤ m^(16*a+45) := by
    calc
      _ ≤ m*(len+time+1)^2 := hr
      _ ≤ m*(m^(E+2))^2 := Nat.mul_le_mul_left _ (Nat.pow_le_pow_left hsum' 2)
      _=m^(2*E+5) := by rw [←pow_mul,←pow_succ']; congr 1; omega
      _ ≤ m^(16*a+45) := pow_mono m _ _ (by omega) (by dsimp [E]; omega)
  have h5 : 5*len ≤ m^21 := by
    have h := Nat.mul_le_mul (show 5 ≤ m by omega) hl
    simpa only [pow_succ'] using h
  have hmD : m ≤ m^D := Nat.le_self_pow (by dsimp [D]; omega) m
  have hwD : writer ≤ m^D := hb.trans (pow_mono m 2400 D (by omega) (le_max_left _ _))
  have hlD : 5*len ≤ m^D := h5.trans (pow_mono m 21 D (by omega) (by dsimp [D]; omega))
  have hrD : ram ≤ m^D := hram.trans (pow_mono m (16*a+45) D (by omega) (le_max_right _ _))
  have h3D : 3 ≤ m^D := (by omega : 3 ≤ m).trans hmD
  have hbase : m+writer+5*len+ram+3 ≤ m^(D+1) := by
    rw [pow_succ]
    nlinarith only [hmD,hwD,hlD,hrD,h3D,hm]
  calc
    _ ≤ m*(m^(D+1))^2 := Nat.mul_le_mul hf (Nat.pow_le_pow_left hbase 2)
    _=m^(2*D+3) := by rw [←pow_mul,←pow_succ']; congr 1; omega
end WLTime.Numeric

namespace WLTime.OneTape.Symbolic.RAMWriter
open scoped Classical
noncomputable section
variable (A : RAM)
def widthFactor : ℕ := 10*(A.width.bound+1)
 theorem width_small (n m : ℕ) (hm : 2 ≤ m) (hn : n ≤ m^8) :
    A.width.bits n+1 ≤ widthFactor A*((Nat.digits 2 m).length+1) := by
  have hm8 : m ≤ m^8 := Nat.le_self_pow (by decide) m
  have hnm : n+2 ≤ m^9 := by
    simpa using Numeric.sum_le_pow hm hn (show 2 ≤ m^8 by omega)
  have hd := Numeric.digits_polynomial (n+2) m 9 (by decide) hnm
  have he : Nat.log2 (n+2)+1=(Nat.digits 2 (n+2)).length := by
    rw [Nat.length_digits 2 (n+2) (by decide) (by omega),Nat.log2_eq_log_two]
  have hw := A.width.logarithmic n
  rw [he] at hw
  have hx := Nat.mul_le_mul_left A.width.bound hd
  unfold widthFactor
  nlinarith only [hw,hx]
 theorem word_cost_small : ∃m₀,∀m ≥ m₀,∀n ≤ m^8,
    RAMAlphabet.budgetConstant A*(A.width.bits n+1)^RAMAlphabet.exponent A ≤ m := by
  obtain ⟨m₀,hm₀⟩ := Numeric.polylog_sublinear
    (RAMAlphabet.budgetConstant A*(widthFactor A)^RAMAlphabet.exponent A) (RAMAlphabet.exponent A)
  refine ⟨m₀+2,?_⟩
  intro m hm n hn
  have hw := width_small A n m (by omega) hn
  calc
    _ ≤ RAMAlphabet.budgetConstant A*(widthFactor A*((Nat.digits 2 m).length+1))^RAMAlphabet.exponent A :=
      Nat.mul_le_mul_left _ (Nat.pow_le_pow_left hw _)
    _=(RAMAlphabet.budgetConstant A*(widthFactor A)^RAMAlphabet.exponent A)*((Nat.digits 2 m).length+1)^RAMAlphabet.exponent A := by rw [mul_pow]; ring
    _ ≤ m := hm₀ m (by omega)
variable (U : OneTape) (d q : ℕ)
 theorem designation_small : ∃m₀,∀m ≥ m₀,∀n ≤ m^8,
    (Diagonal.designation (consumer U d q A n)).length ≤ m := by
  let K := statesBound U d q A+alphabetBound U d q A+3
  let F := 9+widthFactor A
  obtain ⟨m₀,hm₀⟩ := Numeric.polylog_sublinear (13*(K*F)^3) 3
  refine ⟨m₀+2,?_⟩
  intro m hm n hn
  let Y := (Nat.digits 2 n).length+A.width.bits n+2
  let B := K*Y
  have hd := Numeric.digits_polynomial n m 8 (by decide) hn
  have hw := width_small A n m (by omega) hn
  have hY : Y ≤ F*((Nat.digits 2 m).length+1) := by dsimp [Y,F]; nlinarith only [hd,hw]
  have hq : (consumer U d q A n).states ≤ B :=
    (consumer_states U d q A n).trans (Nat.mul_le_mul_right _ (by dsimp [K]; omega))
  have hg : (consumer U d q A n).symbols ≤ B := by
    have h := consumer_alphabet U d q A n
    dsimp [B,K,Y]
    nlinarith
  have hB : 3 ≤ B := by dsimp [B,K,Y]; nlinarith
  calc
    _ ≤ 13*B^3 := Diagonal.designation_upper _ B hq hg hB
    _ ≤ 13*(K*F*((Nat.digits 2 m).length+1))^3 := by
      apply Nat.mul_le_mul_left
      apply Nat.pow_le_pow_left
      have h := Nat.mul_le_mul_left K hY
      simpa only [B,Nat.mul_assoc] using h
    _=(13*(K*F)^3)*((Nat.digits 2 m).length+1)^3 := by ring
    _ ≤ m := hm₀ m (by omega)
end
end WLTime.OneTape.Symbolic.RAMWriter

namespace WLTime
open OneTape.Symbolic OneTape.Symbolic.FullWriter
open scoped Classical
 theorem diagonal_graph_contradiction (s d q k m pad : ℕ) (c : Convention) (D : OneTape)
    (w z : List Bool) (hw : w=Diagonal.designation D++z) (hlen : w.length=m)
    (hk : k=d+q+conventionShift c) (hm : 128 ≤ m) (hs : 1 ≤ s)
    (hd : d=3*s+6) (hq : d+3 ≤ q) (hr : 2 ≤ d+q)
    (hfit : (Diagonal.designation D).length ≤ m)
    (hUfac : 8*((Universal.boundedProgram s).scratch+Fintype.card Universal.Reg+1)*1200^2 ≤ m)
    (hsm : 18*s ≤ m) (hhalt : D.toTM.halts w) (htime : D.toTM.time w ≤ m^s)
    (hpairD : D.toTM.accepts w ↔ ¬Equivalent c k
      (pairGraph (Universal.machine s) d q hr w pad 0)
      (pairGraph (Universal.machine s) d q hr w pad 1)) : False := by
  let U := Universal.machine s
  have hU := Universal.machine_correct s D z (by rw [←hw,hlen]; omega)
  rw [←hw] at hU
  have hUt : U.toTM.time w ≤ w.length^d-1 := by
    apply hU.2.1.trans
    rw [hlen]
    apply (Universal.timeBound_small s D hfit (by omega) hs hsm hUfac).trans
    simpa only [hd] using time_window m s (by omega) hs
  have hwin : 2*(w.length^d-1)+w.length+2<w.length^(q+1) := by
    rw [hlen]; exact space_window m d q (by omega) (by omega) hq
  have hpair := pair_correct_convention U d q hr w (by rw [hlen]; omega) pad hwin c k hk
  have hUb := Diagonal.bounded_accepts_iff U w (w.length^d-1) hU.1 hUt
  have hEq := hpair.trans (not_congr hUb)
  have hc : D.toTM.accepts w ↔ ¬∃t ≤ m^s,(D.toTM.run w t).state.val=1 := by
    have hh := hpairD.trans (not_congr hEq)
    rw [not_not] at hh
    exact hh.trans (by simpa only [hlen] using hU.2.2)
  exact Diagonal.pointwise_contradiction D w (m^s) hhalt htime hc
end WLTime

namespace WLTime
open OneTape.Symbolic OneTape.Symbolic.FullWriter
open scoped Classical
 theorem ram_decides_pair (U : OneTape) (d q k n a : ℕ) (w : List Bool)
    (hr : 2 ≤ d+q) (hbase : baseOrder U d q w.length ≤ n)
    (c : Convention) (p : InputClass) (A : RAM) (hA : Decides (.ram A) c k p)
    (hfast : worstTime (.ram A) p n ≤ n^a) :
    let G := pairGraph U d q hr w (n-baseOrder U d q w.length) 0
    let H := pairGraph U d q hr w (n-baseOrder U d q w.length) 1
    let ys := encodePair G H
    A.halts n ys ∧ A.time n ys ≤ n^a ∧ (A.accepts n ys ↔ Equivalent c k G H) := by
  dsimp only
  let G := pairGraph U d q hr w (n-baseOrder U d q w.length) 0
  let H := pairGraph U d q hr w (n-baseOrder U d q w.length) 1
  let ys := encodePair G H
  have hgn : (listing U d q (d+q+2) w (n-baseOrder U d q w.length)).items.length=n := by
    rw [listing_length,Nat.add_sub_of_le hbase]
  have hprom : p.contains G H := promised_pair U d q hr w _ p
  have hdec := hA _ G H hprom
  change A.halts _ ys ∧ (A.accepts _ ys ↔ Equivalent c k G H) at hdec
  have hhalt : A.halts n ys := by simpa only [hgn] using hdec.1
  have haccept : A.accepts n ys ↔ Equivalent c k G H := by
    have he : A.accepts n ys=A.accepts (listing U d q (d+q+2) w (n-baseOrder U d q w.length)).items.length ys :=
      congrArg (fun j => A.accepts j ys) hgn.symm
    rw [he]
    exact hdec.2
  have htime : A.time n ys ≤ n^a := by
    have ht := worstTime_ge (.ram A) p G H hprom
    change A.time _ ys ≤ worstTime (.ram A) p _ at ht
    rw [hgn] at ht
    exact ht.trans hfast
  exact ⟨hhalt,htime,haccept⟩
 theorem ram_pointwise (s d q k a n m : ℕ) (c : Convention) (p : InputClass) (A : RAM)
    (hA : Decides (.ram A) c k p) (hk : k=d+q+conventionShift c)
    (hm : 128 ≤  m) (hs : 1 ≤  s) (hd : d=3*s+6) (hq : d+3 ≤  q)
    (ha : 2*max 2400 (16*a+45)+3 ≤  s)
    (hbase : baseOrder (Universal.machine s) d q m ≤  n) (hn : n ≤  m^8)
    (hfit : (Diagonal.designation (RAMWriter.consumer (Universal.machine s) d q A n)).length ≤  m)
    (hC : coefficient (Universal.machine s) d q (d+q+2) ≤  m)
    (hcharge : (body (Universal.machine s) d q).charge ≤  m)
    (hfactor : RAMWriter.consumerFactor (Universal.machine s) d q A ≤  m)
    (hword : RAMAlphabet.budgetConstant A*(A.width.bits n+1)^RAMAlphabet.exponent A ≤ m)
    (hUfac : 8*((Universal.boundedProgram s).scratch+Fintype.card Universal.Reg+1)*1200^2 ≤  m)
    (hsm : 18*s ≤  m) :
    ¬worstTime (.ram A) p n ≤  n^a := by
  intro hfast
  let U := Universal.machine s
  let D := RAMWriter.consumer U d q A n
  let z := List.replicate (m-(Diagonal.designation D).length) false
  let w := Diagonal.designation D++z
  have hlen : w.length=m := by
    dsimp [w,z]
    rw [List.length_append,List.length_replicate,Nat.add_sub_of_le hfit]
  have hr : 2 ≤  d+q := by omega
  let G := pairGraph U d q hr w (n-baseOrder U d q w.length) 0
  let H := pairGraph U d q hr w (n-baseOrder U d q w.length) 1
  let ys := encodePair G H
  obtain ⟨hhalt,htime,haccept⟩ := ram_decides_pair U d q k n a w hr
    (by simpa only [hlen] using hbase) c p A hA hfast
  have hprod := RAMWriter.correct U d q A n w (by rw [hlen]; omega) hr
    (by simpa only [hlen] using hbase) ys rfl hhalt
  have hy : ys.length ≤  m^20 := by
    have hy := input_length U d q n w hr (by simpa only [hlen] using hbase)
    exact hy.le.trans (Numeric.input_small n m (by omega) hn)
  have hb : budget U d q n w.length ≤  m^2400 := by
    rw [hlen]
    simpa only [budget,encodeNat_length] using
      Numeric.writer_small (coefficient U d q (d+q+2)) (body U d q).charge n m hm hC hcharge hn
  have hv : A.time n ys ≤  m^(8*a) := by
    calc
      _ ≤  n^a := htime
      _ ≤ (m^8)^a := Nat.pow_le_pow_left hn a
      _=m^(8*a) := (pow_mul m 8 a).symm
  have hDtime : D.toTM.time w ≤  m^s := by
    have hramb : RAMAlphabet.budget A (A.width.bits n) ys.length (A.time n ys) ≤ m*(ys.length+A.time n ys+1)^2 :=
      (RAMAlphabet.budget_bound A _ _ _).trans (Nat.mul_le_mul_right _ hword)
    have hbnd := Numeric.ram_consumer_small m a (budget U d q n w.length) ys.length (A.time n ys)
      (RAMAlphabet.budget A (A.width.bits n) ys.length (A.time n ys)) (RAMWriter.consumerFactor U d q A)
      (by omega) hb hy hv hramb hfactor
    have ht := hprod.2.1
    rw [hlen] at ht hbnd
    exact ht.trans (hbnd.trans (Nat.pow_le_pow_right (by omega) ha))
  have heq : D.toTM.accepts w ↔ ¬Equivalent c k G H :=
    hprod.2.2.trans (not_congr haccept)
  exact diagonal_graph_contradiction s d q k m (n-baseOrder U d q w.length) c D w z rfl hlen
    hk hm hs hd hq hr hfit hUfac hsm hprod.1 hDtime heq
end WLTime

end OAI