| import OAI.Computability.WeisfeilerLeman.RAMInstruction |
|
|
| namespace OAI |
|
|
| universe uK uX uT |
|
|
| namespace WLTime.RAMAlphabet |
| open TypedStack |
| open scoped Classical |
| noncomputable section |
| variable (A : RAM) |
| def instruction (w : ℕ) : (I : RAMInstruction A.registers A.locations) → |
| (∀op ∈ I.operations,op ∈ operations A) → Code (Reg A) (Letter A) |
| | .halt b,_ => haltCode A b |
| | .jump pc,_ => jumpCode A pc |
| | .compute op next,h => .seq (compute A w op (h op (by simp [RAMInstruction.operations]))) |
| (instruction w next (fun q hq => h q (by simp [RAMInstruction.operations,hq]))) |
| | .load dest addr next,h => .seq (memCode A (RAMMemory.load w dest.val addr.val)) |
| (instruction w next h) |
| | .store addr src next,h => .seq (memCode A (RAMMemory.save w addr.val src.val)) |
| (instruction w next h) |
| | .branchZero reg yes no,h => |
| .seq (memCode A (RAMTests.testCode w reg.val)) |
| (.branch (fun v => ((v (.inl 11)).map (decode A)).getD false) |
| (.seq (.pop (.inl 11)) (instruction w no (fun q hq => h q (by simp [RAMInstruction.operations,hq])))) |
| (.seq (.pop (.inl 11)) (instruction w yes (fun q hq => h q (by simp [RAMInstruction.operations,hq]))))) |
| theorem bound_mono (B L D E : ℕ) (h : D≤E) : B*D*(L+D+1)≤B*E*(L+E+2) := |
| Nat.mul_le_mul (Nat.mul_le_mul_left _ h) (by omega) |
| theorem instruction_exec {w : ℕ} (hw : 0<w) (I : RAMInstruction A.registers A.locations) |
| (h : ∀op ∈ I.operations,op ∈ operations A) (C : SparseRAM.Config A.registers A.locations w) : |
| ∃u ≤ unitCost A w*I.depth*(C.log.length+I.depth+1), |
| (instruction A w I h).Exec (state A C) u (state A (SparseRAM.execute I C)) := by |
| induction I generalizing C with |
| | halt b => |
| obtain ⟨u,hu,he⟩ := halt_exec A C b |
| refine ⟨u,?_,he⟩ |
| exact (hu.trans (six_le_unit A w)).trans (by simp only [RAMInstruction.depth,Nat.mul_one]; exact Nat.le_mul_of_pos_right _ (by omega)) |
| | jump pc => |
| refine ⟨6,?_,jump_exec A C pc⟩ |
| exact (six_le_unit A w).trans (by simp only [RAMInstruction.depth,Nat.mul_one]; exact Nat.le_mul_of_pos_right _ (by omega)) |
| | compute op next ih => |
| let hn : ∀q ∈ next.operations,q ∈ operations A := fun q hq => h q (by simp [RAMInstruction.operations,hq]) |
| let hop : op ∈ operations A := h op (by simp [RAMInstruction.operations]) |
| obtain ⟨x,hx,he⟩ := compute_exec A op hop C |
| obtain ⟨y,hy,hf⟩ := ih hn {C with registers := op.apply w C.registers} |
| refine ⟨x+y,?_,Code.Exec.seq he hf⟩ |
| apply combine_cost |
| · exact (hx.trans (op_le_unit A w op hop)).trans (Nat.le_mul_of_pos_right _ (by omega)) |
| · exact hy.trans (bound_mono _ _ _ _ le_rfl) |
| | load dest addr next ih => |
| obtain ⟨x,hx,he⟩ := RAMMemory.load_exec hw C.registers C.log dest addr |
| have hh := mem_exec A he C.pc C.answer |
| obtain ⟨y,hy,hf⟩ := ih h {C with registers := Function.update C.registers dest (WordMemory.read (C.registers addr) C.log)} |
| refine ⟨x+y,?_,Code.Exec.seq hh hf⟩ |
| apply combine_cost |
| · exact hx.trans (memory_le_unit A w C.log.length) |
| · exact hy.trans (bound_mono _ _ _ _ le_rfl) |
| | store addr src next ih => |
| obtain ⟨x,hx,he⟩ := RAMMemory.save_exec C.registers C.log addr src |
| have hh := mem_exec A he C.pc C.answer |
| obtain ⟨y,hy,hf⟩ := ih h {C with log := (C.registers addr,C.registers src)::C.log} |
| refine ⟨x+y,?_,Code.Exec.seq hh hf⟩ |
| apply combine_cost |
| · exact hx.trans ((memory_le_unit A w 0).trans (by simpa using Nat.le_mul_of_pos_right (unitCost A w) (by omega : 0<C.log.length+1))) |
| · change y≤unitCost A w*next.depth*(C.log.length+1+next.depth+1) at hy |
| convert hy using 1 |
| congr 1 |
| omega |
| | branchZero reg yes no ih ih' => |
| let hy : ∀q ∈ yes.operations,q ∈ operations A := fun q hq => h q (by simp [RAMInstruction.operations,hq]) |
| let hn : ∀q ∈ no.operations,q ∈ operations A := fun q hq => h q (by simp [RAMInstruction.operations,hq]) |
| obtain ⟨x,hx,he⟩ := RAMTests.exec C.registers reg (SparseLookup.flatten (WordMemory.entries C.log)) |
| have hh := mem_exec A he C.pc C.answer |
| have hp := mem_exec A (RAMTests.pop_exec (registerBits C.registers) |
| (SparseLookup.flatten (WordMemory.entries C.log)) ((wordBits (C.registers reg)).any id)) C.pc C.answer |
| have htest := test_tops A (registerBits C.registers) (SparseLookup.flatten (WordMemory.entries C.log)) |
| ((wordBits (C.registers reg)).any id) C.pc C.answer |
| have hx' : x+3≤unitCost A w*(C.log.length+1) := |
| (show x+3≤unitCost A w from (by have ht := test_le_unit A w; omega)).trans (Nat.le_mul_of_pos_right _ (by omega)) |
| by_cases hz : (C.registers reg).val=0 |
| · have hb := (ZeroTest.word_zero_iff (C.registers reg)).mpr hz |
| have ht := htest.trans hb |
| obtain ⟨y,hy',hf⟩ := ih hy C |
| have hc := Code.Exec.seq hh (Code.Exec.branch_false |
| (a:=.seq (.pop (.inl 11)) (instruction A w no hn)) (p:=fun v : Tops (Reg A) (Letter A) => ((v (.inl 11)).map (decode A)).getD false) ht (Code.Exec.seq hp hf)) |
| refine ⟨x+(1+(2+y)),?_,?_⟩ |
| · have hy'' := hy'.trans (bound_mono (unitCost A w) C.log.length yes.depth (max yes.depth no.depth) (le_max_left _ _)) |
| have hbound := combine_cost (unitCost A w) C.log.length (max yes.depth no.depth) (x+3) y hx' hy'' |
| simpa only [RAMInstruction.depth,Nat.add_assoc,Nat.add_comm,Nat.add_left_comm] using hbound |
| · convert hc using 1 |
| all_goals try rfl |
| · omega |
| · simp only [SparseRAM.execute,ite_eq_left hz] |
| · have hb : (wordBits (C.registers reg)).any id=true := by |
| cases hb : (wordBits (C.registers reg)).any id |
| · exact False.elim (hz ((ZeroTest.word_zero_iff _).mp hb)) |
| · rfl |
| have ht := htest.trans hb |
| obtain ⟨y,hy',hf⟩ := ih' hn C |
| have hc := Code.Exec.seq hh (Code.Exec.branch_true |
| (b:=.seq (.pop (.inl 11)) (instruction A w yes hy)) (p:=fun v : Tops (Reg A) (Letter A) => ((v (.inl 11)).map (decode A)).getD false) ht (Code.Exec.seq hp hf)) |
| refine ⟨x+(1+(2+y)),?_,?_⟩ |
| · have hy'' := hy'.trans (bound_mono (unitCost A w) C.log.length no.depth (max yes.depth no.depth) (le_max_right _ _)) |
| have hbound := combine_cost (unitCost A w) C.log.length (max yes.depth no.depth) (x+3) y hx' hy'' |
| simpa only [RAMInstruction.depth,Nat.add_assoc,Nat.add_comm,Nat.add_left_comm] using hbound |
| · convert hc using 1 |
| all_goals try rfl |
| · omega |
| · simp only [SparseRAM.execute,ite_eq_right hz] |
| end |
| end WLTime.RAMAlphabet |
| |
| namespace WLTime.RAMAlphabet |
| open TypedStack |
| open scoped Classical |
| noncomputable section |
| variable (A : RAM) |
| theorem encode_length_bound (w : ℕ) : (encodeNat w).length ≤ 2*w+1 := by |
| have hd : (Nat.digits 2 w).length≤w := (Nat.digits_length_le_iff (by decide) w).mpr w.lt_two_pow_self |
| simp only [encodeNat,List.length_append,List.length_replicate,List.length_cons,List.length_nil,List.length_map] |
| omega |
| def exponent : ℕ := 1+Finset.univ.sup (fun i : Index A => (operation A i).exponent) |
| def opConstant (op : WordOperation A.registers) : ℕ := |
| 7+TMPort.factor op.implementation*(2*A.registers+op.constant+4) |
| def constant : ℕ := 1000*(A.registers+1)+∑i : Index A,opConstant A (operation A i) |
| theorem opCost_bound (w : ℕ) (op : WordOperation A.registers) : |
| opCost A w op ≤ opConstant A op*(w+1)^(op.exponent+1) := by |
| have hl := encode_length_bound w |
| have hp : w+1≤(w+1)^(op.exponent+1) := by |
| simpa only [pow_one] using Nat.pow_le_pow_right (by omega : 0<w+1) (by omega : 1≤op.exponent+1) |
| have hq : (w+1)^op.exponent≤(w+1)^(op.exponent+1) := Nat.pow_le_pow_right (by omega) (by omega) |
| have hr : 2*(A.registers*w)≤2*A.registers*((w+1)^(op.exponent+1)) := by |
| calc |
| _=2*A.registers*w := by ring |
| _≤_ := Nat.mul_le_mul_left _ (by omega) |
| have hc := Nat.mul_le_mul_left op.constant hq |
| have hin : (encodeNat w).length+2*(A.registers*w)+op.constant*(w+1)^op.exponent+1≤ |
| (2*A.registers+op.constant+4)*(w+1)^(op.exponent+1) := by nlinarith only [hl,hp,hr,hc] |
| have hh := Nat.mul_le_mul_left (TMPort.factor op.implementation) hin |
| dsimp only [opCost,opConstant] |
| nlinarith only [hl,hp,hh] |
| theorem unitCost_bound (w : ℕ) : unitCost A w ≤ constant A*(w+1)^exponent A := by |
| have he : 1≤exponent A := by unfold exponent; omega |
| have hw : w+1≤(w+1)^exponent A := by simpa only [pow_one] using Nat.pow_le_pow_right (by omega : 0<w+1) he |
| have hs : (∑i : Index A,opCost A w (operation A i)) ≤ |
| (∑i : Index A,opConstant A (operation A i))*(w+1)^exponent A := by |
| rw [Finset.sum_mul] |
| apply Finset.sum_le_sum |
| intro i _ |
| have hi : (operation A i).exponent+1≤exponent A := by |
| have hh := Finset.le_sup (f:=fun i : Index A => (operation A i).exponent) (Finset.mem_univ i) |
| unfold exponent; omega |
| exact (opCost_bound A w (operation A i)).trans (Nat.mul_le_mul_left _ (Nat.pow_le_pow_right (by omega) hi)) |
| have hb := Nat.mul_le_mul_left (1000*(A.registers+1)) hw |
| dsimp only [unitCost,constant] |
| nlinarith only [hs,hb] |
| def opSizeConstant (op : WordOperation A.registers) : ℕ := 10+TMPort.sizeFactor op.implementation*(2*A.registers+4) |
| theorem compute_linear (w : ℕ) (op : WordOperation A.registers) (h : op ∈ operations A) : |
| (compute A w op h).controlSize ≤ opSizeConstant A op*(w+1) := by |
| have he := compute_size A w op h |
| have hl := encode_length_bound w |
| have hh := Nat.mul_le_mul_left (TMPort.sizeFactor op.implementation) |
| (show (encodeNat w).length+2*(A.registers*w)+1≤(2*A.registers+4)*(w+1) by nlinarith only [hl]) |
| dsimp only [opSizeConstant] |
| nlinarith only [he,hl,hh] |
| theorem instruction_linear (I : RAMInstruction A.registers A.locations) : |
| ∃S,∀w h,(instruction A w I h).controlSize≤S*(w+1) := by |
| induction I with |
| | halt b => |
| refine ⟨10,?_⟩ |
| intro w h |
| simp only [instruction,haltCode,Code.controlSize,Code.clear] |
| omega |
| | jump pc => |
| refine ⟨10,?_⟩ |
| intro w h |
| simp only [instruction,jumpCode,Code.controlSize,Code.clear] |
| omega |
| | compute op next ih => |
| obtain ⟨S,hS⟩ := ih |
| refine ⟨opSizeConstant A op+S+1,?_⟩ |
| intro w h |
| have hn : ∀q∈next.operations,q∈operations A := fun q hq => h q (by simp [RAMInstruction.operations,hq]) |
| have ho := compute_linear A w op (h op (by simp [RAMInstruction.operations])) |
| have hs := hS w hn |
| simp only [instruction,Code.controlSize] |
| nlinarith only [ho,hs] |
| | load dest addr next ih => |
| obtain ⟨S,hS⟩ := ih |
| refine ⟨500*(A.registers+1)+S+1,?_⟩ |
| intro w h |
| have hm := RAMMemory.load_size A.registers w dest addr |
| have hs := hS w h |
| simp only [instruction,Code.controlSize,memCode_size] |
| simp only [RAMMemory.cost,Nat.zero_add,Nat.mul_one] at hm |
| nlinarith only [hm,hs] |
| | store addr src next ih => |
| obtain ⟨S,hS⟩ := ih |
| refine ⟨500*(A.registers+1)+S+1,?_⟩ |
| intro w h |
| have hm := RAMMemory.save_size A.registers w addr src |
| have hs := hS w h |
| simp only [instruction,Code.controlSize,memCode_size] |
| simp only [RAMMemory.cost,Nat.zero_add,Nat.mul_one] at hm |
| nlinarith only [hm,hs] |
| | branchZero reg yes no ih ih' => |
| obtain ⟨S,hS⟩ := ih |
| obtain ⟨T,hT⟩ := ih' |
| refine ⟨110*(A.registers+1)+S+T+10,?_⟩ |
| intro w h |
| have hy : ∀q∈yes.operations,q∈operations A := fun q hq => h q (by simp [RAMInstruction.operations,hq]) |
| have hn : ∀q∈no.operations,q∈operations A := fun q hq => h q (by simp [RAMInstruction.operations,hq]) |
| have hs := hS w hy |
| have ht := hT w hn |
| have hm := RAMTests.code_size A.registers w reg |
| simp only [instruction,Code.controlSize,memCode_size] |
| nlinarith only [hs,ht,hm] |
| end |
| end WLTime.RAMAlphabet |
| |
| namespace WLTime.TypedStack.Code |
| variable {K : Type uK} {X : Type uX} {T : Type uT} [DecidableEq K] [DecidableEq T] |
| omit [DecidableEq K] in |
| theorem casesList_size (select : Tops K X → T) (body : T → Code K X) (xs : List T) : |
| (casesList select body xs).controlSize=1+xs.length+(xs.map (fun x => (body x).controlSize)).sum := by |
| induction xs with |
| | nil => rfl |
| | cons x xs ih => simp only [casesList,controlSize,ih,List.length_cons,List.map_cons,List.sum_cons]; omega |
| omit [DecidableEq K] in |
| theorem casesAll_size [Fintype T] (select : Tops K X → T) (body : T → Code K X) : |
| (casesAll select body).controlSize=1+Fintype.card T+∑x : T,(body x).controlSize := by |
| rw [casesAll,casesList_size,Finset.length_toList,Finset.card_univ] |
| congr 1 |
| exact Finset.sum_map_toList _ _ |
| end WLTime.TypedStack.Code |
| namespace WLTime.SparseRAM |
| theorem iterate_fixed (A : RAM) (w : ℕ) (C : Config A.registers A.locations w) (h : C.answer.isSome=true) (t : ℕ) : |
| (step A w)^[t] C=C := by |
| induction t with |
| | zero => rfl |
| | succ t ih => rw [Function.iterate_succ_apply',ih,step_fixed A w C h] |
| end WLTime.SparseRAM |
| namespace WLTime.RAMAlphabet |
| open TypedStack |
| open scoped Classical |
| noncomputable section |
| variable (A : RAM) |
| def depth : ℕ := Finset.univ.sup (fun pc : Fin A.locations => (A.program pc).depth) |
| theorem depth_le (pc : Fin A.locations) : (A.program pc).depth≤depth A := Finset.le_sup (f:=fun pc : Fin A.locations => (A.program pc).depth) (Finset.mem_univ pc) |
| theorem depth_pos : 0<depth A := (A.program ⟨0,A.locations_pos⟩).depth_pos.trans_le (depth_le A _) |
| def selectPC (v : Tops (Reg A) (Letter A)) : Fin A.locations := |
| match v (.inl 12) with |
| | some (.inr (.inl pc)) => pc |
| | _ => ⟨0,A.locations_pos⟩ |
| def dispatch (w : ℕ) : Code (Reg A) (Letter A) := |
| Code.casesAll (selectPC A) (fun pc : Fin A.locations => instruction A w (A.program pc) (mem_program A pc)) |
| def stepBound (w L : ℕ) : ℕ := unitCost A w*depth A*(L+depth A+1)+A.locations |
| theorem stepBound_mono (w L L' : ℕ) (h : L≤L') : stepBound A w L ≤ stepBound A w L' := by |
| unfold stepBound |
| exact Nat.add_le_add_right (Nat.mul_le_mul_left _ (by omega)) _ |
| theorem select_state {w : ℕ} (C : SparseRAM.Config A.registers A.locations w) : selectPC A (tops (state A C))=C.pc := by |
| simp [selectPC,tops,state,liftMem] |
| theorem dispatch_exec {w : ℕ} (hw : 0<w) (C : SparseRAM.Config A.registers A.locations w) : |
| ∃u ≤ stepBound A w C.log.length,(dispatch A w).Exec (state A C) u (state A (SparseRAM.execute (A.program C.pc) C)) := by |
| obtain ⟨t,ht,he⟩ := instruction_exec A hw (A.program C.pc) (mem_program A C.pc) C |
| have hh : ((fun pc : Fin A.locations => instruction A w (A.program pc) (mem_program A pc)) (selectPC A (tops (state A C)))).Exec |
| (state A C) t (state A (SparseRAM.execute (A.program C.pc) C)) := by simpa only [select_state] using he |
| obtain ⟨u,hu,hg⟩ := Code.casesAll_exec (selectPC A) (fun pc : Fin A.locations => instruction A w (A.program pc) (mem_program A pc)) hh |
| refine ⟨u,?_,hg⟩ |
| simp only [Fintype.card_fin] at hu |
| have hd := depth_le A C.pc |
| have hb : t≤unitCost A w*depth A*(C.log.length+depth A+1) := ht.trans |
| (Nat.mul_le_mul (Nat.mul_le_mul_left _ hd) (by omega)) |
| unfold stepBound |
| omega |
| def running (v : Tops (Reg A) (Letter A)) : Bool := !(v (.inl 13)).isSome |
| def loopCode (w : ℕ) : Code (Reg A) (Letter A) := .loop (running A) (dispatch A w) |
| theorem running_state {w : ℕ} (C : SparseRAM.Config A.registers A.locations w) : |
| running A (tops (state A C)) = !C.answer.isSome := by |
| cases h : C.answer <;> simp [running,tops,state,liftMem,h] |
| theorem loop_exec {w : ℕ} (hw : 0<w) (t : ℕ) (C : SparseRAM.Config A.registers A.locations w) |
| (hend : ((SparseRAM.step A w)^[t] C).answer.isSome=true) : |
| ∃u ≤ (stepBound A w (C.log.length+t*depth A)+1)*t+1, |
| (loopCode A w).Exec (state A C) u (state A ((SparseRAM.step A w)^[t] C)) := by |
| induction t generalizing C with |
| | zero => |
| simp only [Function.iterate_zero, id_eq] at hend ⊢ |
| refine ⟨1,by simp,?_⟩ |
| apply Code.Exec.loop_false |
| simpa only [running_state,hend] using (show (!true)=false by rfl) |
| | succ t ih => |
| cases ha : C.answer with |
| | some b => |
| have hc : C.answer.isSome=true := by rw [ha]; rfl |
| have hf := SparseRAM.iterate_fixed A w C hc (t+1) |
| rw [hf] |
| refine ⟨1,by omega,Code.Exec.loop_false ?_⟩ |
| simp only [running_state,hc,Bool.not_true] |
| | none => |
| let C' := SparseRAM.execute (A.program C.pc) C |
| have hs : SparseRAM.step A w C=C' := by simp [SparseRAM.step,ha,C'] |
| have hend' : ((SparseRAM.step A w)^[t] C').answer.isSome=true := by |
| simpa only [Function.iterate_succ_apply,hs] using hend |
| obtain ⟨x,hx,he⟩ := dispatch_exec A hw C |
| obtain ⟨y,hy,hf⟩ := ih C' hend' |
| have hl : C'.log.length≤C.log.length+depth A := |
| (SparseRAM.execute_log_length (A.program C.pc) C).trans (Nat.add_le_add_left (depth_le A C.pc) _) |
| have hb := stepBound_mono A w C.log.length (C.log.length+(t+1)*depth A) (by omega) |
| have hh := stepBound_mono A w (C'.log.length+t*depth A) (C.log.length+(t+1)*depth A) (by nlinarith only [hl]) |
| refine ⟨x+y+1,?_,?_⟩ |
| · have hh' := Nat.mul_le_mul_right t (Nat.add_le_add_right hh 1) |
| nlinarith only [hx,hy,hb,hh'] |
| · have hg := Code.Exec.loop_true (p:=running A) (by simp only [running_state,ha,Option.isSome_none,Bool.not_false]) he hf |
| simpa only [loopCode,Function.iterate_succ_apply,hs] using hg |
| theorem dispatch_linear : ∃S,∀w,(dispatch A w).controlSize≤S*(w+1) := by |
| choose S hS using fun pc : Fin A.locations => instruction_linear A (A.program pc) |
| refine ⟨1+A.locations+∑pc,S pc,?_⟩ |
| intro w |
| have hs : (∑pc : Fin A.locations,(instruction A w (A.program pc) (mem_program A pc)).controlSize)≤(∑pc,S pc)*(w+1) := by |
| rw [Finset.sum_mul] |
| exact Finset.sum_le_sum (fun pc _ => hS pc w (mem_program A pc)) |
| rw [dispatch,Code.casesAll_size,Fintype.card_fin] |
| nlinarith only [hs] |
| end |
| end WLTime.RAMAlphabet |
|
|
| namespace WLTime.RAMAlphabet |
| open TypedStack |
| open scoped Classical |
| noncomputable section |
| variable (A : RAM) |
| def inputMap (i : RAMInput.Reg) : RAMMemory.Reg := ⟨i.val,by omega⟩ |
| theorem inputMap_inj : Function.Injective inputMap := by |
| intro i j h |
| exact Fin.ext (Fin.mk.inj h) |
| def loader (w : ℕ) : Code RAMMemory.Reg Bool := (RAMInput.program w).relabel inputMap |
| theorem loader_exec (w : ℕ) (hw : 0<w) (input : List Bool) (hfit : input.length≤w*2^w) : |
| ∃n ≤ input.length, (fun q => WordMemory.read q (WordMemory.initialLog w input n))=RAM.packedWord w input ∧ |
| ∃u ≤60*(w+1)*(input.length+1),(loader w).Exec (RAMMemory.state input [] [] []) u |
| (RAMMemory.state [] (SparseLookup.flatten (WordMemory.entries (WordMemory.initialLog w input n))) [] []) := by |
| obtain ⟨n,hn,hm,u,hu,he⟩ := RAMInput.program_exec w hw input hfit |
| refine ⟨n,hn,hm,u,hu,?_⟩ |
| apply Code.relabel_exec_of_maps _ inputMap_inj he |
| · intro i; fin_cases i <;> simp [inputMap,RAMMemory.state,RAMInput.state] |
| · intro i; fin_cases i <;> simp [inputMap,RAMMemory.state,RAMInput.state] |
| · intro i hi; fin_cases i <;> simp_all [inputMap,RAMMemory.state,Fin.forall_fin_succ] |
| def inputState (xs : List Bool) : Stacks (Reg A) (Letter A) := fun r => if r=.inl 0 then xs.map Sum.inl else [] |
| def initial (w : ℕ) (xs : List Bool) (n : ℕ) : SparseRAM.Config A.registers A.locations w where |
| pc := ⟨0,A.locations_pos⟩ |
| registers := fun _ => ⟨0,by positivity⟩ |
| log := WordMemory.initialLog w xs n |
| answer := none |
| def initCode (w : ℕ) : Code (Reg A) (Letter A) := |
| .seq (.push (.inl 12) (.inr (.inl ⟨0,A.locations_pos⟩))) |
| (.seq (memCode A (loader w)) (.pushList (.inl 0) ((List.replicate (A.registers*w) false).map Sum.inl))) |
| def initBound (w len : ℕ) : ℕ := 100*(A.registers+1)*(w+1)*(len+1) |
| theorem init_exec (w : ℕ) (hw : 0<w) (input : List Bool) (hfit : input.length≤w*2^w) : |
| ∃n ≤ input.length, (fun q => WordMemory.read q (WordMemory.initialLog w input n))=RAM.packedWord w input ∧ |
| ∃u ≤ initBound A w input.length,(initCode A w).Exec (inputState A input) u (state A (initial A w input n)) := by |
| obtain ⟨n,hn,hm,t,ht,he⟩ := loader_exec w hw input hfit |
| have hp : (Code.push (.inl 12) (.inr (.inl ⟨0,A.locations_pos⟩))).Exec (inputState A input) 2 |
| (fileState A input [] ⟨0,A.locations_pos⟩ none) := by |
| have hh := Code.Exec.push (inputState A input) (.inl 12) (.inr (.inl ⟨0,A.locations_pos⟩)) |
| convert hh using 1 |
| funext r |
| cases r with |
| | inl i => fin_cases i <;> simp [inputState,fileState,liftMem,RAMMemory.state] |
| | inr r => simp [inputState,fileState,liftMem] |
| have hh := mem_exec A he ⟨0,A.locations_pos⟩ none |
| have hg := prefix_exec A (List.replicate (A.registers*w) false) [] |
| (SparseLookup.flatten (WordMemory.entries (WordMemory.initialLog w input n))) ⟨0,A.locations_pos⟩ none |
| have hout : fileState A (List.replicate (A.registers*w) false++[]) (SparseLookup.flatten (WordMemory.entries (WordMemory.initialLog w input n))) ⟨0,A.locations_pos⟩ none=state A (initial A w input n) := by |
| simp only [List.append_nil,state,fileState,initial,RegisterFile.zero] |
| rw [hout,List.length_replicate] at hg |
| refine ⟨n,hn,hm,_,?_,Code.Exec.seq hp (Code.Exec.seq hh hg)⟩ |
| have h₁ : (w+1)*(input.length+1)≤(A.registers+1)*(w+1)*(input.length+1) := |
| Nat.mul_le_mul_right _ (by nlinarith) |
| have h₂ : A.registers*w≤(A.registers+1)*(w+1)*(input.length+1) := by |
| exact (by nlinarith : A.registers*w≤(A.registers+1)*(w+1)).trans (Nat.le_mul_of_pos_right _ (by omega)) |
| have h₃ : 1≤(A.registers+1)*(w+1)*(input.length+1) := by |
| have : 0<(A.registers+1)*(w+1)*(input.length+1) := by positivity |
| omega |
| unfold initBound |
| nlinarith only [ht,h₁,h₂,h₃] |
| theorem initial_forget (n : ℕ) (input : List Bool) (chunks : ℕ) |
| (hm : (fun q => WordMemory.read q (WordMemory.initialLog (A.width.bits n) input chunks))=RAM.packedWord (A.width.bits n) input) : |
| SparseRAM.forget A n (initial A (A.width.bits n) input chunks)=A.initial n input := by |
| unfold SparseRAM.forget initial RAM.initial |
| congr 1 |
| def program (w : ℕ) : Code (Reg A) (Letter A) := .seq (initCode A w) (loopCode A w) |
| def budget (w len time : ℕ) : ℕ := initBound A w len+(stepBound A w (len+time*depth A)+1)*time+1 |
| theorem program_exec (n : ℕ) (input : List Bool) (hfit : input.length≤A.width.bits n*2^(A.width.bits n)) (hh : A.halts n input) : |
| ∃u ≤ budget A (A.width.bits n) input.length (A.time n input),∃b out, |
| (program A (A.width.bits n)).Exec (inputState A input) u out ∧ |
| out (.inl 13)=[.inl b] ∧ (b=true ↔ A.accepts n input) := by |
| obtain ⟨chunks,hchunks,hm,t,ht,he⟩ := init_exec A (A.width.bits n) (A.width.positive n) input hfit |
| let C := initial A (A.width.bits n) input chunks |
| let T := A.time n input |
| let out := (SparseRAM.step A (A.width.bits n))^[T] C |
| have hforget : A.run n input T=SparseRAM.forget A n out := by |
| rw [RAM.run,←initial_forget A n input chunks hm] |
| exact SparseRAM.iterate_forget A n C T |
| have hend : out.answer.isSome=true := by |
| have h := A.time_halted n input hh |
| rw [hforget] at h |
| exact h |
| obtain ⟨s,hs,hf⟩ := loop_exec A (A.width.positive n) T C hend |
| have hl : C.log.length=chunks := WordMemory.initialLog_length _ _ _ |
| rw [hl] at hs |
| obtain ⟨b,hb⟩ := Option.isSome_iff_exists.mp hend |
| refine ⟨t+s,?_,b,state A out,Code.Exec.seq he hf,?_,?_⟩ |
| · have hm' := stepBound_mono A (A.width.bits n) (chunks+T*depth A) (input.length+T*depth A) (by omega) |
| have hx := Nat.mul_le_mul_right T (Nat.add_le_add_right hm' 1) |
| unfold budget |
| dsimp only [T] at * |
| omega |
| · simp [state,liftMem,hb] |
| · have ha : (A.run n input T).answer=some b := by rw [hforget]; exact hb |
| exact (A.accepts_iff_answer n input T b ha).symm |
| theorem init_linear (w : ℕ) : (initCode A w).controlSize≤500*(A.registers+1)*(w+1) := by |
| have he := RAMInput.program_size w |
| simp only [initCode,Code.controlSize,memCode_size,loader,Code.relabel_controlSize,Code.pushList_size,List.length_map,List.length_replicate] |
| nlinarith only [he] |
| theorem program_linear : ∃S,∀w,(program A w).controlSize≤S*(w+1) := by |
| obtain ⟨S,hS⟩ := dispatch_linear A |
| refine ⟨500*(A.registers+1)+S+1,?_⟩ |
| intro w |
| have hi := init_linear A w |
| have hd := hS w |
| simp only [program,loopCode,Code.controlSize] |
| nlinarith only [hi,hd] |
| end |
| end WLTime.RAMAlphabet |
|
|
| end OAI |
|
|
