Download data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLog/BinaryArgminBootstrap.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 4.45 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLog/BinaryArgminBootstrap.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLog/BinaryArgminBootstrap.lean
-
curl -L -o BinaryArgminBootstrap.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLog/BinaryArgminBootstrap.lean
4.45 kB
| import OAI.Algorithms.SubexponentialSAT.LeanCompat | |
| import OAI.Algorithms.SubexponentialSAT.SqrtLog.BinaryArgminScan | |
| namespace OAI.Algorithms | |
| /-! Bootstrap the binary argmin from an empty incumbent. The initial candidate | |
| load is paid explicitly, including the empty-input case. -/ | |
| namespace SubexponentialSAT.SqrtLog.BinaryArgmin | |
| open SubexponentialSAT.BitProgram SubexponentialSAT.StructuredCalls | |
| abbrev installFirst : Cmd 8 9 := .seq replace cleanup | |
| theorem installFirst_eval (B C : ℕ) (next : Entry) (queue : List Bool) | |
| (regs : Fin 8 → Bool) (hn : Fits B C next) : | |
| ∃ n ≤ 100 * (B + C + 1), ∃ regs', | |
| Eval installFirst n (data regs next empty queue) (data regs' empty next queue) := by | |
| let d := data regs next empty queue | |
| have hr := replace_eval d (by rfl) | |
| have hc := cleanup_eval (afterReplace d) | |
| have hf : afterCleanup (afterReplace d) = | |
| data (afterCleanup (afterReplace d)).regs empty next queue := by | |
| apply congrArg₂ StructuredProgram.State.mk | |
| · rfl | |
| · funext j | |
| fin_cases j <;> simp [ afterReplace, afterClear, afterCopy, | |
| StackRoutines.clearStacks, StackRoutines.copyStacks, d, data, store, empty] | |
| refine ⟨9 * next.payload.length + 9 * next.score.length + 25, ?_, | |
| (afterCleanup (afterReplace d)).regs, ?_⟩ | |
| · rcases hn with ⟨hs, hp⟩ | |
| omega | |
| · rw [← hf] | |
| convert Eval.seq hr hc using 1 | |
| simp [afterReplace, afterClear, afterCopy, StackRoutines.clearStacks, | |
| StackRoutines.copyStacks, d, data, store, empty] | |
| omega | |
| /-- Extra callback obligation for the first load, where the incumbent is empty | |
| and need not have the fixed score width. It requires actual traces as usual. -/ | |
| structure FirstLoadSpec (load : Cmd 8 9) (encode : List Entry → List Bool) | |
| (B C cost : ℕ) : Prop where | |
| nil : ∀ regs, ∃ n ≤ cost, ∃ regs', regs' 7 = false ∧ | |
| Eval load n (data regs empty empty (encode [])) | |
| (data regs' empty empty (encode [])) | |
| cons : ∀ next rest regs, Fits B C next → (∀ a ∈ rest, Fits B C a) → | |
| ∃ n ≤ cost, ∃ regs', regs' 7 = true ∧ | |
| Eval load n (data regs empty empty (encode (next :: rest))) | |
| (data regs' next empty (encode rest)) | |
| abbrev selectCommand (load : Cmd 8 9) : Cmd 8 9 := | |
| .seq load (.ite 7 | |
| (.seq installFirst (.seq (scanCommand load) (atom (.set 7 true)))) (.base .skip)) | |
| theorem select_nil (load : Cmd 8 9) (encode : List Entry → List Bool) | |
| (B C cost : ℕ) (hfirst : FirstLoadSpec load encode B C cost) | |
| (regs : Fin 8 → Bool) : | |
| ∃ n ≤ cost + 1, ∃ regs', regs' 7 = false ∧ | |
| Eval (selectCommand load) n (data regs empty empty (encode [])) | |
| (data regs' empty empty (encode [])) := by | |
| obtain ⟨n, hn, regs', hf, ht⟩ := hfirst.nil regs | |
| exact ⟨n + 1, Nat.add_le_add_right hn 1, regs', hf, | |
| Eval.seq ht (Eval.ite_false hf (Eval.base (.skip _)))⟩ | |
| theorem select_cons (load : Cmd 8 9) (encode : List Entry → List Bool) | |
| (B C cost : ℕ) (hload : LoaderSpec load encode B C cost) | |
| (hfirst : FirstLoadSpec load encode B C cost) | |
| (seed : Entry) (rest : List Entry) (regs : Fin 8 → Bool) | |
| (hs : Fits B C seed) (hr : ∀ a ∈ rest, Fits B C a) : | |
| ∃ n ≤ cost + 100 * (B + C + 1) + scanBudget B C cost rest.length + 2, | |
| ∃ regs', regs' 7 = true ∧ | |
| Eval (selectCommand load) n (data regs empty empty (encode (seed :: rest))) | |
| (data regs' empty (HashSelect.best value seed rest) (encode [])) := by | |
| obtain ⟨l, hl, r₁, htrue, hread⟩ := hfirst.cons seed rest regs hs hr | |
| obtain ⟨i, hi, r₂, hinit⟩ := installFirst_eval B C seed (encode rest) r₁ hs | |
| obtain ⟨s, hsb, r₃, _, hscan⟩ := scan_eval load encode B C cost hload seed rest r₂ hs hr | |
| let final := Function.update r₃ 7 true | |
| have hmark : Eval (atom (.set 7 true)) 1 | |
| (data r₃ empty (HashSelect.best value seed rest) (encode [])) | |
| (data final empty (HashSelect.best value seed rest) (encode [])) := | |
| Eval.base (StructuredProgram.Eval.atom (.set 7 true) _) | |
| refine ⟨l + (i + (s + 1) + 1), by omega, final, by simp [final], ?_⟩ | |
| exact Eval.seq hread (Eval.ite_true htrue (Eval.seq hinit (Eval.seq hscan hmark))) | |
| theorem select_cons_linear (B C cost count : ℕ) : | |
| cost + 100 * (B + C + 1) + scanBudget B C cost count + 2 ≤ | |
| (count + 2) * (cost + 100 * (B + C + 1) + 3) := by | |
| unfold scanBudget | |
| nlinarith | |
| end SubexponentialSAT.SqrtLog.BinaryArgmin | |
| end OAI.Algorithms | |