Download data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLog/BucketProgramEnumeration.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 4.47 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLog/BucketProgramEnumeration.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLog/BucketProgramEnumeration.lean
-
curl -L -o BucketProgramEnumeration.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLog/BucketProgramEnumeration.lean
4.47 kB
| import OAI.Algorithms.SubexponentialSAT.LeanCompat | |
| import OAI.Algorithms.SubexponentialSAT.Subexp.PackingTupleBounds | |
| import OAI.Algorithms.SubexponentialSAT.SubexpTupleRefinement | |
| namespace OAI.Algorithms | |
| /-! Runtime Boolean head enumeration by the audited fixed-control tuple | |
| program. Only the supplied head dimension is exponentiated. -/ | |
| namespace SubexponentialSAT.SqrtLog.BucketProgram | |
| open SubexponentialSAT.BitProgram SubexponentialSAT.StructuredCalls | |
| open SubexponentialSAT.Subexp.TupleProgram SubexponentialSAT.SubexpTupleRefinement | |
| def boolCode : SubexponentialSAT.StackEncoding.BlockCode Bool where | |
| width := 1 | |
| width_pos := by decide | |
| block b := [b] | |
| length_block _ := rfl | |
| injective_block := by intro a b h; simpa using h | |
| def alphabet : List (List Bool) := [[false], [true]] | |
| def assignments (h : ℕ) : List (List Bool) := powerRows alphabet h [[]] | |
| @[simp] theorem alphabet_length : alphabet.length = 2 := rfl | |
| @[simp] theorem assignments_length (h : ℕ) : (assignments h).length = 2^h := by | |
| simp [assignments, generated_count] | |
| theorem encode_bool_eq {h : ℕ} (x : Fin h → Bool) : | |
| encodeTuple boolCode x = List.ofFn x := by | |
| simp [encodeTuple, SubexponentialSAT.StackEncoding.encodeDataStack_eq_flatMap, boolCode] | |
| theorem assignments_complete {h : ℕ} (x : Fin h → Bool) : | |
| List.ofFn x ∈ assignments h := by | |
| have hx := encodeTuple_mem_powerRows boolCode [false, true] | |
| (by intro b; cases b <;> simp) h x | |
| rw [encode_bool_eq] at hx | |
| simpa [boolCode, assignments, alphabet] using hx | |
| theorem assignments_sound {h : ℕ} {bits : List Bool} | |
| (hbits : bits ∈ assignments h) : ∃ x : Fin h → Bool, List.ofFn x = bits := by | |
| have hm : bits ∈ powerRows ([false, true].map boolCode.block) h [[]] := by | |
| simpa [assignments, alphabet, boolCode] using hbits | |
| obtain ⟨x, _, hx⟩ := (mem_powerRows_encoded boolCode [false, true] h bits).mp hm | |
| exact ⟨x, (encode_bool_eq x).symm.trans hx⟩ | |
| theorem assignments_nodup (h : ℕ) : (assignments h).Nodup := by | |
| have hx := powerRows_encoded_nodup boolCode [false, true] (by decide) h | |
| simpa [assignments, alphabet, boolCode] using hx | |
| theorem assignment_width {h : ℕ} {bits : List Bool} | |
| (hbits : bits ∈ assignments h) : bits.length = h := by | |
| obtain ⟨x, rfl⟩ := assignments_sound hbits | |
| exact List.length_ofFn | |
| def enumerationCost (h : ℕ) : ℕ := | |
| 800 * (h+1) * (2^h+1) * (h+2) + 9 | |
| abbrev enumerationProgram := generateProgram | |
| theorem enumeration_control_size : size generateCmd + 1 = 83 := generate_control_size | |
| def enumerationInput (h : ℕ) : State 10 9 := | |
| ⟨fun _ => false, fun i => | |
| if i = 1 then ProgramEncoding.encodeRecords alphabet | |
| else if i = 8 then List.replicate h false else []⟩ | |
| theorem enumeration_runsIn (h : ℕ) : | |
| ∃ next : State 10 9, | |
| next.stacks 0 = ProgramEncoding.encodeRecords (assignments h) ∧ | |
| next.stacks 8 = [] ∧ | |
| RunsIn enumerationProgram (enumerationCost h) | |
| ((enumerationInput h).withPC (some enumerationProgram.entry)) | |
| (next.withPC none) := by | |
| have hi : outerInvariant alphabet (List.replicate h false) false | |
| (enumerationInput h) := by simp [outerInvariant, enumerationInput] | |
| obtain ⟨next, hnext, k, hk, he⟩ := generateProgram_runsIn alphabet | |
| (List.replicate h false) false (enumerationInput h) hi | |
| (by simp [enumerationInput]) (by simp [enumerationInput]) | |
| (by simp [enumerationInput]) | |
| refine ⟨next, ?_, hnext.1.2.2.2.2.2.1, k, ?_, he⟩ | |
| · simpa [assignments] using hnext.2.1 | |
| · have hb := SubexponentialSAT.Subexp.PackingTupleBounds.generated_powerCost_le alphabet h 1 | |
| (by intro word hw; simp [alphabet] at hw; rcases hw with rfl | rfl <;> simp) | |
| apply hk.trans | |
| simpa [enumerationCost, alphabet] using Nat.add_le_add_right hb 9 | |
| theorem enumeration_primitive (h : ℕ) : | |
| ∃ next : State 10 9, | |
| next.stacks 0 = ProgramEncoding.encodeRecords (assignments h) ∧ | |
| next.stacks 8 = [] ∧ | |
| Computation.RunsIn (primitive enumerationProgram).step | |
| (primitiveOverhead enumerationProgram * enumerationCost h) | |
| (primitiveCfg enumerationProgram | |
| ((enumerationInput h).withPC (some enumerationProgram.entry))) | |
| (primitiveCfg enumerationProgram (next.withPC none)) := by | |
| obtain ⟨next, hout, hdepth, hrun⟩ := enumeration_runsIn h | |
| exact ⟨next, hout, hdepth, primitive_execution enumerationProgram hrun⟩ | |
| end SubexponentialSAT.SqrtLog.BucketProgram | |
| end OAI.Algorithms | |