math / data /lean /OAI /Algorithms /SubexponentialSAT /SqrtLogSpace /DisjointReuse /BinaryClogProgram.lean
Download data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLogSpace/DisjointReuse/BinaryClogProgram.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 21.8 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLogSpace/DisjointReuse/BinaryClogProgram.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLogSpace/DisjointReuse/BinaryClogProgram.lean
-
curl -L -o BinaryClogProgram.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLogSpace/DisjointReuse/BinaryClogProgram.lean
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 | |