File size: 9,358 Bytes
e5a97c6 | 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 | import Mathlib
import OAI.Combinatorics.MatchingCount.Machines.RegisterControl
import OAI.Combinatorics.MatchingCount.Tapes.TreeAddBits
namespace OAI
namespace MatchingFPRAS.TreeMultiply
open TreeData TreeMachine RegisterProc Turing
open StackAddition (value value_bits)
open RegisterControl (Instr Runs Effect)
abbrev R := Fin 6
inductive Point where
| loop | split | test | copy | add | shift | halt
deriving DecidableEq, Inhabited
instance : Fintype Point := ⟨{.loop,.split,.test,.copy,.add,.shift,.halt},by intro p; cases p <;> simp⟩
def program : Point → RegisterControl.Instr R Point
| .loop => .branch 0 .halt .split
| .split => .call (procedure (TreeMachine.Instr.split (Λ:=Unit) 3 0 (by decide) ())) .test
| .test => .branch 3 .shift .copy
| .copy => .call (procedure (TreeMachine.Instr.copy (Λ:=Unit) 1 4 (by decide) ())) .add
| .add => .call (TreeArithmetic.add 2 4 (by decide)) .shift
| .shift => .call (procedure (TreeMachine.Instr.cons (Λ:=Unit) 4 1 (by decide) ())) .loop
| .halt => .halt
def prep (E : Env R) (b : Bool) (A : List Bool) : Env R := putPair E 3 0 (bit b) (bits A)
def summed (E : Env R) (b : Bool) (B : List Bool) (c : ℕ) : Env R :=
if b then putPair (putPair E 1 4 (bits B) (bits B)) 2 4 (nat (c+value B)) .nil else E
def next (E : Env R) (b : Bool) (A B : List Bool) (c : ℕ) : Env R :=
putPair (summed (prep E b A) b B c) 4 1 .nil (bits (false::B))
def accum (b : Bool) (B : List Bool) (c : ℕ) : ℕ := if b then c+value B else c
def result (E : Env R) : List Bool → List Bool → ℕ → Env R
| [],_,_ => E
| b::A,B,c => result (next E b A B c) A (false::B) (accum b B c)
lemma bits_add_length (A B : List Bool) :
(value A+value B).bits.length≤ max A.length B.length+1 := by
have hh := BinaryNormalize.normalize_length (StackAddition.addDigits false A B)
rw [BinaryNormalize.normalize_bits,StackAddition.addDigits_value,Bool.toNat_false,Nat.add_zero] at hh
exact hh.trans (StackAddition.addDigits_length A B false)
lemma bit_length (b : Bool) : (encode (bit b)).length≤3 := by cases b <;> simp [bit,encode]
lemma next_zero (E : Env R) (b : Bool) (A B : List Bool) (c : ℕ) : next E b A B c 0=bits A := by
cases b <;> simp [next,summed,prep,putPair]
lemma next_one (E : Env R) (b : Bool) (A B : List Bool) (c : ℕ) : next E b A B c 1=bits (false::B) := by
simp [next,putPair]
lemma next_two (E : Env R) (b : Bool) (A B : List Bool) (c : ℕ) (hc : E 2=nat c) :
next E b A B c 2=nat (accum b B c) := by
cases b <;> simp [next,summed,prep,putPair,accum,hc]
lemma next_three (E : Env R) (b : Bool) (A B : List Bool) (c : ℕ) : next E b A B c 3=bit b := by
cases b <;> simp [next,summed,prep,putPair]
lemma next_four (E : Env R) (b : Bool) (A B : List Bool) (c : ℕ) : next E b A B c 4=.nil := by
simp [next,putPair]
lemma next_five (E : Env R) (b : Bool) (A B : List Bool) (c : ℕ) : next E b A B c 5=E 5 := by
cases b <;> simp [next,summed,prep,putPair]
lemma accum_bound (b : Bool) (A B : List Bool) (c D : ℕ)
(hB : B.length+(b::A).length≤D) (hc : c.bits.length+(b::A).length≤D) :
(accum b B c).bits.length+A.length≤D := by
cases b with
| false =>
simp only [accum,Bool.false_eq_true,↓reduceIte]
simp only [List.length_cons] at hc
omega
| true =>
have hh:=bits_add_length c.bits B
rw [value_bits] at hh
simp only [accum,↓reduceIte]
simp only [List.length_cons] at hB hc
omega
lemma output (E : Env R) (A B : List Bool) (c : ℕ) (hc : E 2=nat c) :
result E A B c 2=nat (c+value A*value B) := by
induction A generalizing E B c with
| nil => simpa only [result,value,Nat.zero_mul,Nat.add_zero] using hc
| cons b A ih =>
rw [result,ih _ _ _ (next_two E b A B c hc)]
congr 1
cases b <;> simp only [accum,Bool.false_eq_true,↓reduceIte,value,Bool.toNat_false,
Bool.toNat_true,Nat.zero_add] <;> ring
lemma frame (E : Env R) (A B : List Bool) (c : ℕ) : result E A B c 5=E 5 := by
induction A generalizing E B c with
| nil => rfl
| cons b A ih => rw [result,ih,next_five]
lemma halt_runs (E : Env R) : Runs program (some Point.halt) E E 1 := by
exact (Runs.step Point.halt E none E E 0 1 (Effect.halt E) (Runs.done E))
lemma cycle_runs (E F : Env R) (b : Bool) (A B : List Bool) (c D n : ℕ)
(h0 : E 0=bits (b::A)) (h1 : E 1=bits B) (h2 : E 2=nat c) (h4 : E 4=.nil)
(hB : B.length≤D) (hc : c.bits.length≤D) (h3 : (encode (E 3)).length≤D+3)
(rest : Runs program (some Point.loop) (next E b A B c) F n) :
Runs program (some Point.loop) E F (40*(D+2)+n) := by
have hshift := cons_exec (summed (prep E b A) b B c) 4 1 (by decide) ()
have hs4 : summed (prep E b A) b B c 4=.nil := by
cases b <;> simp [summed,prep,putPair,h4]
have hs1 : summed (prep E b A) b B c 1=bits B := by
cases b <;> simp [summed,prep,putPair,h1]
rw [hs4,hs1] at hshift
change Exec _ _ (encodeEnv (next E b A B c)) 5 at hshift
have tail : Runs program (some Point.shift) (summed (prep E b A) b B c) F (6+n) :=
Runs.step Point.shift _ _ _ _ n 6 (Effect.call _ _ _ _ 5 hshift) rest
have hh : Runs program (some Point.test) (prep E b A) F (31*D+38+n) := by
cases b with
| false =>
have hx : prep E false A 3=.nil := by simp [prep,putPair,bit]
have ht : Runs program (some Point.test) (prep E false A) F (1+(6+n)) :=
Runs.step Point.test _ _ _ _ _ 1 (Effect.nilBranch _ 3 _ _ hx) tail
exact Runs.weaken _ _ _ _ _ ht (by omega)
| true =>
let E' := putPair (prep E true A) 1 4 (bits B) (bits B)
have hp1 : prep E true A 1=bits B := by simp [prep,putPair,h1]
have hp4 : prep E true A 4=.nil := by simp [prep,putPair,h4]
have hcopy := copy_exec (prep E true A) 1 4 (by decide) ()
rw [hp1,hp4] at hcopy
change Exec _ _ (encodeEnv E') (1+3*(encode (bits B)).length+4) at hcopy
have hcopy' := hcopy.mono (show 1+3*(encode (bits B)).length+4≤12*D+8 by
have := bits_length B; omega)
have ha2 : E' 2=bits c.bits := by simp [E',prep,putPair,nat,bits,h2]
have ha4 : E' 4=bits B := by simp [E',putPair]
have hadd := TreeArithmetic.add_bits_exec E' 2 4 (by decide) c.bits B ha2 ha4
rw [value_bits] at hadd
change Exec _ _ (encodeEnv (summed (prep E true A) true B c)) _ at hadd
have hadd' := hadd.mono (show 9*(c.bits.length+B.length)+20≤18*D+20 by omega)
have ha : Runs program (some Point.add) E' F ((18*D+21)+(6+n)) :=
Runs.step Point.add _ _ _ _ _ (18*D+21) (Effect.call _ _ _ _ _ hadd') tail
have hcp : Runs program (some Point.copy) (prep E true A) F
((12*D+9)+((18*D+21)+(6+n))) :=
Runs.step Point.copy _ _ _ _ _ (12*D+9) (Effect.call _ _ _ _ _ hcopy') ha
have hx : prep E true A 3=.cons .nil .nil := by simp [prep,putPair,bit]
have ht : Runs program (some Point.test) (prep E true A) F
(1+((12*D+9)+((18*D+21)+(6+n)))) :=
Runs.step Point.test _ _ _ _ _ 1 (Effect.consBranch _ 3 _ _ .nil .nil hx) hcp
exact Runs.weaken _ _ _ _ _ ht (by omega)
have he0 : E 0=.cons (bit b) (bits A) := h0
have hsplit := split_exec E 3 0 (by decide) () (bit b) (bits A) he0
have hsplit' := hsplit.mono (show (encode (E 3)).length+2*(encode (bit b)).length+4≤D+13 by
have := bit_length b; omega)
have hs : Runs program (some Point.split) E F ((D+14)+(31*D+38+n)) :=
Runs.step Point.split _ _ _ _ _ (D+14) (Effect.call _ _ _ _ _ hsplit') hh
have hl : Runs program (some Point.loop) E F (1+((D+14)+(31*D+38+n))) :=
Runs.step Point.loop _ _ _ _ _ 1 (Effect.consBranch _ 0 _ _ (bit b) (bits A) he0) hs
exact Runs.weaken _ _ _ _ _ hl (by omega)
lemma runs (E : Env R) (A B : List Bool) (c D : ℕ)
(h0 : E 0=bits A) (h1 : E 1=bits B) (h2 : E 2=nat c) (h4 : E 4=.nil)
(hB : B.length+A.length≤D) (hc : c.bits.length+A.length≤D)
(h3 : (encode (E 3)).length≤D+3) :
Runs program (some Point.loop) E (result E A B c) (40*(A.length+1)*(D+2)) := by
induction A generalizing E B c with
| nil =>
have hl : Runs program (some Point.loop) E E 2 :=
Runs.step Point.loop E _ E E 1 1 (Effect.nilBranch _ 0 _ _ h0) (halt_runs E)
exact Runs.weaken _ _ _ _ _ hl (by simp only [List.length_nil]; omega)
| cons b A ih =>
have hr := ih (next E b A B c) (false::B) (accum b B c)
(next_zero E b A B c) (next_one E b A B c) (next_two E b A B c h2)
(next_four E b A B c) (by simp only [List.length_cons] at hB ⊢; omega)
(accum_bound b A B c D hB hc) (by rw [next_three]; have := bit_length b; omega)
have hh := cycle_runs E (result (next E b A B c) A (false::B) (accum b B c))
b A B c D _ h0 h1 h2 h4 (by simp only [List.length_cons] at hB; omega)
(by simp only [List.length_cons] at hc; omega) h3 hr
convert hh using 1 <;> simp only [result,List.length_cons]
ring
def multiply : Proc (K R) := RegisterControl.compile program
theorem exec (E : Env R) (A B : List Bool) (c D : ℕ)
(h0 : E 0=bits A) (h1 : E 1=bits B) (h2 : E 2=nat c) (h4 : E 4=.nil)
(hB : B.length+A.length≤D) (hc : c.bits.length+A.length≤D)
(h3 : (encode (E 3)).length≤D+3) :
Exec multiply (encodeEnv E) (encodeEnv (result E A B c)) (40*(A.length+1)*(D+2)) :=
RegisterControl.compile_exec program _ E _ (runs E A B c D h0 h1 h2 h4 hB hc h3)
end MatchingFPRAS.TreeMultiply
end OAI
|