lean/OAI/Probability/Contingency/BinaryAddition.lean

import Mathlib
import OAI.Probability.Contingency.GreedyTable
import OAI.Probability.Contingency.StackSafety

namespace OAI

/-! Binary Addition. -/

noncomputable section


namespace Contingency.BitModel.StackCode.BinaryAdd
open BinarySubtract
noncomputable section

theorem value_append (as bs : List Bool) :
    value (as++bs)=value as+2^as.length*value bs := by
  induction as with
  | nil => simp [value]
  | cons a as ih =>
    simp only [List.cons_append,value,List.length_cons,pow_succ,ih]
    ring

theorem full_output_value (ds : List Digit) (c : Bool) :
    value (output ds c++[carry ds c])=value (ds.map Digit.a)+value (ds.map Digit.b)+c.toNat := by
  rw [value_append,output_length]
  simpa only [value,Nat.mul_zero,Nat.add_zero] using (word_identity ds c).symm

 

theorem add_tape (ds : List Digit) (m : Memory 4)
    (ha : m.stack 0=ds.map Digit.a) (hb : m.stack 1=ds.map Digit.b)
    (h2 : m.stack 2=[]) :
    ∃ m' : Memory 4,m'.stack 0=[] ∧ m'.stack 1=[] ∧
      (m'.stack 2).length=ds.length+1 ∧
      value (m'.stack 2).reverse=value (ds.map Digit.a)+value (ds.map Digit.b) ∧
      m'.stack 3=m.stack 3 ∧ m'.input=m.input ∧ m'.outputRev=m.outputRev ∧
      ∀ coins : Fin ((3*ds.length+3)*2)→Bool,
        (List.ofFn coins).foldl (fun cfg b => (compile program).step b cfg)
          (encode program (config (.start false) m))=encode program ⟨none,m'⟩ := by
  let m' := ((wordMemory ds false m).pop 0).push 2 (carry ds false)
  have hf := wordMemory_stacks ds false m ha hb
  have h0 : m'.stack 0=[] := by simp [m',Memory.push,Memory.pop,hf.1]
  have h1 : m'.stack 1=[] := by simpa [m',Memory.push,Memory.pop] using hf.2.1
  have ho : m'.stack 2=carry ds false::(output ds false).reverse := by
    simp [m',Memory.push,Memory.pop,hf.2.2.1,h2]
  have h3 : m'.stack 3=m.stack 3 := by simpa [m',Memory.push,Memory.pop] using hf.2.2.2.1
  refine ⟨m',h0,h1,?_,?_,h3,hf.2.2.2.2.1,hf.2.2.2.2.2,?_⟩
  · simp [ho,output_length]
  · rw [ho,List.reverse_cons,List.reverse_reverse]
    simpa using full_output_value ds false
  · intro coins
    rw [BinarySubtract.fold_compiled]
    rw [fold_independent _ (List.replicate (3*ds.length+3) false) (by simp)]
    have hr := finish_run ds false m ha hb (List.replicate (3*ds.length) false) (by simp) false false false
    have he : List.replicate (3*ds.length+3) false=List.replicate (3*ds.length) false++[false,false,false] := by
      rw [List.replicate_add]; rfl
    rw [he,hr]

 

