File size: 7,429 Bytes
2f887db | 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 | import Mathlib
import OAI.Computability.MinUncut.PCP.GraphGap
namespace OAI
section
namespace MinUncutGames.Foundations.PCP.PreprocessingLazyWords
open PortTables GraphTables PreprocessingOverlayTables
open MinUncutGames.Foundations.Complexity
variable {n d : Nat}
def row (table : PortTables.Table n d) (v : Fin n) (p : Fin d) :
DartRow n (n * d) :=
⟨v, table.reverseIndex[rowIndex n d (v, p)], table.relations[rowIndex n d (v, p)]⟩
def trueRelation : RelationTable := Vector.replicate 4096 true
def stayRow (d : Nat) (v : Fin n) (p : Fin d) : DartRow n (n * (2 * d)) :=
⟨v, rowIndex n (2 * d) (v, lazyPorts d (false, p)), trueRelation⟩
def moveRow (table : PortTables.Table n d) (v : Fin n) (p : Fin d) :
DartRow n (n * (2 * d)) :=
⟨v, rowIndex n (2 * d) ((rotation table (v, p)).1,
lazyPorts d (true, (rotation table (v, p)).2)),
table.relations[rowIndex n d (v, p)]⟩
def reverseMap (d j : Nat) : Nat := 2 * d * (j / d) + d + j % d
theorem relation_ext {r s : RelationTable}
(h : ∀ a b, relationAt r a b = relationAt s a b) : r = s := by
apply Vector.ext
intro i hi
simpa only [relationAt, Prod.eta, Equiv.apply_symm_apply, Fin.getElem_fin] using
h (relationIndex.symm ⟨i, hi⟩).1 (relationIndex.symm ⟨i, hi⟩).2
theorem row_lazy_stay (table : PortTables.Table n d) (v : Fin n) (p : Fin d) :
row (lazy table) v (lazyPorts d (false, p)) = stayRow d v p := by
have hr : (lazy table).reverseIndex[rowIndex n (2 * d) (v, lazyPorts d (false, p))] =
rowIndex n (2 * d) (v, lazyPorts d (false, p)) := by
rw [← rowIndex_rotation, lazy_rotation_false]
have hp : (lazy table).relations[rowIndex n (2 * d) (v, lazyPorts d (false, p))] =
trueRelation := by
apply relation_ext
intro a b
simpa only [PortTables.accepts, relationAt, trueRelation, Fin.getElem_fin,
Vector.getElem_replicate] using lazy_accepts_false table v p a b
exact congrArg₂ (DartRow.mk v) hr hp
theorem row_lazy_move (table : PortTables.Table n d) (v : Fin n) (p : Fin d) :
row (lazy table) v (lazyPorts d (true, p)) = moveRow table v p := by
have hr : (lazy table).reverseIndex[rowIndex n (2 * d) (v, lazyPorts d (true, p))] =
rowIndex n (2 * d) ((rotation table (v, p)).1,
lazyPorts d (true, (rotation table (v, p)).2)) := by
rw [← rowIndex_rotation, lazy_rotation_true]
have hp : (lazy table).relations[rowIndex n (2 * d) (v, lazyPorts d (true, p))] =
table.relations[rowIndex n d (v, p)] := by
apply relation_ext
intro a b
exact lazy_accepts_true table v p a b
exact congrArg₂ (DartRow.mk v) hr hp
theorem stayRow_reverse_val (v : Fin n) (p : Fin d) :
(stayRow d v p).reverseIndex.val = 2 * d * v.val + p.val := by
simp only [stayRow, rowIndex_val, lazyPorts_false_val]
omega
theorem moveRow_reverse_val (table : PortTables.Table n d) (v : Fin n) (p : Fin d) :
(moveRow table v p).reverseIndex.val =
reverseMap d (row table v p).reverseIndex.val := by
simp only [moveRow, rowIndex_val, lazyPorts_true_val, reverseMap, row]
change (table.reverseIndex[rowIndex n d (v, p)]).val % d + d +
(2 * d) * ((table.reverseIndex[rowIndex n d (v, p)]).val / d) = _
omega
theorem relationWords_true : relationWords trueRelation = List.replicate 4096 1 := by
simp only [relationWords, trueRelation, Vector.toList_replicate,
List.map_replicate, bitWord, ite_true]
theorem stayRow_words (v : Fin n) (p : Fin d) :
rowWords (stayRow d v p) =
[v.val, 2 * d * v.val + p.val] ++ List.replicate 4096 1 := by
rw [rowWords, stayRow_reverse_val]
exact congrArg (fun words => [v.val, 2 * d * v.val + p.val] ++ words) relationWords_true
theorem moveRow_words (table : PortTables.Table n d) (v : Fin n) (p : Fin d) :
rowWords (moveRow table v p) =
[v.val, reverseMap d (row table v p).reverseIndex.val] ++
relationWords (row table v p).relation := by
rw [rowWords, moveRow_reverse_val]
rfl
theorem ofFn_rowIndex {α : Type*} (f : Fin (n * d) → α) :
List.ofFn f = (List.ofFn fun v : Fin n =>
List.ofFn fun p : Fin d => f (rowIndex n d (v, p))).flatten := by
rw [List.ofFn_mul]
apply congrArg List.flatten
congr 1
funext v
congr 1
funext p
apply congrArg f
apply Fin.ext
simp only [rowIndex_val]
ac_rfl
theorem flatRows_list (table : PortTables.Table n d) :
(flatRows table).toList =
(List.ofFn fun v : Fin n => List.ofFn (row table v)).flatten := by
rw [flatRows, Vector.toList_ofFn, ofFn_rowIndex]
simp only [Equiv.symm_apply_apply]
rfl
theorem ofFn_lazyPorts {α : Type*} (f : Fin (2 * d) → α) :
List.ofFn f = List.ofFn (fun p => f (lazyPorts d (false, p))) ++
List.ofFn (fun p => f (lazyPorts d (true, p))) := by
have hf (p : Fin d) : rowIndex 2 d (0, p) = lazyPorts d (false, p) := by
apply Fin.ext
simp only [rowIndex_val, Fin.val_zero, Nat.mul_zero, Nat.add_zero, lazyPorts_false_val]
have ht (p : Fin d) : rowIndex 2 d ((0 : Fin 1).succ, p) = lazyPorts d (true, p) := by
apply Fin.ext
simp only [rowIndex_val, Fin.val_succ, Fin.val_zero, Nat.zero_add,
Nat.mul_one, lazyPorts_true_val]
simpa only [List.ofFn_succ, List.ofFn_zero, List.flatten_cons, List.flatten_nil,
List.append_nil, hf, ht] using (ofFn_rowIndex (n := 2) (d := d) f)
def vertexRows (table : PortTables.Table n d) (v : Fin n) :
List (DartRow n (n * (2 * d))) :=
List.ofFn (stayRow d v) ++ List.ofFn (moveRow table v)
theorem vertexRows_length (table : PortTables.Table n d) (v : Fin n) :
(vertexRows table v).length = 2 * d := by
simp only [vertexRows, List.length_append, List.length_ofFn]
omega
theorem flatRows_lazy (table : PortTables.Table n d) :
(flatRows (lazy table)).toList = (List.ofFn (vertexRows table)).flatten := by
rw [flatRows_list]
apply congrArg List.flatten
congr 1
funext v
rw [ofFn_lazyPorts]
simp only [row_lazy_stay, row_lazy_move]
rfl
theorem vertexRows_words (table : PortTables.Table n d) (v : Fin n) :
(vertexRows table v).flatMap rowWords =
(List.ofFn fun p : Fin d =>
[v.val, 2 * d * v.val + p.val] ++ List.replicate 4096 1).flatten ++
(List.ofFn fun p : Fin d =>
[v.val, reverseMap d (row table v p).reverseIndex.val] ++
relationWords (row table v p).relation).flatten := by
have hs : rowWords ∘ stayRow d v = fun p : Fin d =>
[v.val, 2 * d * v.val + p.val] ++ List.replicate 4096 1 := by
funext p
exact stayRow_words v p
have hm : rowWords ∘ moveRow table v = fun p : Fin d =>
[v.val, reverseMap d (row table v p).reverseIndex.val] ++
relationWords (row table v p).relation := by
funext p
exact moveRow_words table v p
simp only [vertexRows, List.flatMap_def, List.map_append, List.map_ofFn,
List.flatten_append]
rw [hs, hm]
theorem tableWords_lazy (table : PortTables.Table n d) :
PortTables.tableWords (lazy table) =
[n, n * (2 * d)] ++ (List.ofFn (vertexRows table)).flatten.flatMap rowWords := by
rw [PortTables.tableWords_eq, flatRows_lazy]
theorem tableBits_lazy (table : PortTables.Table n d) :
PortTables.tableBits (lazy table) =
encodeWords ([n, n * (2 * d)] ++
(List.ofFn (vertexRows table)).flatten.flatMap rowWords) := by
change encodeWords (PortTables.tableWords (lazy table)) = _
rw [tableWords_lazy]
end MinUncutGames.Foundations.PCP.PreprocessingLazyWords
end
end OAI
|