Download data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLogSpace/AttainedSignatureProgram.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 26.4 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLogSpace/AttainedSignatureProgram.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLogSpace/AttainedSignatureProgram.lean
-
curl -L -o AttainedSignatureProgram.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLogSpace/AttainedSignatureProgram.lean
26.4 kB
| import OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.AttainedSignatures | |
| import OAI.Algorithms.SubexponentialSAT.SqrtLog.BucketProgramSignatureSemantics | |
| import OAI.Algorithms.SubexponentialSAT.SqrtLog.BucketProgramBounds | |
| import OAI.Algorithms.SubexponentialSAT.BitProgramSpace | |
| import OAI.Algorithms.SubexponentialSAT.SubexpRecordScan | |
| import OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.Enumerators | |
| import OAI.Algorithms.SubexponentialSAT.ProgramStateFrames | |
| /-! | |
| # Native full-key computation for the resumable attained-signature scan | |
| One invocation preserves the assignment and all raw integer constraint rows. | |
| Its local polynomial-time bound controls every scratch stack at every source | |
| prefix. The generator retains candidate and predecessor cursors separately. | |
| -/ | |
| namespace OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.AttainedSignatureProgram | |
| open OAI.Algorithms.SubexponentialSAT.BitProgram OAI.Algorithms.SubexponentialSAT.StructuredCalls OAI.Algorithms.SubexponentialSAT.Subexp.MatrixProgramSupport | |
| open OAI.Algorithms.SubexponentialSAT.SqrtLog.BucketProgram | |
| abbrev Data := State 8 16 | |
| abbrev Code := Cmd 8 16 | |
| def state (regs : Fin 8 → Bool) (W bits : List Bool) | |
| (rows : List (List (List Bool))) (key : List Bool) : Data := | |
| ⟨regs, ![W, [], [], [], [], [], [], [], [], [], [], [], bits, [], key, | |
| words (rows.map words)]⟩ | |
| def signaturePorts : Fin 15 → Fin 16 := Fin.castAdd 1 | |
| def command : Code := | |
| .seq (copy 15 13 11) | |
| (.call (ProgramLinking.liftProgram signatureProgram id signaturePorts)) | |
| def program := compiled command 12 14 | |
| def cost (W bits : List Bool) (rows : List (List (List Bool))) : ℕ := | |
| 7 * (words (rows.map words)).length + 5 + (signatureCost W bits rows + 2) | |
| theorem command_eval (regs : Fin 8 → Bool) (W bits : List Bool) | |
| (rows : List (List (List Bool))) (key : List Bool) | |
| (hlen : ∀ row ∈ rows, row.length = bits.length) : | |
| ∃ n ≤ cost W bits rows, ∃ out, | |
| Eval command n (state regs W bits rows key) | |
| (state out W bits rows (signatureValue W bits rows ++ key)) := by | |
| let a := state regs W bits rows key | |
| obtain ⟨b, hb, hbs⟩ := copy_eval (15 : Fin 16) 13 11 | |
| (by decide) (by decide) (by decide) a rfl | |
| have hproj : projectState id signaturePorts b = signatureState b.regs W bits rows key := by | |
| apply congrArg (StructuredProgram.State.mk b.regs) | |
| funext i | |
| fin_cases i <;> simp [signaturePorts, hbs, a, state, | |
| StackRoutines.copyStacks] | |
| obtain ⟨ns, hns, out, he⟩ := signatureCommand_eval b.regs W bits rows key hlen | |
| rw [← hproj] at he | |
| have hc := eval_call_from_state signatureProgram id signaturePorts b | |
| Function.injective_id (Fin.castAdd_injective _ _) (compiled_halt_trace he 13 14) | |
| have hembed : embedState id signaturePorts b | |
| (signatureState out W bits [] (signatureValue W bits rows ++ key)) = | |
| state out W bits rows (signatureValue W bits rows ++ key) := by | |
| apply embedState_eq_of_ports id signaturePorts b _ _ Function.injective_id | |
| (Fin.castAdd_injective _ _) | |
| · intro i; rfl | |
| · intro i hi; exact (hi ⟨i, rfl⟩).elim | |
| · intro i | |
| fin_cases i <;> simp [signaturePorts, state, signatureState, words] | |
| · intro i hi | |
| have hi15 : i = 15 := by | |
| apply Fin.ext | |
| by_contra hn | |
| have hil : i.val < 15 := by have := i.isLt; omega | |
| exact hi ⟨⟨i.val, hil⟩, Fin.ext rfl⟩ | |
| subst i | |
| simp [hbs, a, state, StackRoutines.copyStacks] | |
| rw [hembed] at hc | |
| exact ⟨_, by dsimp [cost, a, state] at *; omega, out, hb.seq hc⟩ | |
| theorem cost_le (W bits : List Bool) (rows : List (List (List Bool))) (B : ℕ) | |
| (hlen : ∀ row ∈ rows, row.length = bits.length) | |
| (hwidth : ∀ row ∈ rows, ∀ x ∈ row, x.length ≤ B) : | |
| cost W bits rows ≤ 7 * (words (rows.map words)).length + | |
| rows.length * (signatureRowBound W bits.length B + 2) + 8 := by | |
| have hs := signatureCost_bound W bits rows B hlen hwidth | |
| dsimp [cost] | |
| omega | |
| /-- Every physical bit in the complete key is retained; equality is precisely | |
| full integer-signature equality, including every original raw row. -/ | |
| theorem key_eq_iff {h d : ℕ} (W : List Bool) | |
| (c : Fin d → Fin h → List Bool) (A : Fin d → Fin h → ℤ) | |
| (x y : Fin h → Bool) | |
| (hc : ∀ j i, (OAI.Algorithms.SubexponentialSAT.BinaryArithmetic.toNat (c j i) : ℤ) = | |
| (OAI.Algorithms.SubexponentialSAT.BinaryArithmetic.toNat W : ℤ) + A j i) : | |
| signatureValue W (List.ofFn x) (List.ofFn (fun j => List.ofFn (c j))) = | |
| signatureValue W (List.ofFn y) (List.ofFn (fun j => List.ofFn (c j))) ↔ | |
| OAI.Algorithms.SubexponentialSAT.SqrtLog.LayoutSignatureBound.boolSignature A x = | |
| OAI.Algorithms.SubexponentialSAT.SqrtLog.LayoutSignatureBound.boolSignature A y := by | |
| rw [signatureValue_exact_iff W c A x y hc] | |
| exact ⟨fun h => funext h, fun h => congrFun h⟩ | |
| theorem program_runs (regs : Fin 8 → Bool) (W bits : List Bool) | |
| (rows : List (List (List Bool))) | |
| (hlen : ∀ row ∈ rows, row.length = bits.length) : | |
| ∃ n ≤ cost W bits rows + 1, ∃ out, | |
| Trace program n ((state regs W bits rows []).withPC (some program.entry)) | |
| ((state out W bits rows (signatureValue W bits rows)).withPC none) := by | |
| obtain ⟨n, hn, out, he⟩ := command_eval regs W bits rows [] hlen | |
| simp only [List.append_nil] at he | |
| exact ⟨n + 1, Nat.add_le_add_right hn 1, out, compiled_halt_trace he 12 14⟩ | |
| theorem state_stackBits (regs : Fin 8 → Bool) (W bits : List Bool) | |
| (rows : List (List (List Bool))) : | |
| stackBits (state regs W bits rows []).stacks = | |
| W.length + bits.length + (words (rows.map words)).length := by | |
| simp [stackBits, state, Fin.sum_univ_succ, Nat.add_assoc] | |
| /-- A complete per-key execution has polynomial local time. This estimate is | |
| applied to that invocation only, never to the exponential outer traversal. -/ | |
| theorem prefix_stack_bound {labels : ℕ} (p : Program 8 16 labels) | |
| (regs : Fin 8 → Bool) (W bits : List Bool) | |
| (rows : List (List (List Bool))) {steps : ℕ} {intermediate : Cfg 8 16 labels} | |
| (hle : steps ≤ cost W bits rows + 1) | |
| (htrace : Trace p steps | |
| ((state regs W bits rows []).withPC (some p.entry)) intermediate) | |
| (i : Fin 16) : | |
| (intermediate.stacks i).length ≤ | |
| 16 * (W.length + bits.length + (words (rows.map words)).length) + | |
| cost W bits rows + 1 := by | |
| apply StructuredSpace.local_stack_bound p (steps := cost W bits rows + 1) | |
| (initialBound := 16 * (W.length + bits.length + (words (rows.map words)).length)) | |
| _ steps intermediate hle htrace i | |
| change stackBits (state regs W bits rows []).stacks ≤ _ | |
| rw [state_stackBits] | |
| omega | |
| namespace KeyEquality | |
| open OAI.Algorithms.SubexponentialSAT.SubexpRecordScan | |
| /-- The two compared words and the surrounding frame survive comparison. -/ | |
| def command : Cmd 5 6 := | |
| .seq (.call (StackRoutines.copyProgram 0 1 4 (0 : Fin 5) 1)) | |
| (.seq (.call (StackRoutines.copyProgram 2 3 4 (0 : Fin 5) 1)) | |
| (.seq (.call compareKeys) | |
| (.seq (.call (StackRoutines.clearProgram 1 (0 : Fin 5) 1)) | |
| (.call (StackRoutines.clearProgram 3 (0 : Fin 5) 1))))) | |
| def program := compiled command 0 0 | |
| theorem command_eval (regs : Fin 5 → Bool) (left right frame : List Bool) : | |
| ∃ n ≤ 18 * left.length + 9 * right.length + 25, ∃ out, | |
| Eval command n (recordState regs left [] right [] [] frame) | |
| (recordState out left [] right [] [] frame) ∧ | |
| out 4 = decide (left = right) := by | |
| let r₁ := readRegs regs 0 1 none | |
| let r₂ := readRegs r₁ 0 1 none | |
| have h₁ : Eval (.call (StackRoutines.copyProgram 0 1 4 (0 : Fin 5) 1)) | |
| (7 * left.length + 5) | |
| (recordState regs left [] right [] [] frame) | |
| (recordState r₁ left left right [] [] frame) := by | |
| simpa [afterCopy, StackRoutines.copyStacks, recordState, storage, r₁] using | |
| OAI.Algorithms.SubexponentialSAT.SubexpRecordScan.copy_eval (recordState regs left [] right [] [] frame) | |
| 0 1 4 (by decide) (by decide) (by decide) rfl | |
| have h₂ : Eval (.call (StackRoutines.copyProgram 2 3 4 (0 : Fin 5) 1)) | |
| (7 * right.length + 5) | |
| (recordState r₁ left left right [] [] frame) | |
| (recordState r₂ left left right right [] frame) := by | |
| simpa [afterCopy, StackRoutines.copyStacks, recordState, storage, r₂] using | |
| OAI.Algorithms.SubexponentialSAT.SubexpRecordScan.copy_eval (recordState r₁ left left right [] [] frame) | |
| 2 3 4 (by decide) (by decide) (by decide) rfl | |
| obtain ⟨nc, hnc, rc, left', right', hc, hanswer, hl, hr⟩ := | |
| compareKeys_eval r₂ left left right right [] frame | |
| let r₃ := readRegs rc 0 1 none | |
| let r₄ := readRegs r₃ 0 1 none | |
| have h₃ : Eval (.call (StackRoutines.clearProgram 1 (0 : Fin 5) 1)) | |
| (2 * left'.length + 3) | |
| (recordState rc left left' right right' [] frame) | |
| (recordState r₃ left [] right right' [] frame) := by | |
| simpa [afterClear, StackRoutines.clearStacks, recordState, storage, r₃] using | |
| OAI.Algorithms.SubexponentialSAT.SubexpRecordScan.clear_eval (recordState rc left left' right right' [] frame) 1 | |
| have h₄ : Eval (.call (StackRoutines.clearProgram 3 (0 : Fin 5) 1)) | |
| (2 * right'.length + 3) | |
| (recordState r₃ left [] right right' [] frame) | |
| (recordState r₄ left [] right [] [] frame) := by | |
| simpa [afterClear, StackRoutines.clearStacks, recordState, storage, r₄] using | |
| OAI.Algorithms.SubexponentialSAT.SubexpRecordScan.clear_eval (recordState r₃ left [] right right' [] frame) 3 | |
| refine ⟨_, by omega, r₄, h₁.seq (h₂.seq (hc.seq (h₃.seq h₄))), ?_⟩ | |
| simpa [r₄, r₃, readRegs] using hanswer | |
| /-- Every prefix includes both preserved key words, the comparison copies, | |
| all cleanup scratch and the persistent caller frame. -/ | |
| theorem prefix_stack_bound (regs : Fin 5 → Bool) (left right frame : List Bool) | |
| {steps : ℕ} {intermediate : Cfg 5 6 _} | |
| (hle : steps ≤ 18 * left.length + 9 * right.length + 26) | |
| (htrace : Trace program steps | |
| ((recordState regs left [] right [] [] frame).withPC (some program.entry)) intermediate) | |
| (i : Fin 6) : | |
| (intermediate.stacks i).length ≤ | |
| 24 * left.length + 15 * right.length + 6 * frame.length + 26 := by | |
| have hinit : dataBits | |
| ((recordState regs left [] right [] [] frame).withPC (some program.entry)) ≤ | |
| 6 * (left.length + right.length + frame.length) := by | |
| unfold dataBits stackBits | |
| calc | |
| _ ≤ ∑ _j : Fin 6, (left.length + right.length + frame.length) := by | |
| apply Finset.sum_le_sum | |
| intro j _ | |
| fin_cases j <;> simp [storage] <;> omega | |
| _ = _ := by simp | |
| have hsum : (intermediate.stacks i).length ≤ dataBits intermediate := | |
| Finset.single_le_sum (fun j _ => Nat.zero_le ((intermediate.stacks j).length)) | |
| (Finset.mem_univ i) | |
| have hgrow := trace_dataBits program htrace | |
| omega | |
| end KeyEquality | |
| namespace Rescan | |
| abbrev Data := State 16 24 | |
| abbrev Code := Cmd 16 24 | |
| def workState (regs : Fin 16 → Bool) (W : List Bool) | |
| (rows : List (List (List Bool))) (candidate saved predecessor fuel : List Bool) | |
| (fresh : Bool) (bits key : List Bool) : Data := | |
| ⟨regs, ![W, [], [], [], [], [], [], [], [], [], [], [], bits, [], key, | |
| words (rows.map words), candidate, saved, predecessor, fuel, [], [], [fresh], []]⟩ | |
| def signatureRegisters : Fin 8 → Fin 16 := Fin.castAdd 8 | |
| def signatureStacks : Fin 16 → Fin 24 := Fin.castAdd 8 | |
| def keyCall : Code := .call (ProgramLinking.liftProgram | |
| AttainedSignatureProgram.program signatureRegisters signatureStacks) | |
| def equalityRegisters : Fin 5 → Fin 16 := Fin.castAdd 11 | |
| def equalityStacks : Fin 6 → Fin 24 := ![14, 1, 17, 3, 4, 5] | |
| def equalityCall : Code := .call (ProgramLinking.liftProgram | |
| KeyEquality.program equalityRegisters equalityStacks) | |
| theorem keyCall_eval (regs : Fin 16 → Bool) (W : List Bool) | |
| (rows : List (List (List Bool))) (candidate saved predecessor fuel : List Bool) | |
| (fresh : Bool) (bits key : List Bool) | |
| (hlen : ∀ row ∈ rows, row.length = bits.length) : | |
| ∃ n ≤ cost W bits rows + 1, ∃ out, | |
| Eval keyCall n (workState regs W rows candidate saved predecessor fuel fresh bits key) | |
| (workState out W rows candidate saved predecessor fuel fresh bits | |
| (signatureValue W bits rows ++ key)) := by | |
| let a := workState regs W rows candidate saved predecessor fuel fresh bits key | |
| have hr : Function.Injective signatureRegisters := Fin.castAdd_injective _ _ | |
| have hs : Function.Injective signatureStacks := Fin.castAdd_injective _ _ | |
| have hp : projectState signatureRegisters signatureStacks a = | |
| AttainedSignatureProgram.state (regs ∘ signatureRegisters) W bits rows key := by | |
| apply congrArg (StructuredProgram.State.mk _) | |
| funext i | |
| fin_cases i <;> rfl | |
| obtain ⟨n, hn, out, he⟩ := AttainedSignatureProgram.command_eval | |
| (regs ∘ signatureRegisters) W bits rows key hlen | |
| rw [← hp] at he | |
| have hc := eval_call_from_state AttainedSignatureProgram.program | |
| signatureRegisters signatureStacks a hr hs (compiled_halt_trace he 12 14) | |
| let e := embedState signatureRegisters signatureStacks a | |
| (AttainedSignatureProgram.state out W bits rows (signatureValue W bits rows ++ key)) | |
| have heq : e = workState e.regs W rows candidate saved predecessor fuel fresh bits | |
| (signatureValue W bits rows ++ key) := by | |
| apply embedState_eq_of_ports signatureRegisters signatureStacks a _ _ hr hs | |
| · intro i | |
| exact embedState_register signatureRegisters signatureStacks a _ hr i | |
| · intro i hi | |
| exact embedState_register_frame signatureRegisters signatureStacks a _ i hi | |
| · intro i | |
| fin_cases i <;> rfl | |
| · intro i hi | |
| have hil : 16 ≤ i.val := by | |
| by_contra h | |
| exact hi ⟨⟨i.val, by omega⟩, Fin.ext rfl⟩ | |
| fin_cases i <;> simp_all [workState, a] | |
| change Eval keyCall (n + 1) a e at hc | |
| rw [heq] at hc | |
| exact ⟨n + 1, Nat.add_le_add_right hn 1, e.regs, hc⟩ | |
| theorem equalityCall_eval (regs : Fin 16 → Bool) (W : List Bool) | |
| (rows : List (List (List Bool))) (candidate saved predecessor fuel : List Bool) | |
| (fresh : Bool) (bits key : List Bool) : | |
| ∃ n ≤ 18 * key.length + 9 * saved.length + 26, ∃ out, | |
| Eval equalityCall n (workState regs W rows candidate saved predecessor fuel fresh bits key) | |
| (workState out W rows candidate saved predecessor fuel fresh bits key) ∧ | |
| out 4 = decide (key = saved) := by | |
| let a := workState regs W rows candidate saved predecessor fuel fresh bits key | |
| have hr : Function.Injective equalityRegisters := Fin.castAdd_injective _ _ | |
| have hs : Function.Injective equalityStacks := by decide | |
| have hp : projectState equalityRegisters equalityStacks a = | |
| OAI.Algorithms.SubexponentialSAT.SubexpRecordScan.recordState (regs ∘ equalityRegisters) key [] saved [] [] [] := by | |
| apply congrArg (StructuredProgram.State.mk _) | |
| funext i | |
| fin_cases i <;> rfl | |
| obtain ⟨n, hn, out, he, hanswer⟩ := KeyEquality.command_eval | |
| (regs ∘ equalityRegisters) key saved [] | |
| rw [← hp] at he | |
| have hc := eval_call_from_state KeyEquality.program equalityRegisters equalityStacks a hr hs | |
| (compiled_halt_trace he 0 0) | |
| let e := embedState equalityRegisters equalityStacks a | |
| (OAI.Algorithms.SubexponentialSAT.SubexpRecordScan.recordState out key [] saved [] [] []) | |
| have heq : e = workState e.regs W rows candidate saved predecessor fuel fresh bits key := by | |
| apply embedState_eq_of_ports equalityRegisters equalityStacks a _ _ hr hs | |
| · intro i | |
| exact embedState_register equalityRegisters equalityStacks a _ hr i | |
| · intro i hi | |
| exact embedState_register_frame equalityRegisters equalityStacks a _ i hi | |
| · intro i | |
| fin_cases i <;> rfl | |
| · intro i _ | |
| rfl | |
| have ha : e.regs 4 = decide (key = saved) := by | |
| change e.regs (equalityRegisters 4) = _ | |
| rw [embedState_register equalityRegisters equalityStacks a _ hr] | |
| exact hanswer | |
| change Eval equalityCall (n + 1) a e at hc | |
| rw [heq] at hc | |
| exact ⟨n + 1, by omega, e.regs, hc, ha⟩ | |
| def countdownPorts : CounterForPrograms.Ports 16 24 where | |
| register := ⟨![13, 14, 15], by intro i j h; fin_cases i <;> fin_cases j <;> simp_all⟩ | |
| counter := 19 | |
| scratch := 20 | |
| counter_ne_scratch := by decide | |
| def predecessorPorts : CounterForPrograms.Ports 16 24 where | |
| register := countdownPorts.register | |
| counter := 18 | |
| scratch := 20 | |
| counter_ne_scratch := by decide | |
| def clear (i : Fin 24) : Code := .call (StackRoutines.clearProgram i 0 1) | |
| def copy (i j : Fin 24) : Code := .call (StackRoutines.copyProgram i j 21 0 1) | |
| theorem clear_eval (i : Fin 24) (a : Data) : | |
| Eval (clear i) (2 * (a.stacks i).length + 3) a | |
| ⟨readRegs a.regs 0 1 none, StackRoutines.clearStacks i a.stacks⟩ := | |
| .call _ (ListRegisterProgram.clear_run i 0 1 a.regs a.stacks) | |
| theorem copy_eval (i j : Fin 24) (a : Data) | |
| (hij : i ≠ j) (hi : i ≠ 21) (hj : (21 : Fin 24) ≠ j) | |
| (ht : a.stacks 21 = []) : | |
| Eval (copy i j) (7 * (a.stacks i).length + 5) a | |
| ⟨readRegs a.regs 0 1 none, StackRoutines.copyStacks i j a.stacks⟩ := | |
| .call _ (ListRegisterProgram.copy_run i j 21 0 1 hij hi hj (by decide) | |
| a.regs a.stacks ht) | |
| def storeFresh (b : Bool) : Code := .seq (clear 22) | |
| (.base (.seq (.atom (.set 0 b)) (.atom (.push 22 0)))) | |
| /-- Reject only a duplicate full key; keep scanning to charge and complete all | |
| predecessor work independently of success. -/ | |
| def updateFresh : Code := .ite 4 (storeFresh false) (.base .skip) | |
| theorem storeFresh_eval (b : Bool) (regs : Fin 16 → Bool) (W : List Bool) | |
| (rows : List (List (List Bool))) (candidate saved predecessor fuel : List Bool) | |
| (fresh : Bool) (bits key : List Bool) : | |
| ∃ out, Eval (storeFresh b) 7 | |
| (workState regs W rows candidate saved predecessor fuel fresh bits key) | |
| (workState out W rows candidate saved predecessor fuel b bits key) := by | |
| let a := workState regs W rows candidate saved predecessor fuel fresh bits key | |
| let c : Data := ⟨readRegs a.regs 0 1 none, StackRoutines.clearStacks 22 a.stacks⟩ | |
| let d := (StructuredProgram.Atom.set (0 : Fin 16) b).eval c | |
| let e := (StructuredProgram.Atom.push (22 : Fin 24) (0 : Fin 16)).eval d | |
| have hc : Eval (clear 22) 5 a c := clear_eval 22 a | |
| have he : Eval (.base (.seq (.atom (.set 0 b)) (.atom (.push 22 0)))) 2 c e := | |
| .base ((StructuredProgram.Eval.atom _ c).seq (StructuredProgram.Eval.atom _ d)) | |
| have hf : e = workState e.regs W rows candidate saved predecessor fuel b bits key := by | |
| apply congrArg (StructuredProgram.State.mk e.regs) | |
| funext i | |
| fin_cases i <;> simp [d, c, a, workState, StackRoutines.clearStacks, | |
| StructuredProgram.Atom.eval, StructuredProgram.Atom.instr, | |
| StructuredProgram.State.ofCfg, execInstr] | |
| refine ⟨e.regs, ?_⟩ | |
| have ht := hc.seq he | |
| rw [hf] at ht | |
| exact ht | |
| theorem updateFresh_eval (regs : Fin 16 → Bool) (W : List Bool) | |
| (rows : List (List (List Bool))) (candidate saved predecessor fuel : List Bool) | |
| (fresh : Bool) (bits key : List Bool) : | |
| ∃ n ≤ 8, ∃ out, Eval updateFresh n | |
| (workState regs W rows candidate saved predecessor fuel fresh bits key) | |
| (workState out W rows candidate saved predecessor fuel (fresh && !(regs 4)) bits key) := by | |
| cases hf : regs 4 with | |
| | false => | |
| exact ⟨1, by omega, regs, by | |
| simpa [updateFresh, hf] using (Eval.ite_false hf (.base (.skip _)) : | |
| Eval updateFresh 1 | |
| (workState regs W rows candidate saved predecessor fuel fresh bits key) | |
| (workState regs W rows candidate saved predecessor fuel fresh bits key))⟩ | |
| | true => | |
| obtain ⟨out, he⟩ := storeFresh_eval false regs W rows candidate saved predecessor fuel fresh bits key | |
| exact ⟨8, le_rfl, out, by simpa [updateFresh, hf] using (Eval.ite_true hf he : | |
| Eval updateFresh 8 | |
| (workState regs W rows candidate saved predecessor fuel fresh bits key) | |
| (workState out W rows candidate saved predecessor fuel false bits key))⟩ | |
| /-- One predecessor is processed by actual full-signature and byte-equality | |
| programs; the assignment counter is incremented only after all scratch is free. -/ | |
| def body : Code := | |
| .seq (copy 18 12) (.seq keyCall (.seq equalityCall | |
| (.seq updateFresh (.seq (clear 12) (.seq (clear 14) | |
| (Counters.incrementCmd predecessorPorts)))))) | |
| def bodyCost (W predecessor saved : List Bool) (rows : List (List (List Bool))) : ℕ := | |
| 7 * predecessor.length + 5 + (cost W predecessor rows + 1) + | |
| (18 * (signatureValue W predecessor rows).length + 9 * saved.length + 26) + 8 + | |
| (2 * predecessor.length + 3) + (2 * (signatureValue W predecessor rows).length + 3) + | |
| (CounterPrograms.rippleCost true predecessor + 1) | |
| theorem body_eval (regs : Fin 16 → Bool) (W : List Bool) | |
| (rows : List (List (List Bool))) (candidate saved predecessor fuel : List Bool) | |
| (fresh : Bool) (hlen : ∀ row ∈ rows, row.length = predecessor.length) : | |
| ∃ n ≤ bodyCost W predecessor saved rows, ∃ out, | |
| Eval body n (workState regs W rows candidate saved predecessor fuel fresh [] []) | |
| (workState out W rows candidate saved (CounterPrograms.ripple true predecessor) fuel | |
| (fresh && !decide (signatureValue W predecessor rows = saved)) [] []) := by | |
| let a := workState regs W rows candidate saved predecessor fuel fresh [] [] | |
| let r₁ := readRegs regs 0 1 none | |
| have hcopy : Eval (copy 18 12) (7 * predecessor.length + 5) a | |
| (workState r₁ W rows candidate saved predecessor fuel fresh predecessor []) := by | |
| have ht := copy_eval 18 12 a (by decide) (by decide) (by decide) rfl | |
| have he : (⟨readRegs a.regs 0 1 none, StackRoutines.copyStacks 18 12 a.stacks⟩ : Data) = | |
| workState r₁ W rows candidate saved predecessor fuel fresh predecessor [] := by | |
| apply congrArg (StructuredProgram.State.mk r₁) | |
| funext i | |
| fin_cases i <;> simp [a, workState, StackRoutines.copyStacks] | |
| rw [he] at ht | |
| exact ht | |
| obtain ⟨nk, hnk, rk, hk⟩ := keyCall_eval r₁ W rows candidate saved predecessor fuel | |
| fresh predecessor [] hlen | |
| simp only [List.append_nil] at hk | |
| obtain ⟨ne, hne, re, he, hanswer⟩ := equalityCall_eval rk W rows candidate saved predecessor fuel | |
| fresh predecessor (signatureValue W predecessor rows) | |
| obtain ⟨nf, hnf, rf, hf⟩ := updateFresh_eval re W rows candidate saved predecessor fuel | |
| fresh predecessor (signatureValue W predecessor rows) | |
| rw [hanswer] at hf | |
| let fresh' := fresh && !decide (signatureValue W predecessor rows = saved) | |
| let r₂ := readRegs rf 0 1 none | |
| have hclearBits : Eval (clear 12) (2 * predecessor.length + 3) | |
| (workState rf W rows candidate saved predecessor fuel fresh' predecessor | |
| (signatureValue W predecessor rows)) | |
| (workState r₂ W rows candidate saved predecessor fuel fresh' [] | |
| (signatureValue W predecessor rows)) := by | |
| have ht := clear_eval 12 (workState rf W rows candidate saved predecessor fuel fresh' | |
| predecessor (signatureValue W predecessor rows)) | |
| have hs : StackRoutines.clearStacks 12 | |
| (workState rf W rows candidate saved predecessor fuel fresh' predecessor | |
| (signatureValue W predecessor rows)).stacks = | |
| (workState r₂ W rows candidate saved predecessor fuel fresh' [] | |
| (signatureValue W predecessor rows)).stacks := by | |
| funext i | |
| fin_cases i <;> simp [workState, StackRoutines.clearStacks] | |
| rw [hs] at ht | |
| exact ht | |
| let r₃ := readRegs r₂ 0 1 none | |
| have hclearKey : Eval (clear 14) (2 * (signatureValue W predecessor rows).length + 3) | |
| (workState r₂ W rows candidate saved predecessor fuel fresh' [] | |
| (signatureValue W predecessor rows)) | |
| (workState r₃ W rows candidate saved predecessor fuel fresh' [] []) := by | |
| have ht := clear_eval 14 (workState r₂ W rows candidate saved predecessor fuel fresh' [] | |
| (signatureValue W predecessor rows)) | |
| have hs : StackRoutines.clearStacks 14 | |
| (workState r₂ W rows candidate saved predecessor fuel fresh' [] | |
| (signatureValue W predecessor rows)).stacks = | |
| (workState r₃ W rows candidate saved predecessor fuel fresh' [] []).stacks := by | |
| funext i | |
| fin_cases i <;> simp [workState, StackRoutines.clearStacks] | |
| rw [hs] at ht | |
| exact ht | |
| let b := workState r₃ W rows candidate saved predecessor fuel fresh' [] [] | |
| let e := Counters.incrementResult predecessorPorts b | |
| have hincr := Counters.increment_eval predecessorPorts b (by rfl) | |
| have heq : e = workState e.regs W rows candidate saved | |
| (CounterPrograms.ripple true predecessor) fuel fresh' [] [] := by | |
| apply congrArg (StructuredProgram.State.mk e.regs) | |
| exact (Counters.incrementResult_stacks predecessorPorts b (by rfl)).trans (by | |
| funext i | |
| fin_cases i <;> simp [b, workState, predecessorPorts]) | |
| change Eval (Counters.incrementCmd predecessorPorts) | |
| (CounterPrograms.rippleCost true predecessor + 1) b e at hincr | |
| rw [heq] at hincr | |
| refine ⟨_, ?_, e.regs, hcopy.seq (hk.seq (he.seq (hf.seq | |
| (hclearBits.seq (hclearKey.seq hincr)))))⟩ | |
| dsimp [bodyCost] | |
| omega | |
| def keyBound (W : List Bool) (h d B : ℕ) : ℕ := | |
| d * (2 * (widthBound W h B + 1) + 1) | |
| def bodyBound (W saved : List Bool) (rows : List (List (List Bool))) (h B : ℕ) : ℕ := | |
| 17 * h + 20 * keyBound W h rows.length B + 9 * saved.length + | |
| 7 * (words (rows.map words)).length + rows.length * (signatureRowBound W h B + 2) + 62 | |
| theorem bodyCost_le (W predecessor saved : List Bool) (rows : List (List (List Bool))) | |
| (h B : ℕ) (hp : predecessor.length = h) | |
| (hlen : ∀ row ∈ rows, row.length = h) | |
| (hwidth : ∀ row ∈ rows, ∀ x ∈ row, x.length ≤ B) : | |
| bodyCost W predecessor saved rows ≤ bodyBound W saved rows h B := by | |
| have hr : ∀ row ∈ rows, row.length = predecessor.length := by simpa [hp] using hlen | |
| have hc := cost_le W predecessor rows B hr hwidth | |
| have hk := signatureValue_length_bound W predecessor rows B hr hwidth | |
| have hi := CounterPrograms.rippleCost_le true predecessor | |
| rw [hp] at hc hk hi | |
| unfold bodyCost bodyBound keyBound | |
| rw [hp] | |
| omega | |
| def naturalKey (W : List Bool) (rows : List (List (List Bool))) (h i : ℕ) : List Bool := | |
| signatureValue W (ExecCNFTupleEnumeration.fixedBits h i) rows | |
| end Rescan | |
| end OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.AttainedSignatureProgram | |