| 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 |
| |
