File size: 9,080 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 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 | import OAI.Computability.UniqueGames.PCP.EmitRows
import OAI.Computability.UniqueGames.PCP.RuntimeModel
namespace OAI
section
/-!
Exact tape invariant for the old-dart loop. The cursor stores the remaining
input rows, while the reversed tape stores precisely the output headers and
the blocks already emitted. The scan and index-scan tapes are unconstrained:
the next lookup prefixes fresh copies and retains old residues as suffixes.
Finite control state is specified by the actual execution theorems using this
tape invariant.
-/
namespace UniqueGamesTheorem.Foundations.PCP.AlphabetTable.LoopState
open UniqueGamesTheorem.Foundations.Complexity
open RuntimeModel
variable {q : Nat}
def inputBits (input : GenericGraphTables.Table q) : List Bool :=
GenericGraphTables.tableBits input
/-- The output headers are included even before the first old row is read. -/
def prefixWords (input : GenericGraphTables.Table q) (e : Nat) : List Nat :=
[Enumeration.vertexCount input.vertices input.darts q,
Enumeration.dartCount input.darts q] ++
((List.finRange input.darts).take e).flatMap (EmitRows.blockWords input)
def prefixBits (input : GenericGraphTables.Table q) (e : Nat) : List Bool :=
encodeWords (prefixWords input e)
def cursorWords (input : GenericGraphTables.Table q) (e : Nat) : List Nat :=
((GenericGraphTables.rowList input).drop e).flatMap GenericGraphTables.rowWords
def cursorBits (input : GenericGraphTables.Table q) (e : Nat) : List Bool :=
encodeWords (cursorWords input e)
@[simp] theorem prefixWords_zero (input : GenericGraphTables.Table q) :
prefixWords input 0 =
[Enumeration.vertexCount input.vertices input.darts q,
Enumeration.dartCount input.darts q] := by
simp [prefixWords]
@[simp] theorem prefixBits_zero (input : GenericGraphTables.Table q) :
prefixBits input 0 = encodeWords
[Enumeration.vertexCount input.vertices input.darts q,
Enumeration.dartCount input.darts q] := by
rw [prefixBits, prefixWords_zero]
theorem prefixWords_succ (input : GenericGraphTables.Table q) (e : Nat)
(he : e < input.darts) :
prefixWords input (e + 1) =
prefixWords input e ++ EmitRows.blockWords input ⟨e, he⟩ := by
have bound : e < (List.finRange input.darts).length := by simpa using he
have take := List.take_succ_eq_append_getElem bound
have atIndex : (List.finRange input.darts)[e]'bound = (⟨e, he⟩ : Fin input.darts) := by
simp
rw [atIndex] at take
unfold prefixWords
rw [take, List.flatMap_append]
simp only [List.flatMap_cons, List.flatMap_nil, List.append_nil, List.append_assoc]
theorem prefixBits_succ (input : GenericGraphTables.Table q) (e : Nat)
(he : e < input.darts) :
prefixBits input (e + 1) =
prefixBits input e ++ encodeWords (EmitRows.blockWords input ⟨e, he⟩) := by
rw [prefixBits, prefixWords_succ input e he, encodeWords_append]
rfl
theorem prefixBits_reverse_succ (input : GenericGraphTables.Table q) (e : Nat)
(he : e < input.darts) :
(prefixBits input (e + 1)).reverse =
(encodeWords (EmitRows.blockWords input ⟨e, he⟩)).reverse ++
(prefixBits input e).reverse := by
rw [prefixBits_succ input e he, List.reverse_append]
theorem prefixWords_full (input : GenericGraphTables.Table q) :
prefixWords input input.darts = GraphTables.tableWords (Table.build input) := by
have allRows : (List.finRange input.darts).take input.darts = List.finRange input.darts := by
apply List.take_of_length_le
simp
unfold prefixWords
rw [allRows]
exact (EmitRows.tableWords_eq_blocks input).symm
/-- At the terminal guard the stored prefix is the complete concrete output encoding. -/
theorem prefixBits_full (input : GenericGraphTables.Table q) :
prefixBits input input.darts = GraphTables.tableBits (Table.build input) := by
rw [prefixBits, prefixWords_full]
rfl
@[simp] theorem cursorBits_zero (input : GenericGraphTables.Table q) :
cursorBits input 0 =
encodeWords ((GenericGraphTables.rowList input).flatMap GenericGraphTables.rowWords) := by
simp [cursorBits, cursorWords]
theorem cursorWords_succ (input : GenericGraphTables.Table q) (e : Nat)
(he : e < input.darts) :
cursorWords input e =
GenericGraphTables.rowWords input.rows[(⟨e, he⟩ : Fin input.darts)] ++
cursorWords input (e + 1) := by
have bound : e < (GenericGraphTables.rowList input).length := by
simpa only [GenericGraphTables.rowList_length] using he
unfold cursorWords
rw [List.drop_eq_getElem_cons bound, List.flatMap_cons]
simp only [GenericGraphTables.rowList, Vector.getElem_toList, Fin.getElem_fin]
theorem cursorBits_succ (input : GenericGraphTables.Table q) (e : Nat)
(he : e < input.darts) :
cursorBits input e =
encodeWords (GenericGraphTables.rowWords input.rows[(⟨e, he⟩ : Fin input.darts)]) ++
cursorBits input (e + 1) := by
rw [cursorBits, cursorWords_succ input e he, encodeWords_append]
rfl
@[simp] theorem cursorBits_full (input : GenericGraphTables.Table q) :
cursorBits input input.darts = [] := by
have finished := List.drop_length (l := GenericGraphTables.rowList input)
rw [GenericGraphTables.rowList_length] at finished
unfold cursorBits cursorWords
rw [finished]
rfl
/-- Guard-to-guard tape contract. Only scan and indexScan may contain residues. -/
structure Ready (input : GenericGraphTables.Table q) (e : Nat)
(base : Tape → List Bool) : Prop where
le_darts : e ≤ input.darts
original : base .original = inputBits input
cursor : base .cursor = cursorBits input e
vertices : base .vertices = encodeWord input.vertices
darts : base .darts = encodeWord input.darts
counter : base .counter = encodeWord (input.darts - e)
edge : base .edge = encodeWord e
tail : base .tail = []
reverseIndex : base .reverseIndex = []
head : base .head = []
scratch : base .scratch = []
compareLeft : base .compareLeft = []
compareRight : base .compareRight = []
output : base .output = []
reversed : base .reversed = (prefixBits input e).reverse
/-- Changing only lookup residues preserves the complete loop contract. -/
theorem Ready.of_agree {input : GenericGraphTables.Table q} {e : Nat}
{base next : Tape → List Bool} (ready : Ready input e base)
(agree : ∀ tape, tape ≠ .scan → tape ≠ .indexScan → next tape = base tape) :
Ready input e next where
le_darts := ready.le_darts
original := (agree .original (by decide) (by decide)).trans ready.original
cursor := (agree .cursor (by decide) (by decide)).trans ready.cursor
vertices := (agree .vertices (by decide) (by decide)).trans ready.vertices
darts := (agree .darts (by decide) (by decide)).trans ready.darts
counter := (agree .counter (by decide) (by decide)).trans ready.counter
edge := (agree .edge (by decide) (by decide)).trans ready.edge
tail := (agree .tail (by decide) (by decide)).trans ready.tail
reverseIndex := (agree .reverseIndex (by decide) (by decide)).trans ready.reverseIndex
head := (agree .head (by decide) (by decide)).trans ready.head
scratch := (agree .scratch (by decide) (by decide)).trans ready.scratch
compareLeft := (agree .compareLeft (by decide) (by decide)).trans ready.compareLeft
compareRight := (agree .compareRight (by decide) (by decide)).trans ready.compareRight
output := (agree .output (by decide) (by decide)).trans ready.output
reversed := (agree .reversed (by decide) (by decide)).trans ready.reversed
theorem Ready.update_scan {input : GenericGraphTables.Table q} {e : Nat}
{base : Tape → List Bool} (ready : Ready input e base) (word : List Bool) :
Ready input e (Function.update base .scan word) := by
apply ready.of_agree
intro tape notScan _
simp [notScan]
theorem Ready.update_indexScan {input : GenericGraphTables.Table q} {e : Nat}
{base : Tape → List Bool} (ready : Ready input e base) (word : List Bool) :
Ready input e (Function.update base .indexScan word) := by
apply ready.of_agree
intro tape _ notIndexScan
simp [notIndexScan]
theorem Ready.counter_succ {input : GenericGraphTables.Table q} {e : Nat}
{base : Tape → List Bool} (ready : Ready input e base) (he : e < input.darts) :
base .counter = encodeWord (input.darts - (e + 1) + 1) := by
rw [ready.counter]
congr 1
omega
theorem Ready.counter_at_end {input : GenericGraphTables.Table q}
{base : Tape → List Bool} (ready : Ready input input.darts base) :
base .counter = encodeWord 0 := by
simpa only [Nat.sub_self] using ready.counter
theorem Ready.cursor_at_end {input : GenericGraphTables.Table q}
{base : Tape → List Bool} (ready : Ready input input.darts base) :
base .cursor = [] := ready.cursor.trans (cursorBits_full input)
theorem Ready.reversed_at_end {input : GenericGraphTables.Table q}
{base : Tape → List Bool} (ready : Ready input input.darts base) :
base .reversed = (GraphTables.tableBits (Table.build input)).reverse := by
rw [ready.reversed, prefixBits_full]
end UniqueGamesTheorem.Foundations.PCP.AlphabetTable.LoopState
end
end OAI
|