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