Download data/lean/OAI/Algorithms/SubexponentialSAT/Subexp/BlockSearchLoop.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 10.3 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Algorithms/SubexponentialSAT/Subexp/BlockSearchLoop.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Algorithms/SubexponentialSAT/Subexp/BlockSearchLoop.lean
-
curl -L -o BlockSearchLoop.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Algorithms/SubexponentialSAT/Subexp/BlockSearchLoop.lean
10.3 kB
| import OAI.Algorithms.SubexponentialSAT.LeanCompat | |
| import OAI.Algorithms.SubexponentialSAT.Subexp.BlockSearchProgram | |
| import OAI.Algorithms.SubexponentialSAT.Subexp.BlockZeroProgram | |
| namespace OAI.Algorithms | |
| /-! | |
| # Concrete nested control of the universal-block basis search | |
| The matrix-product command is a fixed finite subroutine supplied by | |
| `MatrixPairProgram`. All tuple arrays and split positions are runtime data. | |
| The three loops scan tables, splits, and coefficients, respectively. | |
| -/ | |
| namespace SubexponentialSAT.Subexp.BlockSearchLoop | |
| open BitProgram StructuredCalls BlockSearchProgram | |
| abbrev sequence (commands : List (Cmd 24 42)) : Cmd 24 42 := | |
| commands.foldr Cmd.seq (.base .skip) | |
| abbrev atom (a : StructuredProgram.Atom 24 42) : Cmd 24 42 := .base (.atom a) | |
| abbrev clear (src : Fin 42) : Cmd 24 42 := | |
| .call (StackRoutines.clearProgram src (21 : Fin 24) 22) | |
| abbrev copy (src dst : Fin 42) : Cmd 24 42 := | |
| .call (StackRoutines.copyProgram src dst 9 (21 : Fin 24) 22) | |
| abbrev transfer (src dst : Fin 42) : Cmd 24 42 := | |
| .call (StackRoutines.transferProgram src dst (21 : Fin 24) 22) | |
| def smallRegisters (i : Fin 3) : Fin 24 := Fin.castAdd 21 i | |
| abbrev zeroAt (src : Fin 42) : Cmd 24 42 := | |
| .call (ProgramLinking.liftProgram BlockZeroProgram.program smallRegisters (fun _ => src)) | |
| abbrev skipPrefix : Cmd 24 42 := | |
| .call (ProgramLinking.liftProgram BlockZeroProgram.skipProgram smallRegisters ![22, 23]) | |
| def classifyRegisters : Fin 5 → Fin 24 := ![17, 18, 19, 20, 16] | |
| abbrev classify : Cmd 24 42 := | |
| .call (ProgramLinking.liftProgram BlockZeroProgram.classifyProgram classifyRegisters | |
| (fun _ => (22 : Fin 42))) | |
| /-- Copying preserves the vector used by the second matrix product. -/ | |
| abbrev zeroFrom (src : Fin 42) (flag : Fin 24) : Cmd 24 42 := | |
| sequence [copy src 22, zeroAt 22, atom (.copy flag 2)] | |
| /-- Skip the saved split number of complete coefficient frames, then test | |
| the remaining scalar words. Both the split and full coefficients survive. -/ | |
| abbrev tailZero : Cmd 24 42 := | |
| sequence [copy 8 22, copy 40 23, skipPrefix, zeroAt 23, atom (.copy 19 2)] | |
| def coefficientPorts : SavedPorts 24 42 where | |
| toPorts := ⟨14, 15, 16, 6, 7, by decide, by decide, by decide, by decide⟩ | |
| saved := 14 | |
| temporary := 9 | |
| saved_ne_source := by decide | |
| saved_ne_payload := by decide | |
| temporary_ne_source := by decide | |
| temporary_ne_payload := by decide | |
| saved_ne_temporary := by decide | |
| def dimensionPorts : SavedPorts 24 42 where | |
| toPorts := ⟨11, 12, 13, 3, 4, by decide, by decide, by decide, by decide⟩ | |
| saved := 12 | |
| temporary := 9 | |
| saved_ne_source := by decide | |
| saved_ne_payload := by decide | |
| temporary_ne_source := by decide | |
| temporary_ne_payload := by decide | |
| saved_ne_temporary := by decide | |
| def tablePorts : RecordPrograms.Ports 24 42 := | |
| ⟨8, 9, 10, 0, 2, by decide, by decide, by decide, by decide⟩ | |
| /-- The supplied matrix command computes y=Cx and z=My on fixed work ports. | |
| The rest of this callback uses only concrete copying and Boolean programs. -/ | |
| abbrev coefficientCallback (matrixPair : Cmd 24 42) : Cmd 24 42 := | |
| sequence [transfer 7 34, copy 41 33, copy 10 37, matrixPair, | |
| zeroFrom 34 17, zeroFrom 40 18, tailZero, zeroFrom 30 20, classify, | |
| clear 30, clear 34, clear 40, atom (.set 14 false), atom (.set 15 true)] | |
| /-- The current split is copied into persistent output metadata before its | |
| universal coefficient scan. It remains there when the scan succeeds. -/ | |
| abbrev dimensionCallback (matrixPair : Cmd 24 42) : Cmd 24 42 := | |
| sequence [clear 8, copy 4 8, | |
| savedAllCommand coefficientPorts (coefficientCallback matrixPair), | |
| clear 4, atom (.copy 13 16), atom (.set 11 false), atom (.set 12 true)] | |
| /-- The current table is installed in forward frame order and retained while | |
| the complete split enumeration is scanned. -/ | |
| abbrev tableCallback (matrixPair : Cmd 24 42) : Cmd 24 42 := | |
| sequence [clear 41, transfer 2 41, | |
| savedAnyCommand dimensionPorts (dimensionCallback matrixPair), | |
| atom (.copy 10 13), atom (.set 8 false), atom (.set 9 true)] | |
| abbrev command (matrixPair : Cmd 24 42) : Cmd 24 42 := | |
| .seq (anyCommand tablePorts (tableCallback matrixPair)) (clear 0) | |
| /-- A finite instruction table whose only parameter is another fixed finite | |
| instruction table. It has no dimension- or prime-dependent control labels. -/ | |
| abbrev program (matrixPair : Cmd 24 42) := | |
| compiled (command matrixPair) 0 41 | |
| /-- Persistent physical inputs of the two matrix-product calls. -/ | |
| structure Context where | |
| modulus : List Bool | |
| zeroWord : List Bool | |
| matrix : List Bool | |
| rowCount : List Bool | |
| dimension : List Bool | |
| /-- All work stacks needed by one coefficient test are empty at its boundary. -/ | |
| def WorkReady (a : State 24 42) : Prop := | |
| a.stacks 9 = [] ∧ | |
| ∀ j : Fin 42, 22 ≤ j.val → j ≠ 27 → j ≠ 36 → j ≠ 38 → j ≠ 39 → j ≠ 41 → | |
| a.stacks j = [] | |
| def CoefficientEntry (ctx : Context) (table split : List Bool) (a : State 24 42) : Prop := | |
| a.stacks 27 = ctx.modulus ∧ a.stacks 36 = ctx.zeroWord ∧ | |
| a.stacks 38 = ctx.matrix ∧ a.stacks 39 = ctx.rowCount ∧ | |
| a.stacks 10 = ctx.dimension ∧ a.stacks 41 = table ∧ a.stacks 8 = split ∧ WorkReady a | |
| theorem coefficientEntry_of_stacks_eq (ctx : Context) (table split : List Bool) | |
| {a b : State 24 42} (h : b.stacks = a.stacks) (ha : CoefficientEntry ctx table split a) : | |
| CoefficientEntry ctx table split b := by | |
| simpa only [CoefficientEntry, WorkReady, h] using ha | |
| /-- The arithmetic callback must frame both parent iterators. This contract | |
| is an actual execution obligation for the concrete coefficient code above. -/ | |
| abbrev CoefficientContract (matrixPair : Cmd 24 42) (ctx : Context) (table split : List Bool) | |
| (test : List Bool → Bool) (cost : List Bool → ℕ) (valid : List Bool → Prop) : Prop := | |
| ∀ (bits tail : List Bool) (base : State 24 42), valid bits → | |
| CoefficientEntry ctx table split base → | |
| ∃ n next, n ≤ cost bits ∧ next.stacks = base.stacks ∧ | |
| (∀ j : Fin 24, 8 ≤ j.val → j.val ≤ 13 → next.regs j = base.regs j) ∧ | |
| Eval (coefficientCallback matrixPair) n | |
| (RecordPrograms.state coefficientPorts.toPorts base false true false tail bits.reverse) | |
| (RecordPrograms.state coefficientPorts.toPorts next false true (test bits) tail []) | |
| theorem coefficientContract_scan (matrixPair : Cmd 24 42) (ctx : Context) | |
| (table split : List Bool) (test : List Bool → Bool) (cost : List Bool → ℕ) | |
| (valid : List Bool → Prop) | |
| (h : CoefficientContract matrixPair ctx table split test cost valid) : | |
| RecordPrograms.CallbackContractWithOn coefficientPorts.toPorts | |
| (coefficientCallback matrixPair) test cost (CoefficientEntry ctx table split) | |
| (fun _ a b => b.stacks = a.stacks ∧ | |
| ∀ j : Fin 24, 8 ≤ j.val → j.val ≤ 13 → b.regs j = a.regs j) valid := by | |
| intro bits tail base hv hb | |
| obtain ⟨n, next, hn, hs, hr, he⟩ := h bits tail base hv hb | |
| exact ⟨n, next, hn, coefficientEntry_of_stacks_eq ctx table split hs hb, ⟨hs,hr⟩, he⟩ | |
| /-- A complete coefficient scan frames both enclosing loops, including their | |
| unread serialized tails. The copied working enumeration is empty on exit. -/ | |
| theorem coefficientScan_eval (matrixPair : Cmd 24 42) (ctx : Context) | |
| (table split : List Bool) (test : List Bool → Bool) (cost : List Bool → ℕ) | |
| (valid : List Bool → Prop) | |
| (contract : CoefficientContract matrixPair ctx table split test cost valid) | |
| (records : List (List Bool)) (base : State 24 42) | |
| (hv : ∀ bits ∈ records, valid bits) (hb : CoefficientEntry ctx table split base) | |
| (hs : base.stacks 14 = ProgramEncoding.encodeRecords records) | |
| (h6 : base.stacks 6 = []) (h7 : base.stacks 7 = []) : | |
| ∃ n next, | |
| n ≤ 9 * (ProgramEncoding.encodeRecords records).length + | |
| RecordPrograms.budget (fun bits => cost bits + 2) records + 14 ∧ | |
| next.stacks = base.stacks ∧ | |
| (∀ j : Fin 24, 8 ≤ j.val → j.val ≤ 13 → next.regs j = base.regs j) ∧ | |
| next.regs 16 = records.all test ∧ | |
| Eval (savedAllCommand coefficientPorts (coefficientCallback matrixPair)) n base next := by | |
| let inv := fun a : State 24 42 => CoefficientEntry ctx table split a ∧ | |
| a.stacks = base.stacks ∧ ∀ j : Fin 24, 8 ≤ j.val → j.val ≤ 13 → a.regs j = base.regs j | |
| have hc : RecordPrograms.CallbackContractOn coefficientPorts.toPorts | |
| (coefficientCallback matrixPair) test cost inv valid := by | |
| intro bits tail a hbits ha | |
| obtain ⟨n, next, hn, hst, hreg, he⟩ := contract bits tail a hbits ha.1 | |
| refine ⟨n, next, hn, ?_, he⟩ | |
| exact ⟨coefficientEntry_of_stacks_eq ctx table split hst ha.1, hst.trans ha.2.1, | |
| fun j hj hk => (hreg j hj hk).trans (ha.2.2 j hj hk)⟩ | |
| have htemp : base.stacks coefficientPorts.temporary = [] := hb.2.2.2.2.2.2.2.1 | |
| obtain ⟨n, b, hn, hi, he⟩ := savedAllCommand_eval coefficientPorts | |
| (coefficientCallback matrixPair) test cost inv valid hc records base hv | |
| ⟨hb, rfl, fun _ _ _ => rfl⟩ hs htemp (base.regs 14) (base.regs 15) (base.regs 16) | |
| let next := RecordPrograms.state coefficientPorts.toPorts b false true (records.all test) [] [] | |
| have hstart : RecordPrograms.state coefficientPorts.toPorts base | |
| (base.regs 14) (base.regs 15) (base.regs 16) [] [] = base := by | |
| apply RecordPrograms.state_eq_self <;> simp [coefficientPorts, h6, h7] | |
| refine ⟨n, next, hn, ?_, ?_, ?_, ?_⟩ | |
| · funext j | |
| change (Function.update (Function.update b.stacks 6 []) 7 []) j = base.stacks j | |
| rw [hi.2.1] | |
| by_cases hj : j = 6 <;> by_cases hk : j = 7 <;> subst_vars <;> simp_all | |
| · intro j hj hk | |
| have h14 : j ≠ 14 := by intro h; subst j; change 14 ≤ 13 at hk; omega | |
| have h15 : j ≠ 15 := by intro h; subst j; change 15 ≤ 13 at hk; omega | |
| have h16 : j ≠ 16 := by intro h; subst j; change 16 ≤ 13 at hk; omega | |
| change (RecordPrograms.state coefficientPorts.toPorts b false true | |
| (records.all test) [] []).regs j = _ | |
| rw [RecordPrograms.state_register_frame _ _ _ _ _ _ _ j h14 h15 h16] | |
| exact hi.2.2 j hj hk | |
| · exact RecordPrograms.state_found coefficientPorts.toPorts b false true | |
| (records.all test) [] [] | |
| · simpa only [hstart] using he | |
| end SubexponentialSAT.Subexp.BlockSearchLoop | |
| end OAI.Algorithms | |