lean/OAI/Probability/Contingency/ParseNatRuns.lean

import Mathlib
import OAI.Probability.Contingency.StackSequence

namespace OAI

/-! Parse Nat Runs. -/

noncomputable section


namespace Contingency.BitModel.StackCode.ParseNat
noncomputable section

theorem data_done (m : Memory 4) (h2 : m.stack 2=[]) :
    exec 1 (config .data m)=config .restore (m.pop 2) := by
  rw [exec_one,one_step]
  simp [code,effect,branch,h2,config]; rfl

theorem restore_empty (m : Memory 4) (h1 : m.stack 1=[]) :
    exec 1 (config .restore m)=config .done (m.pop 1) := by
  rw [exec_one,one_step]
  simp [code,effect,branch,h1,config]; rfl

theorem restore_bit (m : Memory 4) (b : Bool) (bs : List Bool) (h1 : m.stack 1=b::bs) :
    exec 2 (config .restore m)=config .restore ((m.pop 1).push 0 b) := by
  change step program false (step program false (config .restore m))=_
  rw [one_step]
  have he : (⟨(effect (code .restore) false m).1,(effect (code .restore) false m).2⟩ : Config program)=config (.place b) (m.pop 1) := by
    cases b <;> simp [code,effect,branch,h1,config] <;> rfl
  rw [he,one_step]; rfl

def restoreMemory : List Bool→Memory 4→Memory 4
  | [],m => m.pop 1
  | b::bs,m => restoreMemory bs ((m.pop 1).push 0 b)

theorem restore_run (bs : List Bool) (m : Memory 4) (h1 : m.stack 1=bs) :
    exec (2*bs.length+1) (config .restore m)=config .done (restoreMemory bs m) := by
  induction bs generalizing m with
  | nil => exact restore_empty m h1
  | cons b bs ih =>
    have he : 2*(b::bs).length+1=2+(2*bs.length+1) := by simp; omega
    rw [he,exec_add,restore_bit m b bs h1,ih]
    · rfl
    · simp [Memory.push,Memory.pop,h1]

theorem restoreMemory_fields (bs : List Bool) (m : Memory 4) (h1 : m.stack 1=bs) :
    (restoreMemory bs m).input=m.input ∧
    (restoreMemory bs m).stack 0=bs.reverse++m.stack 0 ∧
    (restoreMemory bs m).stack 1=[] ∧
    (restoreMemory bs m).stack 2=m.stack 2 ∧
    (restoreMemory bs m).stack 3=m.stack 3 ∧
    (restoreMemory bs m).outputRev=m.outputRev := by
  induction bs generalizing m with
  | nil => simp [restoreMemory,Memory.pop,h1]
  | cons b bs ih =>
    have hh := ih ((m.pop 1).push 0 b) (by simp [Memory.pop,Memory.push,h1])
    simpa [restoreMemory,Memory.pop,Memory.push,List.reverse_cons,List.append_assoc] using hh

theorem halt (m : Memory 4) : exec 1 (config .done m)=⟨none,m⟩ := by
  rw [exec_one,one_step]; rfl

 