theorem add_naturals (x y n : ℕ) (hx : x.size≤n) (hy : y.size≤n) (m : Memory 4)
    (h0 : m.stack 0=bits n x) (h1 : m.stack 1=bits n y) (h2 : m.stack 2=[]) :
    ∃ m' : Memory 4,value (m'.stack 2).reverse=x+y ∧ (m'.stack 2).length=n+1 ∧
      ∀ coins : Fin ((3*n+3)*2)→Bool,
        (List.ofFn coins).foldl (fun cfg b => (compile program).step b cfg)
          (encode program (config (.start false) m))=encode program ⟨none,m'⟩ := by
  let ds := digits (bits n x) (bits n y)
  have hl : (bits n x).length=(bits n y).length := by rw [bits_length _ _ (Nat.size_le.mp hx),bits_length _ _ (Nat.size_le.mp hy)]
  obtain ⟨ha,hb,hd⟩ := digits_maps (bits n x) (bits n y) hl
  obtain ⟨m',_,_,hm,he,_,_,_,hr⟩ := add_tape ds m (h0.trans ha.symm) (h1.trans hb.symm) h2
  have hn : ds.length=n := hd.trans (bits_length n x (Nat.size_le.mp hx))
  refine ⟨m',?_,by simpa [hn] using hm,?_⟩
  · simpa [ds,ha,hb,bits_value] using he
  · let S : ℕ→Prop := fun T => ∀ coins : Fin T→Bool,
        (List.ofFn coins).foldl (fun cfg b => (compile program).step b cfg)
          (encode program (config (.start false) m))=encode program ⟨none,m'⟩
    have hr' : S ((3*ds.length+3)*2) := hr
    have ht : (3*ds.length+3)*2=(3*n+3)*2 := by rw [hn]
    exact Eq.mp (congrArg S ht) hr' 

end
end Contingency.BitModel.StackCode.BinaryAdd

 

 

 

namespace Contingency.BitModel.StackCode.WeightedScan
open BinarySubtract
noncomputable section

inductive Q
  | start (c : Bool)
  | read (c a : Bool)
  | place (c a b : Bool)
  | advance
  | restore
  | back (b : Bool)
  | selected
  | out
  | finish
  deriving DecidableEq, Fintype

def label (q : Q) : Fin (Fintype.card Q) := Fintype.equivFin Q q

def code : Q→Op (Fintype.card Q) 4
  | .start c => .pop 0 (label (if c then .selected else .advance)) (label (.read c false)) (label (.read c true))
  | .read c a => .read (label (.place c a false)) (label (.place c a false)) (label (.place c a true))
  | .place c a b => .push 2 (outBit a b c) (label (.start (nextBorrow a b c)))
  | .advance => .push 3 false (label .restore)
  | .restore => .pop 2 (label (.start false)) (label (.back false)) (label (.back true))
  | .back b => .push 0 b (label .restore)
  | .selected => .pop 3 (label .finish) (label .out) (label .out)
  | .out => .emit false (label .selected)
  | .finish => .halt

def program : Program := ⟨Fintype.card Q,4,label (.start false),fun pc => code ((Fintype.equivFin Q).symm pc)⟩
def config (q : Q) (m : Memory 4) : Config program := ⟨some (label q),m⟩

def exec (t : ℕ) (cfg : Config program) : Config program :=
  (List.replicate t false).foldl (fun cfg b => step program b cfg) cfg

theorem exec_add (s t : ℕ) (cfg : Config program) : exec (s+t) cfg=exec t (exec s cfg) := by
  simp only [exec,List.replicate_add,List.foldl_append]

@[simp] theorem exec_zero (cfg : Config program) : exec 0 cfg=cfg := rfl
@[simp] theorem exec_one (cfg : Config program) : exec 1 cfg=step program false cfg := rfl

theorem one_step (q : Q) (m : Memory 4) (coin : Bool) :
    step program coin (config q m)=⟨(effect (code q) coin m).1,(effect (code q) coin m).2⟩ := by
  simp [step,program,config,label]

theorem first_step (m : Memory 4) (c a coin : Bool) (as : List Bool) (ha : m.stack 0=a::as) :
    step program coin (config (.start c) m)=config (.read c a) (m.pop 0) := by
  rw [one_step]
  cases a <;> simp [code,effect,branch,ha,config] <;> rfl

theorem second_step (m : Memory 4) (c a b coin : Bool) (bs : List Bool) (hb : m.input=b::bs) :
    step program coin (config (.read c a) m)=config (.place c a b) m.read := by
  rw [one_step]
  cases b <;> simp [code,effect,branch,hb,config] <;> rfl

theorem third_step (m : Memory 4) (c a b coin : Bool) :
    step program coin (config (.place c a b) m)=config (.start (nextBorrow a b c)) (m.push 2 (outBit a b c)) := by
  rw [one_step]; rfl

def digitMemory (d : Digit) (c : Bool) (m : Memory 4) : Memory 4 :=
  ((m.pop 0).read).push 2 (outBit d.a d.b c)

def wordMemory : List Digit→Bool→Memory 4→Memory 4
  | [],_,m => m
  | d::ds,c,m => wordMemory ds (nextBorrow d.a d.b c) (digitMemory d c m)

theorem three_steps (m : Memory 4) (d : Digit) (c : Bool) (as bs : List Bool)
    (ha : m.stack 0=d.a::as) (hb : m.input=d.b::bs) :
    exec 3 (config (.start c) m)=config (.start (nextBorrow d.a d.b c)) (digitMemory d c m) := by
  change step program false (step program false (step program false (config (.start c) m)))=_
  rw [first_step m c d.a false as ha,second_step _ c d.a d.b false bs,third_step]
  · rfl
  · exact hb

theorem pass (ds : List Digit) (c : Bool) (m : Memory 4) (rest : List Bool)
    (ha : m.stack 0=ds.map Digit.a) (hb : m.input=ds.map Digit.b++rest) :
    exec (3*ds.length) (config (.start c) m)=config (.start (borrow ds c)) (wordMemory ds c m) := by
  induction ds generalizing c m with
  | nil => rfl
  | cons d ds ih =>
    have he : 3*(d::ds).length=3+3*ds.length := by simp; omega
    rw [he,exec_add,three_steps m d c _ _ ha hb,ih]
    · rfl
    · simp [digitMemory,Memory.push,Memory.pop,Memory.read,ha]
    · simp [digitMemory,Memory.push,Memory.pop,Memory.read,hb]

theorem wordMemory_stacks (ds : List Digit) (c : Bool) (m : Memory 4) (rest : List Bool)
    (ha : m.stack 0=ds.map Digit.a) (hb : m.input=ds.map Digit.b++rest) :
    (wordMemory ds c m).stack 0=[] ∧
    (wordMemory ds c m).stack 2=(output ds c).reverse++m.stack 2 ∧
    (wordMemory ds c m).stack 3=m.stack 3 ∧
    (wordMemory ds c m).input=rest ∧
    (wordMemory ds c m).outputRev=m.outputRev := by
  induction ds generalizing c m with
  | nil => exact ⟨ha,rfl,rfl,hb,rfl⟩
  | cons d ds ih =>
    have h0 : (digitMemory d c m).stack 0=ds.map Digit.a := by
      simp [digitMemory,Memory.push,Memory.pop,Memory.read,ha]
    have hi : (digitMemory d c m).input=ds.map Digit.b++rest := by
      simp [digitMemory,Memory.push,Memory.pop,Memory.read,hb]
    have hh := ih (nextBorrow d.a d.b c) (digitMemory d c m) h0 hi
    refine ⟨hh.1,?_,?_,hh.2.2.2.1,hh.2.2.2.2⟩
    · simpa [wordMemory,output,List.reverse_cons,List.append_assoc,digitMemory,Memory.push,Memory.pop,Memory.read] using hh.2.1
    · simpa [wordMemory,digitMemory,Memory.push,Memory.pop,Memory.read] using hh.2.2.1

end
end Contingency.BitModel.StackCode.WeightedScan

 

 

namespace Contingency.BitModel.StackCode.WeightedScan
open BinarySubtract
noncomputable section

theorem end_word (m : Memory 4) (c : Bool) (h0 : m.stack 0=[]) :
    exec 1 (config (.start c) m)=config (if c then .selected else .advance) (m.pop 0) := by
  rw [exec_one,one_step]
  simp [code,effect,branch,h0,config]; rfl

theorem advance (m : Memory 4) :
    exec 1 (config .advance m)=config .restore (m.push 3 false) := by
  rw [exec_one,one_step]; rfl

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

theorem restore_bit (m : Memory 4) (b : Bool) (bs : List Bool) (h2 : m.stack 2=b::bs) :
    exec 2 (config .restore m)=config .restore ((m.pop 2).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 (.back b) (m.pop 2) := by
    cases b <;> simp [code,effect,branch,h2,config] <;> rfl
  rw [he,one_step]
  rfl

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

theorem restore_run (bs : List Bool) (m : Memory 4) (h2 : m.stack 2=bs) :
    exec (2*bs.length+1) (config .restore m)=config (.start false) (restoreMemory bs m) := by
  induction bs generalizing m with
  | nil => exact restore_empty m h2
  | 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 h2,ih]
    · rfl
    · simp [Memory.push,Memory.pop,h2]

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

theorem selected_empty (m : Memory 4) (h3 : m.stack 3=[]) :
    exec 2 (config .selected m)=⟨none,m.pop 3⟩ := by
  change step program false (step program false (config .selected m))=_
  rw [one_step]
  have he : (⟨(effect (code .selected) false m).1,(effect (code .selected) false m).2⟩ : Config program)=
      config .finish (m.pop 3) := by
    simp [code,effect,branch,h3,config]; rfl
  rw [he,one_step]
  rfl

def emitMemory (m : Memory 4) : Memory 4 :=
  {m.pop 3 with outputRev:=false::m.outputRev}

theorem selected_bit (m : Memory 4) (bs : List Bool) (h3 : m.stack 3=false::bs) :
    exec 2 (config .selected m)=config .selected (emitMemory m) := by
  change step program false (step program false (config .selected m))=_
  rw [one_step]
  have he : (⟨(effect (code .selected) false m).1,(effect (code .selected) false m).2⟩ : Config program)=
      config .out (m.pop 3) := by
    simp [code,effect,branch,h3,config]; rfl
  rw [he,one_step]
  rfl

def selectedMemory : ℕ→Memory 4→Memory 4
  | 0,m => m.pop 3
  | i+1,m => selectedMemory i (emitMemory m)

theorem selected_run (i : ℕ) (m : Memory 4) (h3 : m.stack 3=List.replicate i false) :
    exec (2*i+2) (config .selected m)=⟨none,selectedMemory i m⟩ := by
  induction i generalizing m with
  | zero => exact selected_empty m h3
  | succ i ih =>
    have he : 2*(i+1)+2=2+(2*i+2) := by omega
    rw [he,exec_add,selected_bit m (List.replicate i false) h3,ih]
    · rfl
    · simp [emitMemory,Memory.pop,h3,List.replicate_succ]

theorem selectedMemory_output (i : ℕ) (m : Memory 4) :
    (selectedMemory i m).outputRev=List.replicate i false++m.outputRev := by
  induction i generalizing m with
  | zero => rfl
  | succ i ih =>
    rw [selectedMemory,ih]
    change List.replicate i false++false::m.outputRev=_
    rw [show List.replicate (i+1) false=List.replicate i false++[false] by rw [List.replicate_add]; rfl,List.append_assoc]
    rfl

 

theorem skip_weight (ds : List Digit) (m : Memory 4) (rest : List Bool) (i : ℕ)
    (ha : m.stack 0=ds.map Digit.a) (hb : m.input=ds.map Digit.b++rest)
    (h2 : m.stack 2=[]) (h3 : m.stack 3=List.replicate i false)
    (hsub : value (ds.map Digit.b)≤value (ds.map Digit.a)) :
    ∃ m', exec (5*ds.length+3) (config (.start false) m)=config (.start false) m' ∧
      m'.stack 0=output ds false ∧ m'.stack 2=[] ∧
      m'.stack 3=List.replicate (i+1) false ∧ m'.input=rest ∧ m'.outputRev=m.outputRev := by
  let w := wordMemory ds false m
  have hw := wordMemory_stacks ds false m rest ha hb
  have hc := (subtract_correct ds hsub).1
  let a := (w.pop 0).push 3 false
  have ha2 : a.stack 2=(output ds false).reverse := by
    simpa [a,Memory.push,Memory.pop,h2,w] using hw.2.1
  have hr := restoreMemory_stacks (output ds false).reverse a ha2
  refine ⟨restoreMemory (output ds false).reverse a,?_,?_,hr.2.1,?_,?_,?_⟩
  · have he : 5*ds.length+3=3*ds.length+1+1+(2*(output ds false).reverse.length+1) := by simp; omega
    rw [he,exec_add (3*ds.length+1+1) (2*(output ds false).reverse.length+1),exec_add (3*ds.length+1) 1,exec_add (3*ds.length) 1,pass ds false m rest ha hb,hc,end_word _ false hw.1]
    change exec (2*(output ds false).reverse.length+1) (exec 1 (config .advance (w.pop 0)))=_
    rw [advance,restore_run _ _ ha2]
  · simpa [a,Memory.push,Memory.pop,w,hw.1] using hr.1
  · have hm3 : a.stack 3=List.replicate (i+1) false := by
      simp [a,Memory.push,Memory.pop,w,hw.2.2.1,h3,List.replicate_succ]
    exact hr.2.2.1.trans hm3
  · exact hr.2.2.2.1.trans hw.2.2.2.1
  · exact hr.2.2.2.2.trans hw.2.2.2.2

 
theorem hit_weight (ds : List Digit) (m : Memory 4) (rest : List Bool) (i : ℕ)
    (ha : m.stack 0=ds.map Digit.a) (hb : m.input=ds.map Digit.b++rest)
    (h3 : m.stack 3=List.replicate i false)
    (hlt : value (ds.map Digit.a)<value (ds.map Digit.b)) :
    ∃ m', exec (3*ds.length+2*i+3) (config (.start false) m)=⟨none,m'⟩ ∧
      m'.outputRev=List.replicate i false++m.outputRev := by
  let w := wordMemory ds false m
  have hw := wordMemory_stacks ds false m rest ha hb
  have hc := (borrow_iff ds).mpr hlt
  have hwi : (w.pop 0).stack 3=List.replicate i false := by
    simpa [w,Memory.pop,hw.2.2.1] using h3
  refine ⟨selectedMemory i (w.pop 0),?_,?_⟩
  · have he : 3*ds.length+2*i+3=(3*ds.length+1)+(2*i+2) := by omega
    rw [he,exec_add (3*ds.length+1) (2*i+2),exec_add (3*ds.length) 1,pass ds false m rest ha hb,hc,end_word _ true hw.1]
    exact selected_run i (w.pop 0) hwi
  · rw [selectedMemory_output]
    exact congrArg (List.append (List.replicate i false)) hw.2.2.2.2

end
end Contingency.BitModel.StackCode.WeightedScan

 

 

 

namespace Contingency.BitModel.StackCode.WeightedScan
open BinarySubtract
noncomputable section

def weightTotal (ws : List (List Bool)) : ℕ := (ws.map value).sum

def indexedWeights : List (List Bool)→ℕ→List (ℕ×ℕ)
  | [],_ => []
  | w::ws,i => (i,value w)::indexedWeights ws (i+1)

@[simp] theorem indexed_total (ws : List (List Bool)) (i : ℕ) :
    Contingency.IntegerDraw.total (indexedWeights ws i)=weightTotal ws := by
  induction ws generalizing i with
  | nil => rfl
  | cons w ws ih => simp [indexedWeights,Contingency.IntegerDraw.total,weightTotal,ih]

 

theorem scan_run (ws : List (List Bool)) (as : List Bool) (m : Memory 4)
    (rest : List Bool) (i : ℕ)
    (hlen : ∀ w∈ws,w.length=as.length)
    (ha : m.stack 0=as) (hi : m.input=ws.flatten++rest)
    (h2 : m.stack 2=[]) (h3 : m.stack 3=List.replicate i false)
    (hz : value as<weightTotal ws) :
    ∃ (j : ℕ) (m' : Memory 4), j<ws.length ∧
      Contingency.IntegerDraw.scan (indexedWeights ws i) (value as)=some (i+j) ∧
      exec (3*as.length+2*i+3+j*(5*as.length+5)) (config (.start false) m)=⟨none,m'⟩ ∧
      m'.outputRev=List.replicate (i+j) false++m.outputRev := by
  induction ws generalizing as m i with
  | nil => simp [weightTotal] at hz
  | cons w ws ih =>
    have hw : w.length=as.length := hlen w (by simp)
    let ds := digits as w
    obtain ⟨hda,hdb,hdl⟩ := digits_maps as w hw.symm
    have hha : m.stack 0=ds.map Digit.a := ha.trans hda.symm
    have hhi : m.input=ds.map Digit.b++(ws.flatten++rest) := by
      simpa [ds,hdb,List.flatten_cons,List.append_assoc] using hi
    by_cases hlt : value as<value w
    · obtain ⟨m',hr,ho⟩ := hit_weight ds m (ws.flatten++rest) i hha hhi h3 (by simpa [ds,hda,hdb] using hlt)
      refine ⟨0,m',by simp,?_,?_,?_⟩
      · simp [indexedWeights,Contingency.IntegerDraw.scan,hlt]
      · simpa [ds,hdl] using hr
      · simpa using ho
    · have hsub : value (ds.map Digit.b)≤value (ds.map Digit.a) := by simpa [ds,hda,hdb] using (Nat.le_of_not_gt hlt)
      obtain ⟨m₁,hr,ha₁,h2₁,h3₁,hi₁,ho₁⟩ := skip_weight ds m (ws.flatten++rest) i hha hhi h2 h3 hsub
      have hv := (subtract_correct ds hsub).2
      have hlen₁ : ∀ w∈ws,w.length=(output ds false).length := by
        intro v hv
        simpa [output_length,ds,hdl] using hlen v (by simp [hv])
      have hz₁ : value (output ds false)<weightTotal ws := by
        rw [hv]
        simp only [ds,hda,hdb] at *
        simp only [weightTotal,List.map_cons,List.sum_cons] at hz ⊢
        omega
      obtain ⟨j,m',hj,hscan,hexec,hout⟩ := ih (output ds false) m₁ (i+1) hlen₁ ha₁ hi₁ h2₁ h3₁ hz₁
      refine ⟨j+1,m',by simpa using Nat.succ_lt_succ hj,?_,?_,?_⟩
      · simp only [indexedWeights,Contingency.IntegerDraw.scan,ite_eq_right hlt]
        have he : value (output ds false)=value as-value w := by simpa [ds,hda,hdb] using hv
        rw [he] at hscan
        simpa [Nat.add_assoc,Nat.add_comm,Nat.add_left_comm] using hscan
      · have he : 3*as.length+2*i+3+(j+1)*(5*as.length+5)=
            (5*ds.length+3)+(3*(output ds false).length+2*(i+1)+3+j*(5*(output ds false).length+5)) := by
          simp only [output_length,ds,hdl]
          ring
        rw [he,exec_add,hr,hexec]
      · simpa [ho₁,Nat.add_assoc,Nat.add_comm,Nat.add_left_comm] using hout

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 scan_tape (ws : List (List Bool)) (as : List Bool) (m : Memory 4) (rest : List Bool)
    (hlen : ∀ w∈ws,w.length=as.length)
    (ha : m.stack 0=as) (hi : m.input=ws.flatten++rest)
    (h2 : m.stack 2=[]) (h3 : m.stack 3=[])
    (hz : value as<weightTotal ws) :
    ∃ (t j : ℕ) (m' : Memory 4), t*2≤10*(as.length+1)*ws.length ∧ j<ws.length ∧
      Contingency.IntegerDraw.scan (indexedWeights ws 0) (value as)=some j ∧
      m'.outputRev=List.replicate j false++m.outputRev ∧
      ∀ coins : Fin (t*2)→Bool,
        (List.ofFn coins).foldl (fun cfg b => (compile program).step b cfg)
          (encode program (config (.start false) m))=encode program ⟨none,m'⟩ := by
  obtain ⟨j,m',hj,hs,hr,ho⟩ := scan_run ws as m rest 0 hlen ha hi h2 h3 hz
  let t := 3*as.length+2*0+3+j*(5*as.length+5)
  refine ⟨t,j,m',?_,hj,by simpa using hs,by simpa using ho,?_⟩
  · have hm := Nat.mul_le_mul_left (5*as.length+5) (Nat.succ_le_iff.mpr hj)
    dsimp only [t]
    nlinarith only [hm]
  · intro coins
    rw [BinarySubtract.fold_compiled]
    have he := fold_independent (List.ofFn fun i : Fin t => coins (second i)) (List.replicate t false) (by simp) (config (.start false) m)
    rw [he]
    change encode program (exec t (config (.start false) m))=_
    rw [hr]

end
end Contingency.BitModel.StackCode.WeightedScan

 

 

 

namespace Contingency.BitModel.StackCode

namespace Internal

def work {w : ℕ} (i : Fin w) : Fin (w+2) := i.castSucc.castSucc

def input (w : ℕ) : Fin (w+2) := (Fin.last w).castSucc

def output (w : ℕ) : Fin (w+2) := Fin.last (w+1)

@[simp] theorem work_inj {w : ℕ} (i j : Fin w) : work i=work j ↔ i=j := by simp [work]
@[simp] theorem work_ne_input {w : ℕ} (i : Fin w) : work i≠input w := by simp [work,input]
@[simp] theorem work_ne_output {w : ℕ} (i : Fin w) : work i≠output w := by simp [work,output]
@[simp] theorem input_ne_output (w : ℕ) : input w≠output w := by simp [input,output]
@[simp] theorem input_ne_work {w : ℕ} (i : Fin w) : input w≠work i := (work_ne_input i).symm
@[simp] theorem output_ne_work {w : ℕ} (i : Fin w) : output w≠work i := (work_ne_output i).symm
@[simp] theorem output_ne_input (w : ℕ) : output w≠input w := (input_ne_output w).symm

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 => .push (output w) 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.stack (output w)=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.push (output w) v) := by
  rcases h with ⟨hw,hi,ho⟩
  refine ⟨?_,?_,?_⟩
  · intro j
    simpa [Memory.push] using hw j
  · simpa [Memory.push] using hi
  · simp [Memory.push,ho]

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)

 

def loaded (P : Program) (xs : List Bool) (external : Memory (P.work+2)) : Config (program P) :=
  ⟨some P.start,{external with stack:=Fin.lastCases [] (Fin.lastCases xs (fun _ => []))}⟩

theorem loaded_rel (P : Program) (xs : List Bool) (external : Memory (P.work+2)) :
    ConfigRel P (initial P xs) (loaded P xs external) := by
  refine ⟨rfl,?_,?_,?_⟩
  · intro i
    simp [loaded,initial,work]
  · simp [loaded,initial,input]
  · simp [loaded,initial,output]

 

theorem loaded_run (P : Program) (xs : List Bool) (external : Memory (P.work+2))
    {t : ℕ} (coins : Fin t→Bool) :
    ConfigRel P (run P xs coins)
      ((List.ofFn coins).foldl (fun c v => step (program P) v c) (loaded P xs external)) :=
  fold_rel P _ (loaded_rel P xs external)

end Internal
end Contingency.BitModel.StackCode

 

 

namespace Contingency.BitModel.StackCode.Internal

theorem effect_frame {l w : ℕ} (code : Op l w) (coin : Bool) (b : Memory (w+2)) :
    (effect (op code) coin b).2.input=b.input ∧
      (effect (op code) coin b).2.outputRev=b.outputRev ∧
      (effect (op code) coin b).2.consumed=b.consumed := by
  cases code <;> exact ⟨rfl,rfl,rfl⟩

theorem step_frame (P : Program) (coin : Bool) (b : Config (program P)) :
    (step (program P) coin b).memory.input=b.memory.input ∧
      (step (program P) coin b).memory.outputRev=b.memory.outputRev ∧
      (step (program P) coin b).memory.consumed=b.memory.consumed := by
  rcases b with ⟨s,m⟩
  cases s with
  | none => exact ⟨rfl,rfl,rfl⟩
  | some q => exact effect_frame (P.code q) coin m

theorem fold_frame (P : Program) (coins : List Bool) (b : Config (program P)) :
    (coins.foldl (fun c v => step (program P) v c) b).memory.input=b.memory.input ∧
    (coins.foldl (fun c v => step (program P) v c) b).memory.outputRev=b.memory.outputRev ∧
    (coins.foldl (fun c v => step (program P) v c) b).memory.consumed=b.memory.consumed := by
  induction coins generalizing b with
  | nil => exact ⟨rfl,rfl,rfl⟩
  | cons c coins ih =>
    have hh := ih (step (program P) c b)
    have he := step_frame P c b
    exact ⟨hh.1.trans he.1,hh.2.1.trans he.2.1,hh.2.2.trans he.2.2⟩

theorem tape_fold (P : Program) (cfg : Config P) {t : ℕ} (coins : Fin (t*2)→Bool) :
    (List.ofFn coins).foldl (fun cfg b => (compile P).step b cfg) (encode P cfg)=
      encode P ((List.ofFn (fun i : Fin t => coins (second i))).foldl (fun cfg b => step P b cfg) cfg) := by
  rw [coins_as_pairs,fold_pairs]
  congr 1
  have hh := List.foldl_map (f:=Prod.snd) (g:=fun cfg b => step P b cfg)
    (l:=List.ofFn fun i : Fin t => (coins (first i),coins (second i))) (init:=cfg)
  simpa only [List.map_ofFn,Function.comp_def] using hh.symm

 

theorem loaded_tape (P : Program) (xs : List Bool) (external : Memory (P.work+2))
    {t : ℕ} (coins : Fin (t*2)→Bool) :
    ∃ b : Config (program P),
      (List.ofFn coins).foldl (fun cfg v => (compile (program P)).step v cfg)
          (encode (program P) (loaded P xs external))=encode (program P) b ∧
      b.state=(run P xs (fun i : Fin t => coins (second i))).state ∧
      (∀ i,b.memory.stack (work i)=(run P xs (fun i : Fin t => coins (second i))).memory.stack i) ∧
      b.memory.stack (input P.work)=(run P xs (fun i : Fin t => coins (second i))).memory.input ∧
      b.memory.stack (output P.work)=(run P xs (fun i : Fin t => coins (second i))).memory.outputRev ∧
      b.memory.input=external.input ∧ b.memory.outputRev=external.outputRev ∧
      b.memory.consumed=external.consumed := by
  let bs := List.ofFn fun i : Fin t => coins (second i)
  let b := bs.foldl (fun c v => step (program P) v c) (loaded P xs external)
  have hr := loaded_run P xs external (fun i : Fin t => coins (second i))
  have hf := fold_frame P bs (loaded P xs external)
  exact ⟨b,tape_fold (program P) (loaded P xs external) coins,hr.1,hr.2.1,hr.2.2.1,hr.2.2.2,hf.1,hf.2.1,hf.2.2⟩

end Contingency.BitModel.StackCode.Internal

end

end OAI