math / data /lean /OAI /Algorithms /SubexponentialSAT /BinaryPrograms.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
29.6 kB
import OAI.Algorithms.SubexponentialSAT.LeanCompat
import OAI.Algorithms.SubexponentialSAT.BinaryArithmetic
import OAI.Algorithms.SubexponentialSAT.BitProgram
import OAI.Algorithms.SubexponentialSAT.BitProgramCompile
import OAI.Algorithms.SubexponentialSAT.ProgramLinking
import OAI.Algorithms.SubexponentialSAT.StackRoutines
namespace OAI.Algorithms
/-!
# Fixed-control programs for binary arithmetic
Operands, their widths, and moduli are data. None of the programs in this file
have a control-state set depending on an operand length or numeric parameter.
-/
namespace SubexponentialSAT.BinaryPrograms
open SubexponentialSAT.BinaryArithmetic
open SubexponentialSAT.Computation
/-- Carry generation using three gates after the shared input XOR. -/
def fastCarry (a b c : Bool) : Bool :=
(a && b).xor ((a.xor b) && c)
theorem fastCarry_eq (a b c : Bool) : fastCarry a b c = carryBit a b c := by
cases a <;> cases b <;> cases c <;> decide
theorem addCarry_nonempty (c : Bool) (xs ys : List Bool)
(h : xs ≠ [] ∨ ys ≠ []) :
addCarry c xs ys =
sumBit (xs.headD false) (ys.headD false) c ::
addCarry (fastCarry (xs.headD false) (ys.headD false) c) xs.tail ys.tail := by
cases xs with
| nil =>
cases ys with
| nil => simp at h
| cons b ys => simp [addCarry, carryAdd, fastCarry_eq]
| cons a xs =>
cases ys <;> simp [addCarry, fastCarry_eq]
namespace Add
abbrev Regs := Fin 8 → Bool
abbrev Config := SubexponentialSAT.BitProgram.Cfg 8 3 13
/-- A constant finite program: it never inspects the numeric value or length
of an operand. Registers 0..7 are carry,a,b,present-a,present-b,t,u,v. -/
def program : SubexponentialSAT.BitProgram.Program 8 3 13 where
inputStack := 0
outputStack := 2
entry := 0
code q := match q.val with
| 0 => .pop 0 1 3 1
| 1 => .pop 1 2 4 2
| 2 => .branch 3 4 3
| 3 => .branch 4 4 10
| 4 => .bxor 5 1 2 5
| 5 => .band 6 1 2 6
| 6 => .band 7 5 0 7
| 7 => .bxor 1 5 0 8
| 8 => .bxor 0 6 7 9
| 9 => .push 2 1 0
| 10 => .branch 0 11 12
| 11 => .push 2 0 12
| _ => .halt
def stackState (xs ys out : List Bool) : Fin 3 → List Bool :=
fun k => if k = 0 then xs else if k = 1 then ys else out
def cfg (pc : Option (Fin 13)) (r : Regs) (xs ys out : List Bool) : Config :=
⟨pc, r, stackState xs ys out⟩
@[simp] theorem stacks_zero (xs ys out : List Bool) : stackState xs ys out 0 = xs := rfl
@[simp] theorem stacks_one (xs ys out : List Bool) : stackState xs ys out 1 = ys := rfl
@[simp] theorem stacks_two (xs ys out : List Bool) : stackState xs ys out 2 = out := rfl
@[simp] theorem update_left (xs ys out next : List Bool) :
Function.update (stackState xs ys out) 0 next = stackState next ys out := by
funext k
fin_cases k <;> simp [stackState]
@[simp] theorem update_right (xs ys out next : List Bool) :
Function.update (stackState xs ys out) 1 next = stackState xs next out := by
funext k
fin_cases k <;> simp [stackState]
@[simp] theorem update_output (xs ys out next : List Bool) :
Function.update (stackState xs ys out) 2 next = stackState xs ys next := by
funext k
fin_cases k <;> simp [stackState]
def readRegisters (r : Regs) (a b : Option Bool) : Regs :=
SubexponentialSAT.BitProgram.readRegs (SubexponentialSAT.BitProgram.readRegs r 1 3 a) 2 4 b
def roundRegisters (r : Regs) (a b : Option Bool) : Regs :=
let ra := readRegisters r a b
let rt := Function.update ra 5 (ra 1 ^^ ra 2)
let ru := Function.update rt 6 (rt 1 && rt 2)
let rv := Function.update ru 7 (ru 5 && ru 0)
let rs := Function.update rv 1 (rv 5 ^^ rv 0)
Function.update rs 0 (rs 6 ^^ rs 7)
@[simp] theorem roundRegisters_carry (r : Regs) (a b : Option Bool) :
roundRegisters r a b 0 = fastCarry (a.getD false) (b.getD false) (r 0) := by
simp [roundRegisters, readRegisters, SubexponentialSAT.BitProgram.readRegs, fastCarry]
@[simp] theorem roundRegisters_sum (r : Regs) (a b : Option Bool) :
roundRegisters r a b 1 = sumBit (a.getD false) (b.getD false) (r 0) := by
simp [roundRegisters, readRegisters, SubexponentialSAT.BitProgram.readRegs, sumBit]
theorem round_left (r : Regs) (a : Bool) (xs ys out : List Bool) :
Trace (SubexponentialSAT.BitProgram.step program) 9
(cfg (some 0) r (a :: xs) ys out)
(cfg (some 0) (roundRegisters r (some a) ys.head?)
xs ys.tail (sumBit a (ys.headD false) (r 0) :: out)) := by
apply Trace.of_iterate
cases ys <;>
simp [Function.iterate_succ_apply, SubexponentialSAT.BitProgram.step, SubexponentialSAT.BitProgram.execInstr,
program, cfg, roundRegisters, readRegisters, SubexponentialSAT.BitProgram.readRegs, sumBit]
theorem round_right (r : Regs) (b : Bool) (ys out : List Bool) :
Trace (SubexponentialSAT.BitProgram.step program) 10
(cfg (some 0) r [] (b :: ys) out)
(cfg (some 0) (roundRegisters r none (some b))
[] ys (sumBit false b (r 0) :: out)) := by
apply Trace.of_iterate
simp [Function.iterate_succ_apply, SubexponentialSAT.BitProgram.step, SubexponentialSAT.BitProgram.execInstr,
program, cfg, roundRegisters, readRegisters, SubexponentialSAT.BitProgram.readRegs, sumBit]
theorem finish (r : Regs) (out : List Bool) :
SubexponentialSAT.BitProgram.RunsIn program 7 (cfg (some 0) r [] [] out)
(cfg none (readRegisters r none none) [] []
(if r 0 then true :: out else out)) := by
cases hc : r 0 with
| false =>
refine ⟨6, by decide, ?_⟩
apply Trace.of_iterate
simp [Function.iterate_succ_apply, SubexponentialSAT.BitProgram.step, SubexponentialSAT.BitProgram.execInstr,
program, cfg, readRegisters, SubexponentialSAT.BitProgram.readRegs, hc]
| true =>
refine ⟨7, le_rfl, ?_⟩
apply Trace.of_iterate
simp [Function.iterate_succ_apply, SubexponentialSAT.BitProgram.step, SubexponentialSAT.BitProgram.execInstr,
program, cfg, readRegisters, SubexponentialSAT.BitProgram.readRegs, hc]
theorem run_right (r : Regs) (ys out : List Bool) :
∃ rf : Regs, SubexponentialSAT.BitProgram.RunsIn program (10 * (ys.length + 1))
(cfg (some 0) r [] ys out)
(cfg none rf [] [] ((carryAdd (r 0) ys).reverse ++ out)) := by
induction ys generalizing r out with
| nil =>
refine ⟨readRegisters r none none, ?_⟩
have h := (finish r out).mono (show 7 ≤ 10 * (([] : List Bool).length + 1) by decide)
cases hc : r 0 <;> simpa [carryAdd, hc] using h
| cons b ys ih =>
obtain ⟨rf, hr⟩ := ih (roundRegisters r none (some b))
(sumBit false b (r 0) :: out)
have hs : SubexponentialSAT.BitProgram.RunsIn program 10
(cfg (some 0) r [] (b :: ys) out)
(cfg (some 0) (roundRegisters r none (some b))
[] ys (sumBit false b (r 0) :: out)) :=
⟨10, le_rfl, round_right r b ys out⟩
refine ⟨rf, ?_⟩
have ht := hs.trans hr
have hcost : 10 + 10 * (ys.length + 1) =
10 * ((b :: ys).length + 1) := by simp; omega
rw [hcost] at ht
simpa [carryAdd, roundRegisters_carry, fastCarry_eq, List.reverse_cons,
List.append_assoc] using ht
/-- A complete execution to the halted state, for arbitrary operand lengths. -/
theorem run (r : Regs) (xs ys out : List Bool) :
∃ rf : Regs, SubexponentialSAT.BitProgram.RunsIn program (10 * (max xs.length ys.length + 1))
(cfg (some 0) r xs ys out)
(cfg none rf [] [] ((addCarry (r 0) xs ys).reverse ++ out)) := by
induction xs generalizing r ys out with
| nil => simpa [addCarry] using run_right r ys out
| cons a xs ih =>
obtain ⟨rf, hr⟩ := ih (roundRegisters r (some a) ys.head?) ys.tail
(sumBit a (ys.headD false) (r 0) :: out)
have hs : SubexponentialSAT.BitProgram.RunsIn program 10
(cfg (some 0) r (a :: xs) ys out)
(cfg (some 0) (roundRegisters r (some a) ys.head?)
xs ys.tail (sumBit a (ys.headD false) (r 0) :: out)) :=
⟨9, by decide, round_left r a xs ys out⟩
refine ⟨rf, ?_⟩
have ht := hs.trans hr
have hcost : 10 + 10 * (max xs.length ys.tail.length + 1) =
10 * (max (a :: xs).length ys.length + 1) := by
cases ys <;> simp [max_add_add_right] <;> omega
rw [hcost] at ht
cases ys <;>
simpa [addCarry, roundRegisters_carry, fastCarry_eq, List.reverse_cons,
List.append_assoc, max_add_add_right] using ht
theorem run_value (xs ys : List Bool) :
∃ rf : Regs, ∃ output : List Bool,
BinaryArithmetic.toNat output.reverse = BinaryArithmetic.toNat xs + BinaryArithmetic.toNat ys ∧
SubexponentialSAT.BitProgram.RunsIn program (10 * (max xs.length ys.length + 1))
(cfg (some 0) (fun _ => false) xs ys [])
(cfg none rf [] [] output) := by
obtain ⟨rf, h⟩ := run (fun _ => false) xs ys []
refine ⟨rf, (add xs ys).reverse, ?_, ?_⟩
· simp
· simpa [add] using h
/-- The complete adder followed by an actual stack-transfer loop. Its output
has the same little-endian orientation as its inputs. -/
def littleEndianProgram : SubexponentialSAT.BitProgram.Program 8 3 17 :=
SubexponentialSAT.ProgramLinking.link program
(SubexponentialSAT.StackRoutines.transferProgram (2 : Fin 3) 0 (1 : Fin 8) 3)
theorem littleEndian_run (r : Regs) (xs ys : List Bool) :
∃ rf : Regs, SubexponentialSAT.BitProgram.RunsIn littleEndianProgram
(16 * (max xs.length ys.length + 1))
⟨some 0, r, stackState xs ys []⟩
⟨none, rf, stackState (addCarry (r 0) xs ys) [] []⟩ := by
obtain ⟨rf, hr⟩ := run r xs ys []
let word := addCarry (r 0) xs ys
let reverseProgram :=
SubexponentialSAT.StackRoutines.transferProgram (2 : Fin 3) 0 (1 : Fin 8) 3
have ht := SubexponentialSAT.StackRoutines.transferProgram_trace (2 : Fin 3) 0 (1 : Fin 8) 3
(by decide) (by decide) rf (stackState [] [] word.reverse)
have hh := SubexponentialSAT.StackRoutines.halt_after_trace reverseProgram ht 3 rfl rfl
have hs : SubexponentialSAT.BitProgram.RunsIn reverseProgram (3 * word.length + 3)
(SubexponentialSAT.ProgramLinking.enter reverseProgram (cfg none rf [] [] word.reverse))
⟨none, SubexponentialSAT.BitProgram.readRegs rf 1 3 none, stackState word [] []⟩ := by
refine ⟨3 * word.reverse.length + 2 + 1, by simp, ?_⟩
simpa [SubexponentialSAT.StackRoutines.transferResult, SubexponentialSAT.StackRoutines.transferStacks,
SubexponentialSAT.ProgramLinking.enter, cfg, reverseProgram,
SubexponentialSAT.StackRoutines.transferProgram] using hh
have hr' : SubexponentialSAT.BitProgram.RunsIn program (10 * (max xs.length ys.length + 1))
(cfg (some 0) r xs ys []) (cfg none rf [] [] word.reverse) := by
simpa [word] using hr
have hc := SubexponentialSAT.ProgramLinking.link_runsIn program reverseProgram hr' rfl hs
have hlen := length_addCarry (r 0) xs ys
refine ⟨SubexponentialSAT.BitProgram.readRegs rf 1 3 none, ?_⟩
apply SubexponentialSAT.Computation.RunsIn.mono ?_ (show
10 * (max xs.length ys.length + 1) + (3 * word.length + 3) ≤
16 * (max xs.length ys.length + 1) by dsimp [word]; omega)
simpa [littleEndianProgram, reverseProgram, SubexponentialSAT.ProgramLinking.relabelCfg,
SubexponentialSAT.ProgramLinking.relocatePc, SubexponentialSAT.StackRoutines.transferProgram, cfg] using hc
theorem littleEndian_value (xs ys : List Bool) :
∃ rf : Regs, ∃ output : List Bool,
BinaryArithmetic.toNat output = BinaryArithmetic.toNat xs + BinaryArithmetic.toNat ys ∧
SubexponentialSAT.BitProgram.RunsIn littleEndianProgram (16 * (max xs.length ys.length + 1))
⟨some 0, (fun _ => false), stackState xs ys []⟩
⟨none, rf, stackState output [] []⟩ := by
obtain ⟨rf, hr⟩ := littleEndian_run (fun _ => false) xs ys
exact ⟨rf, add xs ys, toNat_add xs ys, hr⟩
/-- A primitive tape execution, with one fixed compilation factor. -/
theorem primitive_value (xs ys : List Bool) :
∃ rf : Regs, ∃ output : List Bool,
BinaryArithmetic.toNat output = BinaryArithmetic.toNat xs + BinaryArithmetic.toNat ys ∧
SubexponentialSAT.Computation.RunsIn (SubexponentialSAT.BitProgram.primitive littleEndianProgram).step
(SubexponentialSAT.BitProgram.primitiveOverhead littleEndianProgram *
(16 * (max xs.length ys.length + 1)))
(SubexponentialSAT.BitProgram.primitiveCfg littleEndianProgram
⟨some 0, (fun _ => false), stackState xs ys []⟩)
(SubexponentialSAT.BitProgram.primitiveCfg littleEndianProgram
⟨none, rf, stackState output [] []⟩) := by
obtain ⟨rf, output, hv, hr⟩ := littleEndian_value xs ys
exact ⟨rf, output, hv, SubexponentialSAT.BitProgram.primitive_execution littleEndianProgram hr⟩
end Add
namespace Mul
/-- The accumulator specification matched by the fixed-control multiplier. -/
def accumulate : List Bool → List Bool → List Bool → List Bool
| [], _, acc => acc
| b :: bs, ys, acc =>
accumulate bs (false :: ys) (if b then add acc ys else acc)
theorem accumulate_value (xs ys acc : List Bool) :
BinaryArithmetic.toNat (accumulate xs ys acc) = BinaryArithmetic.toNat acc + BinaryArithmetic.toNat xs * BinaryArithmetic.toNat ys := by
induction xs generalizing ys acc with
| nil => simp [accumulate]
| cons b bs ih =>
cases b <;> simp [accumulate, ih] <;> ring
theorem accumulate_length (xs ys acc : List Bool) :
(accumulate xs ys acc).length ≤ max acc.length ys.length + xs.length := by
induction xs generalizing ys acc with
| nil => simp [accumulate]
| cons b bs ih =>
have hi := ih (false :: ys) (if b then add acc ys else acc)
cases b with
| false =>
simp only [accumulate, Bool.false_eq_true, ↓reduceIte, List.length_cons] at *
omega
| true =>
have ha := length_add acc ys
simp only [accumulate, ↓reduceIte, List.length_cons] at *
omega
abbrev Regs := Fin 8 → Bool
abbrev Config := SubexponentialSAT.BitProgram.Cfg 8 6 32
/-- The six ports are multiplier, shifted multiplicand, accumulator, copy,
copy scratch, and reversed sum. Every instruction acts on Boolean data only. -/
def program : SubexponentialSAT.BitProgram.Program 8 6 32 where
inputStack := 0
outputStack := 2
entry := 0
code q := match q.val with
| 0 => .pop 0 1 3 1
| 1 => .branch 3 2 29
| 2 => .branch 1 3 27
| 3 => .pop 1 1 3 4
| 4 => .branch 3 5 6
| 5 => .push 4 1 3
| 6 => .pop 4 1 3 7
| 7 => .branch 3 8 10
| 8 => .push 1 1 9
| 9 => .push 3 1 6
| 10 => .set 0 false 11
| 11 => .pop 2 1 3 12
| 12 => .pop 3 2 4 13
| 13 => .branch 3 15 14
| 14 => .branch 4 15 21
| 15 => .bxor 5 1 2 16
| 16 => .band 6 1 2 17
| 17 => .band 7 5 0 18
| 18 => .bxor 1 5 0 19
| 19 => .bxor 0 6 7 20
| 20 => .push 5 1 11
| 21 => .branch 0 22 23
| 22 => .push 5 0 23
| 23 => .goto 24
| 24 => .pop 5 1 3 25
| 25 => .branch 3 26 27
| 26 => .push 2 1 24
| 27 => .set 1 false 28
| 28 => .push 1 1 0
| 29 => .pop 1 1 3 30
| 30 => .branch 3 29 31
| _ => .halt
def stackState (xs ys acc cp tmp rev : List Bool) : Fin 6 → List Bool :=
![xs, ys, acc, cp, tmp, rev]
@[simp] theorem stack_0 (xs ys acc cp tmp rev : List Bool) :
stackState xs ys acc cp tmp rev 0 = xs := rfl
@[simp] theorem stack_1 (xs ys acc cp tmp rev : List Bool) :
stackState xs ys acc cp tmp rev 1 = ys := rfl
@[simp] theorem stack_2 (xs ys acc cp tmp rev : List Bool) :
stackState xs ys acc cp tmp rev 2 = acc := rfl
@[simp] theorem stack_3 (xs ys acc cp tmp rev : List Bool) :
stackState xs ys acc cp tmp rev 3 = cp := rfl
@[simp] theorem stack_4 (xs ys acc cp tmp rev : List Bool) :
stackState xs ys acc cp tmp rev 4 = tmp := rfl
@[simp] theorem stack_5 (xs ys acc cp tmp rev : List Bool) :
stackState xs ys acc cp tmp rev 5 = rev := rfl
def cfg (pc : Option (Fin 32)) (r : Regs) (xs ys acc cp tmp rev : List Bool) : Config :=
⟨pc, r, stackState xs ys acc cp tmp rev⟩
def loopCfg (r : Regs) (xs ys acc : List Bool) : Config :=
cfg (some 0) r xs ys acc [] [] []
@[simp] theorem update_0 (xs ys acc cp tmp rev next : List Bool) :
Function.update (stackState xs ys acc cp tmp rev) 0 next =
stackState next ys acc cp tmp rev := by
funext k; fin_cases k <;> simp [stackState]
@[simp] theorem update_1 (xs ys acc cp tmp rev next : List Bool) :
Function.update (stackState xs ys acc cp tmp rev) 1 next =
stackState xs next acc cp tmp rev := by
funext k; fin_cases k <;> simp [stackState]
@[simp] theorem update_2 (xs ys acc cp tmp rev next : List Bool) :
Function.update (stackState xs ys acc cp tmp rev) 2 next =
stackState xs ys next cp tmp rev := by
funext k; fin_cases k <;> simp [stackState]
@[simp] theorem update_3 (xs ys acc cp tmp rev next : List Bool) :
Function.update (stackState xs ys acc cp tmp rev) 3 next =
stackState xs ys acc next tmp rev := by
funext k; fin_cases k <;> simp [stackState]
@[simp] theorem update_4 (xs ys acc cp tmp rev next : List Bool) :
Function.update (stackState xs ys acc cp tmp rev) 4 next =
stackState xs ys acc cp next rev := by
funext k; fin_cases k <;> simp [stackState]
@[simp] theorem update_5 (xs ys acc cp tmp rev next : List Bool) :
Function.update (stackState xs ys acc cp tmp rev) 5 next =
stackState xs ys acc cp tmp next := by
funext k; fin_cases k <;> simp [stackState]
def addStack (k : Fin 3) : Fin 6 := ![2, 3, 5] k
def addLabel (k : Fin 13) : Fin 32 := ⟨k.val + 11, by omega⟩
theorem addStack_injective : Function.Injective addStack := by
intro a b h
fin_cases a <;> fin_cases b <;> simp_all [addStack]
theorem add_code : SubexponentialSAT.ProgramLinking.CodeEmbedding Add.program program
id addStack addLabel (some 24) := by
intro q
fin_cases q <;> rfl
theorem extend_addStack (xs ys acc cp tmp rev : List Bool) :
Function.extend addStack (Add.stackState acc cp rev) (stackState xs ys [] [] tmp []) =
stackState xs ys acc cp tmp rev := by
funext k
fin_cases k
· rw [Function.extend_apply']
· rfl
· rintro ⟨a, ha⟩; fin_cases a <;> simp [addStack] at ha
· rw [Function.extend_apply']
· rfl
· rintro ⟨a, ha⟩; fin_cases a <;> simp [addStack] at ha
· exact addStack_injective.extend_apply _ _ (0 : Fin 3)
· exact addStack_injective.extend_apply _ _ (1 : Fin 3)
· rw [Function.extend_apply']
· rfl
· rintro ⟨a, ha⟩; fin_cases a <;> simp [addStack] at ha
· exact addStack_injective.extend_apply _ _ (2 : Fin 3)
theorem embed_add (pc : Option (Fin 13)) (r rf : Regs)
(xs ys acc cp tmp rev : List Bool) :
SubexponentialSAT.ProgramLinking.embedCfg id addStack addLabel (some 24)
(cfg (some 0) r xs ys [] [] tmp []) (Add.cfg pc rf acc cp rev) =
cfg (SubexponentialSAT.ProgramLinking.relocatePc addLabel (some 24) pc)
rf xs ys acc cp tmp rev := by
simp [SubexponentialSAT.ProgramLinking.embedCfg, cfg, Add.cfg, extend_addStack]
/-- The adder is installed as literal instructions in this program's table. -/
theorem add_block (r : Regs) (xs ys acc cp tmp rev : List Bool) :
∃ rf : Regs, SubexponentialSAT.BitProgram.RunsIn program (10 * (max acc.length cp.length + 1))
(cfg (some 11) r xs ys acc cp tmp rev)
(cfg (some 24) rf xs ys [] [] tmp ((addCarry (r 0) acc cp).reverse ++ rev)) := by
obtain ⟨rf, hr⟩ := Add.run r acc cp rev
have ht := SubexponentialSAT.ProgramLinking.relocate_runsIn Add.program program
id addStack addLabel (some 24) (cfg (some 0) r xs ys [] [] tmp [])
Function.injective_id addStack_injective add_code hr
refine ⟨rf, ?_⟩
have hz : addLabel (0 : Fin 13) = (11 : Fin 32) := by
apply Fin.ext
simp [addLabel]
simpa only [embed_add, SubexponentialSAT.ProgramLinking.relocatePc,
hz] using ht
theorem copy_block (r : Regs) (xs ys acc : List Bool) :
SubexponentialSAT.BitProgram.Trace program (7 * ys.length + 4)
(cfg (some 3) r xs ys acc [] [] [])
(cfg (some 10) (SubexponentialSAT.BitProgram.readRegs r 1 3 none) xs ys acc ys [] []) := by
have h := SubexponentialSAT.StackRoutines.copy_trace program 1 3 4 1 3 3 4 5 6 7 8 9 10
(by decide) (by decide) (by decide) (by decide)
rfl rfl rfl rfl rfl rfl rfl r (stackState xs ys acc [] [] []) rfl
simpa [SubexponentialSAT.StackRoutines.copyResult, SubexponentialSAT.StackRoutines.copyStacks, cfg] using h
theorem transfer_block (r : Regs) (xs ys word : List Bool) :
SubexponentialSAT.BitProgram.Trace program (3 * word.length + 2)
(cfg (some 24) r xs ys [] [] [] word.reverse)
(cfg (some 27) (SubexponentialSAT.BitProgram.readRegs r 1 3 none) xs ys word [] [] []) := by
have h := SubexponentialSAT.StackRoutines.transfer_trace program 5 2 1 3 24 25 26 27
(by decide) (by decide) rfl rfl rfl r (stackState xs ys [] [] [] word.reverse)
simpa [SubexponentialSAT.StackRoutines.transferResult, SubexponentialSAT.StackRoutines.transferStacks, cfg] using h
theorem enter_round (r : Regs) (b : Bool) (xs ys acc : List Bool) :
SubexponentialSAT.BitProgram.Trace program 3 (loopCfg r (b :: xs) ys acc)
(cfg (some (if b then 3 else 27))
(SubexponentialSAT.BitProgram.readRegs r 1 3 (some b)) xs ys acc [] [] []) := by
let r' := SubexponentialSAT.BitProgram.readRegs r 1 3 (some b)
have h₁ : SubexponentialSAT.BitProgram.step program (loopCfg r (b :: xs) ys acc) =
some (cfg (some 1) r' xs ys acc [] [] []) := by
have h := SubexponentialSAT.BitProgram.step_code program (loopCfg r (b :: xs) ys acc)
0 (.pop 0 1 3 1) rfl rfl
simpa [SubexponentialSAT.BitProgram.execInstr, loopCfg, cfg, r'] using h
have h₂ : SubexponentialSAT.BitProgram.step program (cfg (some 1) r' xs ys acc [] [] []) =
some (cfg (some 2) r' xs ys acc [] [] []) := by
have h := SubexponentialSAT.BitProgram.step_code program (cfg (some 1) r' xs ys acc [] [] [])
1 (.branch 3 2 29) rfl rfl
simpa [SubexponentialSAT.BitProgram.execInstr, cfg, r', SubexponentialSAT.BitProgram.readRegs] using h
have h₃ : SubexponentialSAT.BitProgram.step program (cfg (some 2) r' xs ys acc [] [] []) =
some (cfg (some (if b then 3 else 27)) r' xs ys acc [] [] []) := by
have h := SubexponentialSAT.BitProgram.step_code program (cfg (some 2) r' xs ys acc [] [] [])
2 (.branch 1 3 27) rfl rfl
cases b <;>
simpa [SubexponentialSAT.BitProgram.execInstr, cfg, r', SubexponentialSAT.BitProgram.readRegs] using h
exact .cons h₁ (.cons h₂ (.cons h₃ (.refl _)))
theorem reset_carry (r : Regs) (xs ys acc : List Bool) :
SubexponentialSAT.BitProgram.Trace program 1 (cfg (some 10) r xs ys acc ys [] [])
(cfg (some 11) (Function.update r 0 false) xs ys acc ys [] []) := by
apply Trace.of_iterate
simp [ SubexponentialSAT.BitProgram.step, SubexponentialSAT.BitProgram.execInstr,
program, cfg]
theorem shift (r : Regs) (xs ys acc : List Bool) :
SubexponentialSAT.BitProgram.Trace program 2 (cfg (some 27) r xs ys acc [] [] [])
(loopCfg (Function.update r 1 false) xs (false :: ys) acc) := by
apply Trace.of_iterate
simp [Function.iterate_succ_apply, SubexponentialSAT.BitProgram.step, SubexponentialSAT.BitProgram.execInstr,
program, cfg, loopCfg]
/-- One full multiplier iteration, including all copy and arithmetic work. -/
theorem round (r : Regs) (b : Bool) (xs ys acc : List Bool) :
∃ rf : Regs, SubexponentialSAT.BitProgram.RunsIn program
(30 * (max acc.length ys.length + 1))
(loopCfg r (b :: xs) ys acc)
(loopCfg rf xs (false :: ys) (if b then add acc ys else acc)) := by
cases b with
| false =>
let r' := SubexponentialSAT.BitProgram.readRegs r 1 3 (some false)
have ht := (enter_round r false xs ys acc).trans (shift r' xs ys acc)
refine ⟨Function.update r' 1 false, 5, by omega, ?_⟩
exact ht
| true =>
let r₁ := SubexponentialSAT.BitProgram.readRegs r 1 3 (some true)
let r₂ := SubexponentialSAT.BitProgram.readRegs r₁ 1 3 none
let r₃ := Function.update r₂ 0 false
have hp := (enter_round r true xs ys acc).trans (copy_block r₁ xs ys acc)
have hp' := hp.trans (reset_carry r₂ xs ys acc)
obtain ⟨r₄, ha⟩ := add_block r₃ xs ys acc ys [] []
have ha' : SubexponentialSAT.BitProgram.RunsIn program (10 * (max acc.length ys.length + 1))
(cfg (some 11) r₃ xs ys acc ys [] [])
(cfg (some 24) r₄ xs ys [] [] [] (add acc ys).reverse) := by
simpa [r₃, add] using ha
let r₅ := SubexponentialSAT.BitProgram.readRegs r₄ 1 3 none
have hq := (transfer_block r₄ xs ys (add acc ys)).trans (shift r₅ xs ys (add acc ys))
have hpRun : SubexponentialSAT.BitProgram.RunsIn program (3 + (7 * ys.length + 4) + 1)
(loopCfg r (true :: xs) ys acc)
(cfg (some 11) r₃ xs ys acc ys [] []) :=
⟨_, le_rfl, hp'⟩
have hqRun : SubexponentialSAT.BitProgram.RunsIn program (3 * (add acc ys).length + 2 + 2)
(cfg (some 24) r₄ xs ys [] [] [] (add acc ys).reverse)
(loopCfg (Function.update r₅ 1 false) xs (false :: ys) (add acc ys)) :=
⟨_, le_rfl, hq⟩
refine ⟨Function.update r₅ 1 false, ?_⟩
have ht := (hpRun.trans ha').trans hqRun
have hlen := length_add acc ys
exact ht.mono (by omega)
theorem finish (r : Regs) (ys acc : List Bool) :
∃ rf : Regs, SubexponentialSAT.BitProgram.Trace program (2 * ys.length + 5)
(loopCfg r [] ys acc) (cfg none rf [] [] acc [] [] []) := by
let r₁ := SubexponentialSAT.BitProgram.readRegs r 1 3 none
have hp : SubexponentialSAT.BitProgram.Trace program 2 (loopCfg r [] ys acc)
(cfg (some 29) r₁ [] ys acc [] [] []) := by
apply Trace.of_iterate
simp [Function.iterate_succ_apply, SubexponentialSAT.BitProgram.step, SubexponentialSAT.BitProgram.execInstr,
program, cfg, loopCfg, r₁, SubexponentialSAT.BitProgram.readRegs]
have hc := SubexponentialSAT.StackRoutines.clear_trace program 1 1 3 29 30 31 rfl rfl
r₁ (stackState [] ys acc [] [] [])
have hc' : SubexponentialSAT.BitProgram.Trace program (2 * ys.length + 2)
(cfg (some 29) r₁ [] ys acc [] [] [])
(cfg (some 31) (SubexponentialSAT.BitProgram.readRegs r₁ 1 3 none) [] [] acc [] [] []) := by
simpa [SubexponentialSAT.StackRoutines.clearResult, SubexponentialSAT.StackRoutines.clearStacks, cfg] using hc
have hh := SubexponentialSAT.StackRoutines.halt_after_trace program (hp.trans hc') 31 rfl rfl
refine ⟨SubexponentialSAT.BitProgram.readRegs r₁ 1 3 none, ?_⟩
convert hh using 1 <;> simp [cfg] ; omega
/-- The complete fixed program computes the accumulator specification. The
bound counts every executed Boolean instruction and every stack operation. -/
theorem run (r : Regs) (xs ys acc : List Bool) (B : ℕ)
(hys : ys.length ≤ B) (hacc : acc.length ≤ B) :
∃ rf : Regs, SubexponentialSAT.BitProgram.RunsIn program
(30 * (xs.length + 1) * (B + xs.length + 1))
(loopCfg r xs ys acc) (cfg none rf [] [] (accumulate xs ys acc) [] [] []) := by
induction xs generalizing r ys acc B with
| nil =>
obtain ⟨rf, hf⟩ := finish r ys acc
exact ⟨rf, 2 * ys.length + 5, by simp; omega, hf⟩
| cons b xs ih =>
obtain ⟨r', hr⟩ := round r b xs ys acc
have hnext : (if b then add acc ys else acc).length ≤ B + 1 := by
have ha := length_add acc ys
cases b <;> simp <;> omega
obtain ⟨rf, hf⟩ := ih r' (false :: ys) (if b then add acc ys else acc) (B + 1)
(by simpa using Nat.succ_le_succ hys) hnext
refine ⟨rf, ?_⟩
have ht := hr.trans hf
have hb : max acc.length ys.length ≤ B := max_le hacc hys
have hcost : 30 * (max acc.length ys.length + 1) +
30 * (xs.length + 1) * (B + 1 + xs.length + 1) ≤
30 * ((b :: xs).length + 1) * (B + (b :: xs).length + 1) := by
simp only [List.length_cons]
nlinarith
exact ht.mono hcost
theorem run_value (xs ys : List Bool) :
∃ rf : Regs, ∃ output : List Bool,
BinaryArithmetic.toNat output = BinaryArithmetic.toNat xs * BinaryArithmetic.toNat ys ∧
SubexponentialSAT.BitProgram.RunsIn program (30 * (xs.length + 1) * (ys.length + xs.length + 1))
(loopCfg (fun _ => false) xs ys [])
(cfg none rf [] [] output [] [] []) := by
obtain ⟨rf, hr⟩ := run (fun _ => false) xs ys [] ys.length le_rfl (by simp)
refine ⟨rf, accumulate xs ys [], ?_, hr⟩
simpa using accumulate_value xs ys []
/-- The fixed-control multiplier also runs on the actual primitive tape
machine. Its polynomial bound contains no word-sized arithmetic operation. -/
theorem primitive_value (xs ys : List Bool) :
∃ rf : Regs, ∃ output : List Bool,
BinaryArithmetic.toNat output = BinaryArithmetic.toNat xs * BinaryArithmetic.toNat ys ∧
SubexponentialSAT.Computation.RunsIn (SubexponentialSAT.BitProgram.primitive program).step
(SubexponentialSAT.BitProgram.primitiveOverhead program *
(30 * (xs.length + 1) * (ys.length + xs.length + 1)))
(SubexponentialSAT.BitProgram.primitiveCfg program (loopCfg (fun _ => false) xs ys []))
(SubexponentialSAT.BitProgram.primitiveCfg program (cfg none rf [] [] output [] [] [])) := by
obtain ⟨rf, output, hv, hr⟩ := run_value xs ys
exact ⟨rf, output, hv, SubexponentialSAT.BitProgram.primitive_execution program hr⟩
end Mul
end SubexponentialSAT.BinaryPrograms
end OAI.Algorithms