import Mathlib
import OAI.Probability.Contingency.IntegerDrawTail

namespace OAI

/-! Stack Safety. -/

noncomputable section


namespace Contingency.BitModel.StackCode
noncomputable section

theorem mass_eq_zero_of_safe (P : Program) (xs : List Bool) (Safe : List Bool→Prop)
    (hs : ∀ (t : ℕ) (f : Fin t→Bool),(run P xs f).state=none → Safe (run P xs f).memory.outputRev.reverse)
    (out : List Bool) (ho : ¬Safe out) (t : ℕ) : mass P xs out t=0 := by
  classical
  unfold mass
  have he : (Finset.univ.filter fun f : Fin t→Bool => (run P xs f).state=none ∧
      (run P xs f).memory.outputRev.reverse=out)=∅ := by
    apply Finset.filter_eq_empty_iff.mpr
    intro f _ hh
    apply ho
    rw [← hh.2]
    exact hs t f hh.1
  rw [he]
  simp

theorem safe_compile (P : Program) (xs : List Bool) (Safe : List Bool→Prop)
    (hs : ∀ (t : ℕ) (f : Fin t→Bool),(run P xs f).state=none → Safe (run P xs f).memory.outputRev.reverse)
    (t : ℕ) (f : Fin t→Bool) (hh : ((compile P).run xs f).state=none) :
    Safe ((compile P).run xs f).outputRev.reverse := by
  classical
  by_contra hn
  have hm := mass_compile_all P xs ((compile P).run xs f).outputRev.reverse t
  rw [mass_eq_zero_of_safe P xs Safe hs _ hn] at hm
  have hc : 0<(Finset.univ.filter fun g : Fin t→Bool => ((compile P).run xs g).state=none ∧
      ((compile P).run xs g).outputRev.reverse=((compile P).run xs f).outputRev.reverse).card := by
    apply Finset.card_pos.mpr
    exact ⟨f,Finset.mem_filter.mpr ⟨Finset.mem_univ _,hh,rfl⟩⟩
  have hp : 0<(compile P).mass xs ((compile P).run xs f).outputRev.reverse t := by
    unfold Machine.mass
    apply div_pos _ (by positivity)
    exact_mod_cast hc
  linarith

end
end Contingency.BitModel.StackCode

 

 

 

open Filter
namespace Contingency.BitModel.StackCode.IntegerDraw
open BinaryTrial
noncomputable section

theorem beValue_snoc (xs : List Bool) (b : Bool) :
    beValue (xs++[b])=2*beValue xs+b.toNat := by
  unfold beValue
  rw [List.foldl_append]
  rfl

theorem beValue_bits_reverse (N : ℕ) : beValue N.bits.reverse=N := by
  induction N using Nat.binaryRec' with
  | zero => rfl
  | bit b n h ih =>
    rw [Nat.bits_append_bit _ _ h,List.reverse_cons,beValue_snoc,ih]
    cases b <;> simp [Nat.bit]

theorem minimal_width (N : ℕ) : 2^N.size≤2*(N+1) := by
  by_cases hn : N.size=0
  · rw [hn]
    simp only [pow_zero]
    omega
  have hh := Nat.lt_size.mp (show N.size-1<N.size by omega)
  have he : N.size=(N.size-1)+1 := by omega
  calc
    2^N.size=2^(N.size-1)*2 := by conv_lhs => rw [he]; rw [pow_succ]
    _ ≤ N*2 := Nat.mul_le_mul_right 2 hh
    _ ≤ 2*(N+1) := by omega

def rawMaximum (N : ℕ) : List Bool := N.bits.reverse

@[simp] theorem rawMaximum_length (N : ℕ) : (rawMaximum N).length=N.size := by
  simp [rawMaximum,Nat.size_eq_bits_len]
@[simp] theorem rawMaximum_value (N : ℕ) : beValue (rawMaximum N)=N := beValue_bits_reverse N

def integerWord (N : ℕ) (u : Fin (N+1)) : List Bool :=
  validWord (rawMaximum N) ⟨u,by simpa using u.isLt⟩

@[simp] theorem integerWord_value (N : ℕ) (u : Fin (N+1)) : beValue (integerWord N u)=u.val := by
  unfold integerWord validWord
  rw [word_value]

@[simp] theorem integerWord_length (N : ℕ) (u : Fin (N+1)) : (integerWord N u).length=N.size := by
  simp [integerWord,validWord,word]

