introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
21.8 kB
import OAI.Algorithms.SubexponentialSAT.CounterPrograms
import OAI.Algorithms.SubexponentialSAT.BinaryArithmetic
import OAI.Algorithms.SubexponentialSAT.StructuredCalls
import OAI.Algorithms.SubexponentialSAT.StackRoutines
import OAI.Algorithms.SubexponentialSAT.ProgramStateFrames
import OAI.Algorithms.SubexponentialSAT.CounterForPrograms
import Mathlib.Data.List.Induction
/-! Actual floor and ceiling logarithm bit programs, without packing or schedule imports. -/
namespace OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.DisjointReuse.BinaryClogProgram.Floor
open OAI.Algorithms.SubexponentialSAT.BitProgram
open OAI.Algorithms.SubexponentialSAT.CounterPrograms
theorem value_eq_toNat (xs : List Bool) : value xs = BinaryArithmetic.toNat xs := by
induction xs with
| nil => rfl
| cons b xs ih => cases b <;> simp [value, BinaryArithmetic.toNat,
BinaryArithmetic.bitVal, ih]
theorem value_append (xs ys : List Bool) :
value (xs ++ ys) = value xs + 2 ^ xs.length * value ys := by
induction xs with
| nil => simp [value]
| cons b xs ih =>
simp only [List.cons_append, value, List.length_cons, ih, pow_succ]
ring
theorem value_lt_two_pow_length (xs : List Bool) : value xs < 2 ^ xs.length := by
induction xs with
| nil => simp [value]
| cons b xs ih =>
cases b <;> simp only [value, Bool.toNat_false, Bool.toNat_true,
List.length_cons, pow_succ] <;> omega
/-- Consume leading zeroes and the first one of a most-significant-first word. -/
def trimTail : List Bool → List Bool
| [] => []
| false :: xs => trimTail xs
| true :: xs => xs
theorem trimTail_length_le (xs : List Bool) : (trimTail xs).length ≤ xs.length := by
induction xs with
| nil => simp [trimTail]
| cons b xs ih => cases b <;> simp [trimTail]; omega
/-- A most-significant one followed by `m` bits has binary logarithm `m`. -/
theorem log2_value_append_true (xs : List Bool) :
Nat.log2 (value (xs ++ [true])) = xs.length := by
have hbound := value_lt_two_pow_length xs
have hpow : 0 < 2 ^ xs.length := Nat.two_pow_pos _
have hval : value (xs ++ [true]) = value xs + 2 ^ xs.length := by
simp [value_append, value]
have hpos : value (xs ++ [true]) ≠ 0 := by omega
apply Nat.le_antisymm
· have hlt : value (xs ++ [true]) < 2 ^ (xs.length + 1) := by
rw [pow_succ]
omega
have h := (Nat.log2_lt hpos).mpr hlt
omega
· exact (Nat.le_log2 hpos).mpr (by omega)
theorem trimTail_reverse_length (xs : List Bool) :
(trimTail xs.reverse).length = Nat.log2 (value xs) := by
induction xs using List.reverseRecOn with
| nil => simp [trimTail, value]
| append_singleton xs b ih =>
cases b with
| false => simpa [List.reverse_append, trimTail, value_append, value] using ih
| true => simp [List.reverse_append, trimTail, log2_value_append_true]
def atoms {r s : ℕ} : List (StructuredProgram.Atom r s) → StructuredProgram.Cmd r s
| [] => .skip
| op :: ops => .seq (.atom op) (atoms ops)
def runAtoms {r s : ℕ} : List (StructuredProgram.Atom r s) →
StructuredProgram.State r s → StructuredProgram.State r s
| [], d => d
| op :: ops, d => runAtoms ops (op.eval d)
theorem atoms_eval {r s : ℕ} (ops : List (StructuredProgram.Atom r s))
(d : StructuredProgram.State r s) :
StructuredProgram.Eval (atoms ops) ops.length d (runAtoms ops d) := by
induction ops generalizing d with
| nil => exact .skip d
| cons op ops ih =>
simpa only [atoms, runAtoms, List.length_cons, Nat.add_comm 1] using
StructuredProgram.Eval.seq (.atom op d) (ih (op.eval d))
/-- Four low bits are discarded; the two read registers are then cleared. -/
def trimProgram : Program 3 3 6 where
inputStack := 1
outputStack := 1
entry := 0
code q := match q.val with
| 0 => .pop 1 0 1 1
| 1 => .branch 1 2 3
| 2 => .branch 0 3 0
| 3 => .set 0 false 4
| 4 => .set 1 false 5
| _ => .halt
def trimCfg (pc : Option (Fin 6)) (b present : Bool) (xs : List Bool) : Cfg 3 3 6 :=
⟨pc, counterRegs b present false, lengthStacks [] xs []⟩
@[simp] theorem update_lengthStacks_one (a b c d : List Bool) :
Function.update (lengthStacks a b c) 1 d = lengthStacks a d c := by
funext i
fin_cases i <;> simp [lengthStacks]
theorem trim_finish (b present : Bool) (xs : List Bool) :
Trace trimProgram 3 (trimCfg (some 3) b present xs) (trimCfg none false false xs) := by
refine .cons (b := trimCfg (some 4) false present xs) ?_
(.cons (b := trimCfg (some 5) false false xs) ?_ (.cons ?_ (.refl _)))
all_goals simp [step, trimProgram, trimCfg, execInstr]
def trimCost : List Bool → ℕ
| [] => 5
| false :: xs => trimCost xs + 3
| true :: _ => 6
theorem trim_trace (xs : List Bool) (b present : Bool) :
Trace trimProgram (trimCost xs) (trimCfg (some 0) b present xs)
(trimCfg none false false (trimTail xs)) := by
induction xs generalizing b present with
| nil =>
refine .cons (b := trimCfg (some 1) false false []) ?_
(.cons ?_ (trim_finish false false []))
all_goals simp [step, trimProgram, trimCfg, execInstr, readRegs]
| cons a xs ih =>
cases a with
| false =>
refine .cons (b := trimCfg (some 1) false true xs) ?_
(.cons (b := trimCfg (some 2) false true xs) ?_
(.cons ?_ (ih false true)))
all_goals simp [step, trimProgram, trimCfg, execInstr, readRegs]
| true =>
refine .cons (b := trimCfg (some 1) true true xs) ?_
(.cons (b := trimCfg (some 2) true true xs) ?_
(.cons ?_ (trim_finish true true xs)))
all_goals simp [step, trimProgram, trimCfg, execInstr, readRegs]
theorem trimCost_le (xs : List Bool) : trimCost xs ≤ 3 * xs.length + 6 := by
induction xs with
| nil => simp [trimCost]
| cons a xs ih => cases a <;> simp only [trimCost, List.length_cons] <;> omega
theorem trim_complete_trace (xs : List Bool) :
Trace trimProgram (trimCost xs) (initial trimProgram xs)
(terminal trimProgram (trimTail xs)) := by
have hi : initial trimProgram xs = trimCfg (some 0) false false xs := by
simp [initial, trimProgram, trimCfg]
constructor <;> funext i <;> fin_cases i <;> simp [counterRegs, lengthStacks]
have ht : terminal trimProgram (trimTail xs) = trimCfg none false false (trimTail xs) := by
simp [terminal, trimProgram, trimCfg]
constructor <;> funext i <;> fin_cases i <;> simp [counterRegs, lengthStacks]
rw [hi, ht]
exact trim_trace xs false false
theorem trim_complete_runs (xs : List Bool) :
RunsIn trimProgram (3 * xs.length + 6) (initial trimProgram xs)
(terminal trimProgram (trimTail xs)) :=
⟨trimCost xs, trimCost_le xs, trim_complete_trace xs⟩
/-! ## Concrete input reversal -/
def reverseTransfer : Program 3 3 4 := StackRoutines.transferProgram 0 1 0 1
theorem reverseTransfer_trace (xs : List Bool) :
Trace reverseTransfer (3 * xs.length + 3) (initial reverseTransfer xs)
(terminal reverseTransfer xs.reverse) := by
have h := StackRoutines.transferProgram_trace (r := 3) (s := 3)
0 1 0 1 (by decide) (by decide) (fun _ => false)
(fun i => if i = 0 then xs else [])
have ht : StackRoutines.transferResult (3 : Fin 4) (0 : Fin 3) 1 (0 : Fin 3) 1
(fun _ => false) (fun i => if i = 0 then xs else []) =
{terminal reverseTransfer xs.reverse with pc := some 3} := by
simp [StackRoutines.transferResult, StackRoutines.transferStacks,
reverseTransfer, StackRoutines.transferProgram, readRegs]
funext i
fin_cases i <;> simp
have hh : Trace reverseTransfer 1
{terminal reverseTransfer xs.reverse with pc := some 3}
(terminal reverseTransfer xs.reverse) := by
refine .cons ?_ (.refl _)
simp [step, reverseTransfer, StackRoutines.transferProgram, execInstr, terminal]
rw [ht] at h
change Trace reverseTransfer (3 * xs.length + 2) (initial reverseTransfer xs)
{terminal reverseTransfer xs.reverse with pc := some 3} at h
exact h.trans hh
theorem enter_terminal_eq_initial {r s l m : ℕ}
(p : Program r s l) (q : Program r s m) (h : p.outputStack = q.inputStack)
(word : List Bool) :
ProgramLinking.enter q (terminal p word) = initial q word := by
simp [ProgramLinking.enter, initial, h]
theorem link_io_runs {r s l m n₁ n₂ : ℕ}
(p : Program r s l) (q : Program r s m) (h : p.outputStack = q.inputStack)
(input middle output : List Bool)
(hp : RunsIn p n₁ (initial p input) (terminal p middle))
(hq : RunsIn q n₂ (initial q middle) (terminal q output)) :
RunsIn (ProgramLinking.link p q) (n₁ + n₂)
(initial (ProgramLinking.link p q) input)
(terminal (ProgramLinking.link p q) output) := by
exact ProgramLinking.link_complete_runsIn p q input output hp rfl
(by simpa only [enter_terminal_eq_initial p q h middle] using hq)
def prepareLogProgram : Program 3 3 10 := ProgramLinking.link reverseTransfer trimProgram
theorem prepareLog_runs (xs : List Bool) :
RunsIn prepareLogProgram (6 * xs.length + 9)
(initial prepareLogProgram xs)
(terminal prepareLogProgram (trimTail xs.reverse)) := by
have h := link_io_runs reverseTransfer trimProgram rfl xs xs.reverse
(trimTail xs.reverse) ⟨_, le_rfl, reverseTransfer_trace xs⟩
(trim_complete_runs xs.reverse)
change RunsIn (ProgramLinking.link reverseTransfer trimProgram) (6 * xs.length + 9)
(initial (ProgramLinking.link reverseTransfer trimProgram) xs)
(terminal (ProgramLinking.link reverseTransfer trimProgram) (trimTail xs.reverse))
convert h using 1
rw [List.length_reverse]
omega
/-! ## Reindex and call the checked binary word-length counter -/
theorem extend_equiv {α β γ : Type*} (e : α ≃ β) (f : α → γ) (frame : β → γ) :
Function.extend e f frame = fun b => f (e.symm b) := by
funext b
simp
theorem lift_equiv_initial {r s l : ℕ} (p : Program r s l) (e : Fin s ≃ Fin s)
(frame : Cfg r s l) (word : List Bool) :
ProgramLinking.embedCfg id e id none frame (initial p word) =
initial (ProgramLinking.liftProgram p id e) word := by
simp [ProgramLinking.embedCfg, ProgramLinking.relocatePc, initial,
extend_equiv]
funext b
simp only [e.symm_apply_eq]
theorem lift_equiv_terminal {r s l : ℕ} (p : Program r s l) (e : Fin s ≃ Fin s)
(frame : Cfg r s l) (word : List Bool) :
ProgramLinking.embedCfg id e id none frame (terminal p word) =
terminal (ProgramLinking.liftProgram p id e) word := by
simp [ProgramLinking.embedCfg, ProgramLinking.relocatePc, terminal,
extend_equiv]
funext b
simp only [e.symm_apply_eq]
def swapStacks : Equiv.Perm (Fin 3) := Equiv.swap 0 1
def swappedLengthProgram : Program 3 3 14 :=
ProgramLinking.liftProgram lengthProgram id swapStacks
theorem swappedLength_correct (xs : List Bool) :
∃ output, value output = xs.length ∧ output.length ≤ xs.length ∧
RunsIn swappedLengthProgram (xs.length * (8 * xs.length + 10) + 3)
(initial swappedLengthProgram xs) (terminal swappedLengthProgram output) := by
obtain ⟨output, hvalue, hlen, hrun⟩ := length_correct xs
have h := ProgramLinking.liftProgram_runsIn lengthProgram id swapStacks
(initial swappedLengthProgram []) Function.injective_id swapStacks.injective hrun
refine ⟨output, hvalue, hlen, ?_⟩
simpa only [swappedLengthProgram, lift_equiv_initial, lift_equiv_terminal] using h
def logProgram : Program 3 3 24 := ProgramLinking.link prepareLogProgram swappedLengthProgram
def logBound (L : ℕ) : ℕ := L * (8 * L + 16) + 12
theorem logBound_eq (L : ℕ) : logBound L = 8 * L ^ 2 + 16 * L + 12 := by
unfold logBound
ring
theorem logBound_mono {L M : ℕ} (h : L ≤ M) : logBound L ≤ logBound M := by
exact Nat.add_le_add_right (Nat.mul_le_mul h (by omega : 8 * L + 16 ≤ 8 * M + 16)) 12
/-- Actual fixed-table logarithm program, correct for arbitrary padded words. -/
theorem log_correct (xs : List Bool) :
∃ output, value output = Nat.log2 (value xs) ∧ output.length ≤ xs.length ∧
RunsIn logProgram (logBound xs.length)
(initial logProgram xs) (terminal logProgram output) := by
obtain ⟨output, hvalue, hlen, hcount⟩ := swappedLength_correct (trimTail xs.reverse)
have hrun := link_io_runs prepareLogProgram swappedLengthProgram rfl
xs (trimTail xs.reverse) output (prepareLog_runs xs) hcount
have htail : (trimTail xs.reverse).length ≤ xs.length := by
simpa using trimTail_length_le xs.reverse
refine ⟨output, hvalue.trans (trimTail_reverse_length xs), hlen.trans htail, hrun.mono ?_⟩
have hmul := Nat.mul_le_mul htail
(show 8 * (trimTail xs.reverse).length + 10 ≤ 8 * xs.length + 10 by omega)
dsimp [logBound]
nlinarith
end OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.DisjointReuse.BinaryClogProgram.Floor
namespace OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.DisjointReuse.BinaryClogProgram.Setup
open BitProgram StructuredCalls
open CounterPrograms (value ripple)
abbrev Data := StructuredProgram.State 3 3
abbrev io (xs : List Bool) : Data := StructuredProgram.ioState 0 xs
def incrementPorts : Fin 2 → Fin 3 := ![0, 1]
theorem incrementPorts_injective : Function.Injective incrementPorts := by
intro i j h
fin_cases i <;> fin_cases j <;> simp_all [incrementPorts]
def increment : Cmd 3 3 :=
.call (ProgramLinking.liftProgram (CounterPrograms.rippleProgram true) id incrementPorts)
theorem increment_eval (xs : List Bool) :
Eval increment (CounterPrograms.rippleCost true xs + 1) (io xs) (io (ripple true xs)) := by
have he := eval_call_lifted (CounterPrograms.rippleProgram true) id incrementPorts
(io xs) Function.injective_id incrementPorts_injective
(a := StructuredProgram.ioState (0 : Fin 2) xs)
(b := StructuredProgram.ioState (0 : Fin 2) (ripple true xs))
(CounterPrograms.ripple_terminal_trace true xs)
have ha : embedState id incrementPorts (io xs)
(StructuredProgram.ioState (0 : Fin 2) xs) = io xs := by
apply embedState_eq_of_ports _ _ _ _ _ Function.injective_id incrementPorts_injective
· intro i; rfl
· intro i hi; exact False.elim (hi ⟨i, rfl⟩)
· intro i; fin_cases i <;> rfl
· intro i hi; rfl
have hb : embedState id incrementPorts (io xs)
(StructuredProgram.ioState (0 : Fin 2) (ripple true xs)) = io (ripple true xs) := by
apply embedState_eq_of_ports _ _ _ _ _ Function.injective_id incrementPorts_injective
· intro i; rfl
· intro i hi; exact False.elim (hi ⟨i, rfl⟩)
· intro i; fin_cases i <;> rfl
· intro i hi
fin_cases i <;> simp_all [incrementPorts, io, StructuredProgram.ioState,
Fin.exists_fin_succ]
change Eval increment _ (embedState id incrementPorts (io xs)
(StructuredProgram.ioState (0 : Fin 2) xs))
(embedState id incrementPorts (io xs)
(StructuredProgram.ioState (0 : Fin 2) (ripple true xs))) at he
simpa only [increment, ha, hb] using he
def logarithm : Cmd 3 3 := .call Floor.logProgram
theorem logarithm_eval (xs : List Bool) :
∃ output t, value output = Nat.log2 (value xs) ∧ output.length ≤ xs.length ∧
t ≤ Floor.logBound xs.length ∧
Eval logarithm t (io xs) (io output) := by
obtain ⟨output, hv, hl, t, ht, he⟩ := Floor.log_correct xs
exact ⟨output, t, hv, hl, ht, .call _ he⟩
/-- The floor binary logarithm plus one, with zero mapped to one. -/
def logSucc : Cmd 3 3 := .seq logarithm increment
theorem logSucc_eval (xs : List Bool) :
∃ output t, value output = Nat.log2 (value xs) + 1 ∧ output.length ≤ xs.length + 1 ∧
t ≤ 32 * (xs.length + 1)^2 ∧ Eval logSucc t (io xs) (io output) := by
obtain ⟨ys, t, hv, hl, ht, he⟩ := logarithm_eval xs
refine ⟨ripple true ys, t + (CounterPrograms.rippleCost true ys + 1), ?_, ?_, ?_,
he.seq (increment_eval ys)⟩
· rw [CounterPrograms.value_increment, hv]
· exact (CounterPrograms.ripple_length_le true ys).trans (by omega)
· have hc := CounterPrograms.rippleCost_le true ys
rw [Floor.logBound_eq] at ht
nlinarith
end OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.DisjointReuse.BinaryClogProgram.Setup
namespace OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.DisjointReuse.BinaryClogProgram
open BitProgram StructuredCalls
open CounterPrograms (value ripple)
abbrev Data := StructuredProgram.State 3 3
abbrev io := Setup.io
def decrement : Cmd 3 3 :=
.call (ProgramLinking.liftProgram (CounterPrograms.rippleProgram false)
id Setup.incrementPorts)
theorem decrement_eval (xs : List Bool) :
Eval decrement (CounterPrograms.rippleCost false xs + 1)
(io xs) (io (ripple false xs)) := by
have he := eval_call_lifted (CounterPrograms.rippleProgram false) id
Setup.incrementPorts (io xs) Function.injective_id Setup.incrementPorts_injective
(a := StructuredProgram.ioState (0 : Fin 2) xs)
(b := StructuredProgram.ioState (0 : Fin 2) (ripple false xs))
(CounterPrograms.ripple_terminal_trace false xs)
have ha : embedState id Setup.incrementPorts (io xs)
(StructuredProgram.ioState (0 : Fin 2) xs) = io xs := by
apply embedState_eq_of_ports _ _ _ _ _ Function.injective_id Setup.incrementPorts_injective
· intro i; rfl
· intro i hi; exact False.elim (hi ⟨i, rfl⟩)
· intro i; fin_cases i <;> rfl
· intro i hi; rfl
have hb : embedState id Setup.incrementPorts (io xs)
(StructuredProgram.ioState (0 : Fin 2) (ripple false xs)) = io (ripple false xs) := by
apply embedState_eq_of_ports _ _ _ _ _ Function.injective_id Setup.incrementPorts_injective
· intro i; rfl
· intro i hi; exact False.elim (hi ⟨i, rfl⟩)
· intro i; fin_cases i <;> rfl
· intro i hi
fin_cases i <;> simp_all [Setup.incrementPorts, io, Setup.io,
StructuredProgram.ioState, Fin.exists_fin_succ]
simpa only [decrement, ha, hb] using he
def zeroPorts : CounterForPrograms.Ports 3 3 where
register := Function.Embedding.refl _
counter := 0
scratch := 1
counter_ne_scratch := by decide
def reset : Cmd 3 3 := .base (Floor.atoms
[.set 0 false, .set 1 false, .set 2 false])
theorem reset_eval (d : Data) : Eval reset 3 d ⟨fun _ => false, d.stacks⟩ := by
have h := Floor.atoms_eval
([.set 0 false, .set 1 false, .set 2 false] : List (StructuredProgram.Atom 3 3)) d
convert Eval.base h using 1
· rfl
· apply congrArg₂ StructuredProgram.State.mk
· funext i; fin_cases i <;> rfl
· rfl
def command : Cmd 3 3 := .seq decrement
(.seq (CounterForPrograms.zeroCmd zeroPorts)
(.ite 2 reset (.seq reset Setup.logSucc)))
theorem clog_eq_log_pred (t : ℕ) (ht : 2 ≤ t) :
Nat.clog 2 t = Nat.log2 (t-1) + 1 := by
rw [Nat.log2_eq_log_two]
apply Nat.le_antisymm
· apply (Nat.le_pow_iff_clog_le (by decide : 1 < 2)).mp
have hp := Nat.lt_pow_succ_log_self (by decide : 1 < 2) (t-1)
omega
· have hp := Nat.pow_log_le_self 2 (show t-1 ≠ 0 by omega)
have hlt : 2 ^ Nat.log 2 (t-1) < t := by omega
have hh := (Nat.pow_lt_iff_lt_clog (by decide : 1 < 2)).mp hlt
omega
private theorem zero_branch_cost_le (r L : ℕ) (hr : r ≤ 8 * L + 7) :
(r + 1) + ((8 * L + 6) + (3 + 1)) ≤ 64 * (L + 2) ^ 2 := by
nlinarith
private theorem nonzero_branch_cost_le (r t L : ℕ) (hr : r ≤ 8 * L + 7)
(ht : t ≤ 32 * (L + 1) ^ 2) :
(r + 1) + ((8 * L + 6) + ((3 + t) + 1)) ≤ 64 * (L + 2) ^ 2 := by
nlinarith
theorem command_eval (xs : List Bool) (hx : 0 < value xs) :
∃ output n, value output = Nat.clog 2 (value xs) ∧
output.length ≤ xs.length + 1 ∧ n ≤ 64*(xs.length+2)^2 ∧
Eval command n (io xs) (io output) := by
let ys := ripple false xs
let z := CounterForPrograms.zeroResult zeroPorts (io ys)
have hy : value ys = value xs - 1 := by
have h := CounterPrograms.value_decrement hx
dsimp [ys]
omega
have hlen : ys.length = xs.length := CounterPrograms.decrement_length hx
have hz := CounterForPrograms.zero_eval zeroPorts (io ys) (by rfl)
have hzs : z.stacks = (io ys).stacks := by
exact CounterForPrograms.install_stacks_self zeroPorts (io ys) _ _ _ rfl
have hzf : z.regs 2 = CounterPrograms.isZero ys := by
exact CounterForPrograms.install_register zeroPorts (io ys) _ _ _ _ _ 2
have hr : Eval reset 3 z (io ys) := by
simpa only [hzs] using reset_eval z
have hc := CounterPrograms.rippleCost_le false xs
by_cases hzero : value ys = 0
· have ht : value xs = 1 := by omega
have hb : z.regs 2 = true := hzf.trans ((CounterPrograms.isZero_eq_true_iff ys).mpr hzero)
refine ⟨ys, (CounterPrograms.rippleCost false xs+1)+((8*ys.length+6)+(3+1)), ?_, ?_, ?_, ?_⟩
· simp [hzero, ht]
· omega
· rw [hlen]
exact zero_branch_cost_le _ _ hc
· exact (decrement_eval xs).seq (hz.seq (Eval.ite_true hb hr))
· obtain ⟨out,n,hv,hl,hn,he⟩ := Setup.logSucc_eval ys
have hb : z.regs 2 = false := hzf.trans
((CounterPrograms.isZero_eq_false_iff ys).mpr (by omega))
refine ⟨out,(CounterPrograms.rippleCost false xs+1)+((8*ys.length+6)+((3+n)+1)), ?_, ?_, ?_, ?_⟩
· rw [hv, hy, clog_eq_log_pred _ (by omega)]
· omega
· rw [hlen] at hn ⊢
exact nonzero_branch_cost_le _ _ _ hc hn
· exact (decrement_eval xs).seq (hz.seq (Eval.ite_false hb (hr.seq he)))
def program := compiled command 0 0
theorem program_runs (xs : List Bool) (hx : 0 < value xs) :
∃ output, value output = Nat.clog 2 (value xs) ∧
output.length ≤ xs.length+1 ∧
RunsIn program (65*(xs.length+2)^2)
(initial program xs) (terminal program output) := by
obtain ⟨out,n,hv,hl,hn,he⟩ := command_eval xs hx
exact ⟨out,hv,hl,n+1,by nlinarith,compiled_io_trace 0 0 he⟩
end OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.DisjointReuse.BinaryClogProgram