| 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 |
|
|