theorem machine_safe (B : List Bool) (t : ℕ) (f : Fin t→Bool) (hh : (machine.run B f).state=none) :
    ∃ u : Fin (beValue B+1),(machine.run B f).outputRev.reverse=validWord B u :=
  safe_compile program B (fun out => ∃ u : Fin (beValue B+1),out=validWord B u)
    (fun _ f hh => stack_safe B f hh) t f hh

 

theorem integer_sampler (N : ℕ) :
    (∀ (t : ℕ) (coins : Fin t→Bool),(machine.run (rawMaximum N) coins).state=none →
      ∃ u : Fin (N+1),(machine.run (rawMaximum N) coins).outputRev.reverse=integerWord N u) ∧
    Tendsto (machine.tail (rawMaximum N)) atTop (nhds 0) ∧
    (∀ u : Fin (N+1),Tendsto (machine.mass (rawMaximum N) (integerWord N u)) atTop (nhds (1/(N+1:ℝ)))) ∧
    Summable (machine.tail (rawMaximum N)) ∧
    (∑' t,machine.tail (rawMaximum N) t)≤52*(N.size:ℝ)+30 := by
  refine ⟨?_,machine_halts_ae _,?_,machine_summable _,?_⟩
  · intro t coins hh
    obtain ⟨u,hu⟩ := machine_safe (rawMaximum N) t coins hh
    refine ⟨⟨u,by simpa using u.isLt⟩,?_⟩
    exact hu
  · intro u
    simpa only [rawMaximum_value,integerWord] using machine_uniform (rawMaximum N) ⟨u,by simpa using u.isLt⟩
  · have hw : 2^(rawMaximum N).length≤2*(beValue (rawMaximum N)+1) := by
      simpa using minimal_width N
    simpa using machine_linear_expected (rawMaximum N) hw

end
end Contingency.BitModel.StackCode.IntegerDraw

 

 

 

namespace Contingency.BitModel.StackCode.BinarySubtract
noncomputable section

def outBit (a b carry : Bool) : Bool := xor (xor a b) carry
def nextBorrow (a b carry : Bool) : Bool := (!a && (b || carry)) || (b && carry)

theorem digit_identity (a b carry : Bool) :
    a.toNat+2*(nextBorrow a b carry).toNat = b.toNat+carry.toNat+(outBit a b carry).toNat := by
  cases a <;> cases b <;> cases carry <;> decide

def value : List Bool→ℕ
  | [] => 0
  | b::bs => b.toNat+2*value bs

structure Digit where
  a : Bool
  b : Bool

def output : List Digit → Bool → List Bool
  | [],_ => []
  | d::ds,c => outBit d.a d.b c :: output ds (nextBorrow d.a d.b c)

def borrow : List Digit → Bool → Bool
  | [],c => c
  | d::ds,c => borrow ds (nextBorrow d.a d.b c)

@[simp] theorem output_length (ds : List Digit) (c : Bool) : (output ds c).length=ds.length := by
  induction ds generalizing c with
  | nil => rfl
  | cons d ds ih => simp [output,ih]

theorem value_lt (bs : List Bool) : value bs<2^bs.length := by
  induction bs with
  | nil => decide
  | cons b bs ih =>
    change b.toNat+2*value bs<2^(bs.length+1)
    rw [pow_succ]
    cases b <;> simp only [Bool.toNat_false,Bool.toNat_true] <;> omega

theorem word_identity (ds : List Digit) (c : Bool) :
    value (ds.map Digit.a)+2^ds.length*(borrow ds c).toNat =
      value (ds.map Digit.b)+c.toNat+value (output ds c) := by
  induction ds generalizing c with
  | nil => simp [value,borrow,output]
  | cons d ds ih =>
    have hd := digit_identity d.a d.b c
    have hh := ih (nextBorrow d.a d.b c)
    simp only [List.map_cons,value,List.length_cons,pow_succ,borrow,output]
    nlinarith

theorem subtract_correct (ds : List Digit) (h : value (ds.map Digit.b)≤value (ds.map Digit.a)) :
    borrow ds false=false ∧ value (output ds false)=value (ds.map Digit.a)-value (ds.map Digit.b) := by
  have hh := word_identity ds false
  have ho := value_lt (output ds false)
  rw [output_length] at ho
  cases hb : borrow ds false <;> simp only [hb,Bool.toNat_false,Bool.toNat_true,Nat.mul_zero,Nat.mul_one,Nat.add_zero] at hh
  · exact ⟨rfl,by omega⟩
  · omega

inductive Q
  | start (carry : Bool)
  | second (carry a : Bool)
  | place (carry a b : Bool)
  | done (carry : Bool)
  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 (.done c)) (label (.second c false)) (label (.second c true))
  | .second c a => .pop 1 (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)))
  | .done _ => .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 digitMemory (d : Digit) (c : Bool) (m : Memory 4) : Memory 4 :=
  ((m.pop 0).pop 1).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 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,config,program,label]

