Download data/lean/OAI/Algorithms/SubexponentialSAT/Subexp/BlockSearchProgram.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 27.4 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Algorithms/SubexponentialSAT/Subexp/BlockSearchProgram.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Algorithms/SubexponentialSAT/Subexp/BlockSearchProgram.lean
-
curl -L -o BlockSearchProgram.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Algorithms/SubexponentialSAT/Subexp/BlockSearchProgram.lean
27.4 kB
| import OAI.Algorithms.SubexponentialSAT.LeanCompat | |
| import OAI.Algorithms.SubexponentialSAT.Subexp.BlockSearch | |
| import OAI.Algorithms.SubexponentialSAT.RecordPrograms | |
| import OAI.Algorithms.SubexponentialSAT.Subexp.TupleProgram | |
| import OAI.Algorithms.SubexponentialSAT.SubexpTupleRefinement | |
| namespace OAI.Algorithms | |
| /-! | |
| # Fixed control for the universal-block finite search | |
| The commands in this file scan runtime framed lists. Their finite control | |
| depends on the supplied finite predicate program and fixed ports, never on | |
| the block dimension, field size, or list lengths. Predicate specifications | |
| are measured `StructuredCalls.Eval` contracts for actual finite code. | |
| -/ | |
| namespace SubexponentialSAT.Subexp.BlockSearchProgram | |
| open BitProgram StructuredCalls | |
| /-- Negate the predicate-result register using two actual instructions. -/ | |
| abbrev negateResult {r s : ℕ} (p : RecordPrograms.Ports r s) : Cmd r s := | |
| .ite p.found (RecordPrograms.atom (.set p.found false)) | |
| (RecordPrograms.atom (.set p.found true)) | |
| theorem negateResult_eval {r s : ℕ} (p : RecordPrograms.Ports r s) (base : State r s) | |
| (v pr result : Bool) (src out : List Bool) : | |
| Eval (negateResult p) 2 (RecordPrograms.state p base v pr result src out) | |
| (RecordPrograms.state p base v pr (!result) src out) := by | |
| cases result with | |
| | false => | |
| apply Eval.ite_false (by simp) | |
| exact RecordPrograms.set_found_eval p base v pr false true src out | |
| | true => | |
| apply Eval.ite_true (by simp) | |
| exact RecordPrograms.set_found_eval p base v pr true false src out | |
| abbrev anyCommand {r s : ℕ} (p : RecordPrograms.Ports r s) (predicate : Cmd r s) : Cmd r s := | |
| RecordPrograms.iterate p predicate | |
| abbrev allCommand {r s : ℕ} (p : RecordPrograms.Ports r s) (predicate : Cmd r s) : Cmd r s := | |
| .seq (RecordPrograms.iterate p (.seq predicate (negateResult p))) (negateResult p) | |
| theorem negated_contract {r s : ℕ} (p : RecordPrograms.Ports r s) | |
| (predicate : Cmd r s) (test : List Bool → Bool) (cost : List Bool → ℕ) | |
| (invariant : State r s → Prop) (valid : List Bool → Prop) | |
| (h : RecordPrograms.CallbackContractOn p predicate test cost invariant valid) : | |
| RecordPrograms.CallbackContractOn p (.seq predicate (negateResult p)) | |
| (fun bits => !(test bits)) (fun bits => cost bits + 2) invariant valid := by | |
| intro bits tail base hv hi | |
| obtain ⟨n, next, hn, hnext, run⟩ := h bits tail base hv hi | |
| exact ⟨n + 2, next, by dsimp; omega, hnext, | |
| run.seq (negateResult_eval p next false true (test bits) tail [])⟩ | |
| theorem not_any_not (records : List (List Bool)) (test : List Bool → Bool) : | |
| (!(records.any (fun bits => !(test bits)))) = records.all test := by | |
| induction records with | |
| | nil => rfl | |
| | cons bits records ih => | |
| cases ht : test bits <;> simp [ht, ih] | |
| /-- A real short-circuiting universal quantifier over encoded records. -/ | |
| theorem allCommand_eval {r s : ℕ} (p : RecordPrograms.Ports r s) | |
| (predicate : Cmd r s) (test : List Bool → Bool) (cost : List Bool → ℕ) | |
| (invariant : State r s → Prop) (valid : List Bool → Prop) | |
| (contract : RecordPrograms.CallbackContractOn p predicate test cost invariant valid) | |
| (records : List (List Bool)) (suffix : List Bool) (base : State r s) | |
| (hrecords : ∀ bits ∈ records, valid bits) (hbase : invariant base) | |
| (v pr result : Bool) : | |
| ∃ n next, n ≤ 5 + RecordPrograms.budget (fun bits => cost bits + 2) records ∧ | |
| invariant next ∧ Eval (allCommand p predicate) n | |
| (RecordPrograms.state p base v pr result (ProgramEncoding.encodeRecords records ++ suffix) []) | |
| (RecordPrograms.state p next false true (records.all test) | |
| (RecordPrograms.unread (fun bits => !(test bits)) records suffix) []) := by | |
| obtain ⟨n, next, hn, hnext, run⟩ := RecordPrograms.iterate_run_on p | |
| (.seq predicate (negateResult p)) (fun bits => !(test bits)) (fun bits => cost bits + 2) | |
| invariant valid (negated_contract p predicate test cost invariant valid contract) | |
| records suffix base hrecords hbase v pr result | |
| refine ⟨n + 2, next, by omega, hnext, ?_⟩ | |
| have hrun := run.seq | |
| (negateResult_eval p next false true (records.any (fun bits => !(test bits))) | |
| (RecordPrograms.unread (fun bits => !(test bits)) records suffix) []) | |
| rw [not_any_not records test] at hrun | |
| exact hrun | |
| /-- The existential quantifier uses the same measured framed-list iterator. -/ | |
| theorem anyCommand_eval {r s : ℕ} (p : RecordPrograms.Ports r s) | |
| (predicate : Cmd r s) (test : List Bool → Bool) (cost : List Bool → ℕ) | |
| (invariant : State r s → Prop) (valid : List Bool → Prop) | |
| (contract : RecordPrograms.CallbackContractOn p predicate test cost invariant valid) | |
| (records : List (List Bool)) (suffix : List Bool) (base : State r s) | |
| (hrecords : ∀ bits ∈ records, valid bits) (hbase : invariant base) | |
| (v pr result : Bool) : | |
| ∃ n next, n ≤ 3 + RecordPrograms.budget cost records ∧ invariant next ∧ | |
| Eval (anyCommand p predicate) n | |
| (RecordPrograms.state p base v pr result (ProgramEncoding.encodeRecords records ++ suffix) []) | |
| (RecordPrograms.state p next false true (records.any test) | |
| (RecordPrograms.unread test records suffix) []) := | |
| RecordPrograms.iterate_run_on p predicate test cost invariant valid contract | |
| records suffix base hrecords hbase v pr result | |
| /-- The semantic history identifies the successful record stored by a concrete | |
| predicate callback. It does not assume a truth oracle or a chosen witness. -/ | |
| theorem selected_of_visits {r s : ℕ} (output : Fin s) | |
| (test : List Bool → Bool) {records : List (List Bool)} {base next : State r s} | |
| (h : RecordPrograms.Visits test (fun bits _ b => b.stacks output = bits) records base next) | |
| (hsuccess : records.any test = true) : | |
| ∃ bits ∈ records, test bits = true ∧ next.stacks output = bits := by | |
| induction h with | |
| | nil base => simp at hsuccess | |
| | @hit bits rest base next ht he => exact ⟨bits, by simp, ht, he⟩ | |
| | @miss bits rest base middle next ht he history ih => | |
| have hr : rest.any test = true := by simpa [ht] using hsuccess | |
| obtain ⟨bits', hbits', htest, hout⟩ := ih hr | |
| exact ⟨bits', by simp [hbits'], htest, hout⟩ | |
| /-- First-success control, with an actual stored successful payload. -/ | |
| theorem searchCommand_eval {r s : ℕ} (p : RecordPrograms.Ports r s) | |
| (predicate : Cmd r s) (output : Fin s) | |
| (test : List Bool → Bool) (cost : List Bool → ℕ) | |
| (invariant : State r s → Prop) (valid : List Bool → Prop) | |
| (contract : RecordPrograms.CallbackContractWithOn p predicate test cost invariant | |
| (fun bits _ b => b.stacks output = bits) valid) | |
| (records : List (List Bool)) (suffix : List Bool) (base : State r s) | |
| (hrecords : ∀ bits ∈ records, valid bits) (hbase : invariant base) | |
| (hexists : ∃ bits ∈ records, test bits = true) (v pr result : Bool) : | |
| ∃ n next bits, n ≤ 3 + RecordPrograms.budget cost records ∧ invariant next ∧ | |
| bits ∈ records ∧ test bits = true ∧ next.stacks output = bits ∧ | |
| Eval (anyCommand p predicate) n | |
| (RecordPrograms.state p base v pr result (ProgramEncoding.encodeRecords records ++ suffix) []) | |
| (RecordPrograms.state p next false true true | |
| (RecordPrograms.unread test records suffix) []) := by | |
| have hs : records.any test = true := List.any_eq_true.mpr hexists | |
| obtain ⟨n, next, hn, hnext, history, run⟩ := RecordPrograms.iterate_run_with_on | |
| p predicate test cost invariant (fun bits _ b => b.stacks output = bits) valid | |
| contract records suffix base hrecords hbase v pr result | |
| obtain ⟨bits, hbits, htest, hout⟩ := selected_of_visits output test history hs | |
| refine ⟨n, next, bits, hn, hnext, hbits, htest, hout, ?_⟩ | |
| simpa only [anyCommand, ProgramEncoding.encodeRecords, hs] using run | |
| /-- The saved enumeration is copied for each quantifier invocation. -/ | |
| structure SavedPorts (r s : ℕ) extends RecordPrograms.Ports r s where | |
| saved : Fin s | |
| temporary : Fin s | |
| saved_ne_source : saved ≠ source | |
| saved_ne_payload : saved ≠ payload | |
| temporary_ne_source : temporary ≠ source | |
| temporary_ne_payload : temporary ≠ payload | |
| saved_ne_temporary : saved ≠ temporary | |
| abbrev savedAllCommand {r s : ℕ} (p : SavedPorts r s) (predicate : Cmd r s) : Cmd r s := | |
| .seq (.call (StackRoutines.copyProgram p.saved p.source p.temporary p.tag p.present)) | |
| (.seq (allCommand p.toPorts predicate) | |
| (.seq (.call (StackRoutines.clearProgram p.source p.tag p.present)) | |
| (RecordPrograms.atom (.set p.present true)))) | |
| abbrev savedAnyCommand {r s : ℕ} (p : SavedPorts r s) (predicate : Cmd r s) : Cmd r s := | |
| .seq (.call (StackRoutines.copyProgram p.saved p.source p.temporary p.tag p.present)) | |
| (.seq (anyCommand p.toPorts predicate) | |
| (.seq (.call (StackRoutines.clearProgram p.source p.tag p.present)) | |
| (RecordPrograms.atom (.set p.present true)))) | |
| private theorem copy_saved_eval {r s : ℕ} (p : SavedPorts r s) (base : State r s) | |
| (bits : List Bool) (hs : base.stacks p.saved = bits) (ht : base.stacks p.temporary = []) | |
| (v pr found : Bool) : | |
| Eval (.call (StackRoutines.copyProgram p.saved p.source p.temporary p.tag p.present)) | |
| (7 * bits.length + 5) | |
| (RecordPrograms.state p.toPorts base v pr found [] []) | |
| (RecordPrograms.state p.toPorts base false false found bits []) := by | |
| have h := TupleProgram.copy_eval p.saved p.source p.temporary p.tag p.present | |
| p.saved_ne_source p.saved_ne_temporary p.temporary_ne_source p.tag_ne_present | |
| (RecordPrograms.state p.toPorts base v pr found [] []) | |
| (by simpa [RecordPrograms.state, p.temporary_ne_source, p.temporary_ne_payload] using ht) | |
| have he : (⟨readRegs (RecordPrograms.state p.toPorts base v pr found [] []).regs | |
| p.tag p.present none, | |
| StackRoutines.copyStacks p.saved p.source | |
| (RecordPrograms.state p.toPorts base v pr found [] []).stacks⟩ : State r s) = | |
| RecordPrograms.state p.toPorts base false false found bits [] := by | |
| apply congrArg₂ StructuredProgram.State.mk | |
| · funext i | |
| by_cases hv : i = p.tag <;> by_cases hp : i = p.present <;> by_cases hf : i = p.found <;> | |
| simp_all [readRegs, RecordPrograms.state, Function.update_apply, | |
| p.tag_ne_present, p.found_ne_tag, p.found_ne_present] | |
| · funext i | |
| by_cases hi : i = p.source <;> by_cases hp : i = p.payload <;> | |
| simp_all [StackRoutines.copyStacks, RecordPrograms.state, Function.update_apply, | |
| p.source_ne_payload, Ne.symm p.source_ne_payload, | |
| p.saved_ne_source, p.saved_ne_payload] | |
| rw [he] at h | |
| simpa [RecordPrograms.state, p.saved_ne_source, p.saved_ne_payload, hs] using h | |
| private theorem clear_source_eval {r s : ℕ} (p : RecordPrograms.Ports r s) | |
| (base : State r s) (bits : List Bool) (v pr found : Bool) : | |
| Eval (.call (StackRoutines.clearProgram p.source p.tag p.present)) (2 * bits.length + 3) | |
| (RecordPrograms.state p base v pr found bits []) | |
| (RecordPrograms.state p base false false found [] []) := by | |
| have h := TupleProgram.clear_eval p.source p.tag p.present | |
| (RecordPrograms.state p base v pr found bits []) | |
| have he : (⟨readRegs (RecordPrograms.state p base v pr found bits []).regs p.tag p.present none, | |
| StackRoutines.clearStacks p.source (RecordPrograms.state p base v pr found bits []).stacks⟩ : | |
| State r s) = RecordPrograms.state p base false false found [] [] := by | |
| apply congrArg₂ StructuredProgram.State.mk | |
| · funext i | |
| by_cases hv : i = p.tag <;> by_cases hp : i = p.present <;> by_cases hf : i = p.found <;> | |
| simp_all [readRegs, RecordPrograms.state, Function.update_apply, | |
| p.tag_ne_present, p.found_ne_tag, p.found_ne_present] | |
| · funext i | |
| by_cases hi : i = p.source <;> by_cases hp : i = p.payload <;> | |
| simp_all [StackRoutines.clearStacks, RecordPrograms.state, Function.update_apply, | |
| p.source_ne_payload] | |
| rw [he] at h | |
| simpa using h | |
| private theorem set_present_eval {r s : ℕ} (p : RecordPrograms.Ports r s) | |
| (base : State r s) (v pr found pr' : Bool) (src out : List Bool) : | |
| Eval (RecordPrograms.atom (.set p.present pr')) 1 | |
| (RecordPrograms.state p base v pr found src out) | |
| (RecordPrograms.state p base v pr' found src out) := by | |
| have he : (StructuredProgram.Atom.set p.present pr').eval | |
| (RecordPrograms.state p base v pr found src out) = | |
| RecordPrograms.state p base v pr' found src out := by | |
| apply congrArg₂ StructuredProgram.State.mk | |
| · funext i | |
| by_cases hv : i = p.tag <;> by_cases hp : i = p.present <;> by_cases hf : i = p.found <;> | |
| simp_all [StructuredProgram.Atom.instr, execInstr, | |
| RecordPrograms.state, p.found_ne_present, | |
| p.tag_ne_present, Ne.symm p.tag_ne_present, p.found_ne_tag, | |
| Ne.symm p.found_ne_tag, Ne.symm p.found_ne_present] | |
| · rfl | |
| rw [← he] | |
| exact .base (.atom _ _) | |
| theorem unread_length_le (test : List Bool → Bool) (records : List (List Bool)) : | |
| (RecordPrograms.unread test records []).length ≤ (ProgramEncoding.encodeRecords records).length := by | |
| induction records with | |
| | nil => simp [RecordPrograms.unread] | |
| | cons bits records ih => | |
| cases h : test bits <;> | |
| simp [RecordPrograms.unread, h, ProgramEncoding.encodeRecords, | |
| Encoding.encodeList] at * <;> omega | |
| /-- Repeated universal scans preserve the saved enumeration and consume their | |
| working source even when a failed predicate stops the scan early. -/ | |
| theorem savedAllCommand_eval {r s : ℕ} (p : SavedPorts r s) | |
| (predicate : Cmd r s) (test : List Bool → Bool) (cost : List Bool → ℕ) | |
| (invariant : State r s → Prop) (valid : List Bool → Prop) | |
| (contract : RecordPrograms.CallbackContractOn p.toPorts predicate test cost invariant valid) | |
| (records : List (List Bool)) (base : State r s) | |
| (hrecords : ∀ bits ∈ records, valid bits) (hbase : invariant base) | |
| (hs : base.stacks p.saved = ProgramEncoding.encodeRecords records) | |
| (ht : base.stacks p.temporary = []) (v pr found : Bool) : | |
| ∃ n next, | |
| n ≤ 9 * (ProgramEncoding.encodeRecords records).length + | |
| RecordPrograms.budget (fun bits => cost bits + 2) records + 14 ∧ | |
| invariant next ∧ Eval (savedAllCommand p predicate) n | |
| (RecordPrograms.state p.toPorts base v pr found [] []) | |
| (RecordPrograms.state p.toPorts next false true (records.all test) [] []) := by | |
| have hcopy := copy_saved_eval p base (ProgramEncoding.encodeRecords records) hs ht v pr found | |
| obtain ⟨n, next, hn, hnext, hall⟩ := allCommand_eval p.toPorts predicate test cost | |
| invariant valid contract records [] base hrecords hbase false false found | |
| simp only [List.append_nil] at hall | |
| have hclear := clear_source_eval p.toPorts next | |
| (RecordPrograms.unread (fun bits => !(test bits)) records []) false true (records.all test) | |
| have hset := set_present_eval p.toPorts next false false (records.all test) true [] [] | |
| refine ⟨_, next, ?_, hnext, hcopy.seq (hall.seq (hclear.seq hset))⟩ | |
| have hl := unread_length_le (fun bits => !(test bits)) records | |
| omega | |
| theorem savedAnyCommand_eval {r s : ℕ} (p : SavedPorts r s) | |
| (predicate : Cmd r s) (test : List Bool → Bool) (cost : List Bool → ℕ) | |
| (invariant : State r s → Prop) (valid : List Bool → Prop) | |
| (contract : RecordPrograms.CallbackContractOn p.toPorts predicate test cost invariant valid) | |
| (records : List (List Bool)) (base : State r s) | |
| (hrecords : ∀ bits ∈ records, valid bits) (hbase : invariant base) | |
| (hs : base.stacks p.saved = ProgramEncoding.encodeRecords records) | |
| (ht : base.stacks p.temporary = []) (v pr found : Bool) : | |
| ∃ n next, | |
| n ≤ 9 * (ProgramEncoding.encodeRecords records).length + | |
| RecordPrograms.budget cost records + 12 ∧ | |
| invariant next ∧ Eval (savedAnyCommand p predicate) n | |
| (RecordPrograms.state p.toPorts base v pr found [] []) | |
| (RecordPrograms.state p.toPorts next false true (records.any test) [] []) := by | |
| have hcopy := copy_saved_eval p base (ProgramEncoding.encodeRecords records) hs ht v pr found | |
| obtain ⟨n, next, hn, hnext, hany⟩ := anyCommand_eval p.toPorts predicate test cost | |
| invariant valid contract records [] base hrecords hbase false false found | |
| simp only [List.append_nil] at hany | |
| have hclear := clear_source_eval p.toPorts next | |
| (RecordPrograms.unread test records []) false true (records.any test) | |
| have hset := set_present_eval p.toPorts next false false (records.any test) true [] [] | |
| refine ⟨_, next, ?_, hnext, hcopy.seq (hany.seq (hclear.seq hset))⟩ | |
| have hl := unread_length_le test records | |
| omega | |
| theorem savedAnyCommand_eval_with {r s : ℕ} (p : SavedPorts r s) | |
| (predicate : Cmd r s) (test : List Bool → Bool) (cost : List Bool → ℕ) | |
| (invariant : State r s → Prop) (effect : List Bool → State r s → State r s → Prop) | |
| (valid : List Bool → Prop) | |
| (contract : RecordPrograms.CallbackContractWithOn p.toPorts predicate test cost invariant effect valid) | |
| (records : List (List Bool)) (base : State r s) | |
| (hrecords : ∀ bits ∈ records, valid bits) (hbase : invariant base) | |
| (hs : base.stacks p.saved = ProgramEncoding.encodeRecords records) | |
| (ht : base.stacks p.temporary = []) (v pr found : Bool) : | |
| ∃ n next, | |
| n ≤ 9 * (ProgramEncoding.encodeRecords records).length + | |
| RecordPrograms.budget cost records + 12 ∧ invariant next ∧ | |
| RecordPrograms.Visits test effect records base next ∧ | |
| Eval (savedAnyCommand p predicate) n | |
| (RecordPrograms.state p.toPorts base v pr found [] []) | |
| (RecordPrograms.state p.toPorts next false true (records.any test) [] []) := by | |
| have hcopy := copy_saved_eval p base (ProgramEncoding.encodeRecords records) hs ht v pr found | |
| obtain ⟨n, next, hn, hnext, history, hany⟩ := RecordPrograms.iterate_run_with_on | |
| p.toPorts predicate test cost invariant effect valid contract records [] base | |
| hrecords hbase false false found | |
| simp only [List.append_nil] at hany | |
| have hclear := clear_source_eval p.toPorts next | |
| (RecordPrograms.unread test records []) false true (records.any test) | |
| have hset := set_present_eval p.toPorts next false false (records.any test) true [] [] | |
| refine ⟨_, next, ?_, hnext, history, hcopy.seq (hany.seq (hclear.seq hset))⟩ | |
| have hl := unread_length_le test records | |
| omega | |
| /-! A full-dimensional candidate needs only universal scalar tests. -/ | |
| open scoped BigOperators | |
| open BlockSearch SubexponentialSAT.QuarticSearch | |
| section Algebra | |
| variable {K : Type*} [Field K] [DecidableEq K] | |
| def pairLinear {N : ℕ} (c : Candidate K N × Candidate K N) : | |
| ((Fin c.1.1.val → K) × (Fin c.2.1.val → K)) →ₗ[K] Vec K N := | |
| (combineLinear c.1).coprod (combineLinear c.2) | |
| omit [DecidableEq K] in | |
| @[simp] theorem pairLinear_apply {N : ℕ} (c : Candidate K N × Candidate K N) | |
| (ab : (Fin c.1.1.val → K) × (Fin c.2.1.val → K)) : | |
| pairLinear c ab = combine c.1 ab.1 + combine c.2 ab.2 := rfl | |
| /-- Two concrete matrix-vector products and three zero comparisons suffice | |
| for one coefficient tuple. -/ | |
| def coefficientTest {m N : ℕ} (M : Fin m → Fin N → K) | |
| (c : Candidate K N × Candidate K N) | |
| (a : Fin c.1.1.val → K) (b : Fin c.2.1.val → K) : Bool := | |
| let y := combine c.1 a + combine c.2 b | |
| (if y = 0 then decide (a = 0 ∧ b = 0) else true) && | |
| decide (matrixMap M y = 0 ↔ b = 0) | |
| /-- An equivalent complete finite checker that replaces the nested spanning | |
| search by injectivity between spaces of the same dimension. -/ | |
| def fullPairTest (alphabet : List K) {m N : ℕ} (M : Fin m → Fin N → K) | |
| (c : Candidate K N × Candidate K N) : Bool := | |
| decide (c.1.1.val + c.2.1.val = N) && | |
| (vectors alphabet c.1.1.val).all (fun a => | |
| (vectors alphabet c.2.1.val).all (fun b => coefficientTest M c a b)) | |
| def FullPairProperty {m N : ℕ} (M : Fin m → Fin N → K) | |
| (c : Candidate K N × Candidate K N) : Prop := | |
| c.1.1.val + c.2.1.val = N ∧ | |
| (∀ a b, combine c.1 a + combine c.2 b = 0 → a = 0 ∧ b = 0) ∧ | |
| (∀ a b, matrixMap M (combine c.1 a + combine c.2 b) = 0 ↔ b = 0) | |
| theorem fullPairTest_iff (alphabet : List K) (hc : ∀ a, a ∈ alphabet) | |
| {m N : ℕ} (M : Fin m → Fin N → K) (c : Candidate K N × Candidate K N) : | |
| fullPairTest alphabet M c = true ↔ FullPairProperty M c := by | |
| simp only [fullPairTest, coefficientTest, Bool.and_eq_true, decide_eq_true_eq, | |
| all_vectors_iff alphabet hc, FullPairProperty] | |
| constructor | |
| · rintro ⟨hd, h⟩ | |
| refine ⟨hd, ?_, ?_⟩ | |
| · intro a b hz | |
| have h' := (h a b).1 | |
| simpa [hz] using h' | |
| · exact fun a b => (h a b).2 | |
| · rintro ⟨hd, hind, hker⟩ | |
| refine ⟨hd, fun a b => ⟨?_, hker a b⟩⟩ | |
| by_cases hz : combine c.1 a + combine c.2 b = 0 | |
| · simpa only [hz, ↓reduceIte, decide_eq_true_eq] using hind a b hz | |
| · simp [hz] | |
| omit [DecidableEq K] in | |
| theorem FullPairProperty.goodPair {m N : ℕ} {M : Fin m → Fin N → K} | |
| {c : Candidate K N × Candidate K N} (h : FullPairProperty M c) : GoodPair M c := by | |
| rcases h with ⟨hd, hind, hker⟩ | |
| have hinj : Function.Injective (pairLinear c) := by | |
| apply LinearMap.ker_eq_bot.mp | |
| apply (Submodule.eq_bot_iff _).mpr | |
| intro ab hab | |
| have hz : combine c.1 ab.1 + combine c.2 ab.2 = 0 := hab | |
| exact Prod.ext (hind ab.1 ab.2 hz).1 (hind ab.1 ab.2 hz).2 | |
| have hdim : Module.finrank K ((Fin c.1.1.val → K) × (Fin c.2.1.val → K)) = | |
| Module.finrank K (Vec K N) := by | |
| simpa [Module.finrank_prod, Module.finrank_pi, Fintype.card_fin] using hd | |
| have hsurj : Function.Surjective (pairLinear c) := | |
| (LinearMap.injective_iff_surjective_of_finrank_eq_finrank hdim).mp hinj | |
| refine ⟨⟨?_, ?_, ?_⟩, hind, ?_⟩ | |
| · intro a ha | |
| exact (hind a 0 (by simpa using ha)).1 | |
| · intro i | |
| have hk := (hker (Pi.single i 1) 0).mpr rfl | |
| simpa [combine, Pi.single_apply, Finset.sum_ite_eq'] using hk | |
| · intro x hx | |
| obtain ⟨⟨a, b⟩, hab⟩ := hsurj x | |
| have hb : b = 0 := (hker a b).mp (by simpa only [← hab, pairLinear_apply] using hx) | |
| refine ⟨a, ?_⟩ | |
| simpa only [pairLinear_apply, hb, combine_zero, add_zero] using hab | |
| · intro x | |
| obtain ⟨⟨a, b⟩, hab⟩ := hsurj x | |
| exact ⟨a, b, hab⟩ | |
| omit [DecidableEq K] in | |
| theorem GoodPair.fullPairProperty {m N : ℕ} {M : Fin m → Fin N → K} | |
| {c : Candidate K N × Candidate K N} (h : GoodPair M c) : FullPairProperty M c := by | |
| have hdim := Submodule.finrank_add_eq_of_isCompl h.isCompl | |
| rw [h.1.finrank_kernel, h.finrank_complement, Module.finrank_pi, Fintype.card_fin] at hdim | |
| refine ⟨hdim, h.2.1, ?_⟩ | |
| intro a b | |
| constructor | |
| · intro hz | |
| obtain ⟨a', ha'⟩ := h.1.2.2 (combine c.1 a + combine c.2 b) hz | |
| have heq : combine c.1 (a - a') + combine c.2 b = 0 := by | |
| rw [combine_sub, ha'] | |
| abel | |
| exact (h.2.1 (a - a') b heq).2 | |
| · intro hb | |
| subst b | |
| simp [combine, map_sum, map_smul, h.1.2.1] | |
| theorem fullPairTest_iff_goodPair (alphabet : List K) (hc : ∀ a, a ∈ alphabet) | |
| {m N : ℕ} (M : Fin m → Fin N → K) (c : Candidate K N × Candidate K N) : | |
| fullPairTest alphabet M c = true ↔ GoodPair M c := | |
| (fullPairTest_iff alphabet hc M c).trans ⟨FullPairProperty.goodPair, GoodPair.fullPairProperty⟩ | |
| theorem fullPairTest_exists (alphabet : List K) (hc : ∀ a, a ∈ alphabet) | |
| {m N : ℕ} (M : Fin m → Fin N → K) : | |
| ∃ c ∈ (candidates alphabet N).product (candidates alphabet N), | |
| fullPairTest alphabet M c = true := by | |
| obtain ⟨c, h⟩ := exists_goodPair M | |
| exact ⟨c, List.mem_product.mpr ⟨mem_candidates alphabet hc c.1, mem_candidates alphabet hc c.2⟩, | |
| (fullPairTest_iff_goodPair alphabet hc M c).mpr h⟩ | |
| /-- A scalar frame is itself a fixed-width injective token for the tuple | |
| generator. Its payload still uses the supplied field-word representation. -/ | |
| def framedCode (code : StackEncoding.BlockCode K) : StackEncoding.BlockCode K where | |
| width := 2 * code.width + 1 | |
| width_pos := by omega | |
| block a := Encoding.frame (code.block a) | |
| length_block a := by simp [code.length_block] | |
| injective_block := by | |
| intro a b h | |
| apply code.injective_block | |
| exact (Encoding.frame_append_injective (rest := []) (rest' := []) (by simpa using h)).1 | |
| def coefficientRecords (code : StackEncoding.BlockCode K) (alphabet : List K) | |
| {N : ℕ} (c : Candidate K N × Candidate K N) : List (List Bool) := | |
| TupleProgram.powerRows (alphabet.map code.block) (c.1.1.val + c.2.1.val) [[]] | |
| /-- Every actual generated coefficient payload is tested, with exactly the | |
| same truth condition as quantifying over the two coefficient spaces. -/ | |
| theorem coefficientRecords_all_iff (code : StackEncoding.BlockCode K) | |
| (alphabet : List K) (hc : ∀ a, a ∈ alphabet) {m N : ℕ} | |
| (M : Fin m → Fin N → K) (c : Candidate K N × Candidate K N) | |
| (test : List Bool → Bool) | |
| (htest : ∀ a b, test (SubexpTupleRefinement.encodeTuple code a ++ | |
| SubexpTupleRefinement.encodeTuple code b) = coefficientTest M c a b) : | |
| (coefficientRecords code alphabet c).all test = true ↔ | |
| ∀ a b, coefficientTest M c a b = true := by | |
| rw [List.all_eq_true] | |
| constructor | |
| · intro h a b | |
| rw [← htest] | |
| exact h _ (SubexpTupleRefinement.encodePair_mem_powerRows code alphabet hc a b) | |
| · intro h bits hbits | |
| obtain ⟨⟨a,b⟩, hab, _⟩ := SubexpTupleRefinement.generated_unique_pair | |
| code alphabet c.1.1.val c.2.1.val bits hbits | |
| rw [← hab, htest] | |
| exact h a b | |
| theorem coefficientRecords_all_iff_goodPair (code : StackEncoding.BlockCode K) | |
| (alphabet : List K) (hc : ∀ a, a ∈ alphabet) {m N : ℕ} | |
| (M : Fin m → Fin N → K) (c : Candidate K N × Candidate K N) | |
| (hdim : c.1.1.val + c.2.1.val = N) (test : List Bool → Bool) | |
| (htest : ∀ a b, test (SubexpTupleRefinement.encodeTuple code a ++ | |
| SubexpTupleRefinement.encodeTuple code b) = coefficientTest M c a b) : | |
| (coefficientRecords code alphabet c).all test = true ↔ GoodPair M c := by | |
| rw [coefficientRecords_all_iff code alphabet hc M c test htest] | |
| rw [← fullPairTest_iff_goodPair alphabet hc M c] | |
| simp only [fullPairTest, hdim, decide_true, Bool.true_and, | |
| all_vectors_iff alphabet hc] | |
| omit [Field K] [DecidableEq K] in | |
| theorem coefficientRecords_length (code : StackEncoding.BlockCode K) (alphabet : List K) | |
| {N : ℕ} (c : Candidate K N × Candidate K N) | |
| (hdim : c.1.1.val + c.2.1.val = N) : | |
| (coefficientRecords code alphabet c).length = alphabet.length^N := by | |
| simp [coefficientRecords, TupleProgram.powerRows_length, hdim] | |
| omit [Field K] [DecidableEq K] in | |
| theorem coefficientRecord_length (code : StackEncoding.BlockCode K) (alphabet : List K) | |
| {N : ℕ} (c : Candidate K N × Candidate K N) | |
| (hdim : c.1.1.val + c.2.1.val = N) (bits : List Bool) | |
| (hb : bits ∈ coefficientRecords code alphabet c) : bits.length = N * code.width := by | |
| obtain ⟨⟨a,b⟩, hab, _⟩ := SubexpTupleRefinement.generated_unique_pair | |
| code alphabet c.1.1.val c.2.1.val bits hb | |
| rw [← hab, List.length_append] | |
| simp only [SubexpTupleRefinement.encodeTuple, StackEncoding.length_encodeDataStack, | |
| List.length_ofFn, ← Nat.add_mul, hdim] | |
| end Algebra | |
| end SubexponentialSAT.Subexp.BlockSearchProgram | |
| end OAI.Algorithms | |