lean/OAI/Computability/VertexCover/Reduction/RejectionCount.lean

import Mathlib
import OAI.Computability.VertexCover.Reduction.CompatibleSingleton

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
section
section
section
section
section
section
section
section
namespace VertexCover.ClauseProjection
open UniqueGames.Foundations.Target

abbrev Pattern := {s : Fin 3 → Bool // ∃ k, s k = true}

instance : Fintype Pattern := inferInstanceAs (Fintype {s : Fin 3 → Bool // ∃ k, s k = true})

theorem pattern_card : Fintype.card Pattern = 7 := by decide

noncomputable def patternEquiv : Pattern ≃ Fin 7 :=
  (Fintype.equivFin Pattern).trans (finCongr pattern_card)

def flipSign (positive b : Bool) : Bool := if positive then b else !b

@[simp] theorem flipSign_flipSign (p b : Bool) : flipSign p (flipSign p b) = b := by
  cases p <;> cases b <;> rfl

def literalAt (F : Formula) (i : Fin F.clauses.length) (k : Fin 3) : Literal F.«variables» :=
  (F.clauses.get i)[k]

noncomputable def game (F : Formula) (hne : F.clauses ≠ []) : LabelCover where
  u := F.clauses.length
  v := F.«variables»
  qU := 7
  qV := 2
  M := F.clauses.length * 3
  qU_pos := by decide
  qV_pos := by decide
  M_pos := Nat.mul_pos (List.length_pos_iff.mpr hne) (by decide)
  left e := (finProdFinEquiv.symm e).1
  right e := (literalAt F (finProdFinEquiv.symm e).1 (finProdFinEquiv.symm e).2).variableIndex
  projection e label := finTwoEquiv.symm
    (flipSign (literalAt F (finProdFinEquiv.symm e).1 (finProdFinEquiv.symm e).2).positive
      ((patternEquiv.symm label).val (finProdFinEquiv.symm e).2))

def clauseValue (F : Formula) (a : Fin F.«variables» → Bool)
    (i : Fin F.clauses.length) (k : Fin 3) : Bool :=
  (literalAt F i k).eval a

theorem clause_eval_iff (F : Formula) (a : Fin F.«variables» → Bool)
    (i : Fin F.clauses.length) :
    (F.clauses.get i).eval a = true ↔ ∃ k : Fin 3, clauseValue F a i k = true := by
  simp only [Clause.eval, Bool.or_eq_true]
  constructor
  · rintro ((h | h) | h)
    · exact ⟨0, h⟩
    · exact ⟨1, h⟩
    · exact ⟨2, h⟩
  · rintro ⟨k, hk⟩
    fin_cases k
    · exact Or.inl (Or.inl hk)
    · exact Or.inl (Or.inr hk)
    · exact Or.inr hk

noncomputable def honestLabeling (F : Formula) (hne : F.clauses ≠ [])
    (a : Fin F.«variables» → Bool)
    (ha : ∀ clause ∈ F.clauses, clause.eval a = true) : (game F hne).Labeling :=
  (fun i => patternEquiv ⟨clauseValue F a i,
      (clause_eval_iff F a i).mp (ha _ (List.get_mem _ i))⟩,
   fun v => finTwoEquiv.symm (a v))

theorem honest_satisfies (F : Formula) (hne : F.clauses ≠ [])
    (a : Fin F.«variables» → Bool)
    (ha : ∀ clause ∈ F.clauses, clause.eval a = true) :
    ∀ e, (game F hne).Satisfies (honestLabeling F hne a ha) e := by
  intro e
  simp only [LabelCover.Satisfies, game, honestLabeling, Equiv.symm_apply_apply]
  congr 1
  change flipSign _ (flipSign _ _) = _
  exact flipSign_flipSign _ _

theorem perfect_complete (F : Formula) (hne : F.clauses ≠ []) (hF : F.Satisfiable) :
    ∃ A : (game F hne).Labeling, ∀ e, (game F hne).Satisfies A e := by
  obtain ⟨a, ha⟩ := hF
  exact ⟨honestLabeling F hne a ha, honest_satisfies F hne a ha⟩

noncomputable def assignmentOf (F : Formula) (hne : F.clauses ≠ [])
    (A : (game F hne).Labeling) (v : Fin F.«variables») : Bool := finTwoEquiv (A.2 v)

theorem satisfies_iff (F : Formula) (hne : F.clauses ≠ [])
    (A : (game F hne).Labeling) (i : Fin F.clauses.length) (k : Fin 3) :
    (game F hne).Satisfies A (finProdFinEquiv (i,k)) ↔
      (patternEquiv.symm (A.1 i)).val k = clauseValue F (assignmentOf F hne A) i k := by
  simp only [LabelCover.Satisfies, game, Equiv.symm_apply_apply]
  change finTwoEquiv.symm (flipSign (literalAt F i k).positive
    ((patternEquiv.symm (A.1 i)).val k)) = A.2 (literalAt F i k).variableIndex ↔
    (patternEquiv.symm (A.1 i)).val k =
      flipSign (literalAt F i k).positive (assignmentOf F hne A (literalAt F i k).variableIndex)
  constructor
  · intro h
    have hh := congrArg finTwoEquiv h
    simp only [Equiv.apply_symm_apply] at hh
    have hf := congrArg (flipSign (literalAt F i k).positive) hh
    simpa only [flipSign_flipSign, assignmentOf] using hf
  · intro h
    rw [h, flipSign_flipSign]
    exact finTwoEquiv.symm_apply_apply _

def unsatisfiedClauses (F : Formula) (a : Fin F.«variables» → Bool) :
    Finset (Fin F.clauses.length) :=
  Finset.univ.filter (fun i => (F.clauses.get i).eval a = false)

theorem reject_of_unsatisfied (F : Formula) (hne : F.clauses ≠ [])
    (A : (game F hne).Labeling) (i : Fin F.clauses.length)
    (hi : i ∈ unsatisfiedClauses F (assignmentOf F hne A)) :
    ∃ k : Fin 3, ¬(game F hne).Satisfies A (finProdFinEquiv (i,k)) := by
  obtain ⟨k, hk⟩ := (patternEquiv.symm (A.1 i)).property
  refine ⟨k, ?_⟩
  intro hsat
  have hclause := (clause_eval_iff F (assignmentOf F hne A) i).mpr
    ⟨k, (satisfies_iff F hne A i k).mp hsat ▸ hk⟩
  have hfalse := (Finset.mem_filter.mp hi).2
  rw [hfalse] at hclause
  cases hclause

theorem rejection_count (F : Formula) (hne : F.clauses ≠ [])
    (A : (game F hne).Labeling) :
    (unsatisfiedClauses F (assignmentOf F hne A)).card ≤
      (Finset.univ.filter (fun e => ¬(game F hne).Satisfies A e)).card := by
  classical
  let bad := unsatisfiedClauses F (assignmentOf F hne A)
  let witness : {i // i ∈ bad} → Fin 3 := fun i =>
    (reject_of_unsatisfied F hne A i.val i.property).choose
  let occurrence : {i // i ∈ bad} → Fin (game F hne).M :=
    fun i => finProdFinEquiv (i.val, witness i)
  have hmap : ∀ i, occurrence i ∈ Finset.univ.filter (fun e => ¬(game F hne).Satisfies A e) := by
    intro i
    exact Finset.mem_filter.mpr ⟨Finset.mem_univ _,
      (reject_of_unsatisfied F hne A i.val i.property).choose_spec⟩
  have hinj : Function.Injective occurrence := by
    intro i j hij
    exact Subtype.ext (congrArg Prod.fst (finProdFinEquiv.injective hij))
  have hcard := Fintype.card_le_of_injective
    (fun i => (⟨occurrence i, hmap i⟩ :
      {e // e ∈ Finset.univ.filter (fun e => ¬(game F hne).Satisfies A e)}))
    (fun i j hij => hinj (congrArg Subtype.val hij))
  simpa only [Fintype.card_coe] using hcard

end VertexCover.ClauseProjection


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
end
end
end
end
end
end
end

end OAI