Download data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLog/BucketProgramDot.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 6.28 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLog/BucketProgramDot.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLog/BucketProgramDot.lean
-
curl -L -o BucketProgramDot.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLog/BucketProgramDot.lean
6.28 kB
| import OAI.Algorithms.SubexponentialSAT.LeanCompat | |
| import OAI.Algorithms.SubexponentialSAT.SqrtLog.BucketProgramArithmetic | |
| import OAI.Algorithms.SubexponentialSAT.Subexp.MatrixProgramSupport | |
| import OAI.Algorithms.SubexponentialSAT.WorkspaceCleanupProgram | |
| import OAI.Algorithms.SubexponentialSAT.ProgramStateFrames | |
| namespace OAI.Algorithms | |
| /-! Actual row-entry parsing, assignment-bit scanning, binary addition and | |
| workspace recycling for one exact offset-signature row. -/ | |
| namespace SubexponentialSAT.SqrtLog.BucketProgram | |
| open SubexponentialSAT.BitProgram SubexponentialSAT.StructuredCalls | |
| open SubexponentialSAT.Subexp.MatrixProgramSupport | |
| abbrev DotData := State 8 12 | |
| abbrev DotCode := Cmd 8 12 | |
| def dotState (regs : Fin 8 → Bool) (W : List Bool) (coeffs : List (List Bool)) | |
| (bits acc : List Bool) : DotData := | |
| ⟨regs, ![W, [], acc, [], [], [], [], [], [], words coeffs, bits, []]⟩ | |
| def choicePort : Fin 9 → Fin 12 := Fin.castAdd 3 | |
| theorem choicePort_injective : Function.Injective choicePort := Fin.castAdd_injective _ _ | |
| def choiceCall : DotCode := .call (ProgramLinking.liftProgram choiceAddProgram id choicePort) | |
| def addView (d : DotData) : AddData := projectState id choicePort d | |
| theorem choiceCall_eval (d : DotData) (hd : addReady (addView d)) : | |
| ∃ t ≤ 100*(addInputLength (addView d)+1)^2+2, ∃ rf word, | |
| Eval choiceCall t d ⟨rf, Function.update d.stacks 3 word⟩ ∧ | |
| SubexponentialSAT.BinaryArithmetic.toNat word = SubexponentialSAT.BinaryArithmetic.toNat (d.stacks 2) + | |
| (if d.regs 0 then SubexponentialSAT.BinaryArithmetic.toNat (d.stacks 1) | |
| else SubexponentialSAT.BinaryArithmetic.toNat (d.stacks 0)) ∧ | |
| word.length ≤ addInputLength (addView d)+1 := by | |
| obtain ⟨t, ht, rf, word, he, hv, hl⟩ := choiceAdd_eval (addView d) hd | |
| have hp : projectState id choicePort d = addView d := rfl | |
| have he' := eval_call_from_state choiceAddProgram id choicePort d | |
| Function.injective_id choicePort_injective (compiled_halt_trace he 0 3) | |
| have hend : embedState id choicePort d ⟨rf, Function.update (addView d).stacks 3 word⟩ = | |
| (⟨rf, Function.update d.stacks 3 word⟩ : DotData) := by | |
| apply embedState_eq_of_ports id choicePort d _ _ Function.injective_id choicePort_injective | |
| · intro i; rfl | |
| · intro i hi; exact (hi ⟨i, rfl⟩).elim | |
| · intro i; fin_cases i <;> rfl | |
| · intro i hi | |
| have h3 : i ≠ 3 := fun h => hi ⟨3, h.symm⟩ | |
| simp [h3] | |
| rw [hend] at he' | |
| exact ⟨t+1, by omega, rf, word, he', hv, hl⟩ | |
| def popAssignment : DotCode := .base (.atom (.pop 10 0 1)) | |
| def dotStep : DotCode := | |
| .seq (readWord 9 1 11 (by decide)) | |
| (.seq popAssignment | |
| (.seq choiceCall | |
| (.seq (WorkspaceCleanupProgram.command 0 1 [1, 2]) (move 3 2 11)))) | |
| def dotStepBound (W coeff acc : List Bool) : ℕ := | |
| 200*(W.length+coeff.length+acc.length+2)^2+30 | |
| theorem dotStep_eval (regs : Fin 8 → Bool) (W coeff : List Bool) | |
| (coeffs : List (List Bool)) (bit : Bool) (bits acc : List Bool) : | |
| ∃ t ≤ dotStepBound W coeff acc, ∃ rf out, | |
| Eval dotStep t (dotState regs W (coeff::coeffs) (bit::bits) acc) | |
| (dotState rf W coeffs bits out) ∧ | |
| SubexponentialSAT.BinaryArithmetic.toNat out = SubexponentialSAT.BinaryArithmetic.toNat acc + | |
| (if bit then SubexponentialSAT.BinaryArithmetic.toNat coeff else SubexponentialSAT.BinaryArithmetic.toNat W) ∧ | |
| out.length ≤ W.length+coeff.length+acc.length+1 := by | |
| let d := dotState regs W (coeff::coeffs) (bit::bits) acc | |
| obtain ⟨a, hea, hsa⟩ := readWord_eval (9 : Fin 12) 1 11 | |
| (by decide) (by decide) (by decide) d coeff (words coeffs) rfl rfl rfl | |
| let b : DotData := ⟨readRegs a.regs 0 1 (some bit), Function.update a.stacks 10 bits⟩ | |
| have hpop : Eval popAssignment 1 a b := by | |
| have ha10 : a.stacks 10 = bit::bits := by rw [hsa]; rfl | |
| have he := Eval.base (StructuredProgram.Eval.atom | |
| (StructuredProgram.Atom.pop (10 : Fin 12) (0 : Fin 8) 1) a) | |
| simpa [popAssignment, b, StructuredProgram.Atom.eval, StructuredProgram.Atom.instr, | |
| StructuredProgram.State.ofCfg, StructuredProgram.State.withPC, execInstr, ha10] using he | |
| have hb (i : Fin 12) : b.stacks i = | |
| (Function.update (Function.update (Function.update d.stacks 9 (words coeffs)) 1 coeff) 10 bits) i := by | |
| simp [b, hsa] | |
| have hready : addReady (addView b) := by | |
| constructor | |
| · rw [show (addView b).stacks 3 = b.stacks 3 from rfl, hb]; rfl | |
| · intro i; fin_cases i <;> simp [addView, projectState, choicePort, addWork, b, hsa, d, dotState] <;> rfl | |
| obtain ⟨tc, htc, rc, out, hec, hvc, hlc⟩ := choiceCall_eval b hready | |
| let c : DotData := ⟨rc, Function.update b.stacks 3 out⟩ | |
| let e := WorkspaceCleanupProgram.finish (0 : Fin 8) 1 ([1,2] : List (Fin 12)) c | |
| have heclean := WorkspaceCleanupProgram.command_eval (0 : Fin 8) 1 | |
| ([1,2] : List (Fin 12)) (by decide) c | |
| obtain ⟨f, hef, hsf⟩ := move_eval (3 : Fin 12) 2 11 | |
| (by decide) (by decide) (by decide) e (by simp [e]) (by simp [e,c,hb,d,dotState]) | |
| have hf : f = dotState f.regs W coeffs bits out := by | |
| apply congrArg (StructuredProgram.State.mk f.regs) | |
| rw [hsf] | |
| funext i | |
| fin_cases i <;> simp [e, c, hb, d, dotState] | |
| have hlen : addInputLength (addView b) = W.length+coeff.length+acc.length := by | |
| simp [addInputLength, addView, projectState, choicePort, hb, d, dotState] | |
| have hvalue : SubexponentialSAT.BinaryArithmetic.toNat out = SubexponentialSAT.BinaryArithmetic.toNat acc + | |
| (if bit then SubexponentialSAT.BinaryArithmetic.toNat coeff else SubexponentialSAT.BinaryArithmetic.toNat W) := by | |
| simpa [b, hsa, d, dotState, readRegs] using hvc | |
| have he3 : e.stacks 3 = out := by simp [e,c] | |
| have hcleanCost : WorkspaceCleanupProgram.cost ([1,2] : List (Fin 12)) c = | |
| 2*(coeff.length+acc.length)+6 := by | |
| simp [WorkspaceCleanupProgram.cost, c, hb, d, dotState] | |
| have he := hea.seq (hpop.seq (hec.seq (heclean.seq hef))) | |
| rw [hf] at he | |
| refine ⟨_, ?_, f.regs, out, he, hvalue, ?_⟩ | |
| · rw [hcleanCost, he3] | |
| rw [hlen] at htc hlc | |
| dsimp [dotStepBound] | |
| nlinarith [Nat.zero_le W.length, Nat.zero_le coeff.length, Nat.zero_le acc.length] | |
| · simpa [hlen] using hlc | |
| end SubexponentialSAT.SqrtLog.BucketProgram | |
| end OAI.Algorithms | |