theorem first_step (m : Memory 4) (c a x : Bool) (as : List Bool) (ha : m.stack 0=a::as) :
    step program x (config (.start c) m)=config (.second 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 x : Bool) (bs : List Bool) (hb : m.stack 1=b::bs) :
    step program x (config (.second c a) m)=config (.place c a b) (m.pop 1) := by
  rw [one_step]
  cases b <;> simp [code,effect,branch,hb,config] <;> rfl

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

theorem three_steps (m : Memory 4) (d : Digit) (c x y z : Bool) (as bs : List Bool)
    (ha : m.stack 0=d.a::as) (hb : m.stack 1=d.b::bs) :
    [x,y,z].foldl (fun cfg b => step program b cfg) (config (.start c) m)=
      config (.start (nextBorrow d.a d.b c)) (digitMemory d c m) := by
  simp only [List.foldl_cons,List.foldl_nil]
  rw [first_step m c d.a x as ha,second_step _ c d.a d.b y bs,third_step]
  · rfl
  · simpa using hb

theorem pass (ds : List Digit) (c : Bool) (m : Memory 4)
    (ha : m.stack 0=ds.map Digit.a) (hb : m.stack 1=ds.map Digit.b) :
    (List.replicate (3*ds.length) false).foldl (fun cfg b => step program b cfg) (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,List.replicate_add,List.foldl_append]
    change (List.replicate (3*ds.length) false).foldl _
      ([false,false,false].foldl _ (config (.start c) m))=_
    rw [three_steps m d c false false false _ _ ha hb,ih]
    · rfl
    · simp [digitMemory,Memory.push,Memory.pop,ha]
    · simp [digitMemory,Memory.push,Memory.pop,hb]

end
end Contingency.BitModel.StackCode.BinarySubtract

 

 

 

namespace Contingency.BitModel.StackCode.BinarySubtract
noncomputable section

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 pass_any (ds : List Digit) (c : Bool) (m : Memory 4)
    (ha : m.stack 0=ds.map Digit.a) (hb : m.stack 1=ds.map Digit.b)
    (coins : List Bool) (hl : coins.length=3*ds.length) :
    coins.foldl (fun cfg b => step program b cfg) (config (.start c) m)=
      config (.start (borrow ds c)) (wordMemory ds c m) := by
  rw [fold_independent coins (List.replicate (3*ds.length) false) (by simpa using hl)]
  exact pass ds c m ha hb

