Download data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLogSpace/CompileSpace.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 8.59 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLogSpace/CompileSpace.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLogSpace/CompileSpace.lean
-
curl -L -o CompileSpace.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLogSpace/CompileSpace.lean
8.59 kB
| import OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.GuardedCompiler | |
| /-! Transfer a genuine bound on every source stack configuration through the | |
| guarded primitive compiler. The bound is independent of the number of source | |
| instructions. Concrete counting programs must prove the source invariant. -/ | |
| namespace OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.CompileSpace | |
| open GuardedCompiler | |
| open scoped BigOperators | |
| private theorem compile_trace_envelope {r s l : ℕ} (p : BitProgram.Program r s l) | |
| (anchor : Fin s → ℤ) (bound inputLength : ℕ) | |
| (hanchor : ∀ i, 0 ≤ anchor i ∧ anchor i ≤ (inputLength : ℤ)) | |
| {a b : BitProgram.Cfg r s l} {sourceSteps : ℕ} | |
| (tr : BitProgram.Trace p sourceSteps a b) {c : LocatedCfg (primitive p)} | |
| (hcfg : c.config = primitiveCfg p a) | |
| (hposition : ∀ i, c.position i = anchor i - ((a.stacks i).length : ℤ)) | |
| (henvelope : ∀ i, -(bound : ℤ) - 7 ≤ c.lower i ∧ | |
| c.upper i ≤ (inputLength : ℤ) + 7) | |
| (hstacks : ∀ prefixSteps intermediate, prefixSteps ≤ sourceSteps → | |
| BitProgram.Trace p prefixSteps a intermediate → | |
| ∀ i, (intermediate.stacks i).length ≤ bound) : | |
| ∃ time ≤ 7 * sourceSteps, ∃ d : LocatedCfg (primitive p), | |
| Computation.Trace (locatedStep (primitive p)) time c d ∧ | |
| d.config = primitiveCfg p b ∧ | |
| (∀ i, d.position i = anchor i - ((b.stacks i).length : ℤ)) ∧ | |
| ∀ i, -(bound : ℤ) - 7 ≤ d.lower i ∧ | |
| d.upper i ≤ (inputLength : ℤ) + 7 := by | |
| induction tr generalizing c with | |
| | refl => exact ⟨0, by omega, c, .refl c, hcfg, hposition, henvelope⟩ | |
| | @cons sourceSteps a next final hs ht ih => | |
| obtain ⟨time₁, htime₁, middle, hrun₁, hcfg₁, hshift⟩ := | |
| primitive_located_step p hs hcfg | |
| have hposition₁ : ∀ i, | |
| middle.position i = anchor i - ((next.stacks i).length : ℤ) := by | |
| intro i | |
| rw [hshift i, hposition i] | |
| omega | |
| have henvelope₁ : ∀ i, -(bound : ℤ) - 7 ≤ middle.lower i ∧ | |
| middle.upper i ≤ (inputLength : ℤ) + 7 := by | |
| apply locatedTrace_envelope_of_margin hrun₁ htime₁ | |
| (fun _ => -(bound : ℤ) - 7) (fun _ => (inputLength : ℤ) + 7) henvelope | |
| intro i | |
| have hlength := hstacks 0 a (by omega) (.refl a) i | |
| have ha := hanchor i | |
| rw [hposition i] | |
| omega | |
| have hstacks₁ : ∀ prefixSteps intermediate, prefixSteps ≤ sourceSteps → | |
| BitProgram.Trace p prefixSteps next intermediate → | |
| ∀ i, (intermediate.stacks i).length ≤ bound := by | |
| intro prefixSteps intermediate hle htrace | |
| exact hstacks (prefixSteps + 1) intermediate (by omega) (.cons hs htrace) | |
| obtain ⟨time₂, htime₂, d, hrun₂, hcfg₂, hposition₂, henvelope₂⟩ := | |
| ih hcfg₁ hposition₁ henvelope₁ hstacks₁ | |
| exact ⟨time₁ + time₂, by omega, d, hrun₁.trans hrun₂, | |
| hcfg₂, hposition₂, henvelope₂⟩ | |
| theorem compile_trace_space {r s l : ℕ} (p : BitProgram.Program r s l) | |
| {input : List Bool} {final : BitProgram.Cfg r s l} {sourceSteps bound : ℕ} | |
| (tr : BitProgram.Trace p sourceSteps (BitProgram.initial p input) final) | |
| (hstacks : ∀ prefixSteps intermediate, prefixSteps ≤ sourceSteps → | |
| BitProgram.Trace p prefixSteps (BitProgram.initial p input) intermediate → | |
| ∀ i, (intermediate.stacks i).length ≤ bound) : | |
| ∃ time ≤ 7 * sourceSteps, ∃ d : LocatedCfg (primitive p), | |
| Computation.Trace (locatedStep (primitive p)) time | |
| (locatedInit (primitive p) input) d ∧ | |
| d.config = primitiveCfg p final ∧ | |
| ∀ prefixSteps intermediate, prefixSteps ≤ time → | |
| Computation.Trace (locatedStep (primitive p)) prefixSteps | |
| (locatedInit (primitive p) input) intermediate → | |
| visitedSpace intermediate ≤ s * (bound + input.length + 15) := by | |
| let anchor : Fin s → ℤ := fun i => if i = p.inputStack then input.length else 0 | |
| have hanchor : ∀ i, 0 ≤ anchor i ∧ anchor i ≤ (input.length : ℤ) := by | |
| intro i | |
| dsimp [anchor] | |
| split_ifs <;> omega | |
| have hposition : ∀ i : Fin s, (locatedInit (primitive p) input).position i = | |
| anchor i - (((BitProgram.initial p input).stacks i).length : ℤ) := by | |
| intro i | |
| by_cases hi : i = p.inputStack <;> simp [locatedInit, anchor, hi] | |
| have henvelope : ∀ i, -(bound : ℤ) - 7 ≤ (locatedInit (primitive p) input).lower i ∧ | |
| (locatedInit (primitive p) input).upper i ≤ (input.length : ℤ) + 7 := by | |
| intro i | |
| simp only [locatedInit, Int.ofNat_eq_natCast] | |
| split_ifs <;> omega | |
| obtain ⟨time, htime, d, hrun, hcfg, _, hspace⟩ := | |
| compile_trace_envelope p anchor bound input.length hanchor tr | |
| (primitive_initial p input).symm hposition henvelope hstacks | |
| refine ⟨time, htime, d, hrun, hcfg, ?_⟩ | |
| intro prefixSteps intermediate hle hprefix | |
| apply (locatedTrace_prefix_space hrun hprefix hle).trans | |
| apply (visitedSpace_le_of_envelope d _ _ hspace).trans | |
| have hwidth : ((input.length : ℤ) + 7 - (-(bound : ℤ) - 7) + 1).toNat = | |
| bound + input.length + 15 := by omega | |
| simp only [hwidth, Finset.sum_const, Finset.card_univ, Fintype.card_fin, Nat.nsmul_eq_mul] | |
| exact le_rfl | |
| /-- Full output-word readback, time, and every-prefix visited space refer to | |
| one and the same primitive execution. The actual source trace and source-stack | |
| invariant must be provided by the concrete counting program. -/ | |
| theorem compile_word_space {r s l : ℕ} (p : BitProgram.Program r s l) | |
| {input output : List Bool} {final : BitProgram.Cfg r s l} {sourceSteps bound : ℕ} | |
| (tr : BitProgram.Trace p sourceSteps (BitProgram.initial p input) final) | |
| (halted : final.pc = none) (hout : final.stacks p.outputStack = output) | |
| (hstacks : ∀ prefixSteps intermediate, prefixSteps ≤ sourceSteps → | |
| BitProgram.Trace p prefixSteps (BitProgram.initial p input) intermediate → | |
| ∀ i, (intermediate.stacks i).length ≤ bound) : | |
| ∃ time ≤ 7 * sourceSteps, ∃ d : LocatedCfg (primitive p), | |
| Computation.Trace (locatedStep (primitive p)) time | |
| (locatedInit (primitive p) input) d ∧ | |
| d.config.state = .inl (output.head?.getD false) ∧ | |
| d.config.tapes p.outputStack = Turing.Tape.mk₁ (output.map some) ∧ | |
| ∀ prefixSteps intermediate, prefixSteps ≤ time → | |
| Computation.Trace (locatedStep (primitive p)) prefixSteps | |
| (locatedInit (primitive p) input) intermediate → | |
| visitedSpace intermediate ≤ s * (bound + input.length + 15) := by | |
| obtain ⟨time, htime, d, hrun, hcfg, hspace⟩ := compile_trace_space p tr hstacks | |
| refine ⟨time, htime, d, hrun, ?_, ?_, hspace⟩ | |
| · rw [hcfg, primitive_halted p final halted, hout] | |
| · rw [hcfg, primitive_tape, hout] | |
| /-- A full word on an arbitrary fixed tape and a separate Boolean halt are | |
| preserved by the same execution used for both resource bounds. -/ | |
| theorem compile_word_answer_space {r s l : ℕ} (p : BitProgram.Program r s l) | |
| (countStack : Fin s) {input word : List Bool} {answer : Bool} | |
| {final : BitProgram.Cfg r s l} {sourceSteps bound : ℕ} | |
| (tr : BitProgram.Trace p sourceSteps (BitProgram.initial p input) final) | |
| (halted : final.pc = none) (hword : final.stacks countStack = word) | |
| (hanswer : final.stacks p.outputStack = [answer]) | |
| (hstacks : ∀ prefixSteps intermediate, prefixSteps ≤ sourceSteps → | |
| BitProgram.Trace p prefixSteps (BitProgram.initial p input) intermediate → | |
| ∀ i, (intermediate.stacks i).length ≤ bound) : | |
| ∃ time ≤ 7 * sourceSteps, ∃ d : LocatedCfg (primitive p), | |
| Computation.Trace (locatedStep (primitive p)) time | |
| (locatedInit (primitive p) input) d ∧ | |
| d.config.state = .inl answer ∧ | |
| d.config.tapes countStack = Turing.Tape.mk₁ (word.map some) ∧ | |
| d.config.tapes p.outputStack = Turing.Tape.mk₁ [some answer] ∧ | |
| ∀ prefixSteps intermediate, prefixSteps ≤ time → | |
| Computation.Trace (locatedStep (primitive p)) prefixSteps | |
| (locatedInit (primitive p) input) intermediate → | |
| visitedSpace intermediate ≤ s * (bound + input.length + 15) := by | |
| obtain ⟨time, htime, d, hrun, hcfg, hspace⟩ := compile_trace_space p tr hstacks | |
| refine ⟨time, htime, d, hrun, ?_, ?_, ?_, hspace⟩ | |
| · rw [hcfg, primitive_halted p final halted, hanswer] | |
| rfl | |
| · rw [hcfg, primitive_tape, hword] | |
| · rw [hcfg, primitive_tape, hanswer] | |
| rfl | |
| end OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.CompileSpace | |