| import Mathlib |
| import OAI.Combinatorics.IndependentSets.PCP.ConstraintGraph |
|
|
| namespace OAI |
|
|
| namespace IndependentSetsGames.Foundations.PCP.QueryIncidence |
|
|
| structure Verifier (E X : Type*) (q : Nat) where |
| query : E → Fin q → X |
| accepts : E → (Fin q → Bool) → Bool |
|
|
| abbrev Label (q : Nat) := Fin q → Bool |
| abbrev Vertex (E X : Type*) := E ⊕ X |
| abbrev Dart (E : Type*) (q : Nat) := (E × Fin q) × Bool |
|
|
| variable {E X : Type*} {q : Nat} |
|
|
| def response (T : Verifier E X q) (assignment : X → Bool) (event : E) : Label q := |
| fun i => assignment (T.query event i) |
|
|
| def zeroSlot (positive : 0 < q) : Fin q := ⟨0, positive⟩ |
|
|
| def decodeRight (positive : 0 < q) (label : Label q) : Bool := label (zeroSlot positive) |
|
|
| def encodeRight (bit : Bool) : Label q := fun _ => bit |
|
|
| @[simp] theorem decode_encodeRight (positive : 0 < q) (bit : Bool) : |
| decodeRight positive (encodeRight bit) = bit := rfl |
|
|
| def canonicalSlot [DecidableEq X] (T : Verifier E X q) (event : E) (i : Fin q) : Fin q := |
| Fin.find (fun j => T.query event j = T.query event i) ⟨i, rfl⟩ |
|
|
| theorem canonicalSlot_query [DecidableEq X] (T : Verifier E X q) (event : E) (i : Fin q) : |
| T.query event (canonicalSlot T event i) = T.query event i := |
| Fin.find_spec (p := fun j => T.query event j = T.query event i) ⟨i, rfl⟩ |
|
|
| def RepeatedConsistent (T : Verifier E X q) (event : E) (label : Label q) : Prop := |
| ∀ i j, T.query event i = T.query event j → label i = label j |
|
|
| instance repeatedConsistentDecidable [DecidableEq X] |
| (T : Verifier E X q) (event : E) (label : Label q) : |
| Decidable (RepeatedConsistent T event label) := by |
| unfold RepeatedConsistent |
| infer_instance |
|
|
| def LeftValid (T : Verifier E X q) (event : E) (label : Label q) : Prop := |
| T.accepts event label = true ∧ RepeatedConsistent T event label |
|
|
| instance leftValidDecidable [DecidableEq X] |
| (T : Verifier E X q) (event : E) (label : Label q) : |
| Decidable (LeftValid T event label) := by |
| unfold LeftValid |
| infer_instance |
|
|
| def incidenceAccept [DecidableEq X] (T : Verifier E X q) (positive : 0 < q) |
| (event : E) (slot : Fin q) (left right : Label q) : Bool := |
| decide (LeftValid T event left) && |
| decide (left (canonicalSlot T event slot) = decodeRight positive right) |
|
|
| def reverse : Dart E q → Dart E q := fun d => (d.1, !d.2) |
|
|
| theorem reverse_involutive : Function.Involutive (reverse : Dart E q → Dart E q) := by |
| rintro ⟨⟨event, slot⟩, orientation⟩ |
| cases orientation <;> rfl |
|
|
| def reverseEquiv : Dart E q ≃ Dart E q where |
| toFun := reverse |
| invFun := reverse |
| left_inv := reverse_involutive |
| right_inv := reverse_involutive |
|
|
| def tail (T : Verifier E X q) : Dart E q → Vertex E X |
| | ((event, _), false) => .inl event |
| | ((event, slot), true) => .inr (T.query event slot) |
|
|
| def predicate [DecidableEq X] (T : Verifier E X q) (positive : 0 < q) : |
| Dart E q → Label q → Label q → Bool |
| | ((event, slot), false), a, b => incidenceAccept T positive event slot a b |
| | ((event, slot), true), a, b => incidenceAccept T positive event slot b a |
|
|
| def graph [DecidableEq X] (T : Verifier E X q) (positive : 0 < q) : |
| ConstraintGraph (Vertex E X) (Dart E q) (Label q) where |
| reverse := reverseEquiv |
| reverse_involutive := reverse_involutive |
| tail := tail T |
| accepts := predicate T positive |
| reverse_accepts := by |
| rintro ⟨⟨event, slot⟩, orientation⟩ a b |
| cases orientation <;> rfl |
|
|
| theorem edgeSatisfied_eq_incidence [DecidableEq X] (T : Verifier E X q) |
| (positive : 0 < q) (labeling : Vertex E X → Label q) |
| (event : E) (slot : Fin q) (orientation : Bool) : |
| (graph T positive).edgeSatisfied labeling ((event, slot), orientation) = |
| incidenceAccept T positive event slot (labeling (.inl event)) |
| (labeling (.inr (T.query event slot))) := by |
| cases orientation <;> rfl |
|
|
| def honestLabeling (T : Verifier E X q) (assignment : X → Bool) : Vertex E X → Label q |
| | .inl event => response T assignment event |
| | .inr address => encodeRight (assignment address) |
|
|
| theorem honest_leftValid (T : Verifier E X q) (assignment : X → Bool) (event : E) |
| (accepted : T.accepts event (response T assignment event) = true) : |
| LeftValid T event (response T assignment event) := by |
| refine ⟨accepted, ?_⟩ |
| intro i j hij |
| exact congrArg assignment hij |
|
|
| theorem honest_incidence [DecidableEq X] (T : Verifier E X q) (positive : 0 < q) |
| (assignment : X → Bool) (event : E) |
| (accepted : T.accepts event (response T assignment event) = true) (slot : Fin q) : |
| incidenceAccept T positive event slot |
| (honestLabeling T assignment (.inl event)) |
| (honestLabeling T assignment (.inr (T.query event slot))) = true := by |
| simp only [incidenceAccept, Bool.and_eq_true, honestLabeling, |
| decode_encodeRight] |
| refine ⟨_root_.decide_eq_true (honest_leftValid T assignment event accepted), ?_⟩ |
| exact _root_.decide_eq_true (congrArg assignment (canonicalSlot_query T event slot)) |
|
|
| theorem perfect_completeness [DecidableEq X] (T : Verifier E X q) (positive : 0 < q) |
| (assignment : X → Bool) |
| (accepted : ∀ event, T.accepts event (response T assignment event) = true) : |
| ∀ dart, (graph T positive).edgeSatisfied (honestLabeling T assignment) dart = true := by |
| rintro ⟨⟨event, slot⟩, orientation⟩ |
| rw [edgeSatisfied_eq_incidence] |
| exact honest_incidence T positive assignment event (accepted event) slot |
|
|
| theorem satisfiable_of_verifier_satisfiable [DecidableEq X] (T : Verifier E X q) |
| (positive : 0 < q) |
| (sat : ∃ assignment : X → Bool, |
| ∀ event, T.accepts event (response T assignment event) = true) : |
| (graph T positive).Satisfiable := by |
| obtain ⟨assignment, h⟩ := sat |
| exact ⟨honestLabeling T assignment, perfect_completeness T positive assignment h⟩ |
|
|
| def decodedAssignment (positive : 0 < q) (labeling : Vertex E X → Label q) : X → Bool := |
| fun address => decodeRight positive (labeling (.inr address)) |
|
|
| theorem incidenceAccept_true [DecidableEq X] (T : Verifier E X q) (positive : 0 < q) |
| (event : E) (slot : Fin q) (left right : Label q) |
| (accepted : incidenceAccept T positive event slot left right = true) : |
| T.accepts event left = true ∧ RepeatedConsistent T event left ∧ |
| left (canonicalSlot T event slot) = decodeRight positive right := by |
| simp only [incidenceAccept, Bool.and_eq_true] at accepted |
| have hvalid : LeftValid T event left := _root_.of_decide_eq_true accepted.1 |
| exact ⟨hvalid.1, hvalid.2, _root_.of_decide_eq_true accepted.2⟩ |
|
|
| theorem all_incidences_imply_event [DecidableEq X] (T : Verifier E X q) |
| (positive : 0 < q) (labeling : Vertex E X → Label q) (event : E) |
| (accepted : ∀ slot, incidenceAccept T positive event slot (labeling (.inl event)) |
| (labeling (.inr (T.query event slot))) = true) : |
| T.accepts event (response T (decodedAssignment positive labeling) event) = true := by |
| have first := incidenceAccept_true T positive event (zeroSlot positive) _ _ |
| (accepted (zeroSlot positive)) |
| have labels_equal : labeling (.inl event) = response T (decodedAssignment positive labeling) event := by |
| funext slot |
| have info := incidenceAccept_true T positive event slot _ _ (accepted slot) |
| exact (first.2.1 slot (canonicalSlot T event slot) |
| (canonicalSlot_query T event slot).symm).trans info.2.2 |
| rw [← labels_equal] |
| exact first.1 |
|
|
| theorem rejected_event_forces_slot [DecidableEq X] (T : Verifier E X q) |
| (positive : 0 < q) (labeling : Vertex E X → Label q) (event : E) |
| (rejected : T.accepts event (response T (decodedAssignment positive labeling) event) = false) : |
| ∃ slot, incidenceAccept T positive event slot (labeling (.inl event)) |
| (labeling (.inr (T.query event slot))) = false := by |
| classical |
| by_contra none |
| have all : ∀ slot, incidenceAccept T positive event slot (labeling (.inl event)) |
| (labeling (.inr (T.query event slot))) = true := by |
| intro slot |
| cases h : incidenceAccept T positive event slot (labeling (.inl event)) |
| (labeling (.inr (T.query event slot))) with |
| | false => exact False.elim (none ⟨slot, h⟩) |
| | true => rfl |
| have h := all_incidences_imply_event T positive labeling event all |
| rw [rejected] at h |
| cases h |
|
|
| def rejectedEvents [Fintype E] (T : Verifier E X q) (assignment : X → Bool) : Finset E := |
| Finset.univ.filter (fun event => T.accepts event (response T assignment event) = false) |
|
|
| def verifierRejectionCount [Fintype E] (T : Verifier E X q) (assignment : X → Bool) : Nat := |
| (rejectedEvents T assignment).card |
|
|
| theorem rejection_count_bound [Fintype E] [DecidableEq X] |
| (T : Verifier E X q) (positive : 0 < q) (labeling : Vertex E X → Label q) : |
| 2 * verifierRejectionCount T (decodedAssignment positive labeling) ≤ |
| (graph T positive).rejectionCount labeling := by |
| classical |
| let failed := rejectedEvents T (decodedAssignment positive labeling) |
| have witnesses : ∀ event, event ∈ failed → |
| ∃ slot, incidenceAccept T positive event slot (labeling (.inl event)) |
| (labeling (.inr (T.query event slot))) = false := by |
| intro event he |
| apply rejected_event_forces_slot T positive labeling event |
| simpa [failed, rejectedEvents] using he |
| let chosen := fun event he => Classical.choose (witnesses event he) |
| let inject : (failed.product (Finset.univ : Finset Bool)) → |
| (graph T positive).rejectedDarts labeling := fun p => |
| ⟨((p.val.1, chosen p.val.1 (Finset.mem_product.mp p.property).1), p.val.2), by |
| apply (ConstraintGraph.mem_rejectedDarts _ _ _).mpr |
| rw [edgeSatisfied_eq_incidence] |
| exact Classical.choose_spec (witnesses p.val.1 (Finset.mem_product.mp p.property).1)⟩ |
| have injective : Function.Injective inject := by |
| intro a b h |
| apply Subtype.ext |
| apply Prod.ext |
| · exact congrArg (fun d => d.val.1.1) h |
| · exact congrArg (fun d => d.val.2) h |
| have bound := Finset.card_le_card_of_injective injective |
| simpa [failed, verifierRejectionCount, ConstraintGraph.rejectionCount, |
| Finset.card_product, Nat.mul_comm] using bound |
|
|
| @[simp] theorem card_label (q : Nat) : Fintype.card (Label q) = 2 ^ q := by |
| simp [Label] |
|
|
| @[simp] theorem card_vertex [Fintype E] [Fintype X] : |
| Fintype.card (Vertex E X) = Fintype.card E + Fintype.card X := by |
| simp [Vertex, Fintype.card_sum] |
|
|
| @[simp] theorem card_dart [Fintype E] : |
| Fintype.card (Dart E q) = 2 * q * Fintype.card E := by |
| simp [Dart, Fintype.card_prod, Nat.mul_comm, Nat.mul_left_comm, Nat.mul_assoc] |
|
|
| theorem gap_transfer [Fintype E] [DecidableEq X] (T : Verifier E X q) |
| (positive : 0 < q) (a b : Nat) |
| (sourceGap : ∀ assignment : X → Bool, |
| a * Fintype.card E ≤ b * verifierRejectionCount T assignment) |
| (labeling : Vertex E X → Label q) : |
| a * Fintype.card (Dart E q) ≤ (b * q) * (graph T positive).rejectionCount labeling := by |
| have source := Nat.mul_le_mul_left (2 * q) (sourceGap (decodedAssignment positive labeling)) |
| have incidences := Nat.mul_le_mul_left (b * q) (rejection_count_bound T positive labeling) |
| rw [card_dart] |
| calc |
| a * (2 * q * Fintype.card E) = (2 * q) * (a * Fintype.card E) := by ac_rfl |
| _ ≤ (2 * q) * (b * verifierRejectionCount T (decodedAssignment positive labeling)) := source |
| _ = (b * q) * (2 * verifierRejectionCount T (decodedAssignment positive labeling)) := by ac_rfl |
| _ ≤ (b * q) * (graph T positive).rejectionCount labeling := incidences |
|
|
| theorem six_query_alphabet : Fintype.card (Label 6) = 64 := by |
| simp |
|
|
| end IndependentSetsGames.Foundations.PCP.QueryIncidence |
|
|
| end OAI |
|
|
