math / data /lean /OAI /Algorithms /SubexponentialSAT /SqrtLogSpace /FactorAssignmentProgram.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
18.1 kB
import OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.FactorArithmeticProgram
import OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.FactorTableProgram
import OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.FactorCacheProgram
import OAI.Algorithms.SubexponentialSAT.SqrtLog.LeafProgramFactorDispatchFrame
import OAI.Algorithms.SubexponentialSAT.SqrtLog.LeafProgramFactorID
import OAI.Algorithms.SubexponentialSAT.SqrtLog.LeafProgramExpansionForward
import OAI.Algorithms.SubexponentialSAT.SqrtLog.LeafProgramFactorServicesBase
/-! The accepted-assignment factor product uses the original finite-ring
indicator and clause programs after the concrete specialized table producer.
Every cache is rebuilt from persistent source words by paid native copies;
neutral factor IDs leave the running multiplicative identity unchanged. -/
namespace OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.FactorAssignmentProgram
open OAI BitProgram StructuredCalls SubexpSetupStorage
open SqrtLog SqrtLog.LeafProgram
noncomputable section
def copy (src dst : Fin 896) : Code :=
.call (StackRoutines.copyProgram src dst 159 0 1)
def clear (src : Fin 896) : Code := .call (StackRoutines.clearProgram src 0 1)
def cleared (a : Data) (src : Fin 896) : Data :=
⟨readRegs a.regs 0 1 none, Function.update a.stacks src []⟩
theorem clear_eval (a : Data) (src : Fin 896) :
Eval (clear src) (2 * (a.stacks src).length + 3) a (cleared a src) :=
Eval.call _ (ListRegisterProgram.clear_run src (0 : Fin 40) 1 a.regs a.stacks)
def move (src dst : Fin 896) : Code := .seq (copy src dst) (clear src)
def moved (a : Data) (src dst : Fin 896) : Data :=
⟨readRegs a.regs 0 1 none,
Function.update (Function.update a.stacks dst (a.stacks src ++ a.stacks dst)) src []⟩
theorem move_eval (a : Data) (src dst : Fin 896)
(hsd : src ≠ dst) (hst : src ≠ 159) (htd : (159 : Fin 896) ≠ dst)
(htmp : a.stacks 159 = []) :
Eval (move src dst) (9 * (a.stacks src).length + 8) a (moved a src dst) := by
have hcopy := SubexpScanPrimitives.copy_eval a src dst 159 0 1 hsd hst htd (by decide) htmp
let b := SubexpScanPrimitives.afterCopy a src dst 0 1
have hclear : Eval (clear src) (2 * (b.stacks src).length + 3) b
⟨readRegs b.regs 0 1 none, Function.update b.stacks src []⟩ :=
Eval.call _ (ListRegisterProgram.clear_run src (0 : Fin 40) 1 b.regs b.stacks)
have hlen : b.stacks src = a.stacks src := by
simp [b, SubexpScanPrimitives.afterCopy, StackRoutines.copyStacks, hsd]
have hout : (⟨readRegs b.regs 0 1 none, Function.update b.stacks src []⟩ : Data) =
moved a src dst := by
apply congrArg₂ StructuredProgram.State.mk
· simp [b, SubexpScanPrimitives.afterCopy, StackRoutines.readRegs_reset]
· rfl
rw [hout] at hclear
have he := hcopy.seq hclear
simpa only [move, copy, hlen, show 7 * (a.stacks src).length + 5 +
(2 * (a.stacks src).length + 3) = 9 * (a.stacks src).length + 8 by omega] using he
/-- Only transient arithmetic, parser and source-worker storage is cleared.
The current record149, pending records150 and running product151 remain live. -/
def callbackScratch : List (Fin 768) :=
List.map Factor.indicatorStacks FactorServices.indicatorScratch ++
[62, 64, 159, 556] ++ FactorDispatch.scratch ++ Expansion.scratch ++ [358]
def clearCallbackLocal : Cmd 16 768 := clearMany callbackScratch
def clearCallback : Code := liftCommand clearCallbackLocal 149 149 localRegister lowStack
noncomputable def callbackInitial (a : Data) : Data :=
embedState localRegister lowStack a
(clearManyState callbackScratch (projectState localRegister lowStack a))
def clearCallbackCost (a : Data) : ℕ :=
clearManyCost callbackScratch (projectState localRegister lowStack a) + 1
theorem clearCallback_eval (a : Data) :
Eval clearCallback (clearCallbackCost a) a (callbackInitial a) :=
eval_liftCommand_from_state clearCallbackLocal 149 149 localRegister lowStack a
(Fin.castAdd_injective _ _) (Fin.castAdd_injective _ _)
(clearMany_eval callbackScratch (projectState localRegister lowStack a))
theorem callbackInitial_low (a : Data) (i : Fin 768) :
(callbackInitial a).stacks (lowStack i) =
if i ∈ callbackScratch then [] else a.stacks (lowStack i) := by
exact (embedState_stack localRegister lowStack a
(clearManyState callbackScratch (projectState localRegister lowStack a))
(Fin.castAdd_injective _ _) i).trans
(clearMany_stacks callbackScratch (projectState localRegister lowStack a) i)
theorem callbackInitial_frame (a : Data) (i : Fin 896)
(hi : i ∉ callbackScratch.map lowStack) :
(callbackInitial a).stacks i = a.stacks i := by
by_cases hlt : i.val < 768
· let j : Fin 768 := ⟨i.val, hlt⟩
have hj : lowStack j = i := Fin.ext rfl
have hn : j ∉ callbackScratch := by
intro hm
exact hi (List.mem_map.mpr ⟨j, hm, hj⟩)
rw [← hj, callbackInitial_low, ite_eq_right hn]
· apply embedState_stack_frame
rintro ⟨j, hj⟩
have hv := congrArg Fin.val hj
change j.val = i.val at hv
omega
theorem callbackInitial_wordBound (a : Data) (P : ℕ) (ha : WordBound P a) :
WordBound P (callbackInitial a) := by
intro i
by_cases hi : i ∈ callbackScratch.map lowStack
· obtain ⟨j, hj, rfl⟩ := List.mem_map.mp hi
rw [callbackInitial_low, ite_eq_left hj]
simp
· rw [callbackInitial_frame a i hi]
exact ha i
theorem clearCallbackCost_le (a : Data) (P : ℕ) (ha : WordBound P a) :
clearCallbackCost a ≤ callbackScratch.length * (2 * P + 3) + 1 :=
Nat.add_le_add_right
(clearManyCost_le callbackScratch (projectState localRegister lowStack a) P
(fun i => ha (lowStack i))) 1
def prepareIncidence : Code :=
.seq (liftLow FactorID.command 149 556) FactorTableProgram.caller
def hashFactor : Code := .seq prepareIncidence
(liftLow (.seq Expansion.forwardCommand FactorEvaluationSpace.hashArithmetic) 154 151)
def markedFactor : Code := .seq prepareIncidence
(liftLow (.seq (Factor.move 154 63) FactorEvaluationSpace.markedArithmetic) 154 151)
def choose : Code := .ite 5 hashFactor (.ite 6 markedFactor (.base .skip))
def returnToRecords : Code :=
.seq (.base (.atom (.set 13 false)))
(.seq (.base (.atom (.set 14 true))) (.base (.atom (.set 15 false))))
def returned (a : Data) : Data :=
⟨Function.update (Function.update (Function.update a.regs 13 false) 14 true) 15 false,
a.stacks⟩
theorem returnToRecords_eval (a : Data) : Eval returnToRecords 3 a (returned a) := by
let b : Data := ⟨Function.update a.regs 13 false, a.stacks⟩
let c : Data := ⟨Function.update b.regs 14 true, a.stacks⟩
have h1 : Eval (.base (.atom (.set 13 false))) 1 a b := .base (.atom _ _)
have h2 : Eval (.base (.atom (.set 14 true))) 1 b c := .base (.atom _ _)
have h3 : Eval (.base (.atom (.set 15 false))) 1 c (returned a) := .base (.atom _ _)
exact h1.seq (h2.seq h3)
def callbackFinished (a : Data) : Data := returned (cleared a 149)
theorem callbackFinish_eval (a : Data) :
Eval (.seq (clear 149) returnToRecords) (2 * (a.stacks 149).length + 6)
a (callbackFinished a) := by
convert (clear_eval a 149).seq (returnToRecords_eval (cleared a 149)) using 1
rfl
def ports : RecordPrograms.Ports 40 896 :=
⟨13, 14, 15, 150, 149, by decide, by decide, by decide, by decide⟩
def callback : Code := .seq clearCallback
(.seq (liftLow FactorDispatch.command 149 154)
(.seq choose (.seq (clear 149) returnToRecords)))
/-- Neutral IDs execute the dispatcher and record cleanup, retaining the
running product. No incidence lookup or arithmetic branch is executed. -/
theorem callback_neutral_eval (a : Data) (rows clauses : List (List Bool))
(marked : Bool) (mark factor : ℕ)
(hrows : a.stacks 701 = Encoding.encodeList id rows)
(hclauses : a.stacks 700 = Encoding.encodeList id clauses)
(hcount : a.stacks 704 = List.replicate rows.length true)
(hmark : a.stacks 705 = Encoding.encodeNat mark)
(hflag : a.stacks 706 = [marked])
(hfactor : a.stacks 149 = (Encoding.encodeNat factor).reverse)
(hvalid : marked = true → mark < clauses.length)
(hhash : ¬factor < rows.length)
(hmarked : (marked && decide (factor = rows.length)) = false) :
∃ steps b, steps ≤ clearCallbackCost a + 9 * (a.stacks 149).length + 15 +
LeafFactorDispatchProgram.budget rows clauses mark factor ∧
Eval callback steps a b ∧
b.stacks = Function.update (callbackInitial a).stacks 149 [] ∧
b.regs 13 = false ∧ b.regs 14 = true ∧ b.regs 15 = false := by
let c := callbackInitial a
let low := projectState id lowStack c
have frame (i : Fin 768) (hi : i ∉ callbackScratch) : low.stacks i = a.stacks (lowStack i) := by
exact (callbackInitial_low a i).trans (ite_eq_right hi)
have hr : low.stacks 701 = Encoding.encodeList id rows := (frame 701 (by decide)).trans hrows
have hc : low.stacks 700 = Encoding.encodeList id clauses := (frame 700 (by decide)).trans hclauses
have hn : low.stacks 704 = List.replicate rows.length true := (frame 704 (by decide)).trans hcount
have hm : low.stacks 705 = Encoding.encodeNat mark := (frame 705 (by decide)).trans hmark
have hf : low.stacks 706 = [marked] := (frame 706 (by decide)).trans hflag
have hid : low.stacks 149 = (Encoding.encodeNat factor).reverse := (frame 149 (by decide)).trans hfactor
have hwork : ∀ i ∈ FactorDispatch.scratch, low.stacks i = [] := by
intro i hi
have hmem : i ∈ callbackScratch := by
simp only [callbackScratch, List.mem_append]
exact Or.inl (Or.inl (Or.inr hi))
exact (callbackInitial_low a i).trans (ite_eq_left hmem)
obtain ⟨kd, rd, hkd, hd, h5, h6, h7⟩ :=
FactorDispatch.command_eval low rows clauses marked mark factor hr hc hn hm hf hid hwork hvalid
let out := FactorDispatch.finished low rd rows clauses marked mark factor
let wide := embedState id lowStack c out
have hdispatch : Eval (liftLow FactorDispatch.command 149 154) (kd + 1) c wide :=
eval_liftCommand_from_state FactorDispatch.command 149 154 id lowStack c
Function.injective_id (Fin.castAdd_injective _ _) hd
have hwide5 : wide.regs 5 = false := by
rw [show wide.regs 5 = out.regs 5 from
embedState_register id lowStack c out Function.injective_id 5]
rw [FactorDispatch.finished_role_hash, h5]
exact decide_eq_false hhash
have hwide6 : wide.regs 6 = false := by
rw [show wide.regs 6 = out.regs 6 from
embedState_register id lowStack c out Function.injective_id 6]
rw [FactorDispatch.finished_role_marked, h6, hmarked]
have hpayload : LeafFactorDispatchProgram.selectedPayload rows clauses marked mark factor = [] := by
simp [LeafFactorDispatchProgram.selectedPayload, hhash, hmarked]
have hlow : out.stacks = low.stacks := by
rw [FactorDispatch.finished_stacks low rd rows clauses marked mark factor hr hc hn hm hwork,
hpayload]
exact Function.update_eq_self_iff.mpr (hwork 154 (by decide)).symm
have hwide : wide.stacks = c.stacks := by
funext i
by_cases hi : i.val < 768
· let j : Fin 768 := ⟨i.val, hi⟩
have hj : lowStack j = i := Fin.ext rfl
rw [← hj, embedState_stack id lowStack c out (Fin.castAdd_injective _ _) j, hlow]
rfl
· apply embedState_stack_frame
rintro ⟨j, hj⟩
have hv := congrArg Fin.val hj
change j.val = i.val at hv
omega
have hchoose : Eval choose 2 wide wide :=
Eval.ite_false hwide5 (Eval.ite_false hwide6 (Eval.base (StructuredProgram.Eval.skip wide)))
refine ⟨clearCallbackCost a + ((kd + 1) + (2 + (2 * (wide.stacks 149).length + 6))),
callbackFinished wide, ?_, (clearCallback_eval a).seq (hdispatch.seq
(hchoose.seq (callbackFinish_eval wide))), ?_, ?_, ?_, ?_⟩
· have h149 : wide.stacks 149 = a.stacks 149 := by
rw [hwide]
exact callbackInitial_frame a 149 (by decide)
have hl149 : low.stacks 149 = a.stacks 149 := frame 149 (by decide)
rw [h149]
rw [hl149] at hkd
omega
· exact congrArg (fun (store : Fin 896 → List Bool) => Function.update store 149 []) hwide
all_goals simp [callbackFinished, returned]
def loop : Code := RecordPrograms.iterate ports callback
def emptyLoopResult (a : Data) : Data :=
⟨Function.update (Function.update (Function.update a.regs 15 false) 13 false) 14 true,
Function.update a.stacks 150 []⟩
/-- Even an empty factor list executes its actual terminating tag. The
running product151 remains the encoded identity generated during setup. -/
theorem loop_empty_eval (a : Data) (hsource : a.stacks 150 = [false]) :
Eval loop 3 a (emptyLoopResult a) := by
let a1 : Data := ⟨Function.update a.regs 15 false, a.stacks⟩
have hs : Eval (.base (.atom (.set (15 : Fin 40) false))) 1 a a1 :=
Eval.base (StructuredProgram.Eval.atom _ _)
have hp := Eval.base (StructuredProgram.Eval.atom
(StructuredProgram.Atom.pop (150 : Fin 896) (13 : Fin 40) 14) a1)
have he : (StructuredProgram.Atom.pop (150 : Fin 896) (13 : Fin 40) 14).eval a1 =
emptyLoopResult a := by
simp [a1, emptyLoopResult, StructuredProgram.Atom.eval, StructuredProgram.Atom.instr,
StructuredProgram.State.ofCfg, execInstr, hsource,
readRegs]
rw [he] at hp
have hwhile : Eval (RecordPrograms.loop ports callback) 1 (emptyLoopResult a) (emptyLoopResult a) :=
Eval.while_false (by simp [emptyLoopResult, ports])
exact hs.seq (hp.seq hwhile)
/-- Factor IDs are an explicitly stored polynomial-size input list. No head
assignment Cartesian product is materialized by this native record traversal. -/
def product : Code := .seq (copy 175 150)
(.seq (copy 69 151) (.seq loop (move 151 854)))
/-- A group with no factor IDs emits the actual staged ring identity. The
empty record tag is consumed, and the full output word is copied to854. -/
theorem product_empty_eval (a : Data) (hids : a.stacks 175 = [false])
(h150 : a.stacks 150 = []) (h151 : a.stacks 151 = [])
(h159 : a.stacks 159 = []) (h854 : a.stacks 854 = []) :
∃ b, Eval product (16 * (a.stacks 69).length + 28) a b ∧
b.stacks = Function.update (Function.update (Function.update a.stacks 150 []) 151 [])
854 (a.stacks 69) := by
let a1 := SubexpScanPrimitives.afterCopy a 175 150 0 1
let a2 := SubexpScanPrimitives.afterCopy a1 69 151 0 1
let a3 := emptyLoopResult a2
have h1 := SubexpScanPrimitives.copy_eval a 175 150 159 0 1
(by decide) (by decide) (by decide) (by decide) h159
have ht1 : a1.stacks 159 = [] := by
simp [a1, SubexpScanPrimitives.afterCopy, StackRoutines.copyStacks, h159]
have h2 := SubexpScanPrimitives.copy_eval a1 69 151 159 0 1
(by decide) (by decide) (by decide) (by decide) ht1
have hsrc : a2.stacks 150 = [false] := by
simp [a2, a1, SubexpScanPrimitives.afterCopy, StackRoutines.copyStacks, h150, hids]
have h3 := loop_empty_eval a2 hsrc
have ht3 : a3.stacks 159 = [] := by
simp [a3, emptyLoopResult, a2, a1, SubexpScanPrimitives.afterCopy,
StackRoutines.copyStacks, h159]
have h4 := move_eval a3 151 854 (by decide) (by decide) (by decide) ht3
have hlen1 : a1.stacks 69 = a.stacks 69 := by
simp [a1, SubexpScanPrimitives.afterCopy, StackRoutines.copyStacks]
have hlen3 : a3.stacks 151 = a.stacks 69 := by
simp [a3, emptyLoopResult, a2, a1, SubexpScanPrimitives.afterCopy,
StackRoutines.copyStacks, h151]
refine ⟨moved a3 151 854, ?_, ?_⟩
· have he := h1.seq (h2.seq (h3.seq h4))
simpa only [product, copy, move, hids, hlen1, hlen3,
List.length_singleton,
show 7 * 1 + 5 + (7 * (a.stacks 69).length + 5 +
(3 + (9 * (a.stacks 69).length + 8))) =
16 * (a.stacks 69).length + 28 by omega] using he
· funext i
by_cases hi150 : i = 150 <;> by_cases hi151 : i = 151 <;> by_cases hi854 : i = 854
all_goals simp [moved, a3, emptyLoopResult, a2, a1, SubexpScanPrimitives.afterCopy,
StackRoutines.copyStacks, hi150, hi151, hi854, h854, h151]
/-- Reclaim all private callback and relocated source storage before the
first factor. The fixed finite list excludes every live caller master. -/
def entryScratch : List (Fin 896) :=
[149, 150, 151, 159, 854] ++ callbackScratch.map lowStack ++
FactorTableProgram.entryPorts
def «initialize» : Code := liftCommand (clearMany entryScratch) 175 854 localRegister id
noncomputable def initialized (a : Data) : Data :=
embedState localRegister id a
(clearManyState entryScratch (projectState localRegister id a))
def initializeCost (a : Data) : ℕ :=
clearManyCost entryScratch (projectState localRegister id a) + 1
theorem initialize_eval (a : Data) :
Eval «initialize» (initializeCost a) a (initialized a) :=
eval_liftCommand_from_state (clearMany entryScratch) 175 854 localRegister id a
(Fin.castAdd_injective _ _) Function.injective_id
(clearMany_eval entryScratch (projectState localRegister id a))
theorem initialized_stacks (a : Data) (i : Fin 896) :
(initialized a).stacks i = if i ∈ entryScratch then [] else a.stacks i := by
exact (embedState_stack localRegister id a
(clearManyState entryScratch (projectState localRegister id a))
Function.injective_id i).trans (clearMany_stacks entryScratch
(projectState localRegister id a) i)
theorem initialized_wordBound (a : Data) (P : ℕ) (ha : WordBound P a) :
WordBound P (initialized a) := by
intro i
rw [initialized_stacks]
split_ifs
· simp
· exact ha i
theorem initializeCost_le (a : Data) (P : ℕ) (ha : WordBound P a) :
initializeCost a ≤ entryScratch.length * (2 * P + 3) + 1 :=
Nat.add_le_add_right
(clearManyCost_le entryScratch (projectState localRegister id a) P ha) 1
/-- A single accepted ambient assignment145 is evaluated. The complete group
product is placed on854 for the head-sum addition; the arithmetic environment
remains installed for that addition. -/
def assignment : Code := .seq «initialize» (.seq setup product)
def program := compiled assignment 175 854
end
end OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.FactorAssignmentProgram