Download data/lean/OAI/Algorithms/SubexponentialSAT/Subexp/AssignmentInputProgram.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 34.4 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Algorithms/SubexponentialSAT/Subexp/AssignmentInputProgram.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Algorithms/SubexponentialSAT/Subexp/AssignmentInputProgram.lean
-
curl -L -o AssignmentInputProgram.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Algorithms/SubexponentialSAT/Subexp/AssignmentInputProgram.lean
34.4 kB
| import OAI.Algorithms.SubexponentialSAT.LeanCompat | |
| import OAI.Algorithms.SubexponentialSAT.Subexp.OneHotAlphabetProgram | |
| import OAI.Algorithms.SubexponentialSAT.Subexp.AssignmentAlphabetSemantics | |
| import OAI.Algorithms.SubexponentialSAT.Subexp.AssignmentRecordViews | |
| import OAI.Algorithms.SubexponentialSAT.Subexp.AssignmentSeedRange | |
| import OAI.Algorithms.SubexponentialSAT.Subexp.AssignmentInputCall | |
| import OAI.Algorithms.SubexponentialSAT.Subexp.AssignmentInputState | |
| import OAI.Algorithms.SubexponentialSAT.Subexp.AssignmentInitProgram | |
| import OAI.Algorithms.SubexponentialSAT.Subexp.PairScoreBounds | |
| namespace OAI.Algorithms | |
| /-! | |
| # Physical input construction for sequential type assignment | |
| All parameters are unary stack data. The fixed program constructs the one-hot | |
| word alphabet, reads its actual first word, derives its packed view, and builds | |
| the exact seed range and dimensions expected by `AssignmentInitProgram`. | |
| -/ | |
| namespace SubexponentialSAT.Subexp.AssignmentInputProgram | |
| open BitProgram StructuredCalls SubexpSetupStorage AssignmentInputCall | |
| def seedCount (delta D E : ℕ) : ℕ := E + (delta + 1) * D | |
| def context (r Q delta D E : ℕ) (pairs : List Bool) : AssignmentInitProgram.Context where | |
| defaultWord := (AssignmentAlphabetSemantics.wordBytes r Q).headD [] | |
| packedAlphabet := (AssignmentAlphabetSemantics.wordBytes r Q).flatten | |
| alphabetRecords := ProgramEncoding.encodeRecords (AssignmentAlphabetSemantics.wordBytes r Q) | |
| width := unary (Q * r) | |
| depth := unary (2 * (delta + 1)) | |
| rawPairs := pairs | |
| seedRecords := AssignmentSeedRange.seedRecords (seedCount delta D E) | |
| seedCount := seedCount delta D E | |
| def outputState (r Q delta D E : ℕ) (pairs : List Bool) : Data := | |
| AssignmentInitProgram.inputState (context r Q delta D E pairs) (fun _ => false) | |
| def colorAlphabet : Code := AssignmentInputCall.call OneHotAlphabetProgram.program | |
| (by decide) (by decide) [(1, 12)] 6 7 | |
| def wordAlphabet : Code := AssignmentInputCall.call TupleProgram.generateProgram | |
| (by decide) (by decide) [(7, 13), (2, 20)] 0 30 | |
| def firstWord : Code := AssignmentInputCall.call AssignmentRecordViews.firstProgram | |
| (by decide) (by decide) [(30, 12)] 2 0 | |
| def packedAlphabet : Code := AssignmentInputCall.call AssignmentRecordViews.flattenProgram | |
| (by decide) (by decide) [(30, 12)] 2 9 | |
| def wordWidth : Code := AssignmentInputCall.call BlockCopyProgram.program | |
| (by decide) (by decide) [(1, 12), (2, 15)] 1 10 | |
| def deltaPlusOne : Code := .seq (copyCmd 3 6 31) (TupleProgram.pushConst 6 0 true) | |
| def depth : Code := copyMany 31 [(6, 34), (6, 34)] | |
| def seedProduct : Code := AssignmentInputCall.call BlockCopyProgram.program | |
| (by decide) (by decide) [(4, 12), (6, 15)] 1 47 | |
| def seedSize : Code := .seq seedProduct (copyCmd 5 47 31) | |
| def seedRange : Code := AssignmentInputCall.call AssignmentSeedRange.program | |
| (by decide) (by decide) [(47, 12)] 5 46 | |
| def cleanup : Code := .seq (clearMany [1, 2, 3, 4, 5, 6, 7]) (resetMany (List.finRange 16)) | |
| def command : Code := | |
| .seq colorAlphabet (.seq wordAlphabet (.seq firstWord (.seq packedAlphabet | |
| (.seq wordWidth (.seq deltaPlusOne (.seq depth (.seq seedSize (.seq seedRange cleanup)))))))) | |
| abbrev program : Program 16 48 (size command + 1) := compiled command 1 30 | |
| /-- A physical stage changes one public stack and restores the private bank. | |
| The witness is an actual measured execution of its finite instruction table. -/ | |
| def Writes (c : Code) (a : Data) (dst : Fin 48) (bits : List Bool) (charge : ℕ) : Prop := | |
| ∃ ticks b, Eval c ticks a b ∧ b.stacks = Function.update a.stacks dst bits ∧ Clean b ∧ | |
| ∀ B, Within a B → bits.length ≤ B → 1 ≤ B → ticks ≤ charge + 400 * (B + 1) | |
| theorem colorAlphabet_eval (a : Data) (n : ℕ) (hc : Clean a) | |
| (h1 : a.stacks 1 = unary n) : | |
| Writes colorAlphabet a 7 (ProgramEncoding.encodeRecords (OneHotAlphabetProgram.rows 0 n)) | |
| (60 * (n + 1) ^ 2 + 1) := by | |
| let pre := project (register (r := 5) (by decide)) (stack (s := 7) (by decide)) | |
| (prepareState 31 work [(1, 12)] a) | |
| have hp : pre = OneHotAlphabetProgram.inputState pre.regs n := by | |
| apply congrArg (StructuredProgram.State.mk pre.regs) | |
| funext i | |
| have h := prepare_one_local (r := 5) (s := 7) (by decide) (by decide) a hc 1 0 i | |
| change pre.stacks i = _ | |
| change pre.stacks i = _ at h | |
| rw [h] | |
| fin_cases i <;> simp [ h1] | |
| obtain ⟨ticks, htime, ht⟩ := OneHotAlphabetProgram.program_runsIn pre.regs n | |
| rw [← hp] at ht | |
| obtain ⟨b, he, hs, hb⟩ := call_eval OneHotAlphabetProgram.program | |
| (by decide) (by decide) [(1, 12)] 6 7 a (OneHotAlphabetProgram.outputState n) | |
| (by decide) (by decide) (by simp [mem_work]) (by simp) hc ht | |
| refine ⟨_, b, he, hs, hb, ?_⟩ | |
| intro B ha hout _ | |
| have ho : Within (OneHotAlphabetProgram.outputState n) B := by | |
| intro j; fin_cases j <;> simp [OneHotAlphabetProgram.outputState, hout] | |
| have h := callCost_le (r := 5) (s := 7) (by decide) (by decide) | |
| [(1, 12)] 6 7 a _ ticks B (by decide) ha ho | |
| exact h.trans (Nat.add_le_add_right htime _) | |
| theorem wordAlphabet_eval (a : Data) (r Q : ℕ) (hc : Clean a) | |
| (h7 : a.stacks 7 = ProgramEncoding.encodeRecords (OneHotAlphabetProgram.rows 0 r)) | |
| (h2 : a.stacks 2 = unary Q) : | |
| Writes wordAlphabet a 30 (ProgramEncoding.encodeRecords (AssignmentAlphabetSemantics.wordBytes r Q)) | |
| (TupleProgram.powerCost (OneHotAlphabetProgram.rows 0 r) Q [[]] + 9) := by | |
| let pre := project (register (r := 10) (by decide)) (stack (s := 9) (by decide)) | |
| (prepareState 31 work [(7, 13), (2, 20)] a) | |
| have hs (i : Fin 9) : pre.stacks i = | |
| if i = 8 then unary Q else if i = 1 then | |
| ProgramEncoding.encodeRecords (OneHotAlphabetProgram.rows 0 r) else [] := by | |
| have h := prepare_two_local (r := 10) (s := 9) | |
| (by decide) (by decide) a hc 7 2 1 8 (by decide) (by decide) i | |
| change pre.stacks i = _ at h | |
| simpa only [h7, h2] using h | |
| have hp : TupleProgram.outerInvariant (OneHotAlphabetProgram.rows 0 r) (unary Q) | |
| (pre.regs 9) pre := by | |
| simp [TupleProgram.outerInvariant, hs] | |
| obtain ⟨out, hout, ticks, htime, ht⟩ := TupleProgram.generateProgram_runsIn | |
| (OneHotAlphabetProgram.rows 0 r) (unary Q) (pre.regs 9) pre hp | |
| (by simp [hs]) (by simp [hs]) (by simp [hs]) | |
| obtain ⟨b, he, hb, hclean⟩ := call_eval TupleProgram.generateProgram | |
| (by decide) (by decide) [(7, 13), (2, 20)] 0 30 a out | |
| (by decide) (by decide) (by simp [mem_work]) (by simp) hc ht | |
| refine ⟨_, b, he, ?_, hclean, ?_⟩ | |
| · rw [hb, hout.2.1] | |
| simp only [List.length_replicate, AssignmentAlphabetSemantics.wordBytes] | |
| · intro B ha hresult hB | |
| rcases hout with ⟨⟨h1, h3, h4, h6, h7', h8, h9⟩, h0, h2', h5⟩ | |
| have halphabet : (ProgramEncoding.encodeRecords (OneHotAlphabetProgram.rows 0 r)).length ≤ B := by | |
| simpa only [← h7] using ha 7 | |
| have ho : Within out B := by | |
| intro j | |
| fin_cases j <;> simp_all [AssignmentAlphabetSemantics.wordBytes] | |
| have h := callCost_le (r := 10) (s := 9) (by decide) (by decide) | |
| [(7, 13), (2, 20)] 0 30 a out ticks B (by decide) ha ho | |
| simp only [List.length_replicate] at htime | |
| exact h.trans (Nat.add_le_add_right htime _) | |
| theorem firstWord_eval (a : Data) (bits : List Bool) (rows : List (List Bool)) | |
| (hc : Clean a) (h30 : a.stacks 30 = ProgramEncoding.encodeRecords (bits :: rows)) : | |
| Writes firstWord a 0 bits (9 * bits.length + 10) := by | |
| let pre := project (register (r := 3) (by decide)) (stack (s := 3) (by decide)) | |
| (prepareState 31 work [(30, 12)] a) | |
| have hp : pre = AssignmentRecordViews.data (pre.regs 0) (pre.regs 1) (pre.regs 2) | |
| (ProgramEncoding.encodeRecords (bits :: rows)) [] [] := by | |
| apply congrArg₂ StructuredProgram.State.mk | |
| · funext i; fin_cases i <;> rfl | |
| · funext i | |
| have h := prepare_one_local (r := 3) (s := 3) (by decide) (by decide) a hc 30 0 i | |
| change pre.stacks i = _ | |
| change pre.stacks i = _ at h | |
| rw [h] | |
| fin_cases i <;> simp [ h30] | |
| have ht := AssignmentRecordViews.first_trace (pre.regs 0) (pre.regs 1) (pre.regs 2) bits rows | |
| rw [← hp] at ht | |
| obtain ⟨b, he, hs, hb⟩ := call_eval AssignmentRecordViews.firstProgram | |
| (by decide) (by decide) [(30, 12)] 2 0 a | |
| (AssignmentRecordViews.data false false false (ProgramEncoding.encodeRecords rows) [] bits) | |
| (by decide) (by decide) (by simp [mem_work]) (by simp) hc ht | |
| refine ⟨_, b, he, hs, hb, ?_⟩ | |
| intro B ha hresult _ | |
| have htail : (ProgramEncoding.encodeRecords rows).length ≤ B := by | |
| have hh := ha 30 | |
| rw [h30] at hh | |
| change (Encoding.encodeList id rows).length ≤ B | |
| change (Encoding.encodeList id (bits :: rows)).length ≤ B at hh | |
| rw [Encoding.length_encodeList_cons] at hh | |
| omega | |
| have ho : Within (AssignmentRecordViews.data false false false | |
| (ProgramEncoding.encodeRecords rows) [] bits) B := by | |
| intro j; fin_cases j <;> simp [ htail, hresult] | |
| exact callCost_le (r := 3) (s := 3) (by decide) (by decide) | |
| [(30, 12)] 2 0 a _ _ B (by decide) ha ho | |
| theorem packedAlphabet_eval (a : Data) (rows : List (List Bool)) (hc : Clean a) | |
| (h30 : a.stacks 30 = ProgramEncoding.encodeRecords rows) : | |
| Writes packedAlphabet a 9 rows.flatten | |
| (9 * (rows.map List.length).sum + 6 * rows.length + 7) := by | |
| let pre := project (register (r := 3) (by decide)) (stack (s := 3) (by decide)) | |
| (prepareState 31 work [(30, 12)] a) | |
| have hp : pre = AssignmentRecordViews.data (pre.regs 0) (pre.regs 1) (pre.regs 2) | |
| (ProgramEncoding.encodeRecords rows ++ []) [] [] := by | |
| apply congrArg₂ StructuredProgram.State.mk | |
| · funext i; fin_cases i <;> rfl | |
| · funext i | |
| have h := prepare_one_local (r := 3) (s := 3) (by decide) (by decide) a hc 30 0 i | |
| change pre.stacks i = _ | |
| change pre.stacks i = _ at h | |
| rw [h] | |
| fin_cases i <;> simp [ h30] | |
| have ht := AssignmentRecordViews.flatten_trace (pre.regs 0) (pre.regs 1) (pre.regs 2) rows [] [] | |
| rw [← hp] at ht | |
| obtain ⟨b, he, hs, hb⟩ := call_eval AssignmentRecordViews.flattenProgram | |
| (by decide) (by decide) [(30, 12)] 2 9 a | |
| (AssignmentRecordViews.data false false false [] [] (rows.flatten ++ [])) | |
| (by decide) (by decide) (by simp [mem_work]) (by simp) hc ht | |
| refine ⟨_, b, he, by simpa using hs, hb, ?_⟩ | |
| intro B ha hresult _ | |
| simp only [List.length_flatten] at hresult | |
| have ho : Within (AssignmentRecordViews.data false false false [] [] (rows.flatten ++ [])) B := by | |
| intro j; fin_cases j <;> simp [ hresult] | |
| exact callCost_le (r := 3) (s := 3) (by decide) (by decide) | |
| [(30, 12)] 2 9 a _ _ B (by decide) ha ho | |
| theorem copies_unary (n m : ℕ) : BlockCopyProgram.copies n (unary m) = unary (n * m) := by | |
| induction n with | |
| | zero => simp | |
| | succ n ih => | |
| rw [BlockCopyProgram.copies_succ, ih] | |
| simp [unary, Nat.add_mul, Nat.add_comm] | |
| theorem repeat_eval (a : Data) (src count dst : Fin 48) (m n : ℕ) | |
| (hc : Clean a) (hsrc : a.stacks src = unary m) (hcount : a.stacks count = unary n) | |
| (hd : dst ∉ work) (htmp : dst ≠ 31) | |
| (hports : ∀ x ∈ [(src, 12), (count, 15)], | |
| x.1 ≠ x.2 ∧ x.1 ≠ 31 ∧ (31 : Fin 48) ≠ x.2) | |
| (hcount12 : count ≠ 12) : | |
| Writes (AssignmentInputCall.call BlockCopyProgram.program (by decide) (by decide) | |
| [(src, 12), (count, 15)] 1 dst) a dst (unary (n * m)) | |
| (n * (7 * m + 7) + 3) := by | |
| let pre := project (register (r := 3) (by decide)) (stack (s := 4) (by decide)) | |
| (prepareState 31 work [(src, 12), (count, 15)] a) | |
| have hp : pre = BlockCopyProgram.initialState n (unary m) [] := by | |
| apply congrArg₂ StructuredProgram.State.mk | |
| · funext i | |
| have h := prepare_regs [(src, 12), (count, 15)] a (register (by decide) i) | |
| (by have := i.isLt; simp only [register, Fin.val_castLE]; omega) | |
| fin_cases i <;> exact h | |
| · funext i | |
| have h := prepare_two_local (r := 3) (s := 4) (by decide) (by decide) | |
| a hc src count 0 3 (by decide) hcount12 i | |
| change pre.stacks i = _ | |
| change pre.stacks i = _ at h | |
| rw [h] | |
| fin_cases i <;> simp [ hsrc, hcount] | |
| have ht := BlockCopyProgram.program_trace n (unary m) [] | |
| rw [← hp] at ht | |
| obtain ⟨b, he, hs, hb⟩ := call_eval BlockCopyProgram.program | |
| (by decide) (by decide) [(src, 12), (count, 15)] 1 dst a | |
| (BlockCopyProgram.data false false (unary m) (BlockCopyProgram.copies n (unary m) ++ []) []) | |
| hd htmp (by simp [mem_work]) hports hc ht | |
| refine ⟨_, b, he, by simpa [BlockCopyProgram.data, copies_unary] using hs, hb, ?_⟩ | |
| intro B ha hresult _ | |
| simp only [List.length_replicate] at hresult | |
| have hm : m ≤ B := by simpa [hsrc] using ha src | |
| have ho : Within (BlockCopyProgram.data false false (unary m) | |
| (BlockCopyProgram.copies n (unary m) ++ []) []) B := by | |
| intro j; fin_cases j <;> simp [BlockCopyProgram.data, copies_unary, hm, hresult] | |
| simpa only [List.length_replicate] using callCost_le (r := 3) (s := 4) | |
| (by decide) (by decide) [(src, 12), (count, 15)] 1 dst a _ _ B (by simp) ha ho | |
| theorem seedRange_eval (a : Data) (n : ℕ) (hc : Clean a) | |
| (h47 : a.stacks 47 = unary n) : | |
| Writes seedRange a 46 (AssignmentSeedRange.seedRecords n) (AssignmentSeedRange.budget n + 1) := by | |
| let pre := project (register (r := 5) (by decide)) (stack (s := 6) (by decide)) | |
| (prepareState 31 work [(47, 12)] a) | |
| have hp : pre = AssignmentSeedRange.inputState pre.regs n := by | |
| apply congrArg (StructuredProgram.State.mk pre.regs) | |
| funext i | |
| have h := prepare_one_local (r := 5) (s := 6) (by decide) (by decide) a hc 47 0 i | |
| change pre.stacks i = _ | |
| change pre.stacks i = _ at h | |
| rw [h] | |
| fin_cases i <;> simp [ h47] | |
| obtain ⟨ticks, htime, ht⟩ := AssignmentSeedRange.program_runsIn pre.regs n | |
| rw [← hp] at ht | |
| obtain ⟨b, he, hs, hb⟩ := call_eval AssignmentSeedRange.program | |
| (by decide) (by decide) [(47, 12)] 5 46 a (AssignmentSeedRange.outputState n) | |
| (by decide) (by decide) (by simp [mem_work]) (by simp) hc ht | |
| refine ⟨_, b, he, hs, hb, ?_⟩ | |
| intro B ha hresult _ | |
| have ho : Within (AssignmentSeedRange.outputState n) B := by | |
| intro j; fin_cases j <;> simp [AssignmentSeedRange.outputState, AssignmentSeedRange.state, hresult] | |
| have h := callCost_le (r := 5) (s := 6) (by decide) (by decide) | |
| [(47, 12)] 5 46 a _ ticks B (by decide) ha ho | |
| exact h.trans (Nat.add_le_add_right htime _) | |
| theorem clean_of_update (a b : Data) (dst : Fin 48) (bits : List Bool) | |
| (hc : Clean a) (hd : dst ∉ work) (htmp : dst ≠ 31) | |
| (hs : b.stacks = Function.update a.stacks dst bits) : Clean b := by | |
| constructor | |
| · intro j hj | |
| have hn : j ≠ dst := by intro h; exact hd (h ▸ hj) | |
| simp [hs, hn, hc.1 j hj] | |
| · simp [hs, Ne.symm htmp, hc.2] | |
| theorem within_of_update (a b : Data) (dst : Fin 48) (bits : List Bool) (B : ℕ) | |
| (ha : Within a B) (hb : bits.length ≤ B) | |
| (hs : b.stacks = Function.update a.stacks dst bits) : Within b B := by | |
| intro j | |
| by_cases hj : j = dst | |
| · subst j; simpa only [hs, Function.update_same] using hb | |
| · simpa [hs, Function.update_apply, hj] using ha j | |
| theorem deltaPlusOne_eval (a : Data) (delta : ℕ) (hc : Clean a) | |
| (h3 : a.stacks 3 = unary delta) (h6 : a.stacks 6 = []) : | |
| Writes deltaPlusOne a 6 (unary (delta + 1)) (7 * delta + 7) := by | |
| let b := copyState 3 6 a | |
| let c := TupleProgram.pushedState 6 0 true b | |
| have h1 := copy_eval 3 6 31 a (by decide) (by decide) (by decide) hc.2 | |
| have h2 := TupleProgram.pushConst_eval 6 0 true b | |
| have hs : c.stacks = Function.update a.stacks 6 (unary (delta + 1)) := by | |
| funext j | |
| by_cases hj : j = 6 | |
| · subst j | |
| simp [c, b, copyState_stack, h3, h6, unary, List.replicate_succ] | |
| · simp [c, b, copyState_stack, hj] | |
| refine ⟨_, c, h1.seq h2, hs, clean_of_update a c 6 _ hc (by decide) (by decide) hs, ?_⟩ | |
| intro B _ _ _ | |
| simp only [h3, List.length_replicate] | |
| omega | |
| theorem depth_eval (a : Data) (n : ℕ) (hc : Clean a) | |
| (h6 : a.stacks 6 = unary n) (h34 : a.stacks 34 = []) : | |
| Writes depth a 34 (unary (2 * n)) (14 * n + 10) := by | |
| let b := copyManyState [(6, 34), (6, 34)] a | |
| have h := copyMany_eval 31 [(6, 34), (6, 34)] a (by simp) hc.2 | |
| have hs : b.stacks = Function.update a.stacks 34 (unary (2 * n)) := by | |
| funext j | |
| by_cases hj : j = 34 | |
| · subst j | |
| simp [b, copyManyState, copyState_stack, h6, h34, unary, | |
| two_mul] | |
| · simp [b, copyManyState, copyState_stack, hj] | |
| refine ⟨_, b, h, hs, clean_of_update a b 34 _ hc (by decide) (by decide) hs, ?_⟩ | |
| intro B _ _ _ | |
| simp [copyManyCost, copyState_stack, h6] | |
| omega | |
| theorem seedSize_eval (a : Data) (delta D E : ℕ) (hc : Clean a) | |
| (h4 : a.stacks 4 = unary D) (h6 : a.stacks 6 = unary (delta + 1)) | |
| (h5 : a.stacks 5 = unary E) : | |
| Writes seedSize a 47 (unary (seedCount delta D E)) | |
| ((delta + 1) * (7 * D + 7) + 3 + (7 * E + 5)) := by | |
| obtain ⟨ticks, b, hb, hs, hc', htime⟩ := repeat_eval a 4 6 47 D (delta + 1) hc h4 h6 | |
| (by decide) (by decide) (by simp) (by decide) | |
| have hcopy := copy_eval 5 47 31 b (by decide) (by decide) (by decide) hc'.2 | |
| let c := copyState 5 47 b | |
| have hout : c.stacks = Function.update a.stacks 47 (unary (seedCount delta D E)) := by | |
| funext j | |
| by_cases hj : j = 47 | |
| · subst j | |
| simp [c, copyState_stack, hs, h5, seedCount, unary] | |
| · simp [c, copyState_stack, hs, hj] | |
| refine ⟨_, c, hb.seq hcopy, hout, | |
| clean_of_update a c 47 _ hc (by decide) (by decide) hout, ?_⟩ | |
| intro B ha hresult hB | |
| have hproduct : (unary ((delta + 1) * D)).length ≤ B := by | |
| simp only [List.length_replicate, seedCount] at hresult ⊢ | |
| omega | |
| have ht := htime B ha hproduct hB | |
| simp only [hs, Function.update_of_ne (show (5 : Fin 48) ≠ 47 by decide), h5, | |
| List.length_replicate] | |
| omega | |
| theorem input_clean (regs : Fin 16 → Bool) (r Q delta D E : ℕ) (pairs : List Bool) : | |
| Clean (inputState regs r Q delta D E pairs) := by | |
| constructor | |
| · intro j hj | |
| rw [mem_work] at hj | |
| have h1 : j ≠ 1 := by intro h; subst j; change 12 ≤ 1 ∧ 1 < 22 at hj; omega | |
| have h2 : j ≠ 2 := by intro h; subst j; change 12 ≤ 2 ∧ 2 < 22 at hj; omega | |
| have h3 : j ≠ 3 := by intro h; subst j; change 12 ≤ 3 ∧ 3 < 22 at hj; omega | |
| have h4 : j ≠ 4 := by intro h; subst j; change 12 ≤ 4 ∧ 4 < 22 at hj; omega | |
| have h5 : j ≠ 5 := by intro h; subst j; change 12 ≤ 5 ∧ 5 < 22 at hj; omega | |
| have h45 : j ≠ 45 := by intro h; subst j; change 12 ≤ 45 ∧ 45 < 22 at hj; omega | |
| simp [inputState, h1, h2, h3, h4, h5, h45] | |
| · rfl | |
| def sourceCharge (r Q delta D E : ℕ) : ℕ := | |
| let rows := AssignmentAlphabetSemantics.wordBytes r Q | |
| (60 * (r + 1) ^ 2 + 1) + | |
| (TupleProgram.powerCost (OneHotAlphabetProgram.rows 0 r) Q [[]] + 9) + | |
| (9 * (rows.headD []).length + 10) + | |
| (9 * (rows.map List.length).sum + 6 * rows.length + 7) + | |
| (Q * (7 * r + 7) + 3) + (7 * delta + 7) + | |
| (14 * (delta + 1) + 10) + | |
| ((delta + 1) * (7 * D + 7) + 3 + (7 * E + 5)) + | |
| (AssignmentSeedRange.budget (seedCount delta D E) + 1) | |
| def sourceBudget (r Q delta D E B : ℕ) : ℕ := | |
| sourceCharge r Q delta D E + 5000 * (B + 1) | |
| /-- The complete fixed producer, including concrete record extraction and | |
| range generation. The only semantic witness chooses names for the actual | |
| emitted word bytes; it is not supplied to the executable program. -/ | |
| theorem command_eval_measured (regs : Fin 16 → Bool) (r Q delta D E B : ℕ) | |
| (pairs : List Bool) (hr : 0 < r) (hB : 1 ≤ B) | |
| (ha : Within (inputState regs r Q delta D E pairs) B) | |
| (hcolor : (ProgramEncoding.encodeRecords (OneHotAlphabetProgram.rows 0 r)).length ≤ B) | |
| (hwords : (ProgramEncoding.encodeRecords (AssignmentAlphabetSemantics.wordBytes r Q)).length ≤ B) | |
| (hfirst : ((AssignmentAlphabetSemantics.wordBytes r Q).headD []).length ≤ B) | |
| (hflat : (AssignmentAlphabetSemantics.wordBytes r Q).flatten.length ≤ B) | |
| (hwidth : Q * r ≤ B) (hdelta : delta + 1 ≤ B) (hdepth : 2 * (delta + 1) ≤ B) | |
| (hseed : seedCount delta D E ≤ B) | |
| (hseeds : (AssignmentSeedRange.seedRecords (seedCount delta D E)).length ≤ B) : | |
| ∃ ticks, ticks ≤ sourceBudget r Q delta D E B ∧ | |
| Eval command ticks (inputState regs r Q delta D E pairs) | |
| (outputState r Q delta D E pairs) := by | |
| let a := inputState regs r Q delta D E pairs | |
| obtain ⟨t1, a1, he1, hs1, hc1, ht1⟩ := colorAlphabet_eval a r (input_clean regs r Q delta D E pairs) rfl | |
| have hb1 := within_of_update a a1 7 _ B ha hcolor hs1 | |
| have hn1 := ht1 B ha hcolor hB | |
| obtain ⟨t2, a2, he2, hs2, hc2, ht2⟩ := wordAlphabet_eval a1 r Q hc1 | |
| (by simp [hs1]) (by simp [hs1, a, inputState]) | |
| have hb2 := within_of_update a1 a2 30 _ B hb1 hwords hs2 | |
| have hn2 := ht2 B hb1 hwords hB | |
| obtain ⟨w, tail, hw, _, _⟩ := AssignmentAlphabetSemantics.wordBytes_order hr Q | |
| have hbytes : AssignmentAlphabetSemantics.wordBytes r Q = | |
| ReadPlan.encodeWord w :: tail.map ReadPlan.encodeWord := hw.symm | |
| have hhead : (AssignmentAlphabetSemantics.wordBytes r Q).headD [] = ReadPlan.encodeWord w := by | |
| simp [hbytes] | |
| have hwlen : (ReadPlan.encodeWord w).length ≤ B := by simpa [hbytes] using hfirst | |
| obtain ⟨t3, a3, he3, hs3, hc3, ht3⟩ := firstWord_eval a2 (ReadPlan.encodeWord w) | |
| (tail.map ReadPlan.encodeWord) hc2 (by simp [hs2, hbytes]) | |
| have hb3 := within_of_update a2 a3 0 _ B hb2 hwlen hs3 | |
| have hn3 := ht3 B hb2 hwlen hB | |
| obtain ⟨t4, a4, he4, hs4, hc4, ht4⟩ := packedAlphabet_eval a3 | |
| (AssignmentAlphabetSemantics.wordBytes r Q) hc3 (by simp [hs3, hs2]) | |
| have hb4 := within_of_update a3 a4 9 _ B hb3 hflat hs4 | |
| have hn4 := ht4 B hb3 hflat hB | |
| have hwlen' : (unary (Q * r)).length ≤ B := by simpa using hwidth | |
| obtain ⟨t5, a5, he5, hs5, hc5, ht5⟩ := repeat_eval a4 1 2 10 r Q hc4 | |
| (by simp [hs4, hs3, hs2, hs1, a, inputState]) | |
| (by simp [hs4, hs3, hs2, hs1, a, inputState]) | |
| (by decide) (by decide) (by simp) (by decide) | |
| have hb5 := within_of_update a4 a5 10 _ B hb4 hwlen' hs5 | |
| have hn5 := ht5 B hb4 hwlen' hB | |
| have hdlen : (unary (delta + 1)).length ≤ B := by simpa using hdelta | |
| obtain ⟨t6, a6, he6, hs6, hc6, ht6⟩ := deltaPlusOne_eval a5 delta hc5 | |
| (by simp [hs5, hs4, hs3, hs2, hs1, a, inputState]) | |
| (by simp [hs5, hs4, hs3, hs2, hs1, a, inputState]) | |
| have hb6 := within_of_update a5 a6 6 _ B hb5 hdlen hs6 | |
| have hn6 := ht6 B hb5 hdlen hB | |
| have hdepthlen : (unary (2 * (delta + 1))).length ≤ B := by simpa using hdepth | |
| obtain ⟨t7, a7, he7, hs7, hc7, ht7⟩ := depth_eval a6 (delta + 1) hc6 | |
| (by simp [hs6]) (by simp [hs6, hs5, hs4, hs3, hs2, hs1, a, inputState]) | |
| have hb7 := within_of_update a6 a7 34 _ B hb6 hdepthlen hs7 | |
| have hn7 := ht7 B hb6 hdepthlen hB | |
| have hseedlen : (unary (seedCount delta D E)).length ≤ B := by simpa using hseed | |
| obtain ⟨t8, a8, he8, hs8, hc8, ht8⟩ := seedSize_eval a7 delta D E hc7 | |
| (by simp [hs7, hs6, hs5, hs4, hs3, hs2, hs1, a, inputState]) | |
| (by simp [hs7, hs6]) | |
| (by simp [hs7, hs6, hs5, hs4, hs3, hs2, hs1, a, inputState]) | |
| have hb8 := within_of_update a7 a8 47 _ B hb7 hseedlen hs8 | |
| have hn8 := ht8 B hb7 hseedlen hB | |
| obtain ⟨t9, a9, he9, hs9, _, ht9⟩ := seedRange_eval a8 (seedCount delta D E) hc8 (by simp [hs8]) | |
| have hb9 := within_of_update a8 a9 46 _ B hb8 hseeds hs9 | |
| have hn9 := ht9 B hb8 hseeds hB | |
| let ac := clearManyState [1, 2, 3, 4, 5, 6, 7] a9 | |
| let af := resetManyState (List.finRange 16) ac | |
| have he10 := (clearMany_eval [1, 2, 3, 4, 5, 6, 7] a9).seq | |
| (resetMany_eval (List.finRange 16) ac) | |
| have haf : af = outputState r Q delta D E pairs := by | |
| apply congrArg₂ StructuredProgram.State.mk | |
| · funext j | |
| change (resetManyState (List.finRange 16) ac).regs j = false | |
| rw [resetMany_regs] | |
| simp | |
| · funext j | |
| change (resetManyState (List.finRange 16) ac).stacks j = _ | |
| rw [resetMany_stacks] | |
| change (clearManyState [1, 2, 3, 4, 5, 6, 7] a9).stacks j = _ | |
| rw [clearMany_stacks] | |
| fin_cases j <;> simp [hs9, hs8, hs7, hs6, hs5, hs4, hs3, hs2, hs1, a, | |
| inputState, | |
| context, hbytes, AssignmentInitProgram.unary] | |
| change Eval cleanup _ a9 af at he10 | |
| rw [haf] at he10 | |
| refine ⟨_, ?_, he1.seq (he2.seq (he3.seq (he4.seq (he5.seq (he6.seq (he7.seq | |
| (he8.seq (he9.seq he10))))))))⟩ | |
| have hcleanup := (clearMany_bound [1, 2, 3, 4, 5, 6, 7] a9 B hb9).2 | |
| simp only [List.length_cons, List.length_nil, List.length_finRange] at hcleanup ⊢ | |
| simp only [sourceBudget, sourceCharge, hhead] | |
| omega | |
| /-- Explicit data-size envelope, including generated arrays. It is assertion | |
| notation only; no bound or table is passed to the machine. -/ | |
| def extent (r Q delta D E : ℕ) (pairs : List Bool) : ℕ := | |
| let rows := AssignmentAlphabetSemantics.wordBytes r Q | |
| 1 + r + Q + delta + D + E + (delta + 1) + 2 * (delta + 1) + Q * r + | |
| seedCount delta D E + r ^ Q + | |
| (ProgramEncoding.encodeRecords (OneHotAlphabetProgram.rows 0 r)).length + | |
| (ProgramEncoding.encodeRecords rows).length + (rows.headD []).length + rows.flatten.length + | |
| (AssignmentSeedRange.seedRecords (seedCount delta D E)).length + pairs.length | |
| def budget (r Q delta D E : ℕ) (pairs : List Bool) : ℕ := | |
| sourceBudget r Q delta D E (extent r Q delta D E pairs) | |
| /-- A closed bound containing only runtime parameter values and input size. -/ | |
| def sizeBound (r Q delta D E inputBits : ℕ) : ℕ := | |
| let M := seedCount delta D E | |
| 1 + r + Q + delta + D + E + (delta + 1) + 2 * (delta + 1) + Q * r + | |
| M + r ^ Q + (1 + (2 * r + 2) * r) + | |
| (1 + (2 * (Q * r) + 2) * r ^ Q) + Q * r + r ^ Q * (Q * r) + | |
| (1 + (2 * M + 2) * M) + inputBits | |
| theorem extent_le_sizeBound (r Q delta D E : ℕ) (pairs : List Bool) (hr : 0 < r) : | |
| extent r Q delta D E pairs ≤ sizeBound r Q delta D E pairs.length := by | |
| have hc : ∀ bits ∈ OneHotAlphabetProgram.rows 0 r, bits.length ≤ r := by | |
| intro bits hb | |
| rw [AssignmentAlphabetSemantics.rows_eq_alphabet] at hb | |
| obtain ⟨c, _, rfl⟩ := List.mem_map.mp hb | |
| simp [AssignmentAlphabetSemantics.oneHot] | |
| have hclen : (OneHotAlphabetProgram.rows 0 r).length = r := by | |
| simp [AssignmentAlphabetSemantics.rows_eq_alphabet] | |
| have hcolor := ProgramEncoding.encodeRecords_length_le (OneHotAlphabetProgram.rows 0 r) r hc | |
| rw [hclen] at hcolor | |
| have hw : ∀ bits ∈ AssignmentAlphabetSemantics.wordBytes r Q, bits.length ≤ Q * r := | |
| fun bits hb => (AssignmentAlphabetSemantics.wordBytes_width hr bits hb).le | |
| have hwords := ProgramEncoding.encodeRecords_length_le | |
| (AssignmentAlphabetSemantics.wordBytes r Q) (Q * r) hw | |
| rw [AssignmentAlphabetSemantics.wordBytes_length] at hwords | |
| have hvolume := PairScoreBounds.volume_le (AssignmentAlphabetSemantics.wordBytes r Q) (Q * r) hw | |
| rw [AssignmentAlphabetSemantics.wordBytes_length] at hvolume | |
| have hflat : (AssignmentAlphabetSemantics.wordBytes r Q).flatten.length ≤ r ^ Q * (Q * r) := by | |
| simpa only [List.length_flatten, PairScoreBounds.volume] using hvolume | |
| have hhead : ((AssignmentAlphabetSemantics.wordBytes r Q).headD []).length = Q * r := by | |
| obtain ⟨a, tail, he, _, _⟩ := AssignmentAlphabetSemantics.wordBytes_order hr Q | |
| rw [← he] | |
| simp [ReadPlan.encodeWord_length, ReadPlan.wordWidth] | |
| have hseeds := ProgramEncoding.encodeRecords_length_le | |
| ((List.range (seedCount delta D E)).map unary) (seedCount delta D E) (by | |
| intro bits hb | |
| obtain ⟨i, hi, rfl⟩ := List.mem_map.mp hb | |
| simpa using (List.mem_range.mp hi).le) | |
| simp only [List.length_map, List.length_range] at hseeds | |
| change (AssignmentSeedRange.seedRecords (seedCount delta D E)).length ≤ _ at hseeds | |
| dsimp only [extent, sizeBound] | |
| rw [hhead] | |
| omega | |
| theorem command_eval (regs : Fin 16 → Bool) (r Q delta D E : ℕ) | |
| (pairs : List Bool) (hr : 0 < r) : | |
| ∃ ticks, ticks ≤ budget r Q delta D E pairs ∧ | |
| Eval command ticks (inputState regs r Q delta D E pairs) | |
| (outputState r Q delta D E pairs) := by | |
| apply command_eval_measured regs r Q delta D E (extent r Q delta D E pairs) pairs hr | |
| · dsimp only [extent] | |
| omega | |
| · intro j | |
| dsimp only [inputState] | |
| split_ifs <;> (try simp only [List.length_replicate, List.length_nil]) <;> | |
| dsimp only [extent] <;> omega | |
| all_goals dsimp only [extent]; omega | |
| theorem budget_le (r Q delta D E : ℕ) (pairs : List Bool) (hr : 0 < r) : | |
| budget r Q delta D E pairs ≤ 20000 * (extent r Q delta D E pairs + 1) ^ 4 := by | |
| let B := extent r Q delta D E pairs | |
| let T := B + 1 | |
| have hrB : r ≤ B := by dsimp [B, extent]; omega | |
| have hQB : Q ≤ B := by dsimp [B, extent]; omega | |
| have hdB : delta ≤ B := by dsimp [B, extent]; omega | |
| have hd1B : delta + 1 ≤ B := by dsimp [B, extent]; omega | |
| have hDB : D ≤ B := by dsimp [B, extent]; omega | |
| have hEB : E ≤ B := by dsimp [B, extent]; omega | |
| have hMB : seedCount delta D E ≤ B := by dsimp [B, extent]; omega | |
| have hpowB : r ^ Q ≤ B := by dsimp [B, extent]; omega | |
| have hhead : ((AssignmentAlphabetSemantics.wordBytes r Q).headD []).length ≤ B := by | |
| dsimp [B, extent]; omega | |
| have hflat : ((AssignmentAlphabetSemantics.wordBytes r Q).map List.length).sum ≤ B := by | |
| have h : (AssignmentAlphabetSemantics.wordBytes r Q).flatten.length ≤ B := by | |
| dsimp [B, extent]; omega | |
| simpa only [List.length_flatten] using h | |
| have hcount : (AssignmentAlphabetSemantics.wordBytes r Q).length ≤ B := by | |
| simpa using hpowB | |
| have hcolorlen : (OneHotAlphabetProgram.rows 0 r).length = r := by | |
| rw [AssignmentAlphabetSemantics.rows_eq_alphabet] | |
| simp | |
| have hcolorwidth : ∀ bits ∈ OneHotAlphabetProgram.rows 0 r, bits.length ≤ r := by | |
| intro bits hb | |
| rw [AssignmentAlphabetSemantics.rows_eq_alphabet] at hb | |
| obtain ⟨c, _, rfl⟩ := List.mem_map.mp hb | |
| simp [AssignmentAlphabetSemantics.oneHot] | |
| have hpower := PairScoreBounds.generated_powerCost_le (OneHotAlphabetProgram.rows 0 r) Q r | |
| (by rw [hcolorlen]; omega) hcolorwidth | |
| rw [hcolorlen] at hpower | |
| have hT : 1 ≤ T := by dsimp [T]; omega | |
| have hrT : r + 1 ≤ T := by dsimp [T]; omega | |
| have hQT : Q + 1 ≤ T := by dsimp [T]; omega | |
| have hDT : D + 1 ≤ T := by dsimp [T]; omega | |
| have hMT : seedCount delta D E + 1 ≤ T := by dsimp [T]; omega | |
| have hlast : (Q + 1) * r + 1 ≤ T ^ 2 := by | |
| have hh := Nat.mul_le_mul hQT hrB | |
| dsimp [T] at hh ⊢ | |
| nlinarith only [hh] | |
| have hpower' : TupleProgram.powerCost (OneHotAlphabetProgram.rows 0 r) Q [[]] ≤ 800 * T ^ 4 := by | |
| calc | |
| _ ≤ 800 * T * T * T ^ 2 := hpower.trans (by gcongr ; omega) | |
| _ = _ := by ring | |
| have hcolor : 60 * (r + 1) ^ 2 ≤ 60 * T ^ 2 := by gcongr | |
| have hseed : AssignmentSeedRange.budget (seedCount delta D E) ≤ 60 * T ^ 2 := | |
| (AssignmentSeedRange.budget_le _).trans (by gcongr) | |
| have hwidth : Q * (7 * r + 7) ≤ 7 * T ^ 2 := by | |
| calc | |
| _ = 7 * Q * (r + 1) := by ring | |
| _ ≤ 7 * T * T := by gcongr ; omega | |
| _ = _ := by ring | |
| have hproduct : (delta + 1) * (7 * D + 7) ≤ 7 * T ^ 2 := by | |
| calc | |
| _ = 7 * (delta + 1) * (D + 1) := by ring | |
| _ ≤ 7 * T * T := by gcongr ; omega | |
| _ = _ := by ring | |
| have hT2 : T ≤ T ^ 2 := le_self_pow hT (by decide) | |
| have hT4 : T ^ 2 ≤ T ^ 4 := pow_le_pow_right' hT (by decide) | |
| have hcharge : sourceCharge r Q delta D E ≤ | |
| 800 * T ^ 4 + 134 * T ^ 2 + 52 * B + 56 := by | |
| dsimp only [sourceCharge] | |
| omega | |
| have hBT : B + 1 = T := rfl | |
| change sourceCharge r Q delta D E + 5000 * T ≤ 20000 * T ^ 4 | |
| omega | |
| theorem program_runsIn (regs : Fin 16 → Bool) (r Q delta D E : ℕ) | |
| (pairs : List Bool) (hr : 0 < r) : | |
| RunsIn program (budget r Q delta D E pairs + 1) | |
| ((inputState regs r Q delta D E pairs).withPC (some program.entry)) | |
| ((outputState r Q delta D E pairs).withPC none) := by | |
| obtain ⟨ticks, hbound, ht⟩ := command_eval regs r Q delta D E pairs hr | |
| exact ⟨ticks + 1, Nat.add_le_add_right hbound 1, compiled_halt_trace ht 1 30⟩ | |
| theorem program_runsIn_closed (regs : Fin 16 → Bool) (r Q delta D E : ℕ) | |
| (pairs : List Bool) (hr : 0 < r) : | |
| RunsIn program (20000 * (sizeBound r Q delta D E pairs.length + 1) ^ 4 + 1) | |
| ((inputState regs r Q delta D E pairs).withPC (some program.entry)) | |
| ((outputState r Q delta D E pairs).withPC none) := by | |
| apply (program_runsIn regs r Q delta D E pairs hr).mono | |
| apply Nat.add_le_add_right | |
| exact (budget_le r Q delta D E pairs hr).trans | |
| (Nat.mul_le_mul_left 20000 (Nat.pow_le_pow_left | |
| (Nat.add_le_add_right (extent_le_sizeBound r Q delta D E pairs hr) 1) 4)) | |
| theorem program_primitive (regs : Fin 16 → Bool) (r Q delta D E : ℕ) | |
| (pairs : List Bool) (hr : 0 < r) : | |
| Computation.RunsIn (primitive program).step | |
| (primitiveOverhead program * | |
| (20000 * (sizeBound r Q delta D E pairs.length + 1) ^ 4 + 1)) | |
| (primitiveCfg program ((inputState regs r Q delta D E pairs).withPC (some program.entry))) | |
| (primitiveCfg program ((outputState r Q delta D E pairs).withPC none)) := | |
| primitive_execution program (program_runsIn_closed regs r Q delta D E pairs hr) | |
| theorem program_trace (regs : Fin 16 → Bool) (r Q delta D E : ℕ) | |
| (pairs : List Bool) (hr : 0 < r) : | |
| ∃ ticks, Trace program ticks | |
| ((inputState regs r Q delta D E pairs).withPC (some program.entry)) | |
| ((outputState r Q delta D E pairs).withPC none) := by | |
| obtain ⟨ticks, _, ht⟩ := command_eval regs r Q delta D E pairs hr | |
| exact ⟨ticks + 1, compiled_halt_trace ht 1 30⟩ | |
| theorem context_word_order (r Q delta D E : ℕ) (pairs : List Bool) (hr : 0 < r) : | |
| ∃ a : MulticolorTypes.Word r Q, ∃ tail : List (MulticolorTypes.Word r Q), | |
| (a :: tail).Nodup ∧ (∀ w, w ∈ a :: tail) ∧ | |
| (context r Q delta D E pairs).defaultWord = ReadPlan.encodeWord a ∧ | |
| (context r Q delta D E pairs).packedAlphabet = | |
| ((a :: tail).map ReadPlan.encodeWord).flatten ∧ | |
| (context r Q delta D E pairs).alphabetRecords = | |
| ProgramEncoding.encodeRecords ((a :: tail).map ReadPlan.encodeWord) ∧ | |
| (context r Q delta D E pairs).width = unary (ReadPlan.encodeWord a).length := by | |
| obtain ⟨a, tail, he, hn, hf⟩ := AssignmentAlphabetSemantics.wordBytes_order hr Q | |
| refine ⟨a, tail, hn, hf, ?_, ?_, ?_, ?_⟩ | |
| · simp [context, ← he] | |
| · simp only [context, he] | |
| · simp only [context, he] | |
| · simp [context, ReadPlan.encodeWord_length, ReadPlan.wordWidth] | |
| end SubexponentialSAT.Subexp.AssignmentInputProgram | |
| end OAI.Algorithms | |