| import Mathlib |
| import OAI.Computability.MaxCut.Estimates.Put |
|
|
| namespace OAI |
|
|
| noncomputable section |
| namespace OptimalMaxCut.CounterMachine.Expr |
| open scoped BigOperators |
| open Finset Command |
|
|
| theorem correct_sum {b f : Expr} (hcb : Correct b) (hcf : Correct f) : Correct (.sum b f) := by |
| intro vars k d M hv hc hb hi ha |
| let args := fun i => d.reg (vars i) |
| let B := b.eval d.input args |
| let F := fun i => f.eval d.input (bind args i) |
| let V := b.valueBudget M |
| let W := f.valueBudget (M+V) |
| let T := f.timeBudget (M+V) |
| have hB : B ≤ V := b.eval_le d.input args M hi ha |
| have hF : ∀ i < B, F i ≤ W := by |
| intro i hi' |
| apply f.eval_le |
| · omega |
| · intro j; cases j with |
| | zero => dsimp [bind]; omega |
| | succ j => exact (ha j).trans (by omega) |
| let state : ℕ → Data ℕ := fun i => |
| ((d.set k (∑ j ∈ range (B-i), F j)).set (k+1) i).set (k+2) (B-i) |
| have hz : ∀ r, k ≤ r → d.reg r = 0 := hc |
| have hbnd := hcb vars (k+1) d M (fun i => by have := hv i; omega) |
| (hc.mono (by omega)) hb hi ha |
| have hstart : state B = d.set (k+1) B := by |
| simp only [state, Nat.sub_self, range_zero, sum_empty] |
| rw [Data.set_clean_zero hc le_rfl] |
| exact Data.set_clean_zero ((hc.mono (by omega)).set_succ B) le_rfl |
| have hloop : Within (.loop (k+1) (.seq (compile (bind vars (k+2)) (k+3) f) |
| (.seq (move (k+3) k) (.inc (k+2))))) (state B) (state 0) (B*(T+2*W+3)+1) := by |
| apply (Within.loop (k+1) _ state B (T+2*W+2)) |
| · intro i hi' |
| simp [state, Data.set] |
| · intro i hi' |
| let j := B-(i+1) |
| let e := decData (state (i+1)) (k+1) |
| have hj : j < B := by dsimp [j]; omega |
| have hindex : B-i = j+1 := by dsimp [j]; omega |
| have heclean : e.Clean (k+3) := by |
| intro r hr |
| have h0 : r ≠ k := by omega |
| have h1 : r ≠ k+1 := by omega |
| have h2 : r ≠ k+2 := by omega |
| simp [e, decData, state, Data.set, h0, h1, h2, hc r (by omega)] |
| have henv : (fun u => e.reg (bind vars (k+2) u)) = bind args j := by |
| funext u |
| cases u with |
| | zero => simp [e, decData, state, Data.set, bind, j] |
| | succ u => |
| have h0 : vars u ≠ k := by have := hv u; omega |
| have h1 : vars u ≠ k+1 := by have := hv u; omega |
| have h2 : vars u ≠ k+2 := by have := hv u; omega |
| simp [e, decData, state, Data.set, bind, args, h0, h1, h2] |
| have heargs : ∀ u, e.reg (bind vars (k+2) u) ≤ M+V := by |
| intro u |
| change (fun u => e.reg (bind vars (k+2) u)) u ≤ M+V |
| rw [henv] |
| cases u with |
| | zero => dsimp [bind]; omega |
| | succ u => exact (ha u).trans (by omega) |
| have hf := hcf (bind vars (k+2)) (k+3) e (M+V) |
| (fun u => by cases u with |
| | zero => dsimp [bind]; omega |
| | succ u => dsimp [bind]; have := hv u; omega) heclean hb (by exact hi.trans (by omega)) heargs |
| rw [henv] at hf |
| change Within _ e (e.set (k+3) (F j)) T at hf |
| have hm := Within.move (e.set (k+3) (F j)) (k+3) k (by omega) |
| let out := (((e.set (k+3) (F j)).set (k+3) 0).set k |
| ((e.set (k+3) (F j)).reg k+(e.set (k+3) (F j)).reg (k+3))) |
| have hh := hf.seq (hm.seq (Within.inc out (k+2))) |
| have hsum : (∑ u ∈ range (B-i), F u) = (∑ u ∈ range j, F u)+F j := by |
| rw [hindex, sum_range_succ] |
| have hout : incData out (k+2) = state i := by |
| apply Data.ext |
| · ext u |
| have hz3 := hc (k+3) (by omega) |
| by_cases h0 : u = k <;> by_cases h1 : u = k+1 <;> |
| by_cases h2 : u = k+2 <;> by_cases h3 : u = k+3 <;> |
| simp [out, e, state, Data.set, incData, decData, |
| h0, h1, h2, h3, j, hsum, hz3] <;> omega |
| all_goals rfl |
| rw [hout] at hh |
| apply hh.mono |
| simp only [Data.set_reg_same] |
| have := hF j hj |
| omega |
| rw [hstart] at hloop |
| have hclear := Within.clear (state 0) (k+2) |
| have hout : (state 0).set (k+2) 0 = d.set k (∑ j ∈ range B, F j) := by |
| dsimp only [state] |
| rw [Data.set_set] |
| apply Data.ext |
| · ext u |
| have hz1 := hc (k+1) (by omega) |
| have hz2 := hc (k+2) (by omega) |
| by_cases h0 : u = k <;> by_cases h1 : u = k+1 <;> by_cases h2 : u = k+2 <;> |
| simp [Data.set, h0, h1, h2, hz1, hz2] |
| all_goals rfl |
| rw [hout] at hclear |
| have hclear' : Within (clear (k+2)) (state 0) (d.set k (∑ j ∈ range B, F j)) (2*B+1) := by |
| simpa [state, Data.set] using hclear |
| have hh := hbnd.seq (hloop.seq hclear') |
| apply hh.mono |
|
|
| change _ ≤ b.timeBudget M+V*(T+2*W+3)+2*V+2 |
| have ht := Nat.mul_le_mul_right (T+2*W+3) hB |
| omega |
|
|
| theorem correct (e : Expr) : Correct e := by |
| induction e with |
| | const n => exact correct_const n |
| | arg i => exact correct_arg i |
| | length => exact correct_length |
| | bit a ih => exact correct_bit ih |
| | add a b ia ib => exact correct_add ia ib |
| | sub a b ia ib => exact correct_sub ia ib |
| | mul a b ia ib => exact correct_mul ia ib |
| | zero a ih => exact correct_zero ih |
| | sum b f ib iF => exact correct_sum ib iF |
|
|
| end OptimalMaxCut.CounterMachine.Expr |
|
|
| namespace OptimalMaxCut.CounterMachine |
|
|
| def Data.restrict (N : ℕ) (d : Data ℕ) : Data (Fin N) := |
| ⟨fun r => d.reg r.val, d.input, d.backup, d.output⟩ |
|
|
| namespace Command |
|
|
| def Bounded (N : ℕ) : Command ℕ → Prop |
| | .skip | .write _ | .discard | .rewind => True |
| | .inc r | .dec r => r < N |
| | .seq a b => Bounded N a ∧ Bounded N b |
| | .test r a b => r < N ∧ Bounded N a ∧ Bounded N b |
| | .read a b c => Bounded N a ∧ Bounded N b ∧ Bounded N c |
| | .loop r b => r < N ∧ Bounded N b |
|
|
| def regCount : Command ℕ → ℕ |
| | .skip | .write _ | .discard | .rewind => 0 |
| | .inc r | .dec r => r+1 |
| | .seq a b => max a.regCount b.regCount |
| | .test r a b => max (r+1) (max a.regCount b.regCount) |
| | .read a b c => max a.regCount (max b.regCount c.regCount) |
| | .loop r b => max (r+1) b.regCount |
|
|
| theorem bounded_of_count (c : Command ℕ) (N : ℕ) (h : c.regCount ≤ N) : c.Bounded N := by |
| induction c <;> simp_all [Bounded, regCount] |
|
|
| def restrict (N : ℕ) : (c : Command ℕ) → Bounded N c → Command (Fin N) |
| | .skip, _ => .skip |
| | .inc r, h => .inc ⟨r,h⟩ |
| | .dec r, h => .dec ⟨r,h⟩ |
| | .write b, _ => .write b |
| | .discard, _ => .discard |
| | .rewind, _ => .rewind |
| | .seq a b, h => .seq (restrict N a h.1) (restrict N b h.2) |
| | .test r a b, h => .test ⟨r,h.1⟩ (restrict N a h.2.1) (restrict N b h.2.2) |
| | .read a b c, h => .read (restrict N a h.1) (restrict N b h.2.1) (restrict N c h.2.2) |
| | .loop r b, h => .loop ⟨r,h.1⟩ (restrict N b h.2) |
|
|
| theorem restrict_inc (N : ℕ) (d : Data ℕ) (r : ℕ) (h : r<N) : |
| (incData d r).restrict N = incData (d.restrict N) ⟨r,h⟩ := by |
| apply Data.ext |
| · ext u |
| simp only [Data.restrict, incData] |
| by_cases hu : u.val = r |
| · have he : u = ⟨r,h⟩ := Fin.ext hu |
| simp [he] |
| · have he : u ≠ ⟨r,h⟩ := fun he => hu (congrArg Fin.val he) |
| simp [hu, he] |
| all_goals rfl |
|
|
| theorem restrict_dec (N : ℕ) (d : Data ℕ) (r : ℕ) (h : r<N) : |
| (decData d r).restrict N = decData (d.restrict N) ⟨r,h⟩ := by |
| apply Data.ext |
| · ext u |
| simp only [Data.restrict, decData] |
| by_cases hu : u.val = r |
| · have he : u = ⟨r,h⟩ := Fin.ext hu |
| simp [he] |
| · have he : u ≠ ⟨r,h⟩ := fun he => hu (congrArg Fin.val he) |
| simp [hu, he] |
| all_goals rfl |
|
|
| theorem Evaluates.restrict {c : Command ℕ} {d e : Data ℕ} {n : ℕ} |
| (he : Evaluates c d e n) (N : ℕ) (h : Bounded N c) : |
| Evaluates (c.restrict N h) (d.restrict N) (e.restrict N) n := by |
| induction he with |
| | skip d => exact Evaluates.skip _ |
| | inc d r => simpa only [Command.restrict, restrict_inc N d r h] using Evaluates.inc (d.restrict N) ⟨r,h⟩ |
| | dec d r => simpa only [Command.restrict, restrict_dec N d r h] using Evaluates.dec (d.restrict N) ⟨r,h⟩ |
| | write d b => exact Evaluates.write _ _ |
| | discard d => exact Evaluates.discard _ |
| | rewind_empty hh => exact Evaluates.rewind_empty hh |
| | rewind_cons hh he ih => exact Evaluates.rewind_cons hh (ih trivial) |
| | seq h1 h2 i1 i2 => exact (i1 h.1).seq (i2 h.2) |
| | test_zero hr he ih => exact Evaluates.test_zero hr (ih h.2.1) |
| | test_pos hr he ih => exact Evaluates.test_pos hr (ih h.2.2) |
| | read_one hr he ih => exact Evaluates.read_one hr (ih h.1) |
| | read_zero hr he ih => exact Evaluates.read_zero hr (ih h.2.1) |
| | read_empty hr he ih => exact Evaluates.read_empty hr (ih h.2.2) |
| | loop_zero hr => exact Evaluates.loop_zero hr |
| | @loop_pos r b d e f n m hr h1 h2 i1 i2 => |
| exact Evaluates.loop_pos hr (by simpa only [restrict_dec N d r h.1] using i1 h.2) (i2 h) |
|
|
| def finite (c : Command ℕ) : Command (Fin c.regCount) := |
| c.restrict c.regCount (c.bounded_of_count _ le_rfl) |
|
|
| theorem finite_evaluates {c : Command ℕ} {d e : Data ℕ} {n : ℕ} |
| (h : Evaluates c d e n) : Evaluates c.finite (d.restrict c.regCount) (e.restrict c.regCount) n := |
| h.restrict _ _ |
|
|
| end Command |
|
|
| open scoped BigOperators |
| open Command |
|
|
| /-- A bit table specified by two bounded-arithmetic expressions. These are |
| syntax, not assumed computable functions or unit-time arithmetic oracles. -/ |
| def table (len bit : Expr) (input : List Bool) : List Bool := |
| List.ofFn (fun i : Fin (len.eval input (fun _ => 0)) => |
| decide (bit.eval input (fun _ => i.val) ≠ 0)) |
|
|
| def emit (r : ℕ) : Command ℕ := .test r (.write false) (.seq (clear r) (.write true)) |
|
|
| theorem emit_evaluates (d : Data ℕ) (r : ℕ) : |
| Within (emit r) d (writeData (d.set r 0) (decide (d.reg r ≠ 0))) (2*d.reg r+3) := by |
| by_cases hr : d.reg r = 0 |
| · refine ⟨2, by omega, ?_⟩ |
| have h := Evaluates.test_zero (r := r) (b := .seq (clear r) (.write true)) hr |
| (Evaluates.write d false) |
| have hd : d.set r 0 = d := by rw [← hr, Data.set_self] |
| simpa [emit, hr, hd] using h |
| · have h := Evaluates.test_pos (a := .write false) hr |
| ((clear_evaluates d r).seq (Evaluates.write (d.set r 0) true)) |
| exact ⟨1+(2*d.reg r+1+1), by omega, by simpa [emit, hr] using h⟩ |
|
|
| def print (len bit : Expr) : Command ℕ := |
| .seq (len.compile (fun _ => 0) 1) |
| (.loop 1 (.seq (bit.compile (fun _ => 1) 2) (emit 2))) |
|
|
| theorem print_evaluates (len bit : Expr) (input : List Bool) : |
| Within (print len bit) (initial input) |
| {initial input with output := table len bit input} |
| (len.timeBudget input.length+len.valueBudget input.length* |
| (bit.timeBudget (input.length+len.valueBudget input.length)+ |
| 2*bit.valueBudget (input.length+len.valueBudget input.length)+4)+1) := by |
| let d : Data ℕ := initial input |
| let L := len.eval input (fun _ => 0) |
| let V := len.valueBudget input.length |
| let M := input.length+V |
| let T := bit.timeBudget M |
| let W := bit.valueBudget M |
| let out := table len bit input |
| have hL : L ≤ V := len.eval_le input _ _ le_rfl (by simp) |
| have holen : out.length = L := by simp [out, table, L] |
| let state : ℕ → Data ℕ := fun i => {d.set 1 i with output := out.drop i} |
| have hlen := len.correct (fun _ => 0) 1 d input.length (by omega) |
| (by intro r hr; rfl) rfl le_rfl (by simp [d, initial]) |
| have hstart : state L = d.set 1 L := by |
| simp [state, ← holen, d, initial, Data.set] |
| have hloop : Within (.loop 1 (.seq (bit.compile (fun _ => 1) 2) (emit 2))) |
| (state L) (state 0) (L*(T+2*W+4)+1) := by |
| apply Within.loop 1 _ state L (T+2*W+3) |
| · intro i hi; simp [state] |
| · intro i hi |
| let e := decData (state (i+1)) 1 |
| have heReg : e.reg = Function.update (fun _ => 0) 1 i := by |
| simp [e, state, decData, Data.set, d, initial] |
| have heClean : e.Clean 2 := by |
| intro r hr |
| rw [heReg] |
| simp [show r ≠ 1 by omega] |
| have heAt : e.reg 1 = i := by simp [heReg] |
| have heArg : (fun u : ℕ => e.reg ((fun _ => 1) u)) = (fun _ => i) := by |
| funext u; simp [heReg] |
| have hc := bit.correct (fun _ => 1) 2 e M (by omega) heClean rfl |
| (by change input.length ≤ M; dsimp [M]; omega) |
| (by intro u; rw [heAt]; dsimp [M]; omega) |
| rw [heArg] at hc |
| let B := bit.eval input (fun _ => i) |
| change Within _ e (e.set 2 B) T at hc |
| have hemit := emit_evaluates (e.set 2 B) 2 |
| have hd : (e.set 2 B).set 2 0 = e := by |
| rw [Data.set_set, Data.set_clean_zero heClean le_rfl] |
| simp only [hd, Data.set_reg_same] at hemit |
| have hh := hc.seq hemit |
| have hdrop : decide (B ≠ 0) :: out.drop (i+1) = out.drop i := by |
| have hi' : i < out.length := by omega |
| rw [← List.getElem_cons_drop hi'] |
| congr 1 |
| simp [out, table, B] |
| have hout : writeData e (decide (B ≠ 0)) = state i := by |
| apply Data.ext |
| · simp [writeData, heReg, state, d, initial, Data.set] |
| · rfl |
| · rfl |
| · exact hdrop |
| rw [hout] at hh |
| apply hh.mono |
| have hB : B ≤ W := bit.eval_le input _ M (by dsimp [M]; omega) (by intro u; dsimp [M]; omega) |
| omega |
| rw [hstart] at hloop |
| have zend : state 0 = {initial input with output := table len bit input} := by |
| simp [state, d, Data.set, initial, out] |
| rw [zend] at hloop |
| exact (hlen.seq hloop).mono (by |
|
|
| change _ ≤ len.timeBudget input.length+V*(T+2*W+4)+1 |
| have := Nat.mul_le_mul_right (T+2*W+4) hL |
| omega) |
|
|
| /-- Required cleanup before Mathlib's exact halt-list convention. -/ |
| def eraseInput : Command ℕ := .seq (inputLength 1 0) (.loop 0 .discard) |
|
|
| theorem eraseInput_evaluates (d : Data ℕ) (hz : d.Clean 0) (hb : d.backup = []) : |
| Within eraseInput d {d with input := []} (7*d.input.length+7) := by |
| have hl := inputLength_evaluates d 1 0 (by omega) (hz 1 (by omega)) (hz 0 le_rfl) hb |
| let state : ℕ → Data ℕ := fun i => {d.set 0 i with input := d.input.drop (d.input.length-i)} |
| have hs : state d.input.length = d.set 0 d.input.length := by simp [state, Data.set] |
| have hf : state 0 = {d with input := []} := by |
| simp [state, Data.set_clean_zero hz le_rfl] |
| have hloop : Within (.loop 0 .discard) (state d.input.length) (state 0) (2*d.input.length+1) := by |
| have h := Within.loop 0 (.discard : Command ℕ) state d.input.length 1 |
| have heq : 2*d.input.length+1 = d.input.length*(1+1)+1 := by omega |
| rw [heq] |
| apply h |
| · intro i hi; simp [state] |
| · intro i hi |
| have he : discardData (decData (state (i+1)) 0) = state i := by |
| apply Data.ext |
| · simp [state, discardData, decData, Data.set] |
| · simp only [discardData, decData, state, Data.set] |
| rw [List.tail_drop] |
| congr 1 |
| omega |
| all_goals rfl |
| exact ⟨1,le_rfl, by rw [← he]; exact Evaluates.discard _⟩ |
| rw [hs, hf] at hloop |
| exact (hl.seq hloop).mono (by omega) |
|
|
| end OptimalMaxCut.CounterMachine |
|
|
| end |
|
|
| end OAI |
|
|
