File size: 10,815 Bytes
760f90e | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 | import OAI.Computability.RationalHitting.StackWords
namespace OAI
namespace RationalHitting.StackLanguage
open Function
variable {K : Type} [DecidableEq K]
lemma wordValue_head_tail (l : List Bool) :
wordValue l = (if l.headD false then 1 else 0)+2*wordValue l.tail := by
cases l with
| nil => rfl
| cons b l => rfl
/-- Grade-school addition, scanning the second operand one bit at a time.
The first operand is shifted after adding the incoming low bit. -/
def addWord : List Bool → List Bool → List Bool
| a, [] => a
| a, false::b => a.headD false :: addWord a.tail b
| a, true::b => (incrementWord a).headD false :: addWord (incrementWord a).tail b
@[simp] theorem addWord_value (a b : List Bool) :
wordValue (addWord a b) = wordValue a + wordValue b := by
induction b generalizing a with
| nil => simp [addWord,wordValue]
| cons x b ih =>
cases x with
| false =>
simp only [addWord,wordValue,Bool.false_eq_true,↓reduceIte,zero_add,ih]
rw [wordValue_head_tail a]
omega
| true =>
simp only [addWord,wordValue,↓reduceIte,ih]
have hh := wordValue_head_tail (incrementWord a)
rw [incrementWord_value] at hh
omega
lemma incrementWord_tail_length (a : List Bool) : (incrementWord a).tail.length ≤ a.length := by
have hh := incrementWord_length a
rw [List.length_tail]
omega
lemma addWord_length (a b : List Bool) : (addWord a b).length ≤ a.length+b.length := by
induction b generalizing a with
| nil => simp [addWord]
| cons x b ih =>
cases x with
| false =>
have hh := ih a.tail
simp only [addWord,List.length_cons]
have ht : a.tail.length ≤ a.length := by simp
omega
| true =>
have hh := ih (incrementWord a).tail
have ht := incrementWord_tail_length a
simp only [addWord,List.length_cons]
omega
/-- Emits one least-significant bit, supplying zero for an exhausted operand. -/
def emitLow (a out : K) : Program K :=
.branch a (.push out false) (.transfer a out) (.transfer a out)
lemma eval_emitLow {a out : K} (hao : a ≠ out) (s : Store K) :
Eval (emitLow a out) s
(update (update s a (s a).tail) out ((s a).headD false::s out)) 2 := by
cases he : s a with
| nil =>
have hh : update (update s a (s a).tail) out ((s a).headD false::s out) =
update s out (false::s out) := by
ext k; by_cases hka : k=a <;> by_cases hko : k=out <;> simp_all
simp only [he] at hh
rw [hh]
exact Eval.branchNone he (Eval.push out false s)
| cons x xs =>
have ht := Eval.transfer a out s
simp only [transfer,he,Function.update_of_ne (Ne.symm hao)] at ht
cases x with
| false => simpa [emitLow,he] using Eval.branchFalse he ht
| true => simpa [emitLow,he] using Eval.branchTrue he ht
/-- Output invariant for the single pass: a reversed low part is on `out`. -/
def addSplit : List Bool → List Bool → List Bool × List Bool
| a, [] => ([],a)
| a, false::b =>
let r := addSplit a.tail b
(a.headD false::r.1,r.2)
| a, true::b =>
let r := addSplit (incrementWord a).tail b
((incrementWord a).headD false::r.1,r.2)
lemma addSplit_spec (a b : List Bool) : (addSplit a b).1++(addSplit a b).2 = addWord a b := by
induction b generalizing a with
| nil => rfl
| cons x b ih => cases x <;> simp [addSplit,addWord,ih]
lemma addSplit_first_length (a b : List Bool) : (addSplit a b).1.length = b.length := by
induction b generalizing a with
| nil => rfl
| cons x b ih => cases x <;> simp [addSplit,ih]
def addBody (a b out tmp flag : K) : Program K :=
.branch b .skip (.seq (.drop b) (emitLow a out))
(.seq (.drop b) (.seq (increment a tmp flag) (emitLow a out)))
def addLoop (a b out tmp flag : K) : Program K := .loop b (addBody a b out tmp flag)
lemma eval_addLoop {a b out tmp flag : K}
(hab : a ≠ b) (hao : a ≠ out) (hat : a ≠ tmp) (haf : a ≠ flag)
(hbo : b ≠ out) (hbt : b ≠ tmp) (hbf : b ≠ flag)
(hot : out ≠ tmp) (hof : out ≠ flag) (htf : tmp ≠ flag)
(s : Store K) (ht : s tmp = []) (hf : s flag = []) :
∃ t ≤ (s b).length*(7*(s a).length+25)+1,
Eval (addLoop a b out tmp flag) s
(update (update (update s a (addSplit (s a) (s b)).2) b []) out
((addSplit (s a) (s b)).1.reverse++s out)) t := by
generalize he : s b = l
induction l generalizing s with
| nil =>
have hh : update (update (update s a (s a)) b []) out (s out) = s := by
ext k; by_cases hka : k=a <;> by_cases hkb : k=b <;> by_cases hko : k=out <;> simp_all
refine ⟨1,by simp,?_⟩
change Eval (addLoop a b out tmp flag) s
(update (update (update s a (s a)) b []) out (s out)) 1
rw [hh]
exact Eval.whileNil he
| cons x l ih =>
let s₁ := update s b l
have hdrop : Eval (Program.drop b) s s₁ 1 := by simpa [s₁,he] using Eval.drop b s
cases x with
| false =>
let s₂ := update (update s₁ a (s a).tail) out ((s a).headD false::s out)
have hh : Eval (emitLow a out) s₁ s₂ 2 := by
simpa [s₂,s₁,hab,Ne.symm hbo] using eval_emitLow hao s₁
have hb : Eval (addBody a b out tmp flag) s s₂ 5 :=
Eval.branchFalse he (Eval.seq hdrop hh)
have hta : s₂ a = (s a).tail := by simp [s₂,hao]
have htb : s₂ b = l := by simp [s₂,s₁,hbo,Ne.symm hab]
have htt : s₂ tmp = [] := by simp [s₂,s₁,Ne.symm hot,Ne.symm hat,Ne.symm hbt,ht]
have htf' : s₂ flag = [] := by simp [s₂,s₁,Ne.symm hof,Ne.symm haf,Ne.symm hbf,hf]
obtain ⟨t,htime,hloop⟩ := ih s₂ htt htf' htb
have h := Eval.whileCons (by simp [he]) hb hloop
have hfinal :
update (update (update s₂ a (addSplit (s₂ a) (s₂ b)).2) b []) out
((addSplit (s₂ a) (s₂ b)).1.reverse++s₂ out) =
update (update (update s a (addSplit (s a) (false::l)).2) b []) out
((addSplit (s a) (false::l)).1.reverse++s out) := by
ext k
by_cases hka : k=a <;> by_cases hkb : k=b <;> by_cases hko : k=out <;>
simp_all [s₂,s₁,addSplit,List.append_assoc]
simp only [htb] at hfinal
rw [hfinal] at h
refine ⟨6+t,?_,by simpa [addLoop,he] using h⟩
simp only [hta] at htime
have hlen : (s a).tail.length ≤ (s a).length := by simp
have hmul := Nat.mul_le_mul_left l.length (Nat.add_le_add_right (Nat.mul_le_mul_left 7 hlen) 25)
simp only [List.length_cons]
nlinarith
| true =>
obtain ⟨u,hu,hinc⟩ := eval_increment hat haf htf s₁
let s₂ := update (update (update s₁ a (incrementWord (s a))) tmp []) flag []
have hii : Eval (increment a tmp flag) s₁ s₂ u := by simpa [s₂,s₁,hab] using hinc
let s₃ := update (update s₂ a (incrementWord (s a)).tail) out
((incrementWord (s a)).headD false::s out)
have hh : Eval (emitLow a out) s₂ s₃ 2 := by
simpa [s₃,s₂,s₁,hat,haf,Ne.symm hao,Ne.symm hbo,hot,hof] using eval_emitLow hao s₂
have hb : Eval (addBody a b out tmp flag) s s₃ (6+u) := by
simpa [addBody,Nat.add_assoc,Nat.add_comm,Nat.add_left_comm] using
(Eval.branchTrue he (Eval.seq hdrop (Eval.seq hii hh)))
have hta : s₃ a = (incrementWord (s a)).tail := by simp [s₃,hao]
have htb : s₃ b = l := by simp [s₃,s₂,s₁,hbo,hbt,hbf,Ne.symm hab]
have htt : s₃ tmp = [] := by simp [s₃,s₂,Ne.symm hot,Ne.symm hat,htf]
have htf' : s₃ flag = [] := by simp [s₃,s₂,Ne.symm hof,Ne.symm haf]
obtain ⟨t,htime,hloop⟩ := ih s₃ htt htf' htb
have h := Eval.whileCons (by simp [he]) hb hloop
have hfinal :
update (update (update s₃ a (addSplit (s₃ a) (s₃ b)).2) b []) out
((addSplit (s₃ a) (s₃ b)).1.reverse++s₃ out) =
update (update (update s a (addSplit (s a) (true::l)).2) b []) out
((addSplit (s a) (true::l)).1.reverse++s out) := by
ext k
by_cases hka : k=a <;> by_cases hkb : k=b <;> by_cases hko : k=out <;>
by_cases hkt : k=tmp <;> by_cases hkf : k=flag <;>
simp_all [s₃,s₂,s₁,addSplit,List.append_assoc]
simp only [htb] at hfinal
rw [hfinal] at h
refine ⟨7+u+t,?_,by simpa [addLoop,he,←Nat.add_assoc] using h⟩
simp only [hta] at htime
have hlen := incrementWord_tail_length (s a)
have hmul := Nat.mul_le_mul_left l.length (Nat.add_le_add_right (Nat.mul_le_mul_left 7 hlen) 25)
simp [s₁,hab,Ne.symm hbt,Ne.symm hbf,ht,hf] at hu
simp only [List.length_cons]
nlinarith
/-- Destructive binary addition. The second operand and all scratch words are
cleared; the first register holds the exact sum. -/
def add (a b out tmp flag : K) : Program K :=
.seq (clear out) (.seq (clear tmp) (.seq (clear flag)
(.seq (addLoop a b out tmp flag) (reverse out a))))
lemma eval_add {a b out tmp flag : K}
(hab : a ≠ b) (hao : a ≠ out) (hat : a ≠ tmp) (haf : a ≠ flag)
(hbo : b ≠ out) (hbt : b ≠ tmp) (hbf : b ≠ flag)
(hot : out ≠ tmp) (hof : out ≠ flag) (htf : tmp ≠ flag)
(s : Store K) :
∃ t ≤ (s b).length*(7*(s a).length+27)+
2*(s out).length+2*(s tmp).length+2*(s flag).length+9,
Eval (add a b out tmp flag) s
(update (update (update (update (update s a (addWord (s a) (s b))) b []) out []) tmp []) flag []) t := by
let s₁ := update s out []
let s₂ := update s₁ tmp []
let s₃ := update s₂ flag []
have ha₃ : s₃ a = s a := by simp [s₃,s₂,s₁,hao,hat,haf]
have hb₃ : s₃ b = s b := by simp [s₃,s₂,s₁,hbo,hbt,hbf]
have ho₃ : s₃ out = [] := by simp [s₃,s₂,s₁,hot,hof]
obtain ⟨t,ht,hloop⟩ := eval_addLoop hab hao hat haf hbo hbt hbf hot hof htf s₃
(by simp [s₃,s₂,htf]) (by simp [s₃])
let s₄ := update (update (update s₃ a (addSplit (s a) (s b)).2) b []) out
(addSplit (s a) (s b)).1.reverse
have hlo : Eval (addLoop a b out tmp flag) s₃ s₄ t := by
simpa [s₄,ha₃,hb₃,ho₃] using hloop
have hrev := eval_reverse (Ne.symm hao) s₄
have h := Eval.seq (eval_clear out s) (Eval.seq (eval_clear tmp s₁)
(Eval.seq (eval_clear flag s₂) (Eval.seq hlo hrev)))
have hfinal : update (update s₄ out []) a ((s₄ out).reverse++s₄ a) =
update (update (update (update (update s a (addWord (s a) (s b))) b []) out []) tmp []) flag [] := by
ext k
by_cases hka : k=a <;> by_cases hkb : k=b <;> by_cases hko : k=out <;>
by_cases hkt : k=tmp <;> by_cases hkf : k=flag <;>
simp_all [s₄,s₃,s₂,s₁,addSplit_spec]
rw [hfinal] at h
refine ⟨_,?_,h⟩
rw [ha₃,hb₃] at ht
simp [s₄,s₃,s₂,s₁,Ne.symm hot,Ne.symm hof,Ne.symm htf,addSplit_first_length]
nlinarith
end RationalHitting.StackLanguage
end OAI
|