File size: 5,160 Bytes
472a116 | 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 | import OAI.Computability.SpaceSimulation.Register.Loop
import OAI.Computability.SpaceSimulation.Stack.Count
namespace OAI
namespace Fifths
namespace Comp
variable {X I : Type} {x : I → List X} {S a b : I → ℕ}
open Bin
theorem ticks (inc : Bool) (h : Fits S a) : Comp x S a
(fun i => if inc then a i + 1 else a i - 1) := by
let k : Unit ⊕ Unit := .inl ()
let t : Unit ⊕ Unit := .inr ()
refine checkSized (SM.carry inc k t) h (fun i B p => ?_)
let v := singleton Unit (a i)
have r : v.ok B := Store.ok_extra.mpr (file_ok.mpr
(le_trans (Nat.le_succ _) p))
have l : (v.st k).length + (v.st t).length + 1 ≤ B := by
change (a i).bits.length + 0 + 1 ≤ B
simpa only [Nat.add_zero, Nat.size_eq_bits_len] using p
have e := SM.exec_carry (i := files (x i)) inc k t (by simp [k,t]) r l
have g : SM.carried v inc k t =
singleton Unit (if inc then a i+1 else a i-1) := by
unfold SM.carried
rw [show v.set t [] = v from Store.set_self v t]
rw [show v.st t = [] from rfl, List.reverse_nil, List.nil_append,
show v.st k = (a i).bits from rfl]
cases inc
· rw [tick_dec]; exact singleton_set _ _ _
· rw [tick_inc]; exact singleton_set _ _ _
rw [g] at e
exact e
theorem plus1 (h : Comp x S a b) : Comp x S a (fun i => b i + 1) :=
h.trans (ticks true h.target)
theorem minus1 (h : Comp x S a b) : Comp x S a (fun i => b i - 1) :=
h.trans (ticks false h.target)
def notZero (n : ℕ) : Bool := n != 0
theorem notZero_eq (n : ℕ) : n.bits.head?.isSome = notZero n := by
by_cases h : n = 0
· subst n; simp [notZero]
have e : n.bits ≠ [] := by simpa using h
cases v : n.bits with
| nil => contradiction
| cons a b => simp [notZero,h]
theorem testnz (h : Comp x S a b) :
Comp x S a (fun i => (notZero (b i)).toNat) := by
refine h.trans ?_
let k : Unit ⊕ Unit := .inl ()
let M (c : Bool) : SM X Empty (Unit ⊕ Unit) Unit :=
(SM.clear k).seq (SM.prepend k c.toNat.bits)
refine checkSized ((SM.peek (fun _ s => (s k).isSome)).bind M)
h.target (fun i B p => ?_)
let v := singleton Unit (b i)
have o : v.ok B := Store.ok_extra.mpr (file_ok.mpr (le_trans (Nat.le_succ _) p))
have eqn := (show (v.see k).isSome = notZero (b i) from notZero_eq _)
refine SM.exec_bind _ _ (y := notZero (b i))
(show (SM.peek _).Exec (files (x i)) B v v _ from eqn ▸ SM.exec_peek o) ?_
have e := SM.exec_clear (i := files (x i)) k o
have g (c : Bool) : (M c).Exec (files (x i)) B v
(singleton Unit c.toNat) () := by
have j : B ≥ 1 := by omega
have u := SM.exec_prepend (i := files (x i)) k c.toNat.bits e.endOk
(by cases c <;> simp [j])
simp only [Store.set_same,List.append_nil,Store.set_set] at u
rw [show k = .inl () from rfl,singleton_set] at u
exact SM.exec_seq e u
exact g _
/-- Accumulating loop. PC logic keeps the original argument, a
remaining count, a current index, and the accumulator. Time for the
counted loop is not charged. -/
theorem fold {n : I → ℕ} (v : I → ℕ → ℕ) (cnt : Comp x S a n)
(ini : Comp x S a (fun i => v i 0))
(sizes : Fits (fun i : Through n => S i.1.1) (fun i => v i.1.1 i.1.2))
(advance : ∀ e : Before n → ℕ,
Comp (fun i : Before n => x i.1.1) (fun i => S i.1.1) e (fun i => a i.1.1) →
Comp (fun i : Before n => x i.1.1) (fun i => S i.1.1) e (fun i => i.1.2) →
Comp (fun i : Before n => x i.1.1) (fun i => S i.1.1) e (fun i => v i.1.1 i.1.2) →
Comp (fun i : Before n => x i.1.1) (fun i => S i.1.1) e
(fun i => v i.1.1 (i.1.2+1))) :
Comp x S a (fun i => v i (n i)) := by
let z : I → ℕ → ℕ :=
fun i j => Bin.pair (a i) (Bin.pair j (Bin.pair (n i-j) (v i j)))
have c : Comp x S a (fun i => z i 0) :=
((Comp.refl cnt.source).pair
((Comp.constant cnt.source 0).pair (cnt.pair ini)))
suffices w : Comp x S (fun i => z i 0) (fun i => z i (n i)) from
(c.trans w).right.right.right
have zsize : Fits (fun i : Through n => S i.1.1) (fun i => z i.1.1 i.1.2) := by
let f : Through n → I := fun i => i.1.1
have h := cnt.target.pull f
refine (cnt.source.pull f).pair ((h.mono ?_).pair ((h.mono ?_).pair sizes))
· exact fun i => i.2
· intro i
exact Nat.sub_le _ _
apply loop n z
· let f : Before n → Through n := fun i => ⟨i.val,i.property.le⟩
have h : Comp (fun i : Before n => x i.1.1) (fun i => S i.1.1)
(fun i => z i.1.1 i.1.2) (fun i => z i.1.1 i.1.2) :=
Comp.refl (zsize.pull f)
have w := advance _ h.left h.right.left h.right.right.right
have g := h.left.pair
(h.right.left.plus1.pair (h.right.right.left.minus1.pair w))
exact g.congr (fun i => by
rw [show n i.1.1-i.1.2-1 = n i.1.1 - (i.1.2+1) by omega])
· have h : Comp (fun i : Through n => x i.1.1) (fun i => S i.1.1)
(fun i => z i.1.1 i.1.2) (fun i => z i.1.1 i.1.2) :=
Comp.refl zsize
refine h.right.right.left.testnz.congr (fun i => ?_)
by_cases e : i.1.2 < n i.1.1
· simp [notZero,e,Nat.ne_of_gt (Nat.sub_pos_of_lt e)]
· simp [notZero,e,Nat.sub_eq_zero_of_le (Nat.le_of_not_gt e)]
end Comp
end Fifths
end OAI
|