| import Mathlib.Algebra.BigOperators.Field |
| import Mathlib.Algebra.BigOperators.Fin |
| import Mathlib.Tactic.FieldSimp |
| import Mathlib.Tactic.Linarith |
| import Mathlib.Tactic.NormNum |
| import OAI.Computability.PerfectCompleteness.Foundations.SourceClause |
| import OAI.Computability.PerfectCompleteness.Reduction.OccurrenceGame |
|
|
| namespace OAI |
|
|
| section |
|
|
| namespace PerfectCompleteness.SourceGame |
|
|
| open SourceClause UniqueGamesTheorem.Foundations.Games |
| open scoped BigOperators |
|
|
| def decodeLabel (signs : Triple) (label : Fin 7) : Triple := |
| (satisfyingTriples signs)[label.val]'(by |
| rw [satisfyingTriples_length] |
| exact label.isLt) |
|
|
| theorem decodeLabel_mem (signs : Triple) (label : Fin 7) : |
| decodeLabel signs label ∈ satisfyingTriples signs := by |
| exact List.getElem_mem _ |
|
|
| theorem decodeLabel_legal (signs : Triple) (label : Fin 7) : |
| localEval signs (decodeLabel signs label) = true := |
| (mem_satisfyingTriples signs _).mp (decodeLabel_mem signs label) |
|
|
| theorem decodeLabel_injective (signs : Triple) : Function.Injective (decodeLabel signs) := by |
| intro a b same |
| apply Fin.ext |
| exact (List.Nodup.getElem_inj (satisfyingTriples_nodup signs)).mp same |
|
|
| def encodeLabel (signs label : Triple) (legal : localEval signs label = true) : Fin 7 := |
| ⟨(satisfyingTriples signs).idxOf label, by |
| have h := List.idxOf_lt_length_of_mem ((mem_satisfyingTriples signs label).mpr legal) |
| simpa using h⟩ |
|
|
| @[simp] theorem decodeLabel_encodeLabel (signs label : Triple) |
| (legal : localEval signs label = true) : |
| decodeLabel signs (encodeLabel signs label legal) = label := by |
| exact List.getElem_idxOf _ |
|
|
| def projection {n m : Nat} (clauses : Fin m → NormalizedClause n) |
| (e : Occurrence m) (answer : Fin 7) : Bool := |
| (decodeLabel (clauses e.1).signs answer).at e.2 |
|
|
| theorem projection_surjective {n m : Nat} (clauses : Fin m → NormalizedClause n) |
| (e : Occurrence m) (answer : Bool) : |
| ∃ label : Fin 7, projection clauses e label = answer := by |
| obtain ⟨t, legal, ht⟩ := coordinate_surjective (clauses e.1).signs e.2 answer |
| refine ⟨encodeLabel (clauses e.1).signs t |
| ((mem_satisfyingTriples _ _).mp legal), ?_⟩ |
| simpa [projection] using ht |
|
|
| theorem projection_pair_surjective {n m : Nat} (clauses : Fin m → NormalizedClause n) |
| (c : Fin m) (i j : Fin 3) (different : i ≠ j) (first second : Bool) : |
| ∃ label : Fin 7, |
| projection clauses (c, i) label = first ∧ projection clauses (c, j) label = second := by |
| obtain ⟨t, legal, ht⟩ := pair_surjective (clauses c).signs i j different first second |
| refine ⟨encodeLabel (clauses c).signs t ((mem_satisfyingTriples _ _).mp legal), ?_⟩ |
| simpa [projection] using ht |
|
|
| theorem leftAlphabet_card : Fintype.card (Fin 7) = 7 := by simp |
| theorem rightAlphabet_card : Fintype.card Bool = 2 := by decide |
|
|
| noncomputable section |
|
|
| def game {n m : Nat} [NeZero m] (clauses : Fin m → NormalizedClause n) : |
| OccurrenceGame (Occurrence m) (Fin m) (Fin n) (Fin 7) Bool := |
| OccurrenceGame.ofProjection (FiniteDistribution.uniform (Occurrence m)) |
| Prod.fst (occurrenceVariable clauses) (projection clauses) |
|
|
| theorem endpointDetermined {n m : Nat} [NeZero m] |
| (clauses : Fin m → NormalizedClause n) : (game clauses).EndpointDetermined := by |
| intro e e' sameClause sameVariable a b |
| have same := occurrence_determined_by_endpoints clauses e e' sameClause sameVariable |
| subst e' |
| rfl |
|
|
| def endpointPredicate {n m : Nat} (clauses : Fin m → NormalizedClause n) |
| (c : Fin m) (v : Fin n) (a : Fin 7) (b : Bool) : Bool := |
| decide (∃ i : Fin 3, (clauses c).variable i = v ∧ |
| (decodeLabel (clauses c).signs a).at i = b) |
|
|
| theorem endpointPredicate_eq_true {n m : Nat} (clauses : Fin m → NormalizedClause n) |
| (c : Fin m) (v : Fin n) (a : Fin 7) (b : Bool) : |
| endpointPredicate clauses c v a b = true ↔ |
| ∃ i : Fin 3, (clauses c).variable i = v ∧ |
| (decodeLabel (clauses c).signs a).at i = b := by |
| exact decide_eq_true_iff |
|
|
| def presentation {n m : Nat} [NeZero m] |
| (clauses : Fin m → NormalizedClause n) : (game clauses).EndpointPresentation where |
| predicate := endpointPredicate clauses |
| agrees e a b := by |
| apply Bool.eq_iff_iff.mpr |
| rw [endpointPredicate_eq_true] |
| simp only [game, OccurrenceGame.ofProjection, occurrenceVariable, decide_eq_true_eq] |
| constructor |
| · intro h |
| exact ⟨e.2, rfl, h⟩ |
| · rintro ⟨i, sameVariable, h⟩ |
| have samePosition : i = e.2 := (clauses e.1).distinct i e.2 sameVariable |
| simpa [projection, samePosition] using h |
|
|
| def questionGame {n m : Nat} [NeZero m] (clauses : Fin m → NormalizedClause n) : |
| Game (Fin m) (Fin n) (Fin 7) Bool := |
| (game clauses).toGame (presentation clauses) |
|
|
| @[simp] theorem questionGame_success {n m : Nat} [NeZero m] |
| (clauses : Fin m → NormalizedClause n) (strategy : Strategy (Fin m) (Fin n) (Fin 7) Bool) : |
| (questionGame clauses).success strategy = (game clauses).success strategy := |
| (game clauses).toGame_success (presentation clauses) strategy |
|
|
| theorem restrict_at {n : Nat} (c : NormalizedClause n) |
| (assignment : Fin n → Bool) (i : Fin 3) : |
| (c.restrict assignment).at i = assignment (c.variable i) := by |
| have cases_three : ∀ i : Fin 3, i = 0 ∨ i = 1 ∨ i = 2 := by decide |
| rcases cases_three i with rfl | rfl | rfl <;> rfl |
|
|
| def completenessStrategy {n m : Nat} (clauses : Fin m → NormalizedClause n) |
| (assignment : Fin n → Bool) (satisfying : ∀ c, (clauses c).clause.eval assignment = true) : |
| Strategy (Fin m) (Fin n) (Fin 7) Bool := |
| (fun c => encodeLabel (clauses c).signs ((clauses c).restrict assignment) |
| (by simpa using satisfying c), assignment) |
|
|
| theorem completeness_wins {n m : Nat} [NeZero m] |
| (clauses : Fin m → NormalizedClause n) (assignment : Fin n → Bool) |
| (satisfying : ∀ c, (clauses c).clause.eval assignment = true) (e : Occurrence m) : |
| (game clauses).wins (completenessStrategy clauses assignment satisfying) e = true := by |
| simp only [game, OccurrenceGame.ofProjection, OccurrenceGame.wins, completenessStrategy, |
| projection, decodeLabel_encodeLabel, decide_eq_true_eq] |
| exact restrict_at (clauses e.1) assignment e.2 |
|
|
| theorem completeness_success {n m : Nat} [NeZero m] |
| (clauses : Fin m → NormalizedClause n) (assignment : Fin n → Bool) |
| (satisfying : ∀ c, (clauses c).clause.eval assignment = true) : |
| (game clauses).success (completenessStrategy clauses assignment satisfying) = 1 := by |
| have h : (game clauses).wins (completenessStrategy clauses assignment satisfying) = |
| fun _ => true := funext (completeness_wins clauses assignment satisfying) |
| unfold OccurrenceGame.success |
| rw [h, FiniteDistribution.probability_true] |
|
|
| theorem completeness_value {n m : Nat} [NeZero m] |
| (clauses : Fin m → NormalizedClause n) (assignment : Fin n → Bool) |
| (satisfying : ∀ c, (clauses c).clause.eval assignment = true) : |
| (game clauses).value = 1 := by |
| apply le_antisymm (game clauses).value_le_one |
| rw [← completeness_success clauses assignment satisfying] |
| exact (game clauses).success_le_value _ |
|
|
| def winCount {n m : Nat} (clauses : Fin m → NormalizedClause n) |
| (strategy : Strategy (Fin m) (Fin n) (Fin 7) Bool) : Nat := |
| ∑ c, agreementCount (clauses c) (decodeLabel (clauses c).signs (strategy.1 c)) strategy.2 |
|
|
| def violatedCount {n m : Nat} (clauses : Fin m → NormalizedClause n) |
| (assignment : Fin n → Bool) : Nat := |
| ∑ c, if (clauses c).clause.eval assignment then 0 else 1 |
|
|
| theorem winCount_add_violated_le {n m : Nat} (clauses : Fin m → NormalizedClause n) |
| (strategy : Strategy (Fin m) (Fin n) (Fin 7) Bool) : |
| winCount clauses strategy + violatedCount clauses strategy.2 ≤ 3 * m := by |
| unfold winCount violatedCount |
| rw [← Finset.sum_add_distrib] |
| calc |
| _ ≤ ∑ _c : Fin m, 3 := by |
| apply Finset.sum_le_sum |
| intro c _ |
| have h := agreementCount_le_two_add_satisfied (clauses c) |
| (decodeLabel (clauses c).signs (strategy.1 c)) strategy.2 |
| (decodeLabel_legal _ _) |
| cases heval : (clauses c).clause.eval strategy.2 <;> |
| simp [heval] at h ⊢ <;> omega |
| _ = 3 * m := by simp [Nat.mul_comm] |
|
|
| private theorem probability_uniform {E : Type*} [Fintype E] [Nonempty E] |
| (event : E → Bool) : |
| (FiniteDistribution.uniform E).probability event = |
| (∑ e, if event e then (1 : ℝ) else 0) / (Fintype.card E : ℝ) := by |
| unfold FiniteDistribution.probability FiniteDistribution.uniform |
| rw [Finset.sum_div] |
| apply Finset.sum_congr rfl |
| intro e _ |
| cases event e <;> simp |
|
|
| theorem success_eq_winCount_div {n m : Nat} [NeZero m] |
| (clauses : Fin m → NormalizedClause n) |
| (strategy : Strategy (Fin m) (Fin n) (Fin 7) Bool) : |
| (game clauses).success strategy = (winCount clauses strategy : ℝ) / (3 * (m : ℝ)) := by |
| have hsum : |
| (∑ e : Occurrence m, if (game clauses).wins strategy e then (1 : ℝ) else 0) = |
| (winCount clauses strategy : ℝ) := by |
| rw [Fintype.sum_prod_type] |
| simp only [winCount, Nat.cast_sum] |
| apply Finset.sum_congr rfl |
| intro c _ |
| rw [Fin.sum_univ_three] |
| simp [game, OccurrenceGame.ofProjection, OccurrenceGame.wins, projection, |
| occurrenceVariable, agreementCount, Triple.at, Nat.cast_add, Nat.cast_ite] |
| change (FiniteDistribution.uniform (Occurrence m)).probability |
| ((game clauses).wins strategy) = _ |
| rw [probability_uniform, hsum] |
| congr 1 |
| simp [Occurrence, mul_comm] |
|
|
| theorem success_le_one_sub_third_violations {n m : Nat} [NeZero m] |
| (clauses : Fin m → NormalizedClause n) |
| (strategy : Strategy (Fin m) (Fin n) (Fin 7) Bool) : |
| (game clauses).success strategy ≤ |
| 1 - ((violatedCount clauses strategy.2 : ℝ) / (m : ℝ)) / 3 := by |
| have hm : (0 : ℝ) < m := by exact_mod_cast Nat.pos_of_neZero m |
| have hden : (0 : ℝ) < 3 * (m : ℝ) := mul_pos (by norm_num) hm |
| have hcount : (winCount clauses strategy : ℝ) + |
| (violatedCount clauses strategy.2 : ℝ) ≤ 3 * (m : ℝ) := by |
| exact_mod_cast winCount_add_violated_le clauses strategy |
| rw [success_eq_winCount_div] |
| apply (div_le_iff₀ hden).mpr |
| have hidentity : |
| (1 - ((violatedCount clauses strategy.2 : ℝ) / (m : ℝ)) / 3) * (3 * (m : ℝ)) = |
| 3 * (m : ℝ) - (violatedCount clauses strategy.2 : ℝ) := by |
| field_simp [ne_of_gt hm] |
| rw [hidentity] |
| linarith |
|
|
| end |
| end PerfectCompleteness.SourceGame |
|
|
| end |
|
|
| end OAI |
|
|
