File size: 5,030 Bytes
92416a2 | 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 | import Mathlib
import OAI.Computability.VertexCover.PCP.AlphabetGraph
namespace OAI
namespace UniqueGames.Foundations.PCP.AlphabetTable.Queries
open UniqueGames.Foundations.Hastad
abbrev RawQuery (q : Nat) :=
(Bool × Cube (Fin q)) ⊕ Cube (Fin q × Fin q)
abbrev LocalEvent (q : Nat) := AlphabetGraph.LocalEvent (Fin q)
def mask {q : Nat} (P : Fin q → Fin q → Bool) (f : Cube (Fin q × Fin q)) :
Cube (Fin q × Fin q) := fun p => if P p.1 p.2 then f p else false
def xorTape {A : Type*} (f g : Cube A) : Cube A := fun a => f a ^^ g a
def andTape {A : Type*} (f g : Cube A) : Cube A := fun a => f a && g a
def inputPairTape {q : Nat} (k : Bool × Cube (Fin q)) : Cube (Fin q × Fin q) :=
fun p => if k.1 then k.2 p.2 else k.2 p.1
def query {q : Nat} (P : Fin q → Fin q → Bool) (event : LocalEvent q)
(slot : Fin 6) : RawQuery q :=
match event with
| (kind, k, f, g, r₀, r₁, r₂) =>
if kind = 0 then
if slot = 0 then .inr (mask P f) else
if slot = 1 then .inr (mask P g) else .inr (mask P (xorTape f g))
else if kind = 1 then
if slot = 0 then .inr (mask P r₀) else
if slot = 1 then .inr (mask P (xorTape r₀ (andTape f g))) else
if slot = 2 then .inr (mask P r₁) else
if slot = 3 then .inr (mask P (xorTape r₁ f)) else
if slot = 4 then .inr (mask P r₂) else .inr (mask P (xorTape r₂ g))
else if kind = 2 then
if slot = 0 then .inr (mask P r₀) else
.inr (mask P (xorTape r₀ (fun _ => true)))
else
if slot = 0 then .inl k else
if slot = 1 then .inr (mask P r₀) else
.inr (mask P (xorTape r₀ (inputPairTape k)))
def globalize {q : Nat} {V E : Type*} (tail head : V) (edge : E) :
RawQuery q → AlphabetGraph.Address V E (Fin q)
| .inl (side, tape) => .inl ((if side then head else tail), tape)
| .inr tape => .inr (edge, tape)
@[simp] theorem mask_idempotent {q : Nat} (P : Fin q → Fin q → Bool)
(f : Cube (Fin q × Fin q)) : mask P (mask P f) = mask P f := by
funext p
cases hp : P p.1 p.2 <;> simp [mask, hp]
theorem mask_of_empty {q : Nat} (P : Fin q → Fin q → Bool)
(empty : ∀ a b, P a b = false) (f : Cube (Fin q × Fin q)) :
mask P f = fun _ => false := by
funext p
simp [mask, empty]
theorem query_is_masked {q : Nat} (P : Fin q → Fin q → Bool)
(event : LocalEvent q) (slot : Fin 6) :
match query P event slot with
| .inl _ => True
| .inr tape => mask P tape = tape := by
rcases event with ⟨kind, k, f, g, r₀, r₁, r₂⟩
by_cases hk₀ : kind = 0 <;> by_cases hk₁ : kind = 1 <;> by_cases hk₂ : kind = 2 <;>
simp only [query, hk₀, hk₁, hk₂, ite_true, ite_false] <;>
split_ifs <;> simp
def extendQuery {q : Nat} (P : Fin q → Fin q → Bool) :
AlphabetReduction.InputCoordinate (Fin q) ⊕ Cube (AlphabetReduction.LegalPair P) →
RawQuery q
| .inl k => .inl k
| .inr tape => .inr (UniformRestriction.extend (fun p : Fin q × Fin q => P p.1 p.2 = true) tape)
theorem query_eq_extend_eventQueries {q : Nat} (P : Fin q → Fin q → Bool)
(kind : Fin 4) (k : AlphabetReduction.InputCoordinate (Fin q))
(f g r₀ r₁ r₂ : Cube (Fin q × Fin q)) (slot : Fin 6) :
query P (kind, k, f, g, r₀, r₁, r₂) slot =
extendQuery P (AssignmentTester.eventQueries (AlphabetReduction.pairEncoding P) kind k
(UniformRestriction.restrict (fun p : Fin q × Fin q => P p.1 p.2 = true) f)
(UniformRestriction.restrict (fun p : Fin q × Fin q => P p.1 p.2 = true) g)
(UniformRestriction.restrict (fun p : Fin q × Fin q => P p.1 p.2 = true) r₀)
(UniformRestriction.restrict (fun p : Fin q × Fin q => P p.1 p.2 = true) r₁)
(UniformRestriction.restrict (fun p : Fin q × Fin q => P p.1 p.2 = true) r₂) slot) := by
by_cases hk₀ : kind = 0 <;> by_cases hk₁ : kind = 1 <;> by_cases hk₂ : kind = 2 <;>
simp only [query, AssignmentTester.eventQueries, hk₀, hk₁, hk₂, ite_true, ite_false]
all_goals split_ifs <;> simp_all only [extendQuery]
all_goals rfl
theorem globalize_extendQuery {q : Nat} {V E : Type*}
(G : ConstraintGraph V E (Fin q)) (e : E)
(x : AlphabetReduction.InputCoordinate (Fin q) ⊕
Cube (AlphabetReduction.LegalPair (G.accepts e))) :
globalize (G.tail e) (G.head e) e (extendQuery (G.accepts e) x) =
AlphabetGraph.globalizeQuery G e x := by
cases x with
| inl k => cases k; rfl
| inr tape => rfl
theorem globalize_query {q : Nat} {V E : Type*}
(G : ConstraintGraph V E (Fin q)) (e : E) (event : LocalEvent q) (slot : Fin 6) :
globalize (G.tail e) (G.head e) e (query (G.accepts e) event slot) =
(AlphabetGraph.verifier G).query (e, event) slot := by
rcases event with ⟨kind, k, f, g, r₀, r₁, r₂⟩
rw [query_eq_extend_eventQueries]
exact globalize_extendQuery G e _
end UniqueGames.Foundations.PCP.AlphabetTable.Queries
end OAI
|