math / data /lean /OAI /Algorithms /SubexponentialSAT /BitProgramSpace.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
3.41 kB
import OAI.Algorithms.SubexponentialSAT.LeanCompat
import OAI.Algorithms.SubexponentialSAT.BitProgram
namespace OAI.Algorithms
/-! Data-size bounds for the concrete Boolean-stack machine. A single
instruction can allocate at most one new bit. These bounds concern the actual
configurations on measured traces, not an auxiliary cost annotation. -/
namespace SubexponentialSAT.BitProgram
open scoped BigOperators
def stackBits {s : ℕ} (stk : Fin s → List Bool) : ℕ :=
∑ k, (stk k).length
theorem stackBits_update {s : ℕ} (stk : Fin s → List Bool) (k : Fin s)
(word : List Bool) :
stackBits (Function.update stk k word) + (stk k).length = stackBits stk + word.length := by
have lengths : (fun i => (Function.update stk k word i).length) =
Function.update (fun i => (stk i).length) k word.length := by
funext i
by_cases hi : i = k
· subst i
simp
· simp only [Function.update_of_ne hi]
unfold stackBits
rw [lengths, Finset.sum_update_of_mem (Finset.mem_univ k), Finset.sdiff_singleton_eq_erase]
have hsum := Finset.sum_erase_add Finset.univ (fun i => (stk i).length) (Finset.mem_univ k)
omega
def dataBits {r s l : ℕ} (c : Cfg r s l) : ℕ := stackBits c.stacks
theorem execInstr_dataBits {r s l : ℕ} (i : Instr r s l) (c : Cfg r s l) :
dataBits (execInstr i c) ≤ dataBits c + 1 := by
cases i <;> try simp [dataBits, execInstr]
· rename_i stack src next
have h := stackBits_update c.stacks stack (c.regs src :: c.stacks stack)
simp only [List.length_cons] at h
change stackBits (Function.update c.stacks stack (c.regs src :: c.stacks stack)) ≤ _
omega
· rename_i stack value present next
have h := stackBits_update c.stacks stack (c.stacks stack).tail
have htail : (c.stacks stack).tail.length ≤ (c.stacks stack).length := by
cases c.stacks stack <;> simp
change stackBits (Function.update c.stacks stack (c.stacks stack).tail) ≤ _
omega
theorem step_dataBits {r s l : ℕ} (p : Program r s l) {a b : Cfg r s l}
(h : step p a = some b) : dataBits b ≤ dataBits a + 1 := by
cases hp : a.pc with
| none => simp [step, hp] at h
| some label =>
simp [step, hp] at h
rw [← h]
exact execInstr_dataBits _ _
theorem trace_dataBits {r s l : ℕ} (p : Program r s l) {a b : Cfg r s l} {n : ℕ}
(h : Trace p n a b) : dataBits b ≤ dataBits a + n := by
induction h with
| refl a => simp
| cons hs ht ih =>
have hstep := step_dataBits p hs
omega
theorem runsIn_dataBits {r s l : ℕ} (p : Program r s l) {a b : Cfg r s l} {n : ℕ}
(h : RunsIn p n a b) : dataBits b ≤ dataBits a + n := by
obtain ⟨t, ht, htrace⟩ := h
exact (trace_dataBits p htrace).trans (Nat.add_le_add_left ht _)
@[simp] theorem initial_dataBits {r s l : ℕ} (p : Program r s l) (input : List Bool) :
dataBits (initial p input) = input.length := by
simp only [dataBits, stackBits ]
have lengths (k : Fin s) : (if k = p.inputStack then input else []).length =
if k = p.inputStack then input.length else 0 := by split_ifs <;> rfl
simp_rw [lengths]
simp
theorem input_runsIn_dataBits {r s l : ℕ} (p : Program r s l)
{input : List Bool} {b : Cfg r s l} {n : ℕ}
(h : RunsIn p n (initial p input) b) : dataBits b ≤ input.length + n := by
simpa using runsIn_dataBits p h
end SubexponentialSAT.BitProgram
end OAI.Algorithms