File size: 4,832 Bytes
8df23f4 | 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 87 88 89 90 91 92 93 94 | import OAI.Computability.BinPacking.PCP.RawInitialMachineCleanup
import OAI.Computability.BinPacking.PCP.RawInitialMachineRows
namespace OAI
namespace BinPackingGames.Foundations.PCP.RawInitialMachineBody
open Turing Target Complexity RawInitialMachineModel RawInitialMachineLoopData
open RawInitialMachineReadClause RawInitialMachineRows RawInitialMachineBudget
private theorem trace_trans {α : Type*} (f : α → α) {a b : Nat} {x y z : α}
(first : f^[a] x = y) (second : f^[b] y = z) : f^[a + b] x = z := by
rw [Nat.add_comm, Function.iterate_add_apply, first, second]
theorem guardTrace_succ (n i remaining : Nat) (input reversed : List Bool)
(state : State) :
(MachineComposition.advance (TM2.step program))^[1]
(some ⟨some .guard, state, loopTapes n i (remaining + 1) input reversed⟩) =
some ⟨some (.fieldStart 0), (state.1, none),
loopTapes n i remaining input reversed⟩ := by
have h := MachineUnaryCounter.guardTrace_succ Tape.counter Label.guard
(.fieldStart 0) (.scan .dummyVariables) program rfl
(loopTapes n i remaining input reversed) remaining [] state.1 state.2
have heq (r : Nat) : MachineUnaryCounter.counterTapes Tape.counter
(loopTapes n i remaining input reversed) r [] = loopTapes n i r input reversed := by
funext tape
cases tape <;> simp [MachineUnaryCounter.counterTapes, loopTapes]
simpa only [heq, Prod.mk.eta] using h
theorem guardTrace_zero (n i : Nat) (input reversed : List Bool) (state : State) :
(MachineComposition.advance (TM2.step program))^[1]
(some ⟨some .guard, state, loopTapes n i 0 input reversed⟩) =
some ⟨some (.scan .dummyVariables), (state.1, none),
loopTapes n i 0 input reversed⟩ := by
have h := MachineUnaryCounter.guardTrace_zero Tape.counter Label.guard
(.fieldStart 0) (.scan .dummyVariables) program rfl
(loopTapes n i 0 input reversed) [] state.1 state.2
have heq : MachineUnaryCounter.counterTapes Tape.counter
(loopTapes n i 0 input reversed) 0 [] = loopTapes n i 0 input reversed := by
funext tape
cases tape <;> simp [MachineUnaryCounter.counterTapes, loopTapes]
simpa only [heq, Prod.mk.eta] using h
theorem bodyTrace {n : Nat} (i remaining : Nat) (c : Clause n)
(suffix reversed : List Bool) (state : State) :
(MachineComposition.advance (TM2.step program))^[bodyTime i c]
(some ⟨some .guard, state,
loopTapes n i (remaining + 1)
(encodeWords (Complexity.clauseWords c) ++ suffix) reversed⟩) =
some ⟨some .guard, (RawInitialRows.clauseSigns c, none),
loopTapes n (i + 1) remaining suffix
((encodeWords (RawInitialRows.clauseWords n i
(RawInitialRows.clauseNames c) (RawInitialRows.clauseSigns c))).reverse ++ reversed)⟩ := by
let input := encodeWords (Complexity.clauseWords c) ++ suffix
let base := loopTapes n i remaining input reversed
let chunk := (encodeWords (RawInitialRows.clauseWords n i
(RawInitialRows.clauseNames c) (RawInitialRows.clauseSigns c))).reverse
let emitted := loopTapes n i remaining input (chunk ++ reversed)
have first := guardTrace_succ n i remaining input reversed state
have read := readClauseTrace base c suffix rfl (fun _ => rfl) (state.1, none)
have rows := rowsTrace (recordTapes base c suffix) n i
(RawInitialRows.clauseNames c) (RawInitialRows.clauseSigns c)
rfl rfl rfl rfl rfl rfl
have frame : outputTapes (recordTapes base c suffix) chunk =
recordTapes emitted c suffix := by
funext tape
cases tape <;> simp [outputTapes, recordTapes, emitted, base, loopTapes]
change (MachineComposition.advance (TM2.step program))^[6 * n + 18 * i +
2 * nameSum c + 48]
(some ⟨some (.scan (.tailVariables 0)), (RawInitialRows.clauseSigns c, none),
recordTapes base c suffix⟩) =
some ⟨some (.cleanupField 0), (RawInitialRows.clauseSigns c, none),
outputTapes (recordTapes base c suffix) chunk⟩ at rows
rw [frame] at rows
have cleanup := RawInitialMachineCleanup.cleanupTrace emitted c suffix i
(fun _ => rfl) rfl (RawInitialRows.clauseSigns c, none)
have finalFrame : Function.update (Function.update emitted .input suffix)
.index (encodeWord (i + 1)) =
loopTapes n (i + 1) remaining suffix (chunk ++ reversed) := by
funext tape
cases tape <;> simp [emitted, loopTapes]
rw [finalFrame] at cleanup
have total := trace_trans _ (trace_trans _ (trace_trans _ first read) rows) cleanup
have time : 1 + ((encodeWords (Complexity.clauseWords c)).length + 7) +
(6 * n + 18 * i + 2 * nameSum c + 48) +
((encodeWords (Complexity.clauseWords c)).length + 7) = bodyTime i c := by
simp only [bodyTime, nameSum]
omega
simpa only [time] using total
end BinPackingGames.Foundations.PCP.RawInitialMachineBody
end OAI
|