import Mathlib
import OAI.Combinatorics.IndependentSets.Model
import OAI.Combinatorics.IndependentSets.Encoding.Target

namespace OAI

namespace LargeIndependentSets
open scoped BigOperators
namespace Normalization

abbrev TargetFormula := IndependentSetsGames.Foundations.Target.Formula
abbrev TargetClause := IndependentSetsGames.Foundations.Target.Clause
abbrev TargetLiteral := IndependentSetsGames.Foundations.Target.Literal

def names (F : Formula) : List ℕ := F.clauses.flatten.map Literal.name

def nameIndex (F : Formula) (v : ℕ) : Fin ((names F).length + 1) :=
  ⟨(names F).idxOf v, Nat.lt_succ_of_le List.idxOf_le_length⟩

def literal (F : Formula) (l : Literal) : TargetLiteral ((names F).length + 1) :=
  ⟨nameIndex F l.name, l.positive⟩

def pad (C : List Literal) (i : Fin 3) : Literal :=
  C[i.val]?.getD (C.headD ⟨0,true⟩)

def clause (F : Formula) (C : List Literal) : TargetClause ((names F).length + 1) :=
  Vector.ofFn (fun i => literal F (pad C i))

lemma literal_eval_true (F : Formula) (l : Literal) (a : Fin ((names F).length+1) → Bool) :
    (literal F l).eval a = true ↔ a (nameIndex F l.name) = l.positive := by
  simp only [literal, IndependentSetsGames.Foundations.Target.Literal.eval]
  have H : ∀ p x : Bool, (if p then x else !x) = true ↔ x = p := by
    intro p x; cases p <;> cases x <;> decide
  exact H _ _

lemma clause_eval_true (F : Formula) (C : List Literal) (hne : C ≠ []) (hw : C.length ≤ 3)
    (a : Fin ((names F).length+1) → Bool) :
    (clause F C).eval a = true ↔ ∃ l ∈ C, a (nameIndex F l.name) = l.positive := by
  cases C with
  | nil => exact False.elim (hne rfl)
  | cons x tail =>
    cases tail with
    | nil => simp [clause, pad, IndependentSetsGames.Foundations.Target.Clause.eval, literal_eval_true]
    | cons y tail =>
      cases tail with
      | nil => simp [clause, pad, IndependentSetsGames.Foundations.Target.Clause.eval, literal_eval_true, or_comm]
      | cons z tail =>
        have ht : tail = [] := by
          apply List.length_eq_zero_iff.mp
          simp only [List.length_cons] at hw
          omega
        subst tail
        simp [clause, pad, IndependentSetsGames.Foundations.Target.Clause.eval, literal_eval_true, or_assoc]

lemma name_mem (F : Formula) (C : List Literal) (hC : C ∈ F.clauses) (l : Literal) (hl : l ∈ C) :
    l.name ∈ names F := by
  exact List.mem_map.mpr ⟨l, List.mem_flatten.mpr ⟨C,hC,hl⟩,rfl⟩

lemma lookup_variable (F : Formula) {v : ℕ} (hv : v ∈ names F) :
    (names F)[(nameIndex F v).val]?.getD 0 = v := by
  simp only [nameIndex]
  rw [List.getElem?_eq_getElem (List.idxOf_lt_length_iff.mpr hv), List.getElem_idxOf]
  rfl

def contradiction : TargetFormula where
  «variables» := 1
  clauses := [Vector.replicate 3 ⟨0,true⟩, Vector.replicate 3 ⟨0,false⟩]

lemma contradiction_unsat : ¬contradiction.Satisfiable := by
  unfold contradiction IndependentSetsGames.Foundations.Target.Formula.Satisfiable
  rintro ⟨a,ha⟩
  have hp := ha (Vector.replicate 3 ⟨0,true⟩) (by simp)
  have hn := ha (Vector.replicate 3 ⟨0,false⟩) (by simp)
  simp only [IndependentSetsGames.Foundations.Target.Clause.eval, Vector.getElem_replicate,
    IndependentSetsGames.Foundations.Target.Literal.eval, Bool.or_self] at hp hn
  cases h : a 0 <;> simp [h] at hp hn

def normalize (F : Formula) : TargetFormula :=
  if [] ∈ F.clauses then contradiction
  else ⟨(names F).length+1,F.clauses.map (clause F)⟩

lemma normalize_satisfiable_iff (F : Formula) : (normalize F).Satisfiable ↔ F.Satisfiable := by
  by_cases hempty : [] ∈ F.clauses
  · rw [normalize,ite_eq_left hempty]
    constructor
    · intro h; exact False.elim (contradiction_unsat h)
    · rintro ⟨a,ha⟩
      obtain ⟨l,hl,_⟩ := ha [] hempty
      simp at hl
  · rw [normalize,ite_eq_right hempty]
    constructor
    · rintro ⟨a,ha⟩
      refine ⟨fun v => a (nameIndex F v),?_⟩
      intro C hC
      exact (clause_eval_true F C (fun h => hempty (h ▸ hC)) (F.width C hC) a).mp
        (ha _ (List.mem_map.mpr ⟨C,hC,rfl⟩))
    · rintro ⟨a,ha⟩
      refine ⟨fun i => a ((names F)[i.val]?.getD 0),?_⟩
      intro C hC
      obtain ⟨D,hD,rfl⟩ := List.mem_map.mp hC
      apply (clause_eval_true F D (fun h => hempty (h ▸ hD)) (F.width D hD) _).mpr
      obtain ⟨l,hl,hs⟩ := ha D hD
      refine ⟨l,hl,?_⟩
      rw [lookup_variable F (name_mem F D hD l hl)]
      exact hs

end Normalization
end LargeIndependentSets

end OAI