Download data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLog/BucketProgramLabelBounds.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/BucketProgramLabelBounds.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLog/BucketProgramLabelBounds.lean
-
curl -L -o BucketProgramLabelBounds.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLog/BucketProgramLabelBounds.lean
4.45 kB
| import OAI.Algorithms.SubexponentialSAT.LeanCompat | |
| import OAI.Algorithms.SubexponentialSAT.SqrtLog.BucketProgramLabelLoop | |
| import OAI.Algorithms.SubexponentialSAT.SqrtLog.BucketProgramBounds | |
| import OAI.Algorithms.SubexponentialSAT.SqrtLog.BucketProgramEnumeration | |
| namespace OAI.Algorithms | |
| /-! Polynomial work per head assignment, hence only 2^h labels. -/ | |
| namespace SubexponentialSAT.SqrtLog.BucketProgram.Label | |
| open SubexponentialSAT.BitProgram SubexponentialSAT.StructuredCalls SubexponentialSAT.Subexp.MatrixProgramSupport | |
| def keyBound (W : List Bool) (h m B : ℕ) : ℕ := m*(2*(widthBound W h B+1)+1) | |
| def matrixBound (h m B : ℕ) : ℕ := m*(2*(h*(2*B+1))+1) | |
| def signatureBound (W : List Bool) (h m B : ℕ) : ℕ := m*(signatureRowBound W h B+2)+1 | |
| def stepBound (W : List Bool) (h m B n : ℕ) : ℕ := | |
| 1+(9*h+7)+(7*matrixBound h m B+5)+(signatureBound W h m B+2)+ | |
| 100*(n+1)*(h+1)+(7*keyBound W h m B+5)+(8*keyBound W h m B+8)+2+ | |
| (8*n+8)+(8*keyBound W h m B+8)+(2*h+3) | |
| theorem matrix_length_bound (rows : List (List (List Bool))) (h B : ℕ) | |
| (hl : ∀ row∈rows,row.length=h) (hb : ∀ row∈rows,∀ x∈row,x.length ≤ B) : | |
| (words (rows.map words)).length ≤ matrixBound h rows.length B := by | |
| have hr : ∀ r∈rows.map words,r.length ≤ h*(2*B+1) := by | |
| intro r hr | |
| obtain ⟨row,hrow,rfl⟩ := List.mem_map.mp hr | |
| simpa [hl row hrow] using words_length_bound row B (hb row hrow) | |
| simpa [matrixBound] using words_length_bound (rows.map words) (h*(2*B+1)) hr | |
| theorem stepCost_bound (W bits : List Bool) (rows : List (List (List Bool))) | |
| (js : List ℕ) (n B : ℕ) (hrows : ∀ row∈rows,row.length=bits.length) | |
| (hb : ∀ row∈rows,∀ x∈row,x.length ≤ B) (hlen : js.length=bits.length) | |
| (hjs : ∀ j∈js,j < n) : | |
| stepCost W bits rows js n ≤ stepBound W bits.length rows.length B n := by | |
| have hm := matrix_length_bound rows bits.length B hrows hb | |
| have hk := signatureValue_length_bound W bits rows B hrows hb | |
| have hs := signatureCost_bound W bits rows B hrows hb | |
| have ht := HeadScatterProgram.totalCost_polynomial n js bits hlen hjs | |
| rw [hlen] at ht | |
| unfold stepCost stepBound matrixBound keyBound signatureBound at * | |
| change (key W bits rows).length ≤ _ at hk | |
| omega | |
| theorem cost_bound (W : List Bool) (rows : List (List (List Bool))) | |
| (js : List ℕ) (n h B : ℕ) (pending : List (List Bool)) | |
| (hrows : ∀ row∈rows,row.length=h) (hb : ∀ row∈rows,∀ x∈row,x.length ≤ B) | |
| (hlen : js.length=h) (hjs : ∀ j∈js,j < n) | |
| (hpending : ∀ bits∈pending,bits.length=h) : | |
| cost W rows js n pending ≤ pending.length*(stepBound W h rows.length B n+2)+1 := by | |
| unfold cost | |
| suffices hs : (pending.map (fun bits => stepCost W bits rows js n+2)).sum ≤ | |
| pending.length*(stepBound W h rows.length B n+2) by omega | |
| induction pending with | |
| | nil => simp | |
| | cons bits rest ih => | |
| have hl := hpending bits (by simp) | |
| have hx := stepCost_bound W bits rows js n B | |
| (by intro row hr; rw [hrows row hr,hl]) hb (hlen.trans hl.symm) hjs | |
| rw [hl] at hx | |
| have ht := ih (fun bits hm => hpending bits (by simp [hm])) | |
| simp only [List.map_cons,List.sum_cons,List.length_cons] | |
| nlinarith | |
| /-- Fixed program bound for all Boolean assignments to the supplied h head | |
| coordinates. The original ambient n occurs only polynomially. -/ | |
| theorem headLabelProgram_runsIn (regs : Fin 8 → Bool) (W : List Bool) | |
| (rows : List (List (List Bool))) (js : List ℕ) (n h B : ℕ) | |
| (hrows : ∀ row∈rows,row.length=h) (hb : ∀ row∈rows,∀ x∈row,x.length ≤ B) | |
| (hlen : js.length=h) (hjs : ∀ j∈js,j < n) : | |
| ∃ rf, RunsIn program (2^h*(stepBound W h rows.length B n+2)+3) | |
| ((state regs W rows js n (assignments h) [] [false]).withPC (some program.entry)) | |
| ((state rf W rows js n [] (recordOutput W rows js n (assignments h) []) | |
| (keyOutput W rows (assignments h) [false])).withPC none) := by | |
| have ha : ∀ bits∈assignments h,bits.length=h := fun bits hm => assignment_width hm | |
| obtain ⟨rf,t,ht,he⟩ := program_runsIn regs W rows js n (assignments h) [] [false] | |
| (by intro bits hm row hr; rw [hrows row hr,ha bits hm]) | |
| (by intro bits hm; rw [hlen,ha bits hm]) hjs | |
| have hc := cost_bound W rows js n h B (assignments h) hrows hb hlen hjs ha | |
| rw [assignments_length] at hc | |
| exact ⟨rf,t,by omega,he⟩ | |
| end SubexponentialSAT.SqrtLog.BucketProgram.Label | |
| end OAI.Algorithms | |