theorem wordMemory_stacks (ds : List Digit) (c : Bool) (m : Memory 4)
    (ha : m.stack 0=ds.map Digit.a) (hb : m.stack 1=ds.map Digit.b) :
    (wordMemory ds c m).stack 0=[] ∧ (wordMemory ds c m).stack 1=[] ∧
    (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=m.input ∧ (wordMemory ds c m).outputRev=m.outputRev := by
  induction ds generalizing c m with
  | nil => exact ⟨ha,hb,rfl,rfl,rfl,rfl⟩
  | cons d ds ih =>
    have h0 : (digitMemory d c m).stack 0=ds.map Digit.a := by
      simp [digitMemory,Memory.push,Memory.pop,ha]
    have h1 : (digitMemory d c m).stack 1=ds.map Digit.b := by
      simp [digitMemory,Memory.push,Memory.pop,hb]
    have hh := ih (nextBorrow d.a d.b c) (digitMemory d c m) h0 h1
    refine ⟨hh.1,hh.2.1,?_,?_,hh.2.2.2.2.1,hh.2.2.2.2.2⟩
    · simpa [wordMemory,output,List.reverse_cons,List.append_assoc,digitMemory,Memory.push,Memory.pop,Function.update_apply] using hh.2.2.1
    · simpa [wordMemory,digitMemory,Memory.push,Memory.pop,Function.update_apply] using hh.2.2.2.1

theorem finish (m : Memory 4) (c b : Bool) (hm : m.stack 0=[]) :
    step program b (config (.start c) m)=config (.done c) (m.pop 0) := by
  simp [step,program,config,label,code,effect,branch,hm]

theorem halt (m : Memory 4) (c b : Bool) :
    step program b (config (.done c) m)=⟨none,m⟩ := by
  simp [step,program,config,label,code,effect]

theorem finish_run (ds : List Digit) (c : Bool) (m : Memory 4)
    (ha : m.stack 0=ds.map Digit.a) (hb : m.stack 1=ds.map Digit.b)
    (coins : List Bool) (hl : coins.length=3*ds.length) (b b' : Bool) :
    (coins++[b,b']).foldl (fun cfg b => step program b cfg) (config (.start c) m)=
      ⟨none,(wordMemory ds c m).pop 0⟩ := by
  rw [List.foldl_append,pass_any ds c m ha hb coins hl]
  simp only [List.foldl_cons,List.foldl_nil]
  rw [finish _ _ _ (wordMemory_stacks ds c m ha hb).1,halt]

theorem fold_compiled (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 tape_pass (ds : List Digit) (c : Bool) (m : Memory 4)
    (ha : m.stack 0=ds.map Digit.a) (hb : m.stack 1=ds.map Digit.b)
    (coins : Fin ((3*ds.length)*2)→Bool) :
    (List.ofFn coins).foldl (fun cfg b => (compile program).step b cfg) (encode program (config (.start c) m))=
      encode program (config (.start (borrow ds c)) (wordMemory ds c m)) := by
  rw [fold_compiled,pass_any ds c m ha hb _ (by simp)]

end
end Contingency.BitModel.StackCode.BinarySubtract

 

 

 

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

def nextCarry (a b c : Bool) : Bool := (a && b) || (a && c) || (b && c)

theorem digit_identity (a b c : Bool) :
    a.toNat+b.toNat+c.toNat = (outBit a b c).toNat+2*(nextCarry a b c).toNat := by
  cases a <;> cases b <;> cases c <;> decide

def output : List Digit → Bool → List Bool
  | [],_ => []
  | d::ds,c => outBit d.a d.b c :: output ds (nextCarry d.a d.b c)

def carry : List Digit → Bool → Bool
  | [],c => c
  | d::ds,c => carry ds (nextCarry d.a d.b c)

@[simp] theorem output_length (ds : List Digit) (c : Bool) : (output ds c).length=ds.length := by
  induction ds generalizing c with
  | nil => rfl
  | cons d ds ih => simp [output,ih]

theorem word_identity (ds : List Digit) (c : Bool) :
    value (ds.map Digit.a)+value (ds.map Digit.b)+c.toNat =
      value (output ds c)+2^ds.length*(carry ds c).toNat := by
  induction ds generalizing c with
  | nil => simp [value,carry,output]
  | cons d ds ih =>
    have hd := digit_identity d.a d.b c
    have hh := ih (nextCarry d.a d.b c)
    simp only [List.map_cons,value,List.length_cons,pow_succ,carry,output]
    nlinarith

inductive Q
  | start (carry : Bool)
  | second (carry a : Bool)
  | place (carry a b : Bool)
  | done (carry : Bool)
  | halt
  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 (.done c)) (label (.second c false)) (label (.second c true))
  | .second c a => .pop 1 (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 (nextCarry a b c)))
  | .done c => .push 2 c (label .halt)
  | .halt => .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 digitMemory (d : Digit) (c : Bool) (m : Memory 4) : Memory 4 :=
  ((m.pop 0).pop 1).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 (nextCarry d.a d.b c) (digitMemory d c m)

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,config,program,label]

theorem first_step (m : Memory 4) (c a x : Bool) (as : List Bool) (ha : m.stack 0=a::as) :
    step program x (config (.start c) m)=config (.second 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 x : Bool) (bs : List Bool) (hb : m.stack 1=b::bs) :
    step program x (config (.second c a) m)=config (.place c a b) (m.pop 1) := by
  rw [one_step]
  cases b <;> simp [code,effect,branch,hb,config] <;> rfl

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

theorem three_steps (m : Memory 4) (d : Digit) (c x y z : Bool) (as bs : List Bool)
    (ha : m.stack 0=d.a::as) (hb : m.stack 1=d.b::bs) :
    [x,y,z].foldl (fun cfg b => step program b cfg) (config (.start c) m)=
      config (.start (nextCarry d.a d.b c)) (digitMemory d c m) := by
  simp only [List.foldl_cons,List.foldl_nil]
  rw [first_step m c d.a x as ha,second_step _ c d.a d.b y bs,third_step]
  · rfl
  · simpa using hb

theorem pass (ds : List Digit) (c : Bool) (m : Memory 4)
    (ha : m.stack 0=ds.map Digit.a) (hb : m.stack 1=ds.map Digit.b) :
    (List.replicate (3*ds.length) false).foldl (fun cfg b => step program b cfg) (config (.start c) m)=
      config (.start (carry 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,List.replicate_add,List.foldl_append]
    change (List.replicate (3*ds.length) false).foldl _
      ([false,false,false].foldl _ (config (.start c) m))=_
    rw [three_steps m d c false false false _ _ ha hb,ih]
    · rfl
    · simp [digitMemory,Memory.push,Memory.pop,ha]
    · simp [digitMemory,Memory.push,Memory.pop,hb]

end
end Contingency.BitModel.StackCode.BinaryAdd

 

 

 

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

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 pass_any (ds : List Digit) (c : Bool) (m : Memory 4)
    (ha : m.stack 0=ds.map Digit.a) (hb : m.stack 1=ds.map Digit.b)
    (coins : List Bool) (hl : coins.length=3*ds.length) :
    coins.foldl (fun cfg b => step program b cfg) (config (.start c) m)=
      config (.start (carry ds c)) (wordMemory ds c m) := by
  rw [fold_independent coins (List.replicate (3*ds.length) false) (by simpa using hl)]
  exact pass ds c m ha hb

theorem wordMemory_stacks (ds : List Digit) (c : Bool) (m : Memory 4)
    (ha : m.stack 0=ds.map Digit.a) (hb : m.stack 1=ds.map Digit.b) :
    (wordMemory ds c m).stack 0=[] ∧ (wordMemory ds c m).stack 1=[] ∧
    (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=m.input ∧ (wordMemory ds c m).outputRev=m.outputRev := by
  induction ds generalizing c m with
  | nil => exact ⟨ha,hb,rfl,rfl,rfl,rfl⟩
  | cons d ds ih =>
    have h0 : (digitMemory d c m).stack 0=ds.map Digit.a := by
      simp [digitMemory,Memory.push,Memory.pop,ha]
    have h1 : (digitMemory d c m).stack 1=ds.map Digit.b := by
      simp [digitMemory,Memory.push,Memory.pop,hb]
    have hh := ih (nextCarry d.a d.b c) (digitMemory d c m) h0 h1
    refine ⟨hh.1,hh.2.1,?_,?_,hh.2.2.2.2.1,hh.2.2.2.2.2⟩
    · simpa [wordMemory,output,List.reverse_cons,List.append_assoc,digitMemory,Memory.push,Memory.pop,Function.update_apply] using hh.2.2.1
    · simpa [wordMemory,digitMemory,Memory.push,Memory.pop,Function.update_apply] using hh.2.2.2.1

theorem finish (m : Memory 4) (c b : Bool) (hm : m.stack 0=[]) :
    step program b (config (.start c) m)=config (.done c) (m.pop 0) := by
  simp [step,program,config,label,code,effect,branch,hm]

theorem final_carry (m : Memory 4) (c b : Bool) :
    step program b (config (.done c) m)=config .halt (m.push 2 c) := by
  rw [one_step]; rfl

theorem halt (m : Memory 4) (b : Bool) :
    step program b (config .halt m)=⟨none,m⟩ := by
  rw [one_step]; rfl

theorem finish_run (ds : List Digit) (c : Bool) (m : Memory 4)
    (ha : m.stack 0=ds.map Digit.a) (hb : m.stack 1=ds.map Digit.b)
    (coins : List Bool) (hl : coins.length=3*ds.length) (b b' b'' : Bool) :
    (coins++[b,b',b'']).foldl (fun cfg b => step program b cfg) (config (.start c) m)=
      ⟨none,((wordMemory ds c m).pop 0).push 2 (carry ds c)⟩ := by
  rw [List.foldl_append,pass_any ds c m ha hb coins hl]
  simp only [List.foldl_cons,List.foldl_nil]
  rw [finish _ _ _ (wordMemory_stacks ds c m ha hb).1,final_carry,halt]

 

theorem tape_pass (ds : List Digit) (c : Bool) (m : Memory 4)
    (ha : m.stack 0=ds.map Digit.a) (hb : m.stack 1=ds.map Digit.b)
    (coins : Fin ((3*ds.length)*2)→Bool) :
    (List.ofFn coins).foldl (fun cfg b => (compile program).step b cfg) (encode program (config (.start c) m))=
      encode program (config (.start (carry ds c)) (wordMemory ds c m)) := by
  rw [BinarySubtract.fold_compiled,pass_any ds c m ha hb _ (by simp)]

end
end Contingency.BitModel.StackCode.BinaryAdd

 

 

 

namespace Contingency.BitModel.StackCode.BinarySubtract
noncomputable section

theorem value_append_false (xs : List Bool) (n : ℕ) :
    value (xs++List.replicate n false)=value xs := by
  induction xs with
  | nil =>
    simp only [List.nil_append,value]
    induction n with
    | zero => rfl
    | succ n ih => simp [List.replicate_succ,value,ih]
  | cons b xs ih => simp [value,ih]

theorem value_bits (x : ℕ) : value x.bits=x := by
  induction x using Nat.binaryRec' with
  | zero => rfl
  | bit b n h ih =>
    rw [Nat.bits_append_bit _ _ h]
    change b.toNat+2*value n.bits=Nat.bit b n
    rw [ih]
    cases b <;> simp [Nat.bit]
    omega

def bits (n x : ℕ) : List Bool := x.bits++List.replicate (n-x.size) false

@[simp] theorem bits_length (n x : ℕ) (h : x<2^n) : (bits n x).length=n := by
  have hh := Nat.size_le.mpr h
  simp only [bits,List.length_append,List.length_replicate]
  have he := Nat.size_eq_bits_len x
  omega

@[simp] theorem bits_value (n x : ℕ) : value (bits n x)=x := by
  rw [bits,value_append_false,value_bits]

def digits (as bs : List Bool) : List Digit := List.zipWith Digit.mk as bs

theorem digits_maps (as bs : List Bool) (h : as.length=bs.length) :
    (digits as bs).map Digit.a=as ∧ (digits as bs).map Digit.b=bs ∧
    (digits as bs).length=as.length := by
  induction as generalizing bs with
  | nil =>
    have he : bs=[] := List.length_eq_zero_iff.mp (by simpa using h.symm)
    subst bs
    exact ⟨rfl,rfl,rfl⟩
  | cons a as ih =>
    cases bs with
    | nil => simp at h
    | cons b bs =>
      have hh := ih bs (by simpa using h)
      simpa [digits,List.zipWith_cons_cons] using hh

theorem borrow_iff (ds : List Digit) :
    borrow ds false=true ↔ value (ds.map Digit.a)<value (ds.map Digit.b) := by
  have hi := word_identity ds false
  have ha := value_lt (ds.map Digit.a)
  have hd := value_lt (output ds false)
  simp only [List.length_map,output_length] at ha hd
  cases hb : borrow ds false <;>
    simp only [hb,Bool.toNat_false,Bool.toNat_true,Nat.mul_zero,Nat.mul_one,Nat.add_zero] at hi
  · constructor
    · intro h; cases h
    · intro h; omega
  · constructor
    · intro h; omega
    · intro h; rfl

 

theorem padded_subtraction (n x y : ℕ) (hx : x<2^n) (hy : y<2^n) :
    let ds := digits (bits n x) (bits n y)
    ds.length=n ∧ (borrow ds false=true ↔ x<y) ∧
      (y≤x → value (output ds false)=x-y) := by
  dsimp only
  obtain ⟨ha,hb,hl⟩ := digits_maps (bits n x) (bits n y) (by rw [bits_length _ _ hx,bits_length _ _ hy])
  refine ⟨hl.trans (bits_length _ _ hx),?_,?_⟩
  · simpa [ha,hb] using borrow_iff (digits (bits n x) (bits n y))
  · intro h
    have hh := subtract_correct (digits (bits n x) (bits n y)) (by simpa [ha,hb] using h)
    simpa [ha,hb] using hh.2

end
end Contingency.BitModel.StackCode.BinarySubtract

end

end OAI