math / data /lean /OAI /Algorithms /SubexponentialSAT /Subexp /AssignmentInputProgram.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
34.4 kB
import OAI.Algorithms.SubexponentialSAT.LeanCompat
import OAI.Algorithms.SubexponentialSAT.Subexp.OneHotAlphabetProgram
import OAI.Algorithms.SubexponentialSAT.Subexp.AssignmentAlphabetSemantics
import OAI.Algorithms.SubexponentialSAT.Subexp.AssignmentRecordViews
import OAI.Algorithms.SubexponentialSAT.Subexp.AssignmentSeedRange
import OAI.Algorithms.SubexponentialSAT.Subexp.AssignmentInputCall
import OAI.Algorithms.SubexponentialSAT.Subexp.AssignmentInputState
import OAI.Algorithms.SubexponentialSAT.Subexp.AssignmentInitProgram
import OAI.Algorithms.SubexponentialSAT.Subexp.PairScoreBounds
namespace OAI.Algorithms
/-!
# Physical input construction for sequential type assignment
All parameters are unary stack data. The fixed program constructs the one-hot
word alphabet, reads its actual first word, derives its packed view, and builds
the exact seed range and dimensions expected by `AssignmentInitProgram`.
-/
namespace SubexponentialSAT.Subexp.AssignmentInputProgram
open BitProgram StructuredCalls SubexpSetupStorage AssignmentInputCall
def seedCount (delta D E : ℕ) : ℕ := E + (delta + 1) * D
def context (r Q delta D E : ℕ) (pairs : List Bool) : AssignmentInitProgram.Context where
defaultWord := (AssignmentAlphabetSemantics.wordBytes r Q).headD []
packedAlphabet := (AssignmentAlphabetSemantics.wordBytes r Q).flatten
alphabetRecords := ProgramEncoding.encodeRecords (AssignmentAlphabetSemantics.wordBytes r Q)
width := unary (Q * r)
depth := unary (2 * (delta + 1))
rawPairs := pairs
seedRecords := AssignmentSeedRange.seedRecords (seedCount delta D E)
seedCount := seedCount delta D E
def outputState (r Q delta D E : ℕ) (pairs : List Bool) : Data :=
AssignmentInitProgram.inputState (context r Q delta D E pairs) (fun _ => false)
def colorAlphabet : Code := AssignmentInputCall.call OneHotAlphabetProgram.program
(by decide) (by decide) [(1, 12)] 6 7
def wordAlphabet : Code := AssignmentInputCall.call TupleProgram.generateProgram
(by decide) (by decide) [(7, 13), (2, 20)] 0 30
def firstWord : Code := AssignmentInputCall.call AssignmentRecordViews.firstProgram
(by decide) (by decide) [(30, 12)] 2 0
def packedAlphabet : Code := AssignmentInputCall.call AssignmentRecordViews.flattenProgram
(by decide) (by decide) [(30, 12)] 2 9
def wordWidth : Code := AssignmentInputCall.call BlockCopyProgram.program
(by decide) (by decide) [(1, 12), (2, 15)] 1 10
def deltaPlusOne : Code := .seq (copyCmd 3 6 31) (TupleProgram.pushConst 6 0 true)
def depth : Code := copyMany 31 [(6, 34), (6, 34)]
def seedProduct : Code := AssignmentInputCall.call BlockCopyProgram.program
(by decide) (by decide) [(4, 12), (6, 15)] 1 47
def seedSize : Code := .seq seedProduct (copyCmd 5 47 31)
def seedRange : Code := AssignmentInputCall.call AssignmentSeedRange.program
(by decide) (by decide) [(47, 12)] 5 46
def cleanup : Code := .seq (clearMany [1, 2, 3, 4, 5, 6, 7]) (resetMany (List.finRange 16))
def command : Code :=
.seq colorAlphabet (.seq wordAlphabet (.seq firstWord (.seq packedAlphabet
(.seq wordWidth (.seq deltaPlusOne (.seq depth (.seq seedSize (.seq seedRange cleanup))))))))
abbrev program : Program 16 48 (size command + 1) := compiled command 1 30
/-- A physical stage changes one public stack and restores the private bank.
The witness is an actual measured execution of its finite instruction table. -/
def Writes (c : Code) (a : Data) (dst : Fin 48) (bits : List Bool) (charge : ℕ) : Prop :=
∃ ticks b, Eval c ticks a b ∧ b.stacks = Function.update a.stacks dst bits ∧ Clean b ∧
∀ B, Within a B → bits.length ≤ B → 1 ≤ B → ticks ≤ charge + 400 * (B + 1)
theorem colorAlphabet_eval (a : Data) (n : ℕ) (hc : Clean a)
(h1 : a.stacks 1 = unary n) :
Writes colorAlphabet a 7 (ProgramEncoding.encodeRecords (OneHotAlphabetProgram.rows 0 n))
(60 * (n + 1) ^ 2 + 1) := by
let pre := project (register (r := 5) (by decide)) (stack (s := 7) (by decide))
(prepareState 31 work [(1, 12)] a)
have hp : pre = OneHotAlphabetProgram.inputState pre.regs n := by
apply congrArg (StructuredProgram.State.mk pre.regs)
funext i
have h := prepare_one_local (r := 5) (s := 7) (by decide) (by decide) a hc 1 0 i
change pre.stacks i = _
change pre.stacks i = _ at h
rw [h]
fin_cases i <;> simp [ h1]
obtain ⟨ticks, htime, ht⟩ := OneHotAlphabetProgram.program_runsIn pre.regs n
rw [← hp] at ht
obtain ⟨b, he, hs, hb⟩ := call_eval OneHotAlphabetProgram.program
(by decide) (by decide) [(1, 12)] 6 7 a (OneHotAlphabetProgram.outputState n)
(by decide) (by decide) (by simp [mem_work]) (by simp) hc ht
refine ⟨_, b, he, hs, hb, ?_⟩
intro B ha hout _
have ho : Within (OneHotAlphabetProgram.outputState n) B := by
intro j; fin_cases j <;> simp [OneHotAlphabetProgram.outputState, hout]
have h := callCost_le (r := 5) (s := 7) (by decide) (by decide)
[(1, 12)] 6 7 a _ ticks B (by decide) ha ho
exact h.trans (Nat.add_le_add_right htime _)
theorem wordAlphabet_eval (a : Data) (r Q : ℕ) (hc : Clean a)
(h7 : a.stacks 7 = ProgramEncoding.encodeRecords (OneHotAlphabetProgram.rows 0 r))
(h2 : a.stacks 2 = unary Q) :
Writes wordAlphabet a 30 (ProgramEncoding.encodeRecords (AssignmentAlphabetSemantics.wordBytes r Q))
(TupleProgram.powerCost (OneHotAlphabetProgram.rows 0 r) Q [[]] + 9) := by
let pre := project (register (r := 10) (by decide)) (stack (s := 9) (by decide))
(prepareState 31 work [(7, 13), (2, 20)] a)
have hs (i : Fin 9) : pre.stacks i =
if i = 8 then unary Q else if i = 1 then
ProgramEncoding.encodeRecords (OneHotAlphabetProgram.rows 0 r) else [] := by
have h := prepare_two_local (r := 10) (s := 9)
(by decide) (by decide) a hc 7 2 1 8 (by decide) (by decide) i
change pre.stacks i = _ at h
simpa only [h7, h2] using h
have hp : TupleProgram.outerInvariant (OneHotAlphabetProgram.rows 0 r) (unary Q)
(pre.regs 9) pre := by
simp [TupleProgram.outerInvariant, hs]
obtain ⟨out, hout, ticks, htime, ht⟩ := TupleProgram.generateProgram_runsIn
(OneHotAlphabetProgram.rows 0 r) (unary Q) (pre.regs 9) pre hp
(by simp [hs]) (by simp [hs]) (by simp [hs])
obtain ⟨b, he, hb, hclean⟩ := call_eval TupleProgram.generateProgram
(by decide) (by decide) [(7, 13), (2, 20)] 0 30 a out
(by decide) (by decide) (by simp [mem_work]) (by simp) hc ht
refine ⟨_, b, he, ?_, hclean, ?_⟩
· rw [hb, hout.2.1]
simp only [List.length_replicate, AssignmentAlphabetSemantics.wordBytes]
· intro B ha hresult hB
rcases hout with ⟨⟨h1, h3, h4, h6, h7', h8, h9⟩, h0, h2', h5⟩
have halphabet : (ProgramEncoding.encodeRecords (OneHotAlphabetProgram.rows 0 r)).length ≤ B := by
simpa only [← h7] using ha 7
have ho : Within out B := by
intro j
fin_cases j <;> simp_all [AssignmentAlphabetSemantics.wordBytes]
have h := callCost_le (r := 10) (s := 9) (by decide) (by decide)
[(7, 13), (2, 20)] 0 30 a out ticks B (by decide) ha ho
simp only [List.length_replicate] at htime
exact h.trans (Nat.add_le_add_right htime _)
theorem firstWord_eval (a : Data) (bits : List Bool) (rows : List (List Bool))
(hc : Clean a) (h30 : a.stacks 30 = ProgramEncoding.encodeRecords (bits :: rows)) :
Writes firstWord a 0 bits (9 * bits.length + 10) := by
let pre := project (register (r := 3) (by decide)) (stack (s := 3) (by decide))
(prepareState 31 work [(30, 12)] a)
have hp : pre = AssignmentRecordViews.data (pre.regs 0) (pre.regs 1) (pre.regs 2)
(ProgramEncoding.encodeRecords (bits :: rows)) [] [] := by
apply congrArg₂ StructuredProgram.State.mk
· funext i; fin_cases i <;> rfl
· funext i
have h := prepare_one_local (r := 3) (s := 3) (by decide) (by decide) a hc 30 0 i
change pre.stacks i = _
change pre.stacks i = _ at h
rw [h]
fin_cases i <;> simp [ h30]
have ht := AssignmentRecordViews.first_trace (pre.regs 0) (pre.regs 1) (pre.regs 2) bits rows
rw [← hp] at ht
obtain ⟨b, he, hs, hb⟩ := call_eval AssignmentRecordViews.firstProgram
(by decide) (by decide) [(30, 12)] 2 0 a
(AssignmentRecordViews.data false false false (ProgramEncoding.encodeRecords rows) [] bits)
(by decide) (by decide) (by simp [mem_work]) (by simp) hc ht
refine ⟨_, b, he, hs, hb, ?_⟩
intro B ha hresult _
have htail : (ProgramEncoding.encodeRecords rows).length ≤ B := by
have hh := ha 30
rw [h30] at hh
change (Encoding.encodeList id rows).length ≤ B
change (Encoding.encodeList id (bits :: rows)).length ≤ B at hh
rw [Encoding.length_encodeList_cons] at hh
omega
have ho : Within (AssignmentRecordViews.data false false false
(ProgramEncoding.encodeRecords rows) [] bits) B := by
intro j; fin_cases j <;> simp [ htail, hresult]
exact callCost_le (r := 3) (s := 3) (by decide) (by decide)
[(30, 12)] 2 0 a _ _ B (by decide) ha ho
theorem packedAlphabet_eval (a : Data) (rows : List (List Bool)) (hc : Clean a)
(h30 : a.stacks 30 = ProgramEncoding.encodeRecords rows) :
Writes packedAlphabet a 9 rows.flatten
(9 * (rows.map List.length).sum + 6 * rows.length + 7) := by
let pre := project (register (r := 3) (by decide)) (stack (s := 3) (by decide))
(prepareState 31 work [(30, 12)] a)
have hp : pre = AssignmentRecordViews.data (pre.regs 0) (pre.regs 1) (pre.regs 2)
(ProgramEncoding.encodeRecords rows ++ []) [] [] := by
apply congrArg₂ StructuredProgram.State.mk
· funext i; fin_cases i <;> rfl
· funext i
have h := prepare_one_local (r := 3) (s := 3) (by decide) (by decide) a hc 30 0 i
change pre.stacks i = _
change pre.stacks i = _ at h
rw [h]
fin_cases i <;> simp [ h30]
have ht := AssignmentRecordViews.flatten_trace (pre.regs 0) (pre.regs 1) (pre.regs 2) rows [] []
rw [← hp] at ht
obtain ⟨b, he, hs, hb⟩ := call_eval AssignmentRecordViews.flattenProgram
(by decide) (by decide) [(30, 12)] 2 9 a
(AssignmentRecordViews.data false false false [] [] (rows.flatten ++ []))
(by decide) (by decide) (by simp [mem_work]) (by simp) hc ht
refine ⟨_, b, he, by simpa using hs, hb, ?_⟩
intro B ha hresult _
simp only [List.length_flatten] at hresult
have ho : Within (AssignmentRecordViews.data false false false [] [] (rows.flatten ++ [])) B := by
intro j; fin_cases j <;> simp [ hresult]
exact callCost_le (r := 3) (s := 3) (by decide) (by decide)
[(30, 12)] 2 9 a _ _ B (by decide) ha ho
theorem copies_unary (n m : ℕ) : BlockCopyProgram.copies n (unary m) = unary (n * m) := by
induction n with
| zero => simp
| succ n ih =>
rw [BlockCopyProgram.copies_succ, ih]
simp [unary, Nat.add_mul, Nat.add_comm]
theorem repeat_eval (a : Data) (src count dst : Fin 48) (m n : ℕ)
(hc : Clean a) (hsrc : a.stacks src = unary m) (hcount : a.stacks count = unary n)
(hd : dst ∉ work) (htmp : dst ≠ 31)
(hports : ∀ x ∈ [(src, 12), (count, 15)],
x.1 ≠ x.2 ∧ x.1 ≠ 31 ∧ (31 : Fin 48) ≠ x.2)
(hcount12 : count ≠ 12) :
Writes (AssignmentInputCall.call BlockCopyProgram.program (by decide) (by decide)
[(src, 12), (count, 15)] 1 dst) a dst (unary (n * m))
(n * (7 * m + 7) + 3) := by
let pre := project (register (r := 3) (by decide)) (stack (s := 4) (by decide))
(prepareState 31 work [(src, 12), (count, 15)] a)
have hp : pre = BlockCopyProgram.initialState n (unary m) [] := by
apply congrArg₂ StructuredProgram.State.mk
· funext i
have h := prepare_regs [(src, 12), (count, 15)] a (register (by decide) i)
(by have := i.isLt; simp only [register, Fin.val_castLE]; omega)
fin_cases i <;> exact h
· funext i
have h := prepare_two_local (r := 3) (s := 4) (by decide) (by decide)
a hc src count 0 3 (by decide) hcount12 i
change pre.stacks i = _
change pre.stacks i = _ at h
rw [h]
fin_cases i <;> simp [ hsrc, hcount]
have ht := BlockCopyProgram.program_trace n (unary m) []
rw [← hp] at ht
obtain ⟨b, he, hs, hb⟩ := call_eval BlockCopyProgram.program
(by decide) (by decide) [(src, 12), (count, 15)] 1 dst a
(BlockCopyProgram.data false false (unary m) (BlockCopyProgram.copies n (unary m) ++ []) [])
hd htmp (by simp [mem_work]) hports hc ht
refine ⟨_, b, he, by simpa [BlockCopyProgram.data, copies_unary] using hs, hb, ?_⟩
intro B ha hresult _
simp only [List.length_replicate] at hresult
have hm : m ≤ B := by simpa [hsrc] using ha src
have ho : Within (BlockCopyProgram.data false false (unary m)
(BlockCopyProgram.copies n (unary m) ++ []) []) B := by
intro j; fin_cases j <;> simp [BlockCopyProgram.data, copies_unary, hm, hresult]
simpa only [List.length_replicate] using callCost_le (r := 3) (s := 4)
(by decide) (by decide) [(src, 12), (count, 15)] 1 dst a _ _ B (by simp) ha ho
theorem seedRange_eval (a : Data) (n : ℕ) (hc : Clean a)
(h47 : a.stacks 47 = unary n) :
Writes seedRange a 46 (AssignmentSeedRange.seedRecords n) (AssignmentSeedRange.budget n + 1) := by
let pre := project (register (r := 5) (by decide)) (stack (s := 6) (by decide))
(prepareState 31 work [(47, 12)] a)
have hp : pre = AssignmentSeedRange.inputState pre.regs n := by
apply congrArg (StructuredProgram.State.mk pre.regs)
funext i
have h := prepare_one_local (r := 5) (s := 6) (by decide) (by decide) a hc 47 0 i
change pre.stacks i = _
change pre.stacks i = _ at h
rw [h]
fin_cases i <;> simp [ h47]
obtain ⟨ticks, htime, ht⟩ := AssignmentSeedRange.program_runsIn pre.regs n
rw [← hp] at ht
obtain ⟨b, he, hs, hb⟩ := call_eval AssignmentSeedRange.program
(by decide) (by decide) [(47, 12)] 5 46 a (AssignmentSeedRange.outputState n)
(by decide) (by decide) (by simp [mem_work]) (by simp) hc ht
refine ⟨_, b, he, hs, hb, ?_⟩
intro B ha hresult _
have ho : Within (AssignmentSeedRange.outputState n) B := by
intro j; fin_cases j <;> simp [AssignmentSeedRange.outputState, AssignmentSeedRange.state, hresult]
have h := callCost_le (r := 5) (s := 6) (by decide) (by decide)
[(47, 12)] 5 46 a _ ticks B (by decide) ha ho
exact h.trans (Nat.add_le_add_right htime _)
theorem clean_of_update (a b : Data) (dst : Fin 48) (bits : List Bool)
(hc : Clean a) (hd : dst ∉ work) (htmp : dst ≠ 31)
(hs : b.stacks = Function.update a.stacks dst bits) : Clean b := by
constructor
· intro j hj
have hn : j ≠ dst := by intro h; exact hd (h ▸ hj)
simp [hs, hn, hc.1 j hj]
· simp [hs, Ne.symm htmp, hc.2]
theorem within_of_update (a b : Data) (dst : Fin 48) (bits : List Bool) (B : ℕ)
(ha : Within a B) (hb : bits.length ≤ B)
(hs : b.stacks = Function.update a.stacks dst bits) : Within b B := by
intro j
by_cases hj : j = dst
· subst j; simpa only [hs, Function.update_same] using hb
· simpa [hs, Function.update_apply, hj] using ha j
theorem deltaPlusOne_eval (a : Data) (delta : ℕ) (hc : Clean a)
(h3 : a.stacks 3 = unary delta) (h6 : a.stacks 6 = []) :
Writes deltaPlusOne a 6 (unary (delta + 1)) (7 * delta + 7) := by
let b := copyState 3 6 a
let c := TupleProgram.pushedState 6 0 true b
have h1 := copy_eval 3 6 31 a (by decide) (by decide) (by decide) hc.2
have h2 := TupleProgram.pushConst_eval 6 0 true b
have hs : c.stacks = Function.update a.stacks 6 (unary (delta + 1)) := by
funext j
by_cases hj : j = 6
· subst j
simp [c, b, copyState_stack, h3, h6, unary, List.replicate_succ]
· simp [c, b, copyState_stack, hj]
refine ⟨_, c, h1.seq h2, hs, clean_of_update a c 6 _ hc (by decide) (by decide) hs, ?_⟩
intro B _ _ _
simp only [h3, List.length_replicate]
omega
theorem depth_eval (a : Data) (n : ℕ) (hc : Clean a)
(h6 : a.stacks 6 = unary n) (h34 : a.stacks 34 = []) :
Writes depth a 34 (unary (2 * n)) (14 * n + 10) := by
let b := copyManyState [(6, 34), (6, 34)] a
have h := copyMany_eval 31 [(6, 34), (6, 34)] a (by simp) hc.2
have hs : b.stacks = Function.update a.stacks 34 (unary (2 * n)) := by
funext j
by_cases hj : j = 34
· subst j
simp [b, copyManyState, copyState_stack, h6, h34, unary,
two_mul]
· simp [b, copyManyState, copyState_stack, hj]
refine ⟨_, b, h, hs, clean_of_update a b 34 _ hc (by decide) (by decide) hs, ?_⟩
intro B _ _ _
simp [copyManyCost, copyState_stack, h6]
omega
theorem seedSize_eval (a : Data) (delta D E : ℕ) (hc : Clean a)
(h4 : a.stacks 4 = unary D) (h6 : a.stacks 6 = unary (delta + 1))
(h5 : a.stacks 5 = unary E) :
Writes seedSize a 47 (unary (seedCount delta D E))
((delta + 1) * (7 * D + 7) + 3 + (7 * E + 5)) := by
obtain ⟨ticks, b, hb, hs, hc', htime⟩ := repeat_eval a 4 6 47 D (delta + 1) hc h4 h6
(by decide) (by decide) (by simp) (by decide)
have hcopy := copy_eval 5 47 31 b (by decide) (by decide) (by decide) hc'.2
let c := copyState 5 47 b
have hout : c.stacks = Function.update a.stacks 47 (unary (seedCount delta D E)) := by
funext j
by_cases hj : j = 47
· subst j
simp [c, copyState_stack, hs, h5, seedCount, unary]
· simp [c, copyState_stack, hs, hj]
refine ⟨_, c, hb.seq hcopy, hout,
clean_of_update a c 47 _ hc (by decide) (by decide) hout, ?_⟩
intro B ha hresult hB
have hproduct : (unary ((delta + 1) * D)).length ≤ B := by
simp only [List.length_replicate, seedCount] at hresult ⊢
omega
have ht := htime B ha hproduct hB
simp only [hs, Function.update_of_ne (show (5 : Fin 48) ≠ 47 by decide), h5,
List.length_replicate]
omega
theorem input_clean (regs : Fin 16 → Bool) (r Q delta D E : ℕ) (pairs : List Bool) :
Clean (inputState regs r Q delta D E pairs) := by
constructor
· intro j hj
rw [mem_work] at hj
have h1 : j ≠ 1 := by intro h; subst j; change 12 ≤ 1 ∧ 1 < 22 at hj; omega
have h2 : j ≠ 2 := by intro h; subst j; change 12 ≤ 2 ∧ 2 < 22 at hj; omega
have h3 : j ≠ 3 := by intro h; subst j; change 12 ≤ 3 ∧ 3 < 22 at hj; omega
have h4 : j ≠ 4 := by intro h; subst j; change 12 ≤ 4 ∧ 4 < 22 at hj; omega
have h5 : j ≠ 5 := by intro h; subst j; change 12 ≤ 5 ∧ 5 < 22 at hj; omega
have h45 : j ≠ 45 := by intro h; subst j; change 12 ≤ 45 ∧ 45 < 22 at hj; omega
simp [inputState, h1, h2, h3, h4, h5, h45]
· rfl
def sourceCharge (r Q delta D E : ℕ) : ℕ :=
let rows := AssignmentAlphabetSemantics.wordBytes r Q
(60 * (r + 1) ^ 2 + 1) +
(TupleProgram.powerCost (OneHotAlphabetProgram.rows 0 r) Q [[]] + 9) +
(9 * (rows.headD []).length + 10) +
(9 * (rows.map List.length).sum + 6 * rows.length + 7) +
(Q * (7 * r + 7) + 3) + (7 * delta + 7) +
(14 * (delta + 1) + 10) +
((delta + 1) * (7 * D + 7) + 3 + (7 * E + 5)) +
(AssignmentSeedRange.budget (seedCount delta D E) + 1)
def sourceBudget (r Q delta D E B : ℕ) : ℕ :=
sourceCharge r Q delta D E + 5000 * (B + 1)
/-- The complete fixed producer, including concrete record extraction and
range generation. The only semantic witness chooses names for the actual
emitted word bytes; it is not supplied to the executable program. -/
theorem command_eval_measured (regs : Fin 16 → Bool) (r Q delta D E B : ℕ)
(pairs : List Bool) (hr : 0 < r) (hB : 1 ≤ B)
(ha : Within (inputState regs r Q delta D E pairs) B)
(hcolor : (ProgramEncoding.encodeRecords (OneHotAlphabetProgram.rows 0 r)).length ≤ B)
(hwords : (ProgramEncoding.encodeRecords (AssignmentAlphabetSemantics.wordBytes r Q)).length ≤ B)
(hfirst : ((AssignmentAlphabetSemantics.wordBytes r Q).headD []).length ≤ B)
(hflat : (AssignmentAlphabetSemantics.wordBytes r Q).flatten.length ≤ B)
(hwidth : Q * r ≤ B) (hdelta : delta + 1 ≤ B) (hdepth : 2 * (delta + 1) ≤ B)
(hseed : seedCount delta D E ≤ B)
(hseeds : (AssignmentSeedRange.seedRecords (seedCount delta D E)).length ≤ B) :
∃ ticks, ticks ≤ sourceBudget r Q delta D E B ∧
Eval command ticks (inputState regs r Q delta D E pairs)
(outputState r Q delta D E pairs) := by
let a := inputState regs r Q delta D E pairs
obtain ⟨t1, a1, he1, hs1, hc1, ht1⟩ := colorAlphabet_eval a r (input_clean regs r Q delta D E pairs) rfl
have hb1 := within_of_update a a1 7 _ B ha hcolor hs1
have hn1 := ht1 B ha hcolor hB
obtain ⟨t2, a2, he2, hs2, hc2, ht2⟩ := wordAlphabet_eval a1 r Q hc1
(by simp [hs1]) (by simp [hs1, a, inputState])
have hb2 := within_of_update a1 a2 30 _ B hb1 hwords hs2
have hn2 := ht2 B hb1 hwords hB
obtain ⟨w, tail, hw, _, _⟩ := AssignmentAlphabetSemantics.wordBytes_order hr Q
have hbytes : AssignmentAlphabetSemantics.wordBytes r Q =
ReadPlan.encodeWord w :: tail.map ReadPlan.encodeWord := hw.symm
have hhead : (AssignmentAlphabetSemantics.wordBytes r Q).headD [] = ReadPlan.encodeWord w := by
simp [hbytes]
have hwlen : (ReadPlan.encodeWord w).length ≤ B := by simpa [hbytes] using hfirst
obtain ⟨t3, a3, he3, hs3, hc3, ht3⟩ := firstWord_eval a2 (ReadPlan.encodeWord w)
(tail.map ReadPlan.encodeWord) hc2 (by simp [hs2, hbytes])
have hb3 := within_of_update a2 a3 0 _ B hb2 hwlen hs3
have hn3 := ht3 B hb2 hwlen hB
obtain ⟨t4, a4, he4, hs4, hc4, ht4⟩ := packedAlphabet_eval a3
(AssignmentAlphabetSemantics.wordBytes r Q) hc3 (by simp [hs3, hs2])
have hb4 := within_of_update a3 a4 9 _ B hb3 hflat hs4
have hn4 := ht4 B hb3 hflat hB
have hwlen' : (unary (Q * r)).length ≤ B := by simpa using hwidth
obtain ⟨t5, a5, he5, hs5, hc5, ht5⟩ := repeat_eval a4 1 2 10 r Q hc4
(by simp [hs4, hs3, hs2, hs1, a, inputState])
(by simp [hs4, hs3, hs2, hs1, a, inputState])
(by decide) (by decide) (by simp) (by decide)
have hb5 := within_of_update a4 a5 10 _ B hb4 hwlen' hs5
have hn5 := ht5 B hb4 hwlen' hB
have hdlen : (unary (delta + 1)).length ≤ B := by simpa using hdelta
obtain ⟨t6, a6, he6, hs6, hc6, ht6⟩ := deltaPlusOne_eval a5 delta hc5
(by simp [hs5, hs4, hs3, hs2, hs1, a, inputState])
(by simp [hs5, hs4, hs3, hs2, hs1, a, inputState])
have hb6 := within_of_update a5 a6 6 _ B hb5 hdlen hs6
have hn6 := ht6 B hb5 hdlen hB
have hdepthlen : (unary (2 * (delta + 1))).length ≤ B := by simpa using hdepth
obtain ⟨t7, a7, he7, hs7, hc7, ht7⟩ := depth_eval a6 (delta + 1) hc6
(by simp [hs6]) (by simp [hs6, hs5, hs4, hs3, hs2, hs1, a, inputState])
have hb7 := within_of_update a6 a7 34 _ B hb6 hdepthlen hs7
have hn7 := ht7 B hb6 hdepthlen hB
have hseedlen : (unary (seedCount delta D E)).length ≤ B := by simpa using hseed
obtain ⟨t8, a8, he8, hs8, hc8, ht8⟩ := seedSize_eval a7 delta D E hc7
(by simp [hs7, hs6, hs5, hs4, hs3, hs2, hs1, a, inputState])
(by simp [hs7, hs6])
(by simp [hs7, hs6, hs5, hs4, hs3, hs2, hs1, a, inputState])
have hb8 := within_of_update a7 a8 47 _ B hb7 hseedlen hs8
have hn8 := ht8 B hb7 hseedlen hB
obtain ⟨t9, a9, he9, hs9, _, ht9⟩ := seedRange_eval a8 (seedCount delta D E) hc8 (by simp [hs8])
have hb9 := within_of_update a8 a9 46 _ B hb8 hseeds hs9
have hn9 := ht9 B hb8 hseeds hB
let ac := clearManyState [1, 2, 3, 4, 5, 6, 7] a9
let af := resetManyState (List.finRange 16) ac
have he10 := (clearMany_eval [1, 2, 3, 4, 5, 6, 7] a9).seq
(resetMany_eval (List.finRange 16) ac)
have haf : af = outputState r Q delta D E pairs := by
apply congrArg₂ StructuredProgram.State.mk
· funext j
change (resetManyState (List.finRange 16) ac).regs j = false
rw [resetMany_regs]
simp
· funext j
change (resetManyState (List.finRange 16) ac).stacks j = _
rw [resetMany_stacks]
change (clearManyState [1, 2, 3, 4, 5, 6, 7] a9).stacks j = _
rw [clearMany_stacks]
fin_cases j <;> simp [hs9, hs8, hs7, hs6, hs5, hs4, hs3, hs2, hs1, a,
inputState,
context, hbytes, AssignmentInitProgram.unary]
change Eval cleanup _ a9 af at he10
rw [haf] at he10
refine ⟨_, ?_, he1.seq (he2.seq (he3.seq (he4.seq (he5.seq (he6.seq (he7.seq
(he8.seq (he9.seq he10))))))))⟩
have hcleanup := (clearMany_bound [1, 2, 3, 4, 5, 6, 7] a9 B hb9).2
simp only [List.length_cons, List.length_nil, List.length_finRange] at hcleanup ⊢
simp only [sourceBudget, sourceCharge, hhead]
omega
/-- Explicit data-size envelope, including generated arrays. It is assertion
notation only; no bound or table is passed to the machine. -/
def extent (r Q delta D E : ℕ) (pairs : List Bool) : ℕ :=
let rows := AssignmentAlphabetSemantics.wordBytes r Q
1 + r + Q + delta + D + E + (delta + 1) + 2 * (delta + 1) + Q * r +
seedCount delta D E + r ^ Q +
(ProgramEncoding.encodeRecords (OneHotAlphabetProgram.rows 0 r)).length +
(ProgramEncoding.encodeRecords rows).length + (rows.headD []).length + rows.flatten.length +
(AssignmentSeedRange.seedRecords (seedCount delta D E)).length + pairs.length
def budget (r Q delta D E : ℕ) (pairs : List Bool) : ℕ :=
sourceBudget r Q delta D E (extent r Q delta D E pairs)
/-- A closed bound containing only runtime parameter values and input size. -/
def sizeBound (r Q delta D E inputBits : ℕ) : ℕ :=
let M := seedCount delta D E
1 + r + Q + delta + D + E + (delta + 1) + 2 * (delta + 1) + Q * r +
M + r ^ Q + (1 + (2 * r + 2) * r) +
(1 + (2 * (Q * r) + 2) * r ^ Q) + Q * r + r ^ Q * (Q * r) +
(1 + (2 * M + 2) * M) + inputBits
theorem extent_le_sizeBound (r Q delta D E : ℕ) (pairs : List Bool) (hr : 0 < r) :
extent r Q delta D E pairs ≤ sizeBound r Q delta D E pairs.length := by
have hc : ∀ bits ∈ OneHotAlphabetProgram.rows 0 r, bits.length ≤ r := by
intro bits hb
rw [AssignmentAlphabetSemantics.rows_eq_alphabet] at hb
obtain ⟨c, _, rfl⟩ := List.mem_map.mp hb
simp [AssignmentAlphabetSemantics.oneHot]
have hclen : (OneHotAlphabetProgram.rows 0 r).length = r := by
simp [AssignmentAlphabetSemantics.rows_eq_alphabet]
have hcolor := ProgramEncoding.encodeRecords_length_le (OneHotAlphabetProgram.rows 0 r) r hc
rw [hclen] at hcolor
have hw : ∀ bits ∈ AssignmentAlphabetSemantics.wordBytes r Q, bits.length ≤ Q * r :=
fun bits hb => (AssignmentAlphabetSemantics.wordBytes_width hr bits hb).le
have hwords := ProgramEncoding.encodeRecords_length_le
(AssignmentAlphabetSemantics.wordBytes r Q) (Q * r) hw
rw [AssignmentAlphabetSemantics.wordBytes_length] at hwords
have hvolume := PairScoreBounds.volume_le (AssignmentAlphabetSemantics.wordBytes r Q) (Q * r) hw
rw [AssignmentAlphabetSemantics.wordBytes_length] at hvolume
have hflat : (AssignmentAlphabetSemantics.wordBytes r Q).flatten.length ≤ r ^ Q * (Q * r) := by
simpa only [List.length_flatten, PairScoreBounds.volume] using hvolume
have hhead : ((AssignmentAlphabetSemantics.wordBytes r Q).headD []).length = Q * r := by
obtain ⟨a, tail, he, _, _⟩ := AssignmentAlphabetSemantics.wordBytes_order hr Q
rw [← he]
simp [ReadPlan.encodeWord_length, ReadPlan.wordWidth]
have hseeds := ProgramEncoding.encodeRecords_length_le
((List.range (seedCount delta D E)).map unary) (seedCount delta D E) (by
intro bits hb
obtain ⟨i, hi, rfl⟩ := List.mem_map.mp hb
simpa using (List.mem_range.mp hi).le)
simp only [List.length_map, List.length_range] at hseeds
change (AssignmentSeedRange.seedRecords (seedCount delta D E)).length ≤ _ at hseeds
dsimp only [extent, sizeBound]
rw [hhead]
omega
theorem command_eval (regs : Fin 16 → Bool) (r Q delta D E : ℕ)
(pairs : List Bool) (hr : 0 < r) :
∃ ticks, ticks ≤ budget r Q delta D E pairs ∧
Eval command ticks (inputState regs r Q delta D E pairs)
(outputState r Q delta D E pairs) := by
apply command_eval_measured regs r Q delta D E (extent r Q delta D E pairs) pairs hr
· dsimp only [extent]
omega
· intro j
dsimp only [inputState]
split_ifs <;> (try simp only [List.length_replicate, List.length_nil]) <;>
dsimp only [extent] <;> omega
all_goals dsimp only [extent]; omega
theorem budget_le (r Q delta D E : ℕ) (pairs : List Bool) (hr : 0 < r) :
budget r Q delta D E pairs ≤ 20000 * (extent r Q delta D E pairs + 1) ^ 4 := by
let B := extent r Q delta D E pairs
let T := B + 1
have hrB : r ≤ B := by dsimp [B, extent]; omega
have hQB : Q ≤ B := by dsimp [B, extent]; omega
have hdB : delta ≤ B := by dsimp [B, extent]; omega
have hd1B : delta + 1 ≤ B := by dsimp [B, extent]; omega
have hDB : D ≤ B := by dsimp [B, extent]; omega
have hEB : E ≤ B := by dsimp [B, extent]; omega
have hMB : seedCount delta D E ≤ B := by dsimp [B, extent]; omega
have hpowB : r ^ Q ≤ B := by dsimp [B, extent]; omega
have hhead : ((AssignmentAlphabetSemantics.wordBytes r Q).headD []).length ≤ B := by
dsimp [B, extent]; omega
have hflat : ((AssignmentAlphabetSemantics.wordBytes r Q).map List.length).sum ≤ B := by
have h : (AssignmentAlphabetSemantics.wordBytes r Q).flatten.length ≤ B := by
dsimp [B, extent]; omega
simpa only [List.length_flatten] using h
have hcount : (AssignmentAlphabetSemantics.wordBytes r Q).length ≤ B := by
simpa using hpowB
have hcolorlen : (OneHotAlphabetProgram.rows 0 r).length = r := by
rw [AssignmentAlphabetSemantics.rows_eq_alphabet]
simp
have hcolorwidth : ∀ bits ∈ OneHotAlphabetProgram.rows 0 r, bits.length ≤ r := by
intro bits hb
rw [AssignmentAlphabetSemantics.rows_eq_alphabet] at hb
obtain ⟨c, _, rfl⟩ := List.mem_map.mp hb
simp [AssignmentAlphabetSemantics.oneHot]
have hpower := PairScoreBounds.generated_powerCost_le (OneHotAlphabetProgram.rows 0 r) Q r
(by rw [hcolorlen]; omega) hcolorwidth
rw [hcolorlen] at hpower
have hT : 1 ≤ T := by dsimp [T]; omega
have hrT : r + 1 ≤ T := by dsimp [T]; omega
have hQT : Q + 1 ≤ T := by dsimp [T]; omega
have hDT : D + 1 ≤ T := by dsimp [T]; omega
have hMT : seedCount delta D E + 1 ≤ T := by dsimp [T]; omega
have hlast : (Q + 1) * r + 1 ≤ T ^ 2 := by
have hh := Nat.mul_le_mul hQT hrB
dsimp [T] at hh ⊢
nlinarith only [hh]
have hpower' : TupleProgram.powerCost (OneHotAlphabetProgram.rows 0 r) Q [[]] ≤ 800 * T ^ 4 := by
calc
_ ≤ 800 * T * T * T ^ 2 := hpower.trans (by gcongr ; omega)
_ = _ := by ring
have hcolor : 60 * (r + 1) ^ 2 ≤ 60 * T ^ 2 := by gcongr
have hseed : AssignmentSeedRange.budget (seedCount delta D E) ≤ 60 * T ^ 2 :=
(AssignmentSeedRange.budget_le _).trans (by gcongr)
have hwidth : Q * (7 * r + 7) ≤ 7 * T ^ 2 := by
calc
_ = 7 * Q * (r + 1) := by ring
_ ≤ 7 * T * T := by gcongr ; omega
_ = _ := by ring
have hproduct : (delta + 1) * (7 * D + 7) ≤ 7 * T ^ 2 := by
calc
_ = 7 * (delta + 1) * (D + 1) := by ring
_ ≤ 7 * T * T := by gcongr ; omega
_ = _ := by ring
have hT2 : T ≤ T ^ 2 := le_self_pow hT (by decide)
have hT4 : T ^ 2 ≤ T ^ 4 := pow_le_pow_right' hT (by decide)
have hcharge : sourceCharge r Q delta D E ≤
800 * T ^ 4 + 134 * T ^ 2 + 52 * B + 56 := by
dsimp only [sourceCharge]
omega
have hBT : B + 1 = T := rfl
change sourceCharge r Q delta D E + 5000 * T ≤ 20000 * T ^ 4
omega
theorem program_runsIn (regs : Fin 16 → Bool) (r Q delta D E : ℕ)
(pairs : List Bool) (hr : 0 < r) :
RunsIn program (budget r Q delta D E pairs + 1)
((inputState regs r Q delta D E pairs).withPC (some program.entry))
((outputState r Q delta D E pairs).withPC none) := by
obtain ⟨ticks, hbound, ht⟩ := command_eval regs r Q delta D E pairs hr
exact ⟨ticks + 1, Nat.add_le_add_right hbound 1, compiled_halt_trace ht 1 30⟩
theorem program_runsIn_closed (regs : Fin 16 → Bool) (r Q delta D E : ℕ)
(pairs : List Bool) (hr : 0 < r) :
RunsIn program (20000 * (sizeBound r Q delta D E pairs.length + 1) ^ 4 + 1)
((inputState regs r Q delta D E pairs).withPC (some program.entry))
((outputState r Q delta D E pairs).withPC none) := by
apply (program_runsIn regs r Q delta D E pairs hr).mono
apply Nat.add_le_add_right
exact (budget_le r Q delta D E pairs hr).trans
(Nat.mul_le_mul_left 20000 (Nat.pow_le_pow_left
(Nat.add_le_add_right (extent_le_sizeBound r Q delta D E pairs hr) 1) 4))
theorem program_primitive (regs : Fin 16 → Bool) (r Q delta D E : ℕ)
(pairs : List Bool) (hr : 0 < r) :
Computation.RunsIn (primitive program).step
(primitiveOverhead program *
(20000 * (sizeBound r Q delta D E pairs.length + 1) ^ 4 + 1))
(primitiveCfg program ((inputState regs r Q delta D E pairs).withPC (some program.entry)))
(primitiveCfg program ((outputState r Q delta D E pairs).withPC none)) :=
primitive_execution program (program_runsIn_closed regs r Q delta D E pairs hr)
theorem program_trace (regs : Fin 16 → Bool) (r Q delta D E : ℕ)
(pairs : List Bool) (hr : 0 < r) :
∃ ticks, Trace program ticks
((inputState regs r Q delta D E pairs).withPC (some program.entry))
((outputState r Q delta D E pairs).withPC none) := by
obtain ⟨ticks, _, ht⟩ := command_eval regs r Q delta D E pairs hr
exact ⟨ticks + 1, compiled_halt_trace ht 1 30⟩
theorem context_word_order (r Q delta D E : ℕ) (pairs : List Bool) (hr : 0 < r) :
∃ a : MulticolorTypes.Word r Q, ∃ tail : List (MulticolorTypes.Word r Q),
(a :: tail).Nodup ∧ (∀ w, w ∈ a :: tail) ∧
(context r Q delta D E pairs).defaultWord = ReadPlan.encodeWord a ∧
(context r Q delta D E pairs).packedAlphabet =
((a :: tail).map ReadPlan.encodeWord).flatten ∧
(context r Q delta D E pairs).alphabetRecords =
ProgramEncoding.encodeRecords ((a :: tail).map ReadPlan.encodeWord) ∧
(context r Q delta D E pairs).width = unary (ReadPlan.encodeWord a).length := by
obtain ⟨a, tail, he, hn, hf⟩ := AssignmentAlphabetSemantics.wordBytes_order hr Q
refine ⟨a, tail, hn, hf, ?_, ?_, ?_, ?_⟩
· simp [context, ← he]
· simp only [context, he]
· simp only [context, he]
· simp [context, ReadPlan.encodeWord_length, ReadPlan.wordWidth]
end SubexponentialSAT.Subexp.AssignmentInputProgram
end OAI.Algorithms