| import Mathlib |
| import OAI.Computability.VertexCover.PCP.ClauseVerifier |
|
|
| namespace OAI |
|
|
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| |
| section |
|
|
| namespace UniqueGames.Foundations.Hastad.SourceContexts |
|
|
| open Target PCP |
|
|
| def clauseAnswerEquiv : ClauseAnswer ≃ Bool × Bool × Bool where |
| toFun a := (a.first, a.second, a.third) |
| invFun a := ⟨a.1, a.2.1, a.2.2⟩ |
| left_inv a := by cases a; rfl |
| right_inv a := by rcases a with ⟨a, b, «c»⟩; rfl |
|
|
| def clauseAnswerFinEquiv : ClauseAnswer ≃ Fin 8 := |
| clauseAnswerEquiv.trans |
| ((Equiv.prodCongr finTwoEquiv.symm |
| (Equiv.prodCongr finTwoEquiv.symm finTwoEquiv.symm)).trans |
| ((Equiv.prodCongr (Equiv.refl (Fin 2)) finProdFinEquiv).trans finProdFinEquiv)) |
| |
| instance clauseAnswerFintype : Fintype ClauseAnswer := |
| Fintype.ofEquiv (Bool × Bool × Bool) clauseAnswerEquiv.symm |
| |
| instance clauseAnswerInhabited : Inhabited ClauseAnswer := ⟨⟨false, false, false⟩⟩ |
| |
| instance slotFintype : Fintype Slot where |
| elems := {.first, .second, .third} |
| complete s := by cases s <;> simp |
| |
| instance slotInhabited : Inhabited Slot := ⟨.first⟩ |
|
|
| @[simp] theorem card_clauseAnswer : Fintype.card ClauseAnswer = 8 := by |
| rw [Fintype.card_congr clauseAnswerFinEquiv] |
| rfl |
|
|
| @[simp] theorem card_slot : Fintype.card Slot = 3 := by decide |
|
|
| abbrev I (u : ℕ) := Fin u → Bool |
| abbrev J (u : ℕ) := Fin u → ClauseAnswer |
| abbrev ClauseContext (F : Formula) (u : ℕ) := Fin u → Fin F.clauses.length |
| abbrev VariableContext (F : Formula) (u : ℕ) := Fin u → Fin F.«variables» |
| abbrev SlotContext (u : ℕ) := Fin u → Slot |
|
|
| @[simp] theorem card_I (u : ℕ) : Fintype.card (I u) = 2 ^ u := by simp [I] |
| @[simp] theorem card_J (u : ℕ) : Fintype.card (J u) = 8 ^ u := by simp [J] |
| @[simp] theorem card_ClauseContext (F : Formula) (u : ℕ) : |
| Fintype.card (ClauseContext F u) = F.clauses.length ^ u := by simp [ClauseContext] |
| @[simp] theorem card_VariableContext (F : Formula) (u : ℕ) : |
| Fintype.card (VariableContext F u) = F.«variables» ^ u := by simp [VariableContext] |
| @[simp] theorem card_SlotContext (u : ℕ) : |
| Fintype.card (SlotContext u) = 3 ^ u := by simp [SlotContext] |
|
|
| def localConsistent {n : ℕ} (clause : Clause n) (answer : ClauseAnswer) : Bool := |
| decide (∀ s s' : Slot, nameAt clause s = nameAt clause s' → |
| answerAt answer s = answerAt answer s') |
|
|
| @[simp] theorem localConsistent_eq_true_iff {n : ℕ} |
| (clause : Clause n) (answer : ClauseAnswer) : |
| localConsistent clause answer = true ↔ |
| ∀ s s' : Slot, nameAt clause s = nameAt clause s' → |
| answerAt answer s = answerAt answer s' := by |
| simp [localConsistent] |
|
|
| def validJ (F : Formula) {u : ℕ} («c» : ClauseContext F u) (j : J u) : Bool := |
| decide ((∀ t, localSatisfies (clauseAt F («c» t)) (j t) = true) ∧ |
| ∀ t t' s s', nameAt (clauseAt F («c» t)) s = nameAt (clauseAt F («c» t')) s' → |
| answerAt (j t) s = answerAt (j t') s') |
|
|
| @[simp] theorem validJ_eq_true_iff (F : Formula) {u : ℕ} |
| («c» : ClauseContext F u) (j : J u) : |
| validJ F «c» j = true ↔ |
| (∀ t, localSatisfies (clauseAt F («c» t)) (j t) = true) ∧ |
| ∀ t t' s s', nameAt (clauseAt F («c» t)) s = nameAt (clauseAt F («c» t')) s' → |
| answerAt (j t) s = answerAt (j t') s' := by |
| simp [validJ] |
|
|
| theorem validJ_satisfies (F : Formula) {u : ℕ} («c» : ClauseContext F u) |
| (j : J u) (hj : validJ F «c» j = true) (t : Fin u) : |
| localSatisfies (clauseAt F («c» t)) (j t) = true := |
| ((validJ_eq_true_iff F «c» j).mp hj).1 t |
|
|
| theorem validJ_consistent (F : Formula) {u : ℕ} («c» : ClauseContext F u) |
| (j : J u) (hj : validJ F «c» j = true) (t : Fin u) (s : Slot) |
| (t' : Fin u) (s' : Slot) |
| (hname : nameAt (clauseAt F («c» t)) s = nameAt (clauseAt F («c» t')) s') : |
| answerAt (j t) s = answerAt (j t') s' := |
| ((validJ_eq_true_iff F «c» j).mp hj).2 t t' s s' hname |
|
|
| theorem validJ_localConsistent (F : Formula) {u : ℕ} («c» : ClauseContext F u) |
| (j : J u) (hj : validJ F «c» j = true) (t : Fin u) : |
| localConsistent (clauseAt F («c» t)) (j t) = true := by |
| apply (localConsistent_eq_true_iff _ _).mpr |
| intro s s' hs |
| exact validJ_consistent F «c» j hj t s t s' hs |
|
|
| def canonicalSlot {n : ℕ} (clause : Clause n) (v : Fin n) : Slot := |
| if nameAt clause .first = v then .first |
| else if nameAt clause .second = v then .second else .third |
|
|
| theorem canonicalSlot_name {n : ℕ} (clause : Clause n) (v : Fin n) |
| (hv : ∃ s, nameAt clause s = v) : nameAt clause (canonicalSlot clause v) = v := by |
| by_cases hfirst : nameAt clause .first = v |
| · simp [canonicalSlot, hfirst] |
| by_cases hsecond : nameAt clause .second = v |
| · simp [canonicalSlot, hfirst, hsecond] |
| obtain ⟨s, hs⟩ := hv |
| cases s with |
| | first => exact False.elim (hfirst hs) |
| | second => exact False.elim (hsecond hs) |
| | third => simpa [canonicalSlot, hfirst, hsecond] using hs |
|
|
| def pi (F : Formula) {u : ℕ} («c» : ClauseContext F u) (v : VariableContext F u) |
| (j : J u) : I u := |
| fun t => answerAt (j t) (canonicalSlot (clauseAt F («c» t)) (v t)) |
|
|
| def sampledVariables (F : Formula) {u : ℕ} («c» : ClauseContext F u) |
| (s : SlotContext u) : VariableContext F u := |
| fun t => nameAt (clauseAt F («c» t)) (s t) |
|
|
| theorem sampledVariables_supported (F : Formula) {u : ℕ} |
| («c» : ClauseContext F u) (s : SlotContext u) : |
| ∀ t, ∃ slot, nameAt (clauseAt F («c» t)) slot = sampledVariables F «c» s t := |
| fun t => ⟨s t, rfl⟩ |
|
|
| theorem sampled_eq_pi (F : Formula) {u : ℕ} («c» : ClauseContext F u) |
| (v : VariableContext F u) (j : J u) (hj : validJ F «c» j = true) |
| (t : Fin u) (s : Slot) (hs : nameAt (clauseAt F («c» t)) s = v t) : |
| answerAt (j t) s = pi F «c» v j t := by |
| exact validJ_consistent F «c» j hj t s t |
| (canonicalSlot (clauseAt F («c» t)) (v t)) |
| (hs.trans (canonicalSlot_name _ _ ⟨s, hs⟩).symm) |
|
|
| theorem sampled_answers_eq_of_visible_eq (F : Formula) {u : ℕ} |
| («c» : ClauseContext F u) (s s' : SlotContext u) (j : J u) |
| (hj : validJ F «c» j = true) |
| (hvisible : sampledVariables F «c» s = sampledVariables F «c» s') : |
| (fun t => answerAt (j t) (s t)) = fun t => answerAt (j t) (s' t) := by |
| funext t |
| exact validJ_consistent F «c» j hj t (s t) t (s' t) (congrFun hvisible t) |
|
|
| def honestJ (F : Formula) {u : ℕ} («c» : ClauseContext F u) |
| (assignment : Fin F.«variables» → Bool) : J u := |
| fun t => honestAnswer (clauseAt F («c» t)) assignment |
|
|
| def honestI (F : Formula) {u : ℕ} (v : VariableContext F u) |
| (assignment : Fin F.«variables» → Bool) : I u := |
| fun t => assignment (v t) |
|
|
| theorem honestJ_valid (F : Formula) {u : ℕ} («c» : ClauseContext F u) |
| (assignment : Fin F.«variables» → Bool) |
| (hs : ∀ clause ∈ F.clauses, clause.eval assignment = true) : |
| validJ F «c» (honestJ F «c» assignment) = true := by |
| apply (validJ_eq_true_iff F «c» _).mpr |
| constructor |
| · intro t |
| exact (honest_satisfies _ assignment).trans (hs _ (List.getElem_mem _)) |
| · intro t t' s s' hname |
| simp only [honestJ, honest_answerAt] |
| exact congrArg assignment hname |
|
|
| theorem pi_honest (F : Formula) {u : ℕ} («c» : ClauseContext F u) |
| (v : VariableContext F u) (assignment : Fin F.«variables» → Bool) |
| (hsupport : ∀ t, ∃ s, nameAt (clauseAt F («c» t)) s = v t) : |
| pi F «c» v (honestJ F «c» assignment) = honestI F v assignment := by |
| funext t |
| exact (honest_answerAt _ assignment _).trans |
| (congrArg assignment (canonicalSlot_name _ _ (hsupport t))) |
|
|
| theorem pi_honest_sampled (F : Formula) {u : ℕ} («c» : ClauseContext F u) |
| (s : SlotContext u) (assignment : Fin F.«variables» → Bool) : |
| pi F «c» (sampledVariables F «c» s) (honestJ F «c» assignment) = |
| honestI F (sampledVariables F «c» s) assignment := |
| pi_honest F «c» _ assignment (sampledVariables_supported F «c» s) |
|
|
| def baseAccepts (F : Formula) (v : Fin F.«variables») («c» : Fin F.clauses.length) |
| (i : Bool) (j : ClauseAnswer) : Bool := |
| decide (localSatisfies (clauseAt F «c») j = true ∧ |
| localConsistent (clauseAt F «c») j = true ∧ |
| answerAt j (canonicalSlot (clauseAt F «c») v) = i) |
|
|
| @[simp] theorem baseAccepts_eq_true_iff (F : Formula) (v : Fin F.«variables») |
| («c» : Fin F.clauses.length) (i : Bool) (j : ClauseAnswer) : |
| baseAccepts F v «c» i j = true ↔ |
| localSatisfies (clauseAt F «c») j = true ∧ |
| localConsistent (clauseAt F «c») j = true ∧ |
| answerAt j (canonicalSlot (clauseAt F «c») v) = i := by |
| simp [baseAccepts] |
|
|
| theorem projection_implies_coordinate_accepts (F : Formula) {u : ℕ} |
| («c» : ClauseContext F u) (v : VariableContext F u) (i : I u) (j : J u) |
| (hj : validJ F «c» j = true) (hpi : pi F «c» v j = i) (t : Fin u) : |
| baseAccepts F (v t) («c» t) (i t) (j t) = true := by |
| exact (baseAccepts_eq_true_iff F _ _ _ _).mpr |
| ⟨validJ_satisfies F «c» j hj t, validJ_localConsistent F «c» j hj t, congrFun hpi t⟩ |
|
|
| theorem baseAccepts_implies_sampled (F : Formula) («c» : Fin F.clauses.length) |
| (s : Slot) (i : Bool) (j : ClauseAnswer) |
| (h : baseAccepts F (nameAt (clauseAt F «c») s) «c» i j = true) : |
| (localSatisfies (clauseAt F «c») j && decide (answerAt j s = i)) = true := by |
| obtain ⟨hsat, hcons, heq⟩ := (baseAccepts_eq_true_iff F _ _ _ _).mp h |
| have hname := canonicalSlot_name (clauseAt F «c») (nameAt (clauseAt F «c») s) ⟨s, rfl⟩ |
| have hans := (localConsistent_eq_true_iff _ _).mp hcons s |
| (canonicalSlot (clauseAt F «c») (nameAt (clauseAt F «c») s)) hname.symm |
| simp [hsat, hans.trans heq] |
|
|
| theorem projection_implies_sampled_accepts (F : Formula) {u : ℕ} |
| («c» : ClauseContext F u) (s : SlotContext u) (i : I u) (j : J u) |
| (hj : validJ F «c» j = true) (hpi : pi F «c» (sampledVariables F «c» s) j = i) : |
| ∀ t, (localSatisfies (clauseAt F («c» t)) (j t) && |
| decide (answerAt (j t) (s t) = i t)) = true := by |
| intro t |
| exact baseAccepts_implies_sampled F («c» t) (s t) (i t) (j t) |
| (projection_implies_coordinate_accepts F «c» _ i j hj hpi t) |
|
|
| end UniqueGames.Foundations.Hastad.SourceContexts |
|
|
| end |
|
|
|
|
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
|
|
| end OAI |
|
|
