File size: 8,403 Bytes
760f90e | 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 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 | import Mathlib.Tactic.FinCases
import OAI.Computability.UniqueGames.Machines.GraphCounterModel
namespace OAI
/-! Actual cleanup and emission of the counter followed by the preserved graph. -/
namespace UniqueGamesTheorem.Foundations.Complexity.GraphCounterFinish
open Turing GraphCounterModel
def extraTapes (rest original : List Bool) : ExtraTape → List Bool
| .input => rest
| .archive => original
| _ => []
def frame (input archive counter reversed output : List Bool) : Tape → List Bool
| .inl i => if i = 2 then counter else []
| .inr .input => input
| .inr .archive => archive
| .inr .scratch => reversed
| .inr .output => output
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 start_eq (counter rest original : List Bool) :
clockConfiguration (extraTapes rest original) none
(haltList MachineLogCounter.machine counter) =
⟨some (.inr .clearInput), initialState, frame rest original counter [] []⟩ := by
rw [MachineLogCounter.haltList_eq]
unfold clockConfiguration
congr 1
funext tape
cases tape with
| inl i => fin_cases i <;> simp [clockTapes, frame, MachineLogCounter.configuration,
MachineLogCounter.rawTapes]
| inr k => cases k <;> rfl
theorem finish_eq (word : List Bool) :
(⟨none, initialState, frame [] [] [] [] word⟩ : TM2.Cfg Alphabet Label State) =
haltList machine word := by
unfold haltList
congr 1
funext tape
cases tape with
| inl i => simp [machine, frame]
| inr k => cases k <;> simp [machine, frame]; rfl
theorem drainTrace (rest original counter : List Bool) :
(MachineComposition.advance (TM2.step program))^[rest.length + 1]
(some ⟨some (.inr .clearInput), initialState, frame rest original counter [] []⟩) =
some ⟨some (.inr .clockCopy), initialState, frame [] original counter [] []⟩ := by
have h := (MachineDrain.drainInTime (Sum.inr ExtraTape.input) (Sum.inr ExtraLabel.clearInput)
(some (.inr .clockCopy)) program rfl (frame rest original counter [] [])
MachineLogCounter.initialState none).evals_in_steps
change (MachineComposition.advance (TM2.step program))^[rest.length + 1]
(some ⟨some (.inr .clearInput), initialState, frame rest original counter [] []⟩) = _ at h
have update : Function.update (frame rest original counter [] []) (.inr .input) [] =
frame [] original counter [] [] := by
funext tape
cases tape with
| inl i => simp [frame]
| inr k => cases k <;> simp [frame]
simpa only [update, initialState] using h
theorem clockCopyTrace (original counter : List Bool) :
(MachineComposition.advance (TM2.step program))^[counter.length + 1]
(some ⟨some (.inr .clockCopy), initialState, frame [] original counter [] []⟩) =
some ⟨some (.inr .archiveCopy), initialState, frame [] original [] counter.reverse []⟩ := by
have h := (Reduction.MachineTransfer.transferAtInTime (Sum.inl (2 : Fin 3))
(Sum.inr ExtraTape.scratch) (by decide) id false (.inr .clockCopy)
(some (.inr .archiveCopy)) program rfl (frame [] original counter [] [])
MachineLogCounter.initialState none).evals_in_steps
change (MachineComposition.advance (TM2.step program))^[counter.length + 1]
(some ⟨some (.inr .clockCopy), initialState, frame [] original counter [] []⟩) = _ at h
have update : Reduction.MachineTransfer.tapesAt (Sum.inl (2 : Fin 3))
(Sum.inr ExtraTape.scratch) (frame [] original counter [] []) []
((frame [] original counter [] [] (.inl 2)).reverse.map id ++
frame [] original counter [] [] (.inr .scratch)) =
frame [] original [] counter.reverse [] := by
funext tape
cases tape with
| inl i => fin_cases i <;> simp [Reduction.MachineTransfer.tapesAt, frame]
| inr k => cases k <;> simp [Reduction.MachineTransfer.tapesAt, frame]
simpa only [update, initialState] using h
theorem archiveCopyTrace (original counter : List Bool) :
(MachineComposition.advance (TM2.step program))^[original.length + 1]
(some ⟨some (.inr .archiveCopy), initialState, frame [] original [] counter.reverse []⟩) =
some ⟨some (.inr .finalReverse), initialState,
frame [] [] [] (original.reverse ++ counter.reverse) []⟩ := by
have h := (Reduction.MachineTransfer.transferAtInTime (Sum.inr ExtraTape.archive)
(Sum.inr ExtraTape.scratch) (by decide) id false (.inr .archiveCopy)
(some (.inr .finalReverse)) program rfl (frame [] original [] counter.reverse [])
MachineLogCounter.initialState none).evals_in_steps
change (MachineComposition.advance (TM2.step program))^[original.length + 1]
(some ⟨some (.inr .archiveCopy), initialState, frame [] original [] counter.reverse []⟩) = _ at h
have update : Reduction.MachineTransfer.tapesAt (Sum.inr ExtraTape.archive)
(Sum.inr ExtraTape.scratch) (frame [] original [] counter.reverse []) []
((frame [] original [] counter.reverse [] (.inr .archive)).reverse.map id ++
frame [] original [] counter.reverse [] (.inr .scratch)) =
frame [] [] [] (original.reverse ++ counter.reverse) [] := by
funext tape
cases tape with
| inl i => simp [Reduction.MachineTransfer.tapesAt, frame]
| inr k => cases k <;> simp [Reduction.MachineTransfer.tapesAt, frame]
simpa only [update, initialState] using h
theorem reverseTrace (original counter : List Bool) :
(MachineComposition.advance (TM2.step program))^[original.length + counter.length + 1]
(some ⟨some (.inr .finalReverse), initialState,
frame [] [] [] (original.reverse ++ counter.reverse) []⟩) =
some (haltList machine (counter ++ original)) := by
have h := (Reduction.MachineTransfer.transferAtInTime (Sum.inr ExtraTape.scratch)
(Sum.inr ExtraTape.output) (by decide) id false (.inr .finalReverse) none program rfl
(frame [] [] [] (original.reverse ++ counter.reverse) []) MachineLogCounter.initialState none).evals_in_steps
change (MachineComposition.advance (TM2.step program))^[
(original.reverse ++ counter.reverse).length + 1]
(some ⟨some (.inr .finalReverse), initialState,
frame [] [] [] (original.reverse ++ counter.reverse) []⟩) = _ at h
have update : Reduction.MachineTransfer.tapesAt (Sum.inr ExtraTape.scratch)
(Sum.inr ExtraTape.output) (frame [] [] [] (original.reverse ++ counter.reverse) []) []
((frame [] [] [] (original.reverse ++ counter.reverse) [] (.inr .scratch)).reverse.map id ++
frame [] [] [] (original.reverse ++ counter.reverse) [] (.inr .output)) =
frame [] [] [] [] (counter ++ original) := by
funext tape
cases tape with
| inl i => simp [Reduction.MachineTransfer.tapesAt, frame]
| inr k => cases k <;> simp [Reduction.MachineTransfer.tapesAt, frame]
rw [update] at h
rw [← finish_eq]
simp only [List.length_append, List.length_reverse] at h
exact h
theorem finishTrace (counter rest original : List Bool) :
(MachineComposition.advance (TM2.step program))^[
rest.length + 2 * counter.length + 2 * original.length + 4]
(some (clockConfiguration (extraTapes rest original) none
(haltList MachineLogCounter.machine counter))) =
some (haltList machine (counter ++ original)) := by
rw [start_eq]
have total := trace_trans _
(trace_trans _ (trace_trans _ (drainTrace rest original counter)
(clockCopyTrace original counter)) (archiveCopyTrace original counter))
(reverseTrace original counter)
simpa only [show rest.length + 1 + (counter.length + 1) + (original.length + 1) +
(original.length + counter.length + 1) =
rest.length + 2 * counter.length + 2 * original.length + 4 by omega] using total
def finishInTime (counter rest original : List Bool) :
StateTransition.EvalsToInTime (TM2.step program)
(clockConfiguration (extraTapes rest original) none (haltList MachineLogCounter.machine counter))
(some (haltList machine (counter ++ original)))
(rest.length + 2 * counter.length + 2 * original.length + 4) where
steps := rest.length + 2 * counter.length + 2 * original.length + 4
evals_in_steps := finishTrace counter rest original
steps_le_m := le_rfl
end UniqueGamesTheorem.Foundations.Complexity.GraphCounterFinish
end OAI
|