import OAI.Algorithms.SubexponentialSAT.LeanCompat import OAI.Algorithms.SubexponentialSAT.SubexpSetupStorage namespace OAI.Algorithms /-! One-output physical calls in the assignment-input workspace. -/ namespace SubexponentialSAT.Subexp.AssignmentInputCall open BitProgram StructuredCalls SubexpSetupStorage abbrev Data := State 16 48 abbrev Code := Cmd 16 48 def work : List (Fin 48) := List.ofFn (fun i : Fin 10 => ⟨12 + i.val, by omega⟩) theorem mem_work (j : Fin 48) : j ∈ work ↔ 12 ≤ j.val ∧ j.val < 22 := by simp only [work, List.mem_ofFn] constructor · rintro ⟨i, rfl⟩ change 12 ≤ 12 + i.val ∧ 12 + i.val < 22 have := i.isLt omega · rintro ⟨hlo, hhi⟩ exact ⟨⟨j.val - 12, by omega⟩, Fin.ext (by simp; omega)⟩ def stack {s : ℕ} (hs : s ≤ 10) (i : Fin s) : Fin 48 := ⟨12 + i.val, by omega⟩ def register {r : ℕ} (hr : r ≤ 16) (i : Fin r) : Fin 16 := i.castLE hr theorem stack_injective {s : ℕ} (hs : s ≤ 10) : Function.Injective (stack hs) := by intro i j h apply Fin.ext have h' := congrArg Fin.val h simpa [stack] using h' theorem register_injective {r : ℕ} (hr : r ≤ 16) : Function.Injective (register hr) := by intro i j h apply Fin.ext exact congrArg (fun x : Fin 16 => x.val) h theorem stack_mem {s : ℕ} (hs : s ≤ 10) (i : Fin s) : stack hs i ∈ work := by rw [mem_work] have := i.isLt simp only [stack, Fin.val_mk] omega def Clean (a : Data) : Prop := (∀ j ∈ work, a.stacks j = []) ∧ a.stacks 31 = [] theorem beforeCopies_stacks (a : Data) (hc : Clean a) : (beforeCopies 31 work a).stacks = a.stacks := by funext j simp only [beforeCopies, resetMany_stacks, clearMany_stacks] by_cases hw : j ∈ work · simp [hw, hc.1 j hw] · by_cases he : j = 31 · subst j; simp [hw, hc.2] · simp [hw, he] theorem prepare_one_stacks (a : Data) (hc : Clean a) (src dst : Fin 48) (hd : dst ∈ work) : (prepareState 31 work [(src, dst)] a).stacks = Function.update a.stacks dst (a.stacks src) := by simp [prepareState, copyManyState, copyState_stack, beforeCopies_stacks a hc, hc.1 dst hd] theorem prepare_two_stacks (a : Data) (hc : Clean a) (src dst src' dst' : Fin 48) (hd : dst ∈ work) (hd' : dst' ∈ work) (hdd : dst' ≠ dst) (hsd : src' ≠ dst) : (prepareState 31 work [(src, dst), (src', dst')] a).stacks = Function.update (Function.update a.stacks dst (a.stacks src)) dst' (a.stacks src') := by simp [prepareState, copyManyState, copyState_stack, beforeCopies_stacks a hc, hc.1 dst hd, hc.1 dst' hd', hdd, hsd] theorem prepare_one_local {r s : ℕ} (hr : r ≤ 16) (hs : s ≤ 10) (a : Data) (hc : Clean a) (src : Fin 48) (q : Fin s) (i : Fin s) : (project (register hr) (stack hs) (prepareState 31 work [(src, stack hs q)] a)).stacks i = if i = q then a.stacks src else [] := by change (prepareState 31 work [(src, stack hs q)] a).stacks (stack hs i) = _ rw [prepare_one_stacks a hc src (stack hs q) (stack_mem hs q)] by_cases he : i = q · subst i; simp · have hne := fun h => he (stack_injective hs h) rw [Function.update_of_ne hne] simp [he, hc.1 _ (stack_mem hs i)] theorem prepare_two_local {r s : ℕ} (hr : r ≤ 16) (hs : s ≤ 10) (a : Data) (hc : Clean a) (src src' : Fin 48) (q q' : Fin s) (hqq : q' ≠ q) (hsrc : src' ≠ stack hs q) (i : Fin s) : (project (register hr) (stack hs) (prepareState 31 work [(src, stack hs q), (src', stack hs q')] a)).stacks i = if i = q' then a.stacks src' else if i = q then a.stacks src else [] := by change (prepareState 31 work [(src, stack hs q), (src', stack hs q')] a).stacks (stack hs i) = _ rw [prepare_two_stacks a hc src (stack hs q) src' (stack hs q') (stack_mem hs q) (stack_mem hs q') (fun h => hqq (stack_injective hs h)) hsrc] by_cases he' : i = q' · subst i; simp · have hne' := fun h => he' (stack_injective hs h) by_cases he : i = q · subst i rw [Function.update_of_ne hne'] simp [he'] · have hne := fun h => he (stack_injective hs h) rw [Function.update_of_ne hne', Function.update_of_ne hne] simp [he, he', hc.1 _ (stack_mem hs i)] theorem prepare_regs (inputs : List (Fin 48 × Fin 48)) (a : Data) (j : Fin 16) (hj : j.val < 9) : (prepareState 31 work inputs a).regs j = false := by have hbefore : ∀ i : Fin 16, i.val < 9 → (beforeCopies 31 work a).regs i = false := by intro i hi exact resetWork_reg _ ⟨i.val, hi⟩ suffices ∀ (b : Data), (∀ i : Fin 16, i.val < 9 → b.regs i = false) → (copyManyState inputs b).regs j = false from this _ hbefore induction inputs with | nil => intro b hb; exact hb j hj | cons p ps ih => intro b hb apply ih (copyState p.1 p.2 b) intro i hi by_cases h0 : i = 0 · subst i; simp [copyState, readRegs] · by_cases h1 : i = 1 · subst i; simp [copyState, readRegs] · simpa [copyState, readRegs, h0, h1] using hb i hi theorem prepare_frame (inputs : List (Fin 48 × Fin 48)) (a : Data) (hin : ∀ p ∈ inputs, p.2 ∈ work) (hc : Clean a) (j : Fin 48) (hj : j ∉ work) : (prepareState 31 work inputs a).stacks j = a.stacks j := by rw [prepareState, copyMany_frame inputs _ j] · simp only [beforeCopies, resetMany_stacks, clearMany_stacks, ite_eq_right hj] by_cases he : j = 31 · subst j simp [hc.2] · simp [he] · intro p hp he exact hj (he.symm ▸ hin p hp) theorem finish_one_stacks {r s : ℕ} (hr : r ≤ 16) (hs : s ≤ 10) (inputs : List (Fin 48 × Fin 48)) (a : Data) (out : State r s) (q : Fin s) (dst : Fin 48) (hd : dst ∉ work) (hin : ∀ p ∈ inputs, p.2 ∈ work) (hc : Clean a) : (finishState work [(stack hs q, dst)] (embedState (register hr) (stack hs) (prepareState 31 work inputs a) out)).stacks = Function.update a.stacks dst (out.stacks q) := by let middle := embedState (register hr) (stack hs) (prepareState 31 work inputs a) out have hqd : stack hs q ≠ dst := by intro he exact hd (he ▸ stack_mem hs q) have hq : middle.stacks (stack hs q) = out.stacks q := embedState_stack _ _ _ _ (stack_injective hs) q funext j have hform : (finishState work [(stack hs q, dst)] middle).stacks j = if j ∈ work then [] else if j = dst then middle.stacks (stack hs q) else middle.stacks j := by by_cases he : j = dst <;> simp [finishState, resetMany_stacks, clearMany_stacks, copyManyState, copyState, StackRoutines.copyStacks, hqd, he] rw [hform] by_cases hw : j ∈ work · have hne : j ≠ dst := by intro he; exact hd (he ▸ hw) simp [hw, hne, hc.1 j hw] · have hf : middle.stacks j = a.stacks j := by rw [embedState_stack_frame] · exact prepare_frame inputs a hin hc j hw · rintro ⟨i, rfl⟩ exact hw (stack_mem hs i) simp [hw, hf, hq, Function.update_apply] abbrev call {r s l : ℕ} (p : Program r s l) (hr : r ≤ 16) (hs : s ≤ 10) (inputs : List (Fin 48 × Fin 48)) (q : Fin s) (dst : Fin 48) : Code := isolated p (register hr) (stack hs) 31 work inputs [(stack hs q, dst)] noncomputable def callCost {r s : ℕ} (hr : r ≤ 16) (hs : s ≤ 10) (inputs : List (Fin 48 × Fin 48)) (q : Fin s) (dst : Fin 48) (a : Data) (out : State r s) (ticks : ℕ) : ℕ := prepareCost 31 work inputs a + (ticks + finishCost work [(stack hs q, dst)] (embedState (register hr) (stack hs) (prepareState 31 work inputs a) out)) theorem call_eval {r s l : ℕ} (p : Program r s l) (hr : r ≤ 16) (hs : s ≤ 10) (inputs : List (Fin 48 × Fin 48)) (q : Fin s) (dst : Fin 48) (a : Data) (out : State r s) {ticks : ℕ} (hd : dst ∉ work) (htmp : dst ≠ 31) (hin : ∀ x ∈ inputs, x.2 ∈ work) (hports : ∀ x ∈ inputs, x.1 ≠ x.2 ∧ x.1 ≠ 31 ∧ (31 : Fin 48) ≠ x.2) (hc : Clean a) (ht : Trace p ticks ((project (register hr) (stack hs) (prepareState 31 work inputs a)).withPC (some p.entry)) (out.withPC none)) : ∃ b, Eval (call p hr hs inputs q dst) (callCost hr hs inputs q dst a out ticks) a b ∧ b.stacks = Function.update a.stacks dst (out.stacks q) ∧ Clean b := by have hframe : ¬ ∃ j, stack hs j = (31 : Fin 48) := by rintro ⟨j, h⟩ have hm := stack_mem hs j rw [h, mem_work] at hm change 12 ≤ 31 ∧ 31 < 22 at hm omega have ho : ∀ x ∈ [(stack hs q, dst)], x.1 ≠ x.2 ∧ x.1 ≠ 31 ∧ (31 : Fin 48) ≠ x.2 := by intro x hx simp only [List.mem_singleton] at hx subst x refine ⟨?_, ?_, Ne.symm htmp⟩ · intro he change stack hs q = dst at he exact hd (he ▸ stack_mem hs q) · intro he; exact hframe ⟨q, he⟩ have h := isolated_eval p (register hr) (stack hs) (register_injective hr) (stack_injective hs) 31 work inputs [(stack hs q, dst)] a out hports ho hframe ht have hout := finish_one_stacks hr hs inputs a out q dst hd hin hc refine ⟨_, h, hout, ?_⟩ constructor · intro j hj have hne : j ≠ dst := by intro he; exact hd (he ▸ hj) rw [hout, Function.update_of_ne hne] exact hc.1 j hj · rw [hout, Function.update_of_ne (Ne.symm htmp)] exact hc.2 /-- A uniform bound on the contents of each physical stack. -/ def Within {r s : ℕ} (a : State r s) (B : ℕ) : Prop := ∀ j, (a.stacks j).length ≤ B theorem within_mono {r s : ℕ} {a : State r s} {B C : ℕ} (h : Within a B) (hBC : B ≤ C) : Within a C := fun j => (h j).trans hBC theorem within_clear (port : Fin 48) (a : Data) (B : ℕ) (h : Within a B) : Within (clearState port a) B := by intro j by_cases hj : j = port · subst j; simp [clearState] · simpa [clearState, hj] using h j theorem clearMany_bound (ports : List (Fin 48)) (a : Data) (B : ℕ) (h : Within a B) : Within (clearManyState ports a) B ∧ clearManyCost ports a ≤ ports.length * (2 * B + 3) := by induction ports generalizing a with | nil => exact ⟨h, by simp [clearManyCost]⟩ | cons p ps ih => obtain ⟨hs, ht⟩ := ih (clearState p a) (within_clear p a B h) refine ⟨hs, ?_⟩ have hp := h p simp only [clearManyCost, List.length_cons] nlinarith theorem within_copy (src dst : Fin 48) (a : Data) (B : ℕ) (h : Within a B) : Within (copyState src dst a) (2 * B) := by intro j by_cases hj : j = dst · subst j simp only [copyState_stack, Function.update_self, List.length_append] have hs := h src have hd := h dst omega · rw [copyState_frame src dst j a hj] exact (h j).trans (by omega) theorem copyMany_bound (inputs : List (Fin 48 × Fin 48)) (a : Data) (B : ℕ) (h : Within a B) : Within (copyManyState inputs a) (2 ^ inputs.length * B) ∧ copyManyCost inputs a ≤ inputs.length * (7 * 2 ^ inputs.length * B + 5) := by induction inputs generalizing a B with | nil => simpa [copyManyState, copyManyCost] using h | cons p ps ih => obtain ⟨hs, ht⟩ := ih (copyState p.1 p.2 a) (2 * B) (within_copy p.1 p.2 a B h) constructor · simpa only [copyManyState, List.length_cons, pow_succ, Nat.mul_assoc, Nat.mul_left_comm, Nat.mul_comm] using hs · have hp := h p.1 have hpow : 1 ≤ 2 ^ ps.length := one_le_pow₀ (by decide) have hpowB := Nat.mul_le_mul_right B hpow simp only [copyManyCost, List.length_cons, pow_succ] nlinarith theorem within_reset (rs : List (Fin 16)) (a : Data) (B : ℕ) (h : Within a B) : Within (resetManyState rs a) B := by simpa only [Within, resetMany_stacks] using h theorem prepare_bound (inputs : List (Fin 48 × Fin 48)) (a : Data) (B : ℕ) (hn : inputs.length ≤ 2) (h : Within a B) : Within (prepareState 31 work inputs a) (4 * B) ∧ prepareCost 31 work inputs a ≤ 100 * (B + 1) := by obtain ⟨hc, hct⟩ := clearMany_bound [31] a B h obtain ⟨hw, hwt⟩ := clearMany_bound work (clearManyState [31] a) B hc have hb : Within (beforeCopies 31 work a) B := within_reset _ _ _ hw obtain ⟨hi, hit⟩ := copyMany_bound inputs (beforeCopies 31 work a) B hb have hpow : 2 ^ inputs.length ≤ 4 := by have : inputs.length = 0 ∨ inputs.length = 1 ∨ inputs.length = 2 := by omega rcases this with he | he | he <;> simp [he] constructor · exact within_mono hi (Nat.mul_le_mul_right B hpow) · have hlen : work.length = 10 := by simp [work] have hit' : copyManyCost inputs (beforeCopies 31 work a) ≤ 2 * (7 * 4 * B + 5) := by apply hit.trans exact Nat.mul_le_mul hn (by gcongr) simp only [List.length_singleton] at hct rw [hlen] at hwt unfold prepareCost nlinarith theorem within_embed {r s : ℕ} (hr : r ≤ 16) (hs : s ≤ 10) (a : Data) (out : State r s) (B : ℕ) (ha : Within a B) (ho : Within out B) : Within (embedState (register hr) (stack hs) a out) B := by classical intro j by_cases hj : ∃ i, stack hs i = j · obtain ⟨i, rfl⟩ := hj rw [embedState_stack _ _ _ _ (stack_injective hs)] exact ho i · rw [embedState_stack_frame _ _ _ _ j hj] exact ha j theorem finish_bound (q dst : Fin 48) (a : Data) (B : ℕ) (h : Within a B) : finishCost work [(q, dst)] a ≤ 60 * (B + 1) := by obtain ⟨hc, hct⟩ := clearMany_bound [dst] a B h obtain ⟨hp, hpt⟩ := copyMany_bound [(q, dst)] (clearManyState [dst] a) B hc have hp' : Within (copyManyState [(q, dst)] (clearManyState [dst] a)) (2 * B) := by simpa using hp have hwt := (clearMany_bound work _ (2 * B) hp').2 have hlen : work.length = 10 := by simp [work] rw [hlen] at hwt simp only [List.length_singleton, pow_one, Nat.one_mul] at hct hpt unfold finishCost simp only [List.map_cons, List.map_nil] nlinarith theorem callCost_le {r s : ℕ} (hr : r ≤ 16) (hs : s ≤ 10) (inputs : List (Fin 48 × Fin 48)) (q : Fin s) (dst : Fin 48) (a : Data) (out : State r s) (ticks B : ℕ) (hn : inputs.length ≤ 2) (ha : Within a B) (ho : Within out B) : callCost hr hs inputs q dst a out ticks ≤ ticks + 400 * (B + 1) := by obtain ⟨hp, hpt⟩ := prepare_bound inputs a B hn ha have hm := within_embed hr hs (prepareState 31 work inputs a) out (4 * B) hp (within_mono ho (by omega)) have hf := finish_bound (stack hs q) dst _ (4 * B) hm unfold callCost omega end SubexponentialSAT.Subexp.AssignmentInputCall end OAI.Algorithms