math / data /lean /OAI /Computability /MinUncut /PCP /GraphTables.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
30.9 kB
import Mathlib
import OAI.Computability.MinUncut.PCP.Generator
import OAI.Computability.MinUncut.Encoding.GameEncoding
namespace OAI
section
namespace MinUncutGames.Foundations.PCP.GraphTables
open MinUncutGames.Foundations.Complexity
abbrev Label := Fin 64
abbrev RelationTable := Vector Bool 4096
def relationIndex : Label × Label ≃ Fin 4096 := finProdFinEquiv
theorem relationIndex_val (a b : Label) :
(relationIndex (a, b)).val = b.val + 64 * a.val := rfl
def relationAt (table : RelationTable) (a b : Label) : Bool :=
table[relationIndex (a, b)]
def relationOf (predicate : Label → Label → Bool) : RelationTable :=
Vector.ofFn (fun i => predicate (relationIndex.symm i).1 (relationIndex.symm i).2)
@[simp] theorem relationAt_relationOf (predicate : Label → Label → Bool) (a b : Label) :
relationAt (relationOf predicate) a b = predicate a b := by
simp [relationAt, relationOf]
structure DartRow (vertices darts : Nat) where
tail : Fin vertices
reverseIndex : Fin darts
relation : RelationTable
abbrev Rows (vertices darts : Nat) := Vector (DartRow vertices darts) darts
def reverseAt {n m : Nat} (rows : Rows n m) (e : Fin m) : Fin m :=
rows[e].reverseIndex
def acceptsAt {n m : Nat} (rows : Rows n m) (e : Fin m) (a b : Label) : Bool :=
relationAt rows[e].relation a b
def Valid {n m : Nat} (rows : Rows n m) : Prop :=
(∀ e, reverseAt rows (reverseAt rows e) = e) ∧
(∀ e a b, acceptsAt rows (reverseAt rows e) b a = acceptsAt rows e a b)
instance {n m : Nat} (rows : Rows n m) : Decidable (Valid rows) := by
unfold Valid
infer_instance
structure Table where
vertices : Nat
darts : Nat
rows : Rows vertices darts
valid : Valid rows
def rowList (table : Table) : List (DartRow table.vertices table.darts) := table.rows.toList
@[simp] theorem rowList_length (table : Table) : (rowList table).length = table.darts := by
simp [rowList]
def semantics (table : Table) : ConstraintGraph (Fin table.vertices) (Fin table.darts) Label where
reverse :=
{ toFun := reverseAt table.rows
invFun := reverseAt table.rows
left_inv := table.valid.1
right_inv := table.valid.1 }
reverse_involutive := table.valid.1
tail e := table.rows[e].tail
accepts := acceptsAt table.rows
reverse_accepts := table.valid.2
@[simp] theorem semantics_reverse (table : Table) (e : Fin table.darts) :
(semantics table).reverse e = table.rows[e].reverseIndex := rfl
@[simp] theorem semantics_tail (table : Table) (e : Fin table.darts) :
(semantics table).tail e = table.rows[e].tail := rfl
@[simp] theorem semantics_accepts (table : Table) (e : Fin table.darts) (a b : Label) :
(semantics table).accepts e a b = relationAt table.rows[e].relation a b := rfl
def graphRows {n m : Nat} (G : ConstraintGraph (Fin n) (Fin m) Label) : Rows n m :=
Vector.ofFn (fun e => ⟨G.tail e, G.reverse e, relationOf (G.accepts e)⟩)
@[simp] theorem reverseAt_graphRows {n m : Nat}
(G : ConstraintGraph (Fin n) (Fin m) Label) (e : Fin m) :
reverseAt (graphRows G) e = G.reverse e := by
simp [reverseAt, graphRows]
@[simp] theorem acceptsAt_graphRows {n m : Nat}
(G : ConstraintGraph (Fin n) (Fin m) Label) (e : Fin m) (a b : Label) :
acceptsAt (graphRows G) e a b = G.accepts e a b := by
simp [acceptsAt, graphRows]
theorem graphRows_valid {n m : Nat} (G : ConstraintGraph (Fin n) (Fin m) Label) :
Valid (graphRows G) := by
constructor
· intro e
simpa using G.reverse_involutive e
· intro e a b
simpa using G.reverse_accepts e a b
def ofGraph {n m : Nat} (G : ConstraintGraph (Fin n) (Fin m) Label) : Table :=
⟨n, m, graphRows G, graphRows_valid G⟩
@[simp] theorem semantics_ofGraph_reverse {n m : Nat}
(G : ConstraintGraph (Fin n) (Fin m) Label) (e : Fin m) :
(semantics (ofGraph G)).reverse e = G.reverse e := by
exact reverseAt_graphRows G e
@[simp] theorem semantics_ofGraph_tail {n m : Nat}
(G : ConstraintGraph (Fin n) (Fin m) Label) (e : Fin m) :
(semantics (ofGraph G)).tail e = G.tail e := by
change (graphRows G)[e.val].tail = G.tail e
simp only [graphRows, Vector.getElem_ofFn]
@[simp] theorem semantics_ofGraph_accepts {n m : Nat}
(G : ConstraintGraph (Fin n) (Fin m) Label) (e : Fin m) (a b : Label) :
(semantics (ofGraph G)).accepts e a b = G.accepts e a b := by
exact acceptsAt_graphRows G e a b
@[simp] theorem semantics_ofGraph_edgeSatisfied {n m : Nat}
(G : ConstraintGraph (Fin n) (Fin m) Label) (labeling : Fin n → Label) (e : Fin m) :
(semantics (ofGraph G)).edgeSatisfied labeling e = G.edgeSatisfied labeling e := by
simp [ConstraintGraph.edgeSatisfied, ConstraintGraph.head]
theorem constraintGraph_ext {V E A : Type*} {G H : ConstraintGraph V E A}
(hr : ∀ e, G.reverse e = H.reverse e) (ht : G.tail = H.tail)
(hp : G.accepts = H.accepts) : G = H := by
cases G with
| mk reverse hinv tail accepts htranspose =>
cases H with
| mk reverse' hinv' tail' accepts' htranspose' =>
dsimp only at hr ht hp
have he : reverse = reverse' := Equiv.ext hr
cases he
cases ht
cases hp
rfl
@[simp] theorem semantics_ofGraph {n m : Nat}
(G : ConstraintGraph (Fin n) (Fin m) Label) : semantics (ofGraph G) = G := by
apply constraintGraph_ext
· exact semantics_ofGraph_reverse G
· funext e
exact semantics_ofGraph_tail G e
· funext e a b
exact semantics_ofGraph_accepts G e a b
@[simp] theorem semantics_ofGraph_rejectionCount {n m : Nat}
(G : ConstraintGraph (Fin n) (Fin m) Label) (labeling : Fin n → Label) :
(semantics (ofGraph G)).rejectionCount labeling = G.rejectionCount labeling := by
rw [semantics_ofGraph]
rfl
def enumeratedGraph {V E A : Type*} {n m : Nat} (G : ConstraintGraph V E A)
(vertexOrder : V ≃ Fin n) (dartOrder : E ≃ Fin m) (labelOrder : A ≃ Label) :
ConstraintGraph (Fin n) (Fin m) Label where
reverse := (dartOrder.symm.trans G.reverse).trans dartOrder
reverse_involutive e := by
change dartOrder (G.reverse (dartOrder.symm
(dartOrder (G.reverse (dartOrder.symm e))))) = e
rw [dartOrder.symm_apply_apply, G.reverse_involutive, dartOrder.apply_symm_apply]
tail e := vertexOrder (G.tail (dartOrder.symm e))
accepts e a b := G.accepts (dartOrder.symm e) (labelOrder.symm a) (labelOrder.symm b)
reverse_accepts e a b := by
change G.accepts (dartOrder.symm (dartOrder (G.reverse (dartOrder.symm e))))
(labelOrder.symm b) (labelOrder.symm a) = _
rw [dartOrder.symm_apply_apply]
exact G.reverse_accepts _ _ _
theorem enumeratedGraph_edgeSatisfied {V E A : Type*} {n m : Nat}
(G : ConstraintGraph V E A) (vertexOrder : V ≃ Fin n) (dartOrder : E ≃ Fin m)
(labelOrder : A ≃ Label) (labeling : V → A) (e : E) :
(enumeratedGraph G vertexOrder dartOrder labelOrder).edgeSatisfied
(fun v => labelOrder (labeling (vertexOrder.symm v))) (dartOrder e) =
G.edgeSatisfied labeling e := by
simp [ConstraintGraph.edgeSatisfied, ConstraintGraph.head, enumeratedGraph]
theorem enumeratedGraph_rejectionCount {V E A : Type*} [Fintype E] {n m : Nat}
(G : ConstraintGraph V E A) (vertexOrder : V ≃ Fin n) (dartOrder : E ≃ Fin m)
(labelOrder : A ≃ Label) (labeling : V → A) :
(enumeratedGraph G vertexOrder dartOrder labelOrder).rejectionCount
(fun v => labelOrder (labeling (vertexOrder.symm v))) = G.rejectionCount labeling := by
classical
unfold ConstraintGraph.rejectionCount
symm
apply Finset.card_equiv dartOrder
intro e
simp only [ConstraintGraph.mem_rejectedDarts, enumeratedGraph_edgeSatisfied]
def ofEnumeratedGraph {V E A : Type*} {n m : Nat} (G : ConstraintGraph V E A)
(vertexOrder : V ≃ Fin n) (dartOrder : E ≃ Fin m) (labelOrder : A ≃ Label) : Table :=
ofGraph (enumeratedGraph G vertexOrder dartOrder labelOrder)
def bitWord (b : Bool) : Nat := if b then 1 else 0
def parseBit : Nat → Option Bool
| 0 => some false
| 1 => some true
| _ => none
@[simp] theorem parseBit_bitWord (b : Bool) : parseBit (bitWord b) = some b := by
cases b <;> rfl
@[simp] theorem parseBits_bitWords (bits : List Bool) :
(bits.map bitWord).mapM parseBit = some bits := by
induction bits with
| nil => rfl
| cons bit bits ih => simp [ih]
def relationWords (relation : RelationTable) : List Nat := relation.toList.map bitWord
@[simp] theorem relationWords_length (relation : RelationTable) :
(relationWords relation).length = 4096 := by simp [relationWords]
def parseRelation (words : List Nat) : Option RelationTable := do
let bits ← words.mapM parseBit
if length_ok : bits.length = 4096 then
some ⟨bits.toArray, by simpa using length_ok⟩
else none
@[simp] theorem parseRelation_encoded (relation : RelationTable) :
parseRelation (relationWords relation) = some relation := by
unfold parseRelation relationWords
rw [parseBits_bitWords]
simp
exact Vector.toArray_toList
def rowWords {n m : Nat} (row : DartRow n m) : List Nat :=
[row.tail.val, row.reverseIndex.val] ++ relationWords row.relation
def parseRow (vertices darts : Nat) : List Nat → Option (DartRow vertices darts × List Nat)
| tail :: reverseIndex :: words => do
let tail ← parseLabel vertices tail
let reverseIndex ← parseLabel darts reverseIndex
let relation ← parseRelation (words.take 4096)
return (⟨tail, reverseIndex, relation⟩, words.drop 4096)
| _ => none
@[simp] theorem parseRow_encoded {n m : Nat} (row : DartRow n m) (rest : List Nat) :
parseRow n m (rowWords row ++ rest) = some (row, rest) := by
cases row with
| mk tail reverseIndex relation =>
have taken := List.take_left' (l₂ := rest) (relationWords_length relation)
have dropped := List.drop_left' (l₂ := rest) (relationWords_length relation)
simp [rowWords, parseRow, taken, dropped]
def parseRows (vertices darts : Nat) :
Nat → List Nat → Option (List (DartRow vertices darts) × List Nat)
| 0, words => some ([], words)
| count + 1, words => do
let (row, words) ← parseRow vertices darts words
let (rows, words) ← parseRows vertices darts count words
return (row :: rows, words)
@[simp] theorem parseRows_encoded {n m : Nat} (rows : List (DartRow n m)) (rest : List Nat) :
parseRows n m rows.length (rows.flatMap rowWords ++ rest) = some (rows, rest) := by
induction rows with
| nil => rfl
| cons row rows ih => simp [parseRows, List.append_assoc, ih]
def tableWords (table : Table) : List Nat :=
[table.vertices, table.darts] ++ (rowList table).flatMap rowWords
def tableBits (table : Table) : List Bool := encodeWords (tableWords table)
def decodeTableWords : List Nat → Option Table
| vertices :: darts :: words => do
let (parsed, trailing) ← parseRows vertices darts darts words
if trailing = [] then
if length_ok : parsed.length = darts then
let rows : Rows vertices darts := ⟨parsed.toArray, by simpa using length_ok⟩
if valid : Valid rows then some ⟨vertices, darts, rows, valid⟩ else none
else none
else none
| _ => none
@[simp] theorem decodeTableWords_encoded (table : Table) :
decodeTableWords (tableWords table) = some table := by
cases table with
| mk vertices darts rows valid =>
have parsed := parseRows_encoded rows.toList []
simp only [Vector.length_toList, List.append_nil] at parsed
simp [tableWords, rowList, decodeTableWords, parsed, valid, Vector.toArray_toList]
def decodeTableBits (bits : List Bool) : Option Table :=
decodeWords bits >>= decodeTableWords
@[simp] theorem decodeTableBits_encoded (table : Table) :
decodeTableBits (tableBits table) = some table := by
simp [decodeTableBits, tableBits]
def encoding : Computability.Encoding Table Bool where
encode := tableBits
decode := decodeTableBits
decode_encode := decodeTableBits_encoded
theorem tableBits_injective : Function.Injective tableBits := encoding.encode_injective
@[simp] theorem rowWords_length {n m : Nat} (row : DartRow n m) :
(rowWords row).length = 4098 := by simp [rowWords]
theorem rowsWords_length {n m : Nat} (rows : List (DartRow n m)) :
(rows.flatMap rowWords).length = 4098 * rows.length := by
induction rows with
| nil => rfl
| cons row rows ih => simp [ih, Nat.mul_add, Nat.add_comm]
@[simp] theorem tableWords_length (table : Table) :
(tableWords table).length = 2 + 4098 * table.darts := by
simp only [tableWords, List.length_append, List.length_cons, List.length_nil,
rowsWords_length, rowList_length]
theorem tableWords_length_le_bits (table : Table) :
2 + 4098 * table.darts ≤ (tableBits table).length := by
rw [tableBits, encodeWords_length, ← tableWords_length]
omega
theorem relationBits_length_le (relation : RelationTable) :
(encodeWords (relationWords relation)).length ≤ 8192 := by
have h := encodeWords_length_le (relationWords relation) 1 (by
intro word hword
obtain ⟨bit, _, rfl⟩ := List.mem_map.mp hword
cases bit <;> decide)
simpa only [relationWords_length] using h
theorem rowBits_length_le {n m : Nat} (row : DartRow n m) :
(encodeWords (rowWords row)).length ≤ n + m + 8192 := by
have ht := row.tail.isLt
have hr := row.reverseIndex.isLt
have hp := relationBits_length_le row.relation
simp only [rowWords, encodeWords_append, List.length_append, encodeWords,
encodeWord_length, List.length_nil] at ⊢
omega
theorem rowsBits_length_le {n m : Nat} (rows : List (DartRow n m)) :
(encodeWords (rows.flatMap rowWords)).length ≤ rows.length * (n + m + 8192) := by
induction rows with
| nil => simp [encodeWords]
| cons row rows ih =>
have hrow := rowBits_length_le row
simp only [List.flatMap_cons, encodeWords_append, List.length_append,
List.length_cons, Nat.add_mul, Nat.one_mul]
omega
theorem tableBits_length_le (table : Table) :
(tableBits table).length ≤ table.vertices + table.darts + 2 +
table.darts * (table.vertices + table.darts + 8192) := by
have hrows := rowsBits_length_le (rowList table)
rw [rowList_length] at hrows
simp only [tableBits, tableWords, encodeWords_append, List.length_append,
encodeWords, encodeWord_length, List.length_nil]
omega
theorem vertices_le_tableBits_length (table : Table) :
table.vertices ≤ (tableBits table).length := by
simp only [tableBits, tableWords, encodeWords_append, List.length_append,
encodeWords, encodeWord_length, List.length_nil]
omega
theorem darts_le_tableBits_length (table : Table) :
table.darts ≤ (tableBits table).length := by
simp only [tableBits, tableWords, encodeWords_append, List.length_append,
encodeWords, encodeWord_length, List.length_nil]
omega
end MinUncutGames.Foundations.PCP.GraphTables
end
section
namespace MinUncutGames.Foundations.PCP.PoweringWalks
structure PortGraph (V D : Type*) where
rot : (V × D) ≃ (V × D)
rot_involutive : Function.Involutive rot
abbrev Edge (V D : Type*) := V × D
abbrev Walk (V D : Type*) (t : Nat) := V × (Fin t → D)
variable {V D : Type*}
def next (G : PortGraph V D) (v : V) (d : D) : V := (G.rot (v, d)).1
@[simp] theorem rot_rot (G : PortGraph V D) (e : Edge V D) :
G.rot (G.rot e) = e := G.rot_involutive e
def walkEnd (G : PortGraph V D) : V → List D → V
| v, [] => v
| v, d :: ds => walkEnd G (next G v d) ds
@[simp] theorem walkEnd_nil (G : PortGraph V D) (v : V) : walkEnd G v [] = v := rfl
@[simp] theorem walkEnd_cons (G : PortGraph V D) (v : V) (d : D) (ds : List D) :
walkEnd G v (d :: ds) = walkEnd G (next G v d) ds := rfl
theorem walkEnd_append (G : PortGraph V D) (v : V) (as bs : List D) :
walkEnd G v (as ++ bs) = walkEnd G (walkEnd G v as) bs := by
induction as generalizing v with
| nil => rfl
| cons d ds ih => exact ih (next G v d)
def splitHead (V D : Type*) (n : Nat) :
Walk V D (n + 1) ≃ ((V × D) × (Fin n → D)) where
toFun w := ((w.1, w.2 0), fun j => w.2 j.succ)
invFun z := (z.1.1, Fin.cases z.1.2 z.2)
left_inv w := by
apply Prod.ext
· rfl
funext j
exact Fin.cases rfl (fun _ => rfl) j
right_inv z := rfl
def rotateHead (G : PortGraph V D) (n : Nat) : Walk V D (n + 1) ≃ Walk V D (n + 1) :=
(splitHead V D n).trans
((Equiv.prodCongr G.rot (Equiv.refl (Fin n → D))).trans (splitHead V D n).symm)
@[simp] theorem rotateHead_vertex (G : PortGraph V D) (n : Nat) (w : Walk V D (n + 1)) :
(rotateHead G n w).1 = next G w.1 (w.2 0) := rfl
@[simp] theorem rotateHead_zero (G : PortGraph V D) (n : Nat) (w : Walk V D (n + 1)) :
(rotateHead G n w).2 0 = (G.rot (w.1, w.2 0)).2 := rfl
@[simp] theorem rotateHead_succ (G : PortGraph V D) (n : Nat)
(w : Walk V D (n + 1)) (j : Fin n) :
(rotateHead G n w).2 j.succ = w.2 j.succ := rfl
def permutePorts {t : Nat} (σ : Fin t ≃ Fin t) : Walk V D t ≃ Walk V D t where
toFun w := (w.1, fun j => w.2 (σ j))
invFun w := (w.1, fun j => w.2 (σ.symm j))
left_inv w := by
apply Prod.ext
· rfl
funext j
exact congrArg w.2 (σ.apply_symm_apply j)
right_inv w := by
apply Prod.ext
· rfl
funext j
exact congrArg w.2 (σ.symm_apply_apply j)
def wordEnd (G : PortGraph V D) : (n : Nat) → V → (Fin n → D) → V
| 0, v, _ => v
| n + 1, v, p => wordEnd G n (next G v (p 0)) (fun j => p j.succ)
def endpoint (G : PortGraph V D) {n : Nat} (w : Walk V D n) : V :=
wordEnd G n w.1 w.2
theorem natCard_walk [Finite V] [Finite D] (n : Nat) :
Nat.card (Walk V D n) = Nat.card V * Nat.card D ^ n := by
simp [Walk, Nat.card_prod, Nat.card_fun]
def headTailEquiv (V D : Type*) (n : Nat) :
Walk V D (n + 1) ≃ (Walk V D n × D) where
toFun w := ((w.1, fun j => w.2 j.succ), w.2 0)
invFun z := (z.1.1, Fin.cases z.2 z.1.2)
left_inv w := by
apply Prod.ext
· rfl
· funext j
exact Fin.cases rfl (fun _ => rfl) j
right_inv z := rfl
def advanceTail {n : Nat} (G : PortGraph V D) (w : Walk V D (n + 1)) : Walk V D n :=
((G.rot (w.1, w.2 0)).1, fun j => w.2 j.succ)
def edgeAt (G : PortGraph V D) :
(n : Nat) → Walk V D (n + 1) → Fin (n + 1) → Edge V D
| 0, w, _ => (w.1, w.2 0)
| n + 1, w, k => Fin.cases (w.1, w.2 0)
(fun j => edgeAt G n (advanceTail G w) j) k
def pivotEquiv (G : PortGraph V D) :
(n : Nat) → Fin (n + 1) →
(Walk V D (n + 1) ≃ (Edge V D × (Fin n → D)))
| 0, _ => splitHead V D 0
| n + 1, k => Fin.cases (splitHead V D (n + 1))
(fun j => (rotateHead G (n + 1)).trans
((headTailEquiv V D (n + 1)).trans
((Equiv.prodCongr (pivotEquiv G n j) (Equiv.refl D)).trans
(headTailEquiv (Edge V D) D n).symm))) k
theorem pivotEquiv_fst (G : PortGraph V D) :
∀ (n : Nat) (k : Fin (n + 1)) (w : Walk V D (n + 1)),
(pivotEquiv G n k w).1 = edgeAt G n w k := by
intro n
induction n with
| zero => intro k w; rfl
| succ n ih =>
intro k w
refine Fin.cases ?_ (fun j => ?_) k
· rfl
· change (pivotEquiv G n j (advanceTail G w)).1 =
edgeAt G n (advanceTail G w) j
exact ih j (advanceTail G w)
theorem edgeAt_port (G : PortGraph V D) :
∀ (n : Nat) (w : Walk V D (n + 1)) (k : Fin (n + 1)),
(edgeAt G n w k).2 = w.2 k := by
intro n
induction n with
| zero =>
intro w k
have hk : k = 0 := Fin.eq_zero k
subst k
rfl
| succ n ih =>
intro w k
refine Fin.cases ?_ (fun j => ?_) k
· rfl
· exact ih (advanceTail G w) j
theorem pivotEquiv_zero_apply (G : PortGraph V D) (n : Nat) (w : Walk V D (n + 1)) :
pivotEquiv G n 0 w = ((w.1, w.2 0), fun j => w.2 j.succ) := by
cases n <;> rfl
theorem pivotEquiv_succ_apply (G : PortGraph V D)
(n : Nat) (k : Fin (n + 1)) (w : Walk V D (n + 2)) :
pivotEquiv G (n + 1) k.succ w =
((pivotEquiv G n k (advanceTail G w)).1,
Fin.cases (G.rot (w.1, w.2 0)).2
(pivotEquiv G n k (advanceTail G w)).2) := rfl
def projectedFiberEquiv {X E R : Type*} (e : X ≃ E × R) (f : X → E)
(he : ∀ x, (e x).1 = f x) (a : E) : {x // f x = a} ≃ R where
toFun x := (e x.val).2
invFun r := ⟨e.symm (a, r), by
exact (he _).symm.trans (congrArg Prod.fst (e.apply_symm_apply (a, r)))⟩
left_inv x := by
apply Subtype.ext
apply e.injective
rw [e.apply_symm_apply]
exact Prod.ext ((he x.val).trans x.property).symm rfl
right_inv r := congrArg Prod.snd (e.apply_symm_apply (a, r))
def projectedEventEquiv {X E R : Type*} (e : X ≃ E × R) (f : X → E)
(he : ∀ x, (e x).1 = f x) (P : E → Prop) :
{x // P (f x)} ≃ ({a // P a} × R) where
toFun x := (⟨(e x.val).1, by rw [he]; exact x.property⟩, (e x.val).2)
invFun ar := ⟨e.symm (ar.1.val, ar.2), by
have h : f (e.symm (ar.1.val, ar.2)) = ar.1.val :=
(he _).symm.trans (congrArg Prod.fst (e.apply_symm_apply (ar.1.val, ar.2)))
simpa only [h] using ar.1.property⟩
left_inv x := by
apply Subtype.ext
exact e.symm_apply_apply x.val
right_inv ar := by
apply Prod.ext
· apply Subtype.ext
exact congrArg Prod.fst (e.apply_symm_apply (ar.1.val, ar.2))
· change (e (e.symm (ar.1.val, ar.2))).2 = ar.2
exact congrArg Prod.snd (e.apply_symm_apply (ar.1.val, ar.2))
theorem natCard_edgeAt_fiber (G : PortGraph V D) (n : Nat) (k : Fin (n + 1))
(a : Edge V D) :
Nat.card {w : Walk V D (n + 1) // edgeAt G n w k = a} = Nat.card D ^ n := by
calc
_ = Nat.card (Fin n → D) := Nat.card_congr
(projectedFiberEquiv (pivotEquiv G n k) (fun w => edgeAt G n w k)
(pivotEquiv_fst G n k) a)
_ = _ := by simp [Nat.card_fun]
theorem natCard_edgeAt_event (G : PortGraph V D) (n : Nat) (k : Fin (n + 1))
(P : Edge V D → Prop) :
Nat.card {w : Walk V D (n + 1) // P (edgeAt G n w k)} =
Nat.card {a : Edge V D // P a} * Nat.card D ^ n := by
calc
_ = Nat.card ({a : Edge V D // P a} × (Fin n → D)) := Nat.card_congr
(projectedEventEquiv (pivotEquiv G n k) (fun w => edgeAt G n w k)
(pivotEquiv_fst G n k) P)
_ = _ := by simp [Nat.card_prod, Nat.card_fun]
def leftFromPivot (G : PortGraph V D) :
(n : Nat) → Fin (n + 1) → V → (Fin n → D) → V
| 0, _, v, _ => v
| n + 1, k, v, r => Fin.cases v
(fun j => next G (leftFromPivot G n j v (fun m => r m.succ)) (r 0)) k
def rightFromPivot (G : PortGraph V D) :
(n : Nat) → Fin (n + 1) → Edge V D → (Fin n → D) → V
| 0, _, e, _ => next G e.1 e.2
| n + 1, k, e, r => Fin.cases
(wordEnd G (n + 1) (next G e.1 e.2) r)
(fun j => rightFromPivot G n j e (fun m => r m.succ)) k
theorem leftFromPivot_zero (G : PortGraph V D) (n : Nat)
(v : V) (r : Fin n → D) : leftFromPivot G n 0 v r = v := by
cases n <;> rfl
theorem rightFromPivot_zero (G : PortGraph V D) (n : Nat)
(e : Edge V D) (r : Fin n → D) :
rightFromPivot G n 0 e r = wordEnd G n (next G e.1 e.2) r := by
cases n <;> rfl
theorem leftFromPivot_actual (G : PortGraph V D) :
∀ (n : Nat) (k : Fin (n + 1)) (w : Walk V D (n + 1)),
leftFromPivot G n k (pivotEquiv G n k w).1.1 (pivotEquiv G n k w).2 = w.1 := by
intro n
induction n with
| zero => intro k w; rfl
| succ n ih =>
intro k w
refine Fin.cases ?_ (fun j => ?_) k
· rfl
· rw [pivotEquiv_succ_apply]
change next G
(leftFromPivot G n j (pivotEquiv G n j (advanceTail G w)).1.1
(pivotEquiv G n j (advanceTail G w)).2)
(G.rot (w.1, w.2 0)).2 = w.1
rw [ih j (advanceTail G w)]
change (G.rot ((G.rot (w.1, w.2 0)).1, (G.rot (w.1, w.2 0)).2)).1 = w.1
exact congrArg Prod.fst (rot_rot G (w.1, w.2 0))
theorem rightFromPivot_actual (G : PortGraph V D) :
∀ (n : Nat) (k : Fin (n + 1)) (w : Walk V D (n + 1)),
rightFromPivot G n k (pivotEquiv G n k w).1 (pivotEquiv G n k w).2 =
endpoint G w := by
intro n
induction n with
| zero => intro k w; rfl
| succ n ih =>
intro k w
refine Fin.cases ?_ (fun j => ?_) k
· rfl
· rw [pivotEquiv_succ_apply]
change rightFromPivot G n j (pivotEquiv G n j (advanceTail G w)).1
(pivotEquiv G n j (advanceTail G w)).2 = endpoint G w
rw [ih j (advanceTail G w)]
rfl
end MinUncutGames.Foundations.PCP.PoweringWalks
end
section
namespace MinUncutGames.Foundations.PCP.PortTables
open PoweringWalks
abbrev Label := GraphTables.Label
def rowIndex (vertices ports : Nat) :
Fin vertices × Fin ports ≃ Fin (vertices * ports) := finProdFinEquiv
@[simp] theorem rowIndex_val (n d : Nat) (e : Fin n × Fin d) :
(rowIndex n d e).val = e.2.val + d * e.1.val := rfl
structure Table (vertices ports : Nat) where
reverseIndex : Vector (Fin (vertices * ports)) (vertices * ports)
relations : Vector GraphTables.RelationTable (vertices * ports)
involutive : Function.Involutive
(fun i : Fin (vertices * ports) => reverseIndex[i])
transpose : ∀ (i : Fin (vertices * ports)) (a b : Label),
GraphTables.relationAt relations[reverseIndex[i]] b a =
GraphTables.relationAt relations[i] a b
variable {n d : Nat}
def rotation (table : Table n d) (e : Fin n × Fin d) : Fin n × Fin d :=
(rowIndex n d).symm table.reverseIndex[rowIndex n d e]
def accepts (table : Table n d) (e : Fin n × Fin d) (a b : Label) : Bool :=
GraphTables.relationAt table.relations[rowIndex n d e] a b
@[simp] theorem rowIndex_rotation (table : Table n d) (e : Fin n × Fin d) :
rowIndex n d (rotation table e) = table.reverseIndex[rowIndex n d e] := by
exact (rowIndex n d).apply_symm_apply _
theorem rotation_involutive (table : Table n d) : Function.Involutive (rotation table) := by
intro e
simp only [rotation, Equiv.apply_symm_apply]
exact (congrArg (rowIndex n d).symm (table.involutive (rowIndex n d e))).trans
((rowIndex n d).symm_apply_apply e)
theorem accepts_rotation (table : Table n d) (e : Fin n × Fin d) (a b : Label) :
accepts table (rotation table e) b a = accepts table e a b := by
simpa only [accepts, rowIndex_rotation] using table.transpose (rowIndex n d e) a b
def portGraph (table : Table n d) : PortGraph (Fin n) (Fin d) where
rot :=
{ toFun := rotation table
invFun := rotation table
left_inv := rotation_involutive table
right_inv := rotation_involutive table }
rot_involutive := rotation_involutive table
@[simp] theorem portGraph_rot (table : Table n d) (e : Fin n × Fin d) :
(portGraph table).rot e = rotation table e := rfl
def baseGraph (table : Table n d) : ConstraintGraph (Fin n) (Fin n × Fin d) Label where
reverse := (portGraph table).rot
reverse_involutive := rotation_involutive table
tail := Prod.fst
accepts := accepts table
reverse_accepts := accepts_rotation table
@[simp] theorem baseGraph_reverse (table : Table n d) (e : Fin n × Fin d) :
(baseGraph table).reverse e = rotation table e := rfl
@[simp] theorem baseGraph_tail (table : Table n d) (e : Fin n × Fin d) :
(baseGraph table).tail e = e.1 := rfl
@[simp] theorem baseGraph_head (table : Table n d) (e : Fin n × Fin d) :
(baseGraph table).head e = (rotation table e).1 := rfl
@[simp] theorem baseGraph_accepts (table : Table n d) (e : Fin n × Fin d) (a b : Label) :
(baseGraph table).accepts e a b = accepts table e a b := rfl
def ofPortGraph (G : PortGraph (Fin n) (Fin d))
(predicate : (Fin n × Fin d) → Label → Label → Bool)
(htranspose : ∀ e a b, predicate (G.rot e) b a = predicate e a b) : Table n d where
reverseIndex := Vector.ofFn (fun i => rowIndex n d (G.rot ((rowIndex n d).symm i)))
relations := Vector.ofFn (fun i => GraphTables.relationOf (predicate ((rowIndex n d).symm i)))
involutive := by
intro i
simp only [Fin.getElem_fin, Vector.getElem_ofFn, Fin.eta,
Equiv.symm_apply_apply]
exact (congrArg (rowIndex n d) (G.rot_involutive ((rowIndex n d).symm i))).trans
((rowIndex n d).apply_symm_apply i)
transpose := by
intro i a b
simp only [Fin.getElem_fin, Vector.getElem_ofFn, Fin.eta,
Equiv.symm_apply_apply, GraphTables.relationAt_relationOf]
exact htranspose ((rowIndex n d).symm i) a b
@[simp] theorem rotation_ofPortGraph (G : PortGraph (Fin n) (Fin d))
(predicate : (Fin n × Fin d) → Label → Label → Bool)
(htranspose : ∀ e a b, predicate (G.rot e) b a = predicate e a b)
(e : Fin n × Fin d) : rotation (ofPortGraph G predicate htranspose) e = G.rot e := by
simp only [rotation, ofPortGraph, Fin.getElem_fin, Vector.getElem_ofFn, Fin.eta,
Equiv.symm_apply_apply]
@[simp] theorem accepts_ofPortGraph (G : PortGraph (Fin n) (Fin d))
(predicate : (Fin n × Fin d) → Label → Label → Bool)
(htranspose : ∀ e a b, predicate (G.rot e) b a = predicate e a b)
(e : Fin n × Fin d) (a b : Label) :
accepts (ofPortGraph G predicate htranspose) e a b = predicate e a b := by
simp only [accepts, ofPortGraph, Fin.getElem_fin, Vector.getElem_ofFn, Fin.eta,
Equiv.symm_apply_apply, GraphTables.relationAt_relationOf]
def flatRows (table : Table n d) : GraphTables.Rows n (n * d) :=
Vector.ofFn (fun i =>
⟨((rowIndex n d).symm i).1, table.reverseIndex[i], table.relations[i]⟩)
@[simp] theorem reverseAt_flatRows (table : Table n d) (i : Fin (n * d)) :
GraphTables.reverseAt (flatRows table) i = table.reverseIndex[i] := by
simp [GraphTables.reverseAt, flatRows]
@[simp] theorem acceptsAt_flatRows (table : Table n d) (i : Fin (n * d)) (a b : Label) :
GraphTables.acceptsAt (flatRows table) i a b = GraphTables.relationAt table.relations[i] a b := by
simp [GraphTables.acceptsAt, flatRows]
theorem flatRows_valid (table : Table n d) : GraphTables.Valid (flatRows table) := by
constructor
· intro i
simpa only [reverseAt_flatRows] using table.involutive i
· intro i a b
simpa only [reverseAt_flatRows, acceptsAt_flatRows] using table.transpose i a b
def graphTable (table : Table n d) : GraphTables.Table :=
⟨n, n * d, flatRows table, flatRows_valid table⟩
def tableWords (table : Table n d) : List Nat := GraphTables.tableWords (graphTable table)
def tableBits (table : Table n d) : List Bool := GraphTables.tableBits (graphTable table)
abbrev Input (ports : Nat) := (vertices : Nat) × Table vertices ports
def inputBits {ports : Nat} (input : Input ports) : List Bool := tableBits input.2
theorem tableWords_eq (table : Table n d) :
tableWords table = [n, n * d] ++ (flatRows table).toList.flatMap GraphTables.rowWords := rfl
theorem tableWords_length (table : Table n d) :
(tableWords table).length = 2 + 4098 * (n * d) :=
GraphTables.tableWords_length (graphTable table)
theorem vertices_le_tableBits_length (table : Table n d) : n ≤ (tableBits table).length :=
GraphTables.vertices_le_tableBits_length (graphTable table)
end MinUncutGames.Foundations.PCP.PortTables
end
end OAI