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