theorem parse_word (bs : List Bool) (m : Memory 4) (rest : List Bool)
    (hi : m.input=List.replicate bs.length true++false::(bs++rest))
    (h1 : m.stack 1=[]) (h2 : m.stack 2=[]) :
    ∃ m' : Memory 4,exec (7*bs.length+4) (config .prefix m)=⟨none,m'⟩ ∧
      m'.input=rest ∧ m'.stack 0=bs++m.stack 0 ∧
      m'.stack 1=[] ∧ m'.stack 2=[] ∧ m'.stack 3=m.stack 3 ∧ m'.outputRev=m.outputRev := by
  let p := prefixMemory bs.length m
  have hp := prefixMemory_fields bs.length m (bs++rest) hi
  have hp2 : p.stack 2=List.replicate bs.length false := by simpa [p,h2] using hp.2.2.2.1
  let d := dataMemory bs p
  have hd := dataMemory_fields bs p rest hp.1 hp2
  have hd1 : (d.pop 2).stack 1=bs.reverse := by
    simpa [d,Memory.pop,p,hp.2.2.1,h1] using hd.2.2.1
  let r := restoreMemory bs.reverse (d.pop 2)
  have hr := restoreMemory_fields bs.reverse (d.pop 2) hd1
  refine ⟨r,?_,?_,?_,hr.2.2.1,?_,?_,?_⟩
  · have he : 7*bs.length+4=(((2*bs.length+1)+3*bs.length)+1)+(2*bs.reverse.length+1)+1 := by simp; omega
    rw [he,exec_add _ 1,exec_add (((2*bs.length+1)+3*bs.length)+1) (2*bs.reverse.length+1),exec_add ((2*bs.length+1)+3*bs.length) 1,exec_add (2*bs.length+1) (3*bs.length)]
    rw [prefix_run bs.length m (bs++rest) hi,data_run bs p rest hp.1 hp2,data_done _ hd.2.2.2.1,restore_run bs.reverse (d.pop 2) hd1,halt]
  · exact hr.1.trans hd.1
  · calc
      r.stack 0=bs.reverse.reverse++(d.pop 2).stack 0 := hr.2.1
      _ = bs++m.stack 0 := by
        simp only [List.reverse_reverse]
        congr 1
        simpa [Memory.pop] using hd.2.1.trans hp.2.1
  · have hd2 : d.stack 2=[] := hd.2.2.2.1
    exact hr.2.2.2.1.trans (by simp [Memory.pop,hd2])
  · exact hr.2.2.2.2.1.trans (hd.2.2.2.2.1.trans hp.2.2.2.2.1)
  · exact hr.2.2.2.2.2.trans (hd.2.2.2.2.2.trans hp.2.2.2.2.2)

theorem step_independent (cfg : Config program) (b b' : Bool) :
    step program b cfg=step program b' cfg := by
  rcases cfg with ⟨s,m⟩
  cases s with
  | none => rfl
  | some pc =>
    unfold step
    dsimp only [program]
    cases (Fintype.equivFin Q).symm pc <;> rfl

theorem fold_independent (xs ys : List Bool) (hl : xs.length=ys.length) (cfg : Config program) :
    xs.foldl (fun cfg b => step program b cfg) cfg=ys.foldl (fun cfg b => step program b cfg) cfg := by
  induction xs generalizing ys cfg with
  | nil => cases ys <;> simp_all
  | cons x xs ih =>
    cases ys with
    | nil => simp at hl
    | cons y ys =>
      simp only [List.length_cons,Nat.add_right_cancel_iff] at hl
      simp only [List.foldl_cons]
      rw [step_independent _ x y]
      exact ih _ hl _

 

theorem parse_nat_tape (x : ℕ) (rest : List Bool) :
    ∃ m' : Memory 4,m'.input=rest ∧ m'.stack 0=x.bits ∧
      m'.stack 1=[] ∧ m'.stack 2=[] ∧ m'.stack 3=[] ∧ m'.outputRev=[] ∧
      ∀ coins : Fin ((7*x.size+4)*2)→Bool,
        (compile program).run (encodeNat x++rest) coins=encode program ⟨none,m'⟩ := by
  let m : Memory 4 := ⟨encodeNat x++rest,0,fun _ => [],fun _ => 0,[]⟩
  have hi : m.input=List.replicate x.bits.length true++false::(x.bits++rest) := by
    simp [m,encodeNat,List.append_assoc]
  obtain ⟨m',hr,hi',h0,h1,h2,h3,ho⟩ := parse_word x.bits m rest hi rfl rfl
  refine ⟨m',hi',by simpa [m] using h0,h1,h2,h3,ho,?_⟩
  intro coins
  rw [run_eq]
  unfold run
  have he := fold_independent (List.ofFn fun i : Fin (7*x.size+4) => coins (second i)) (List.replicate (7*x.size+4) false) (by simp) (initial program (encodeNat x++rest))
  rw [he]
  change encode program (exec (7*x.size+4) (config .prefix m))=_
  simpa only [Nat.size_eq_bits_len] using congrArg (encode program) hr

end
end Contingency.BitModel.StackCode.ParseNat

 

 

 

namespace Contingency.BitModel.StackCode.PrepareMaximum
noncomputable section

def reg (i : Fin 4) : Fin 6 := i.castAdd 2

theorem reg_injective : Function.Injective reg := by
  intro i j h
  apply Fin.ext
  exact congrArg (fun x : Fin 6 => x.val) h

abbrev parser : Program :=
  ⟨ParseNat.program.labels,6,ParseNat.program.start,fun q => Registers.op reg (ParseNat.program.code q)⟩

def program : Program := Sequence.program parser 4 0 (Transfer.code (0 : Fin 6) 4)

theorem parser_noCoin : ∀ q,NoCoin (parser.code q) := by
  intro q
  apply noCoin_registers
  change NoCoin (ParseNat.code ((Fintype.equivFin ParseNat.Q).symm q))
  cases (Fintype.equivFin ParseNat.Q).symm q <;> trivial

theorem noCoin : ∀ q,NoCoin (program.code q) := by
  apply noCoin_sequence _ _ _ _ parser_noCoin
  intro q
  fin_cases q <;> trivial

 

theorem prepare (N : ℕ) (rest : List Bool) :
    ∃ (t : ℕ) (m' : Memory 6),t≤9*N.size+6 ∧
      (∀ i : Fin 4,m'.stack (reg i)=[]) ∧
      m'.stack 4=IntegerDraw.rawMaximum N ∧ m'.stack 5=[] ∧
      m'.input=rest ∧ m'.outputRev=[] ∧
      ∀ coins : List Bool,coins.length=t →
        coins.foldl (fun c b => step program b c) (initial program (encodeNat N++rest))=⟨none,m'⟩ := by
  let xs := encodeNat N++rest
  let m₄ : Memory 4 := (initial ParseNat.program xs).memory
  have hi : m₄.input=List.replicate N.bits.length true++false::(N.bits++rest) := by
    simp [m₄,initial,xs,encodeNat,List.append_assoc]
  obtain ⟨m₄',hp,hi',h0,h1,h2,h3,ho⟩ := ParseNat.parse_word N.bits m₄ rest hi rfl rfl
  let T := 7*N.size+4
  have hp' : (List.replicate T false).foldl (fun c b => step ParseNat.program b c)
      (initial ParseNat.program xs)=⟨none,m₄'⟩ := by
    simpa only [ParseNat.exec,T,Nat.size_eq_bits_len,ParseNat.config,m₄,initial,ParseNat.program] using hp
  let c₆ := (List.replicate T false).foldl (fun c b => step parser b c) (initial parser xs)
  have hr₀ : Registers.ConfigRel ParseNat.program reg (initial ParseNat.program xs) (initial parser xs) :=
    ⟨rfl,fun _ => rfl,rfl,rfl,rfl⟩
  have hr := Registers.fold_rel ParseNat.program reg reg_injective (List.replicate T false) hr₀
  rw [hp'] at hr
  have hc : c₆.state=none := hr.1
  have hs : ∀ i : Fin 4,c₆.memory.stack (reg i)=m₄'.stack i := hr.2.1
  have hs0 : c₆.memory.stack 0=N.bits := by simpa [reg,m₄,initial] using (hs 0).trans h0
  have hs1 : c₆.memory.stack 1=[] := (hs 1).trans h1
  have hs2 : c₆.memory.stack 2=[] := (hs 2).trans h2
  have hs3 : c₆.memory.stack 3=[] := by simpa [reg,m₄,initial] using (hs 3).trans h3
  have frame (j : Fin 6) (hj : ∀ i,reg i≠j) : c₆.memory.stack j=[] :=
    Registers.fold_frame ParseNat.program reg (List.replicate T false) (initial parser xs) j hj
  have hs4 : c₆.memory.stack 4=[] := frame 4 (by intro i h; have hv := congrArg Fin.val h; have hi := i.isLt; change i.val=4 at hv; omega)
  have hs5 : c₆.memory.stack 5=[] := frame 5 (by intro i h; have hv := congrArg Fin.val h; have hi := i.isLt; change i.val=5 at hv; omega)
  obtain ⟨t,ht,hfirst⟩ := Sequence.deterministic_first_time parser
    (noCoin_deterministic parser parser_noCoin) (initial parser xs) T hc
  have hf := hfirst (List.replicate t false) (by simp)
  let m' := Transfer.memory (0 : Fin 6) 4 N.bits c₆.memory
  have hm := Transfer.memory_fields (0 : Fin 6) 4 (by decide) N.bits c₆.memory hs0
  refine ⟨t+(2*N.bits.length+2),m',?_,?_,?_,?_,?_,?_,?_⟩
  · simp only [Nat.size_eq_bits_len]
    dsimp only [T] at ht
    omega
  · intro i
    fin_cases i
    · exact hm.1
    · exact (hm.2.2.1 1 (by decide) (by decide)).trans hs1
    · exact (hm.2.2.1 2 (by decide) (by decide)).trans hs2
    · exact (hm.2.2.1 3 (by decide) (by decide)).trans hs3
  · simpa only [m',IntegerDraw.rawMaximum,hs4,List.append_nil] using hm.2.1
  · exact (hm.2.2.1 5 (by decide) (by decide)).trans hs5
  · exact hm.2.2.2.1.trans (hr.2.2.1.trans hi')
  · exact hm.2.2.2.2.1.trans (hr.2.2.2.1.trans ho)
  · intro coins hlen
    rw [Sequence.deterministic_fold program (noCoin_deterministic program noCoin) _ _
      (List.replicate (t+(2*N.bits.length+2)) false) (by simpa using hlen)]
    rw [List.replicate_add]
    have hl := Sequence.link_run parser 4 0 (Transfer.code (0 : Fin 6) 4)
      (initial parser xs) (List.replicate t false) (List.replicate (2*N.bits.length+2) false) hf.1
    rw [hf.2] at hl
    change (List.replicate t false++List.replicate (2*N.bits.length+2) false).foldl
      (fun c b => step program b c) (initial program xs)=⟨none,m'⟩
    have ht_run := Transfer.run (0 : Fin 6) 4 (by decide) N.bits c₆.memory hs0
    change (List.replicate (2*N.bits.length+2) false).foldl
      (fun c b => step (Transfer.program (0 : Fin 6) 4) b c)
      (Transfer.config (0 : Fin 6) 4 0 c₆.memory)=⟨none,m'⟩ at ht_run
    change (List.replicate t false++List.replicate (2*N.bits.length+2) false).foldl
      (fun c b => step program b c) (initial program xs)=
        Sequence.right parser 4 0 (Transfer.code (0 : Fin 6) 4)
          ((List.replicate (2*N.bits.length+2) false).foldl
            (fun c b => step (Transfer.program (0 : Fin 6) 4) b c)
            (Transfer.config (0 : Fin 6) 4 0 c₆.memory)) at hl
    exact hl.trans (congrArg (fun c : Config (Transfer.program (0 : Fin 6) 4) =>
      Sequence.right parser 4 0 (Transfer.code (0 : Fin 6) 4) c) ht_run)

end
end Contingency.BitModel.StackCode.PrepareMaximum

 

 

 

namespace Contingency.BitModel.StackCode.PreparedIntegerCall
noncomputable section

abbrev callee : Program :=
  ⟨IntegerDraw.program.labels,6,IntegerDraw.program.start,
    fun q => Internal.op (IntegerDraw.program.code q)⟩

def program : Program := Sequence.program PrepareMaximum.program
  callee.labels callee.start callee.code

def result (c : Config callee) : Config program :=
  Sequence.right PrepareMaximum.program callee.labels callee.start callee.code c

 
theorem prepared_first (N : ℕ) (rest : List Bool) :
    ∃ (t : ℕ) (m : Memory 6),t≤9*N.size+6 ∧
      (∀ i : Fin 4,m.stack (PrepareMaximum.reg i)=[]) ∧
      m.stack 4=IntegerDraw.rawMaximum N ∧ m.stack 5=[] ∧
      m.input=rest ∧ m.outputRev=[] ∧
      ∀ a : List Bool,a.length=t →
        Sequence.FirstHalt PrepareMaximum.program
          (initial PrepareMaximum.program (encodeNat N++rest)) a ∧
        a.foldl (fun c b => step PrepareMaximum.program b c)
          (initial PrepareMaximum.program (encodeNat N++rest))=⟨none,m⟩ := by
  obtain ⟨T,m,hT,hw,hi,ho,he,hout,hr⟩ := PrepareMaximum.prepare N rest
  have hrun := hr (List.replicate T false) (by simp)
  obtain ⟨t,ht,hf⟩ := Sequence.deterministic_first_time PrepareMaximum.program
    (noCoin_deterministic _ PrepareMaximum.noCoin)
    (initial PrepareMaximum.program (encodeNat N++rest)) T
    (by rw [hrun])
  refine ⟨t,m,ht.trans hT,hw,hi,ho,he,hout,?_⟩
  intro a ha
  exact ⟨(hf a ha).1,((hf a ha).2).trans hrun⟩

 

theorem refinement (N : ℕ) (rest : List Bool) :
    ∃ t≤9*N.size+6,∀ a : List Bool,a.length=t → ∀ b : List Bool,
      ∃ c : Config callee,
        (a++b).foldl (fun c x => step program x c)
          (initial program (encodeNat N++rest))=result c ∧
        Internal.ConfigRel IntegerDraw.program
          (b.foldl (fun c x => step IntegerDraw.program x c)
            (initial IntegerDraw.program (IntegerDraw.rawMaximum N))) c ∧
        c.memory.input=rest ∧ c.memory.outputRev=[] := by
  obtain ⟨t,m,ht,hw,hi,ho,he,hout,hr⟩ := prepared_first N rest
  refine ⟨t,ht,?_⟩
  intro a ha b
  let start : Config callee := ⟨some callee.start,m⟩
  have hrel : Internal.ConfigRel IntegerDraw.program
      (initial IntegerDraw.program (IntegerDraw.rawMaximum N)) start := by
    refine ⟨rfl,?_,hi,ho⟩
    intro i
    exact hw i
  let c := b.foldl (fun c x => step callee x c) start
  have hc := Internal.fold_rel IntegerDraw.program b hrel
  have hf := Internal.fold_frame IntegerDraw.program b start
  refine ⟨c,?_,hc,hf.1.trans he,hf.2.1.trans hout⟩
  have hh := Sequence.link_run PrepareMaximum.program callee.labels callee.start callee.code
    (initial PrepareMaximum.program (encodeNat N++rest)) a b (hr a ha).1
  rw [(hr a ha).2] at hh
  exact hh

 

theorem tape_refinement (N : ℕ) (rest : List Bool) :
    ∃ t≤9*N.size+6,∀ (s : ℕ) (coins : Fin ((t+s)*2)→Bool),
      ∃ c : Config callee,
        (compile program).run (encodeNat N++rest) coins=encode program (result c) ∧
        Internal.ConfigRel IntegerDraw.program
          (((List.ofFn fun i : Fin (t+s) => coins (second i)).drop t).foldl
            (fun c x => step IntegerDraw.program x c)
            (initial IntegerDraw.program (IntegerDraw.rawMaximum N))) c ∧
        c.memory.input=rest ∧ c.memory.outputRev=[] := by
  obtain ⟨t,ht,hr⟩ := refinement N rest
  refine ⟨t,ht,?_⟩
  intro s coins
  let xs := List.ofFn fun i : Fin (t+s) => coins (second i)
  obtain ⟨c,hc,hm,hi,ho⟩ := hr (xs.take t) (by simp [xs]) (xs.drop t)
  rw [List.take_append_drop] at hc
  refine ⟨c,?_,hm,hi,ho⟩
  rw [run_eq]
  exact congrArg (encode program) hc

end
end Contingency.BitModel.StackCode.PreparedIntegerCall

 

 

 

namespace Contingency.BitModel.StackCode.InputCall
open Internal (work input)

def op {l w : ℕ} : Op l w→Op l (w+2)
  | .push i b q => .push (work i) b q
  | .pop i e z o => .pop (work i) e z o
  | .read e z o => .pop (input w) e z o
  | .coin z o => .coin z o
  | .emit b q => .emit b q
  | .jump q => .jump q
  | .halt => .halt

def program (P : Program) : Program := ⟨P.labels,P.work+2,P.start,fun q => op (P.code q)⟩

 

def MemoryRel {w : ℕ} (a : Memory w) (b : Memory (w+2)) : Prop :=
  (∀ i,b.stack (work i)=a.stack i) ∧
    b.stack (input w)=a.input ∧ b.outputRev=a.outputRev

theorem push_work {w : ℕ} {a : Memory w} {b : Memory (w+2)} (h : MemoryRel a b)
    (i : Fin w) (v : Bool) : MemoryRel (a.push i v) (b.push (work i) v) := by
  rcases h with ⟨hw,hi,ho⟩
  refine ⟨?_,?_,?_⟩
  · intro j
    simp [Memory.push,Function.update_apply,hw]
  · simpa [Memory.push] using hi
  · simpa [Memory.push] using ho

theorem pop_work {w : ℕ} {a : Memory w} {b : Memory (w+2)} (h : MemoryRel a b)
    (i : Fin w) : MemoryRel (a.pop i) (b.pop (work i)) := by
  rcases h with ⟨hw,hi,ho⟩
  refine ⟨?_,?_,?_⟩
  · intro j
    simp [Memory.pop,Function.update_apply,hw]
  · simpa [Memory.pop] using hi
  · simpa [Memory.pop] using ho

theorem read_input {w : ℕ} {a : Memory w} {b : Memory (w+2)} (h : MemoryRel a b) :
    MemoryRel a.read (b.pop (input w)) := by
  rcases h with ⟨hw,hi,ho⟩
  refine ⟨?_,?_,?_⟩
  · intro j
    simpa [Memory.pop,Memory.read] using hw j
  · simp [Memory.pop,Memory.read,hi]
  · simpa [Memory.pop,Memory.read] using ho

theorem emit_output {w : ℕ} {a : Memory w} {b : Memory (w+2)} (h : MemoryRel a b) (v : Bool) :
    MemoryRel {a with outputRev:=v::a.outputRev} {b with outputRev:=v::b.outputRev} := by
  exact ⟨h.1,h.2.1,congrArg (v::·) h.2.2⟩

theorem effect_rel {l w : ℕ} (code : Op l w) (coin : Bool)
    {a : Memory w} {b : Memory (w+2)} (h : MemoryRel a b) :
    (effect (op code) coin b).1=(effect code coin a).1 ∧
      MemoryRel (effect code coin a).2 (effect (op code) coin b).2 := by
  cases code with
  | push i v q => exact ⟨rfl,push_work h i v⟩
  | pop i e z o => exact ⟨by simp [op,effect,h.1 i],pop_work h i⟩
  | read e z o => exact ⟨by simp [op,effect,h.2.1],read_input h⟩
  | coin z o => exact ⟨rfl,h⟩
  | emit v q => exact ⟨rfl,emit_output h v⟩
  | jump q => exact ⟨rfl,h⟩
  | halt => exact ⟨rfl,h⟩

def ConfigRel (P : Program) (a : Config P) (b : Config (program P)) : Prop :=
  b.state=a.state ∧ MemoryRel a.memory b.memory

theorem step_rel (P : Program) (coin : Bool) {a : Config P} {b : Config (program P)}
    (h : ConfigRel P a b) : ConfigRel P (step P coin a) (step (program P) coin b) := by
  rcases a with ⟨sa,ma⟩
  rcases b with ⟨sb,mb⟩
  obtain ⟨hs,hm⟩ := h
  dsimp only at hs hm
  subst sb
  cases sa with
  | none => exact ⟨rfl,hm⟩
  | some pc => exact effect_rel (P.code pc) coin hm

theorem fold_rel (P : Program) (coins : List Bool) {a : Config P} {b : Config (program P)}
    (h : ConfigRel P a b) :
    ConfigRel P (coins.foldl (fun c v => step P v c) a)
      (coins.foldl (fun c v => step (program P) v c) b) := by
  induction coins generalizing a b with
  | nil => exact h
  | cons v coins ih => exact ih (step_rel P v h)

end Contingency.BitModel.StackCode.InputCall

 

 

 

open scoped BigOperators
open Filter
namespace Contingency.BitModel.StackCode.EncodedInteger
noncomputable section

abbrev callee : Program :=
  ⟨IntegerDraw.program.labels,6,IntegerDraw.program.start,
    fun q => InputCall.op (IntegerDraw.program.code q)⟩

def program : Program := Sequence.program PrepareMaximum.program
  callee.labels callee.start callee.code

def result (c : Config callee) : Config program :=
  Sequence.right PrepareMaximum.program callee.labels callee.start callee.code c

 

theorem refinement (N : ℕ) (rest : List Bool) :
    ∃ t≤9*N.size+6,∀ (s : ℕ) (f : Fin (t+s)→Bool),
      ((run program (encodeNat N++rest) f).state=none ↔
        (run IntegerDraw.program (IntegerDraw.rawMaximum N) (fun i => f (Fin.natAdd t i))).state=none) ∧
      (run program (encodeNat N++rest) f).memory.outputRev=
        (run IntegerDraw.program (IntegerDraw.rawMaximum N) (fun i => f (Fin.natAdd t i))).memory.outputRev := by
  obtain ⟨t,m,ht,hw,hi,ho,he,hout,hr⟩ := PreparedIntegerCall.prepared_first N rest
  refine ⟨t,ht,?_⟩
  intro s f
  let a := List.ofFn fun i : Fin t => f (i.castAdd s)
  let b := List.ofFn fun i : Fin s => f (Fin.natAdd t i)
  have ha := hr a (by simp [a])
  let start : Config callee := ⟨some callee.start,m⟩
  have hrel : InputCall.ConfigRel IntegerDraw.program
      (initial IntegerDraw.program (IntegerDraw.rawMaximum N)) start := by
    refine ⟨rfl,?_,hi,hout⟩
    intro i
    exact hw i
  have hc := InputCall.fold_rel IntegerDraw.program b hrel
  have hh := Sequence.link_run PrepareMaximum.program callee.labels callee.start callee.code
    (initial PrepareMaximum.program (encodeNat N++rest)) a b ha.1
  rw [ha.2] at hh
  have hr' : run program (encodeNat N++rest) f=
      result (b.foldl (fun c x => step callee x c) start) := by
    unfold run
    rw [List.ofFn_add]
    exact hh
  rw [hr']
  constructor
  · change Option.map (Fin.natAdd PrepareMaximum.program.labels)
        (b.foldl (fun c x => step callee x c) start).state=none ↔ _
    rw [Option.map_eq_none_iff]
    exact (congrArg (fun v => v=none) hc.1).to_iff
  · exact hc.2.2.2

 
theorem shifted_laws (N : ℕ) (rest : List Bool) :
    ∃ t≤9*N.size+6,∀ s : ℕ,
      (∀ out,mass program (encodeNat N++rest) out (t+s)=
        mass IntegerDraw.program (IntegerDraw.rawMaximum N) out s) ∧
      tail program (encodeNat N++rest) (t+s)=
        tail IntegerDraw.program (IntegerDraw.rawMaximum N) s := by
  classical
  obtain ⟨t,ht,hr⟩ := refinement N rest
  refine ⟨t,ht,?_⟩
  intro s
  have hi : Function.Injective (Fin.natAdd t : Fin s→Fin (t+s)) := by
    intro i j h
    simpa using h
  constructor
  · intro out
    unfold mass
    simp only [(hr s _).1,(hr s _).2]
    simpa only [Fintype.card_fin,Function.comp_def] using CoordinateLaw.probability_restrict (Fin.natAdd t) hi
      (fun f => (run IntegerDraw.program (IntegerDraw.rawMaximum N) f).state=none ∧
        (run IntegerDraw.program (IntegerDraw.rawMaximum N) f).memory.outputRev.reverse=out)
  · unfold tail
    simp only [ne_eq,(hr s _).1]
    simpa only [Fintype.card_fin,Function.comp_def] using CoordinateLaw.probability_restrict (Fin.natAdd t) hi
      (fun f => (run IntegerDraw.program (IntegerDraw.rawMaximum N) f).state≠none)

 

theorem stack_safe (N : ℕ) (rest : List Bool) {s : ℕ} (f : Fin s→Bool)
    (h : (run program (encodeNat N++rest) f).state=none) :
    ∃ u : Fin (N+1),(run program (encodeNat N++rest) f).memory.outputRev.reverse=
      IntegerDraw.integerWord N u := by
  obtain ⟨t,ht,hr⟩ := refinement N rest
  let g : Fin (t+s)→Bool := fun i => if h : i.val<s then f ⟨i,h⟩ else false
  have hg : (fun i : Fin s => g ⟨i,lt_of_lt_of_le i.isLt (by omega : s≤t+s)⟩)=f := by
    funext i
    simp [g,i.isLt]
  have hp := run_prefix_halt program (encodeNat N++rest) s (t+s) (by omega) g (by simpa [hg] using h)
  rw [hg] at hp
  have hh := (hr s g).1.mp (by rw [hp]; exact h)
  obtain ⟨u,hu⟩ := IntegerDraw.stack_safe (IntegerDraw.rawMaximum N)
    (fun i => g (Fin.natAdd t i)) hh
  refine ⟨⟨u,by simpa using u.isLt⟩,?_⟩
  rw [← hp,(hr s g).2]
  exact hu

end
end Contingency.BitModel.StackCode.EncodedInteger

 

 

 

open scoped BigOperators
open Filter
namespace Contingency.BitModel.StackCode.EncodedInteger
noncomputable section

def machine : Machine := compile program

theorem stack_summable (N : ℕ) (rest : List Bool) :
    Summable (tail program (encodeNat N++rest)) := by
  obtain ⟨t,ht,hl⟩ := shifted_laws N rest
  apply (summable_nat_add_iff t).1
  simpa only [Nat.add_comm, (hl _).2] using
    IntegerDraw.stack_summable (IntegerDraw.rawMaximum N)

theorem stack_expected (N : ℕ) (rest : List Bool) :
    (∑' s,tail program (encodeNat N++rest) s)≤35*(N.size:ℝ)+21 := by
  obtain ⟨t,ht,hl⟩ := shifted_laws N rest
  have hs := stack_summable N rest
  rw [← hs.sum_add_tsum_nat_add t]
  have hb : (∑ s∈Finset.range t,tail program (encodeNat N++rest) s)≤(t:ℝ) := by
    calc
      _ ≤ ∑ s∈Finset.range t,(1:ℝ) := by
        exact Finset.sum_le_sum fun _ _ => IntegerDraw.tail_le_one _ _ _
      _ = _ := by simp
  have he : (∑' s,tail program (encodeNat N++rest) (s+t))=
      ∑' s,tail IntegerDraw.program (IntegerDraw.rawMaximum N) s := by
    congr 1
    funext s
    simpa only [Nat.add_comm] using (hl s).2
  rw [he]
  have hw : 2^(IntegerDraw.rawMaximum N).length≤
      2*(BinaryTrial.beValue (IntegerDraw.rawMaximum N)+1) := by
    simpa using IntegerDraw.minimal_width N
  have hi := IntegerDraw.stack_linear_expected (IntegerDraw.rawMaximum N) hw
  simp only [IntegerDraw.rawMaximum_length] at hi
  have ht' : (t:ℝ)≤9*(N.size:ℝ)+6 := by exact_mod_cast ht
  push_cast at hi
  linarith

theorem stack_uniform (N : ℕ) (rest : List Bool) (u : Fin (N+1)) :
    Tendsto (mass program (encodeNat N++rest) (IntegerDraw.integerWord N u))
      atTop (nhds (1/(N+1:ℝ))) := by
  obtain ⟨t,ht,hl⟩ := shifted_laws N rest
  apply (tendsto_add_atTop_iff_nat t).1
  have he : (fun s => mass program (encodeNat N++rest) (IntegerDraw.integerWord N u) (s+t))=
      mass IntegerDraw.program (IntegerDraw.rawMaximum N) (IntegerDraw.integerWord N u) := by
    funext s
    simpa only [Nat.add_comm] using (hl s).1 (IntegerDraw.integerWord N u)
  rw [he]
  simpa only [IntegerDraw.rawMaximum_value,IntegerDraw.integerWord] using
    IntegerDraw.stack_uniform (IntegerDraw.rawMaximum N) ⟨u,by simpa using u.isLt⟩

 

theorem integer_sampler (N : ℕ) (rest : List Bool) :
    (∀ (t : ℕ) (coins : Fin t→Bool),(machine.run (encodeNat N++rest) coins).state=none →
      ∃ u : Fin (N+1),(machine.run (encodeNat N++rest) coins).outputRev.reverse=IntegerDraw.integerWord N u) ∧
    Tendsto (machine.tail (encodeNat N++rest)) atTop (nhds 0) ∧
    (∀ u : Fin (N+1),Tendsto (machine.mass (encodeNat N++rest) (IntegerDraw.integerWord N u))
      atTop (nhds (1/(N+1:ℝ)))) ∧
    Summable (machine.tail (encodeNat N++rest)) ∧
    (∑' t,machine.tail (encodeNat N++rest) t)≤70*(N.size:ℝ)+42 := by
  have hs := tail_summable_compile program (encodeNat N++rest) (stack_summable N rest)
  refine ⟨?_,hs.tendsto_atTop_zero,?_,hs,?_⟩
  · exact safe_compile program (encodeNat N++rest)
      (fun out => ∃ u : Fin (N+1),out=IntegerDraw.integerWord N u)
      (fun _ f h => stack_safe N rest f h)
  · intro u
    exact mass_limit_compile program (encodeNat N++rest) (IntegerDraw.integerWord N u) _
      (stack_uniform N rest u)
  · rw [machine,expected_compile program (encodeNat N++rest) (stack_summable N rest)]
    linarith [stack_expected N rest]

end
end Contingency.BitModel.StackCode.EncodedInteger

end

end OAI