File size: 3,995 Bytes
4a56cd6 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 | import OAI.Algorithms.SubexponentialSAT.LeanCompat
import OAI.Algorithms.SubexponentialSAT.Subexp.MatrixProgramSupport
namespace OAI.Algorithms
/-! A fixed EOF-controlled reversal of a raw list of framed words. -/
namespace SubexponentialSAT.SqrtLog.BucketProgram
open SubexponentialSAT.BitProgram SubexponentialSAT.StructuredCalls SubexponentialSAT.Subexp.MatrixProgramSupport
abbrev PreReverseData := State 8 4
abbrev PreReverseCode := Cmd 8 4
abbrev preReverseState (regs : Fin 8 → Bool) (xs : List (List Bool))
(out : List Bool) : PreReverseData := ⟨regs, ![words xs,[],[],out]⟩
abbrev preReverseStep : PreReverseCode :=
.seq (readWord 0 1 2 (by decide)) (emitFrame 1 3 2 (by decide))
theorem preReverseStep_eval (regs : Fin 8 → Bool) (x : List Bool)
(xs : List (List Bool)) (out : List Bool) :
∃ rf, Eval preReverseStep (17*x.length+15)
(preReverseState regs (x::xs) out)
(preReverseState rf xs (Encoding.frame x++out)) := by
let d := preReverseState regs (x::xs) out
obtain ⟨a,ha,hsa⟩ := readWord_eval (0 : Fin 4) 1 2
(by decide) (by decide) (by decide) d x (words xs) rfl rfl rfl
obtain ⟨b,hb,hsb⟩ := emitFrame_eval (1 : Fin 4) 3 2
(by decide) (by decide) (by decide) a (by rw [hsa]; rfl)
have ha1 : a.stacks 1=x := by rw [hsa]; rfl
have hend : b=preReverseState b.regs xs (Encoding.frame x++out) := by
apply congrArg (StructuredProgram.State.mk b.regs)
rw [hsb,hsa]
funext i; fin_cases i <;> rfl
have he := ha.seq hb
rw [hend,ha1] at he
exact ⟨b.regs, by convert he using 1 ; omega⟩
abbrev preReversePeek : PreReverseCode := .base (.atom (.peek 0 0 1))
abbrev preReverseBody : PreReverseCode := .seq preReverseStep preReversePeek
abbrev preReverseLoop : PreReverseCode := .while 1 preReverseBody
abbrev preReverseCommand : PreReverseCode := .seq preReversePeek preReverseLoop
abbrev preReverseProgram := compiled preReverseCommand 0 3
abbrev preReverseReady (regs : Fin 8 → Bool) (xs : List (List Bool))
(out : List Bool) : PreReverseData :=
preReverseState (readRegs regs 0 1 (words xs).head?) xs out
def preReverseCost (xs : List (List Bool)) : ℕ :=
(xs.map (fun x => 17*x.length+17)).sum+1
theorem preReversePeek_eval (regs : Fin 8 → Bool) (xs : List (List Bool))
(out : List Bool) : Eval preReversePeek 1 (preReverseState regs xs out)
(preReverseReady regs xs out) := Eval.base (StructuredProgram.Eval.atom _ _)
theorem preReverseLoop_eval (regs : Fin 8 → Bool) (xs : List (List Bool))
(out : List Bool) : ∃ rf,
Eval preReverseLoop (preReverseCost xs) (preReverseReady regs xs out)
(preReverseState rf [] (words xs.reverse++out)) := by
induction xs generalizing regs out with
| nil =>
refine ⟨(preReverseReady regs [] out).regs, ?_⟩
change Eval preReverseLoop 1 (preReverseReady regs [] out) (preReverseReady regs [] out)
exact Eval.while_false (show (preReverseReady regs [] out).regs 1 = false by
simp [words, readRegs])
| cons x xs ih =>
obtain ⟨rm,hm⟩ := preReverseStep_eval (preReverseReady regs (x::xs) out).regs x xs out
obtain ⟨rf,hf⟩ := ih rm (Encoding.frame x++out)
have hg : (preReverseReady regs (x::xs) out).regs 1=true := by
cases x <;> simp [words,Encoding.frame,readRegs]
have he := Eval.while_true hg (hm.seq (preReversePeek_eval rm xs _)) hf
refine ⟨rf, ?_⟩
convert he using 1 <;>
simp [preReverseCost,List.reverse_cons,words_append,words,List.append_assoc] ; omega
theorem preReverseCommand_eval (regs : Fin 8 → Bool) (xs : List (List Bool))
(out : List Bool) : ∃ rf,
Eval preReverseCommand (preReverseCost xs+1) (preReverseState regs xs out)
(preReverseState rf [] (words xs.reverse++out)) := by
obtain ⟨rf,hf⟩ := preReverseLoop_eval regs xs out
exact ⟨rf, by simpa [Nat.add_comm] using (preReversePeek_eval regs xs out).seq hf⟩
end SubexponentialSAT.SqrtLog.BucketProgram
end OAI.Algorithms
|