lean/OAI/Combinatorics/IndependentSets/Encoding/BinaryNormalize.lean

import Mathlib
import OAI.Combinatorics.IndependentSets.Encoding.BinaryEvents
import OAI.Combinatorics.IndependentSets.Encoding.BinaryNameTables

namespace OAI

namespace LargeIndependentSets.BinaryNormalize
open BinarySyntax BinaryNames
open IndependentSetsGames.Foundations

abbrev varCount (s : List Bool) : ℕ := s.length+1

def dense (s : List Bool) (p : ℕ) : Target.Literal (varCount s) :=
  ⟨⟨key s p,Nat.lt_succ_of_le (key_le s p)⟩,raw s p⟩

def constant (s : List Bool) (b : Bool) : Target.Literal (varCount s) := ⟨0,b⟩

def triple {n : ℕ} (a b c : Target.Literal n) : Target.Clause n := ⟨#[a,b,c],rfl⟩

def tautology (s : List Bool) : Target.Clause (varCount s) :=
  triple (constant s true) (constant s false) (constant s true)

def unitClause (s : List Bool) (b : Bool) : Target.Clause (varCount s) :=
  triple (constant s b) (constant s b) (constant s b)

def sourceClause (s : List Bool) (p : ℕ) (r : Fin 3) : Target.Clause (varCount s) :=
  triple (dense s p) (dense s (if 1 ≤ r.val then next s p else p))
    (dense s (if 2 ≤ r.val then next s (next s p) else p))

def eventAt (s : List Bool) (p : ℕ) : Option Mark :=
  event (run .headerMark (s.take p)) (raw s p)

def row (s : List Bool) (p : ℕ) (side : Bool) : Target.Clause (varCount s) :=
  match eventAt s p with
  | none => tautology s
  | some .empty => unitClause s side
  | some (.first r) => if side then tautology s else sourceClause s p r

def normalize (s : List Bool) : Target.Formula :=
  ⟨varCount s,(List.range s.length).flatMap (fun p => [row s p false,row s p true])⟩

@[simp] lemma literal_eval_iff {n : ℕ} (l : Target.Literal n) (σ : Fin n → Bool) :
    l.eval σ = true ↔ σ l.variableIndex = l.positive := by
  cases h : l.positive <;> simp [Target.Literal.eval,h]

@[simp] lemma triple_eval {n : ℕ} (a b c : Target.Literal n) (σ : Fin n → Bool) :
    (triple a b c).eval σ = true ↔ a.eval σ = true ∨ b.eval σ = true ∨ c.eval σ = true := by
  simp [triple,Target.Clause.eval,or_assoc]

lemma foldr_bits (n : ℕ) : n.bits.foldr Nat.bit 0 = n := by
  induction n using Nat.binaryRec' with
  | zero => simp
  | bit b n h ih => simp [Nat.bits_append_bit n b h,ih]

@[simp] lemma tautology_eval (s : List Bool) (σ : Fin (varCount s) → Bool) :
    (tautology s).eval σ = true := by
  simp [tautology,constant]

@[simp] lemma unitClause_eval (s : List Bool) (b : Bool) (σ : Fin (varCount s) → Bool) :
    (unitClause s b).eval σ = true ↔ σ 0 = b := by
  simp [unitClause,constant]

lemma eventAt_iff (s : List Bool) (p : ℕ) (hp : p<s.length) (e : Mark) :
    eventAt s p = some e ↔ (p,e) ∈ events .headerMark s := by
  simpa [eventAt,raw,List.getElem?_eq_getElem hp] using
    (events_complete .headerMark s p hp e).symm

def Realizes (s : List Bool) (σ : Fin (varCount s) → Bool) (θ : ℕ → Bool) : Prop :=
  ∀ pre l post, s=pre++literalBits l++post →
    σ ⟨key s pre.length,Nat.lt_succ_of_le (key_le s pre.length)⟩ = θ l.name

lemma raw_literal (pre post : List Bool) (l : Literal) :
    raw (pre++literalBits l++post) pre.length = l.positive := by
  rw [show pre.length=pre.length+0 by omega,raw_middle _ _ _ 0 (by simp [literalBits])]
  rfl

lemma dense_eval_iff {s : List Bool} {σ : Fin (varCount s) → Bool} {θ : ℕ → Bool}
    (h : Realizes s σ θ) (pre post : List Bool) (l : Literal)
    (hs : s=pre++literalBits l++post) :
    (dense s pre.length).eval σ = true ↔ θ l.name=l.positive := by
  rw [literal_eval_iff]
  change σ ⟨key s pre.length,_⟩ = raw s pre.length ↔ _
  rw [h pre l post hs,hs,raw_literal]

lemma exists_realizes_forward (s : List Bool) (θ : ℕ → Bool) :
    ∃ σ, Realizes s σ θ := by
  refine ⟨fun x => θ ((payload s x.val).foldr Nat.bit 0),?_⟩
  intro pre l post hs
  have hp : pre.length ≤ s.length := by simp only [hs,List.length_append]; omega
  change θ ((payload s (key s pre.length)).foldr Nat.bit 0)=θ l.name
  rw [key_payload s pre.length hp,hs,payload_literal,foldr_bits]

lemma exists_realizes_backward (s : List Bool) (σ : Fin (varCount s) → Bool) :
    ∃ θ, Realizes s σ θ := by
  classical
  let occurs (v : ℕ) := ∃ p, p ≤ s.length ∧ payload s p=v.bits
  let pos (v : ℕ) (h : occurs v) : ℕ := Classical.choose h
  let θ : ℕ → Bool := fun v => if h : occurs v then
    σ ⟨key s (pos v h),Nat.lt_succ_of_le (key_le s _)⟩ else false
  refine ⟨θ,?_⟩
  intro pre l post hs
  have hp : pre.length ≤ s.length := by simp only [hs,List.length_append]; omega
  have hv : payload s pre.length=l.name.bits := by rw [hs,payload_literal]
  have ho : occurs l.name := ⟨pre.length,hp,hv⟩
  dsimp only [θ]
  rw [dite_eq_left ho]
  have hpos := Classical.choose_spec ho
  have hkey : key s pre.length=key s (pos l.name ho) :=
    key_eq s _ _ hp hpos.1 (hv.trans hpos.2.symm)
  congr 1
  exact Fin.ext hkey

lemma sourceClause_one {s : List Bool} {σ : Fin (varCount s) → Bool} {θ : ℕ → Bool}
    (h : Realizes s σ θ) (pre post : List Bool) (a : Literal)
    (hs : s=pre++literalBits a++post) :
    (sourceClause s pre.length 0).eval σ=true ↔ θ a.name=a.positive := by
  simp only [sourceClause,Fin.val_zero,show ¬1≤0 by omega,show ¬2≤0 by omega,ite_false,
    triple_eval,or_self]
  exact dense_eval_iff h pre post a hs

lemma sourceClause_two {s : List Bool} {σ : Fin (varCount s) → Bool} {θ : ℕ → Bool}
    (h : Realizes s σ θ) (pre post : List Bool) (a b : Literal)
    (hs : s=pre++literalBits a++literalBits b++post) :
    (sourceClause s pre.length 1).eval σ=true ↔
      θ a.name=a.positive ∨ θ b.name=b.positive := by
  have ha : s=pre++literalBits a++(literalBits b++post) := by simpa [List.append_assoc] using hs
  have hb : s=(pre++literalBits a)++literalBits b++post := hs
  have hn : next s pre.length=(pre++literalBits a).length := by rw [ha,next_literal]
  simp only [sourceClause,show (1 : Fin 3).val=1 from rfl,le_refl,show ¬2≤1 by omega,
    ite_true,ite_false,triple_eval,hn,dense_eval_iff h pre _ a ha,
    dense_eval_iff h _ post b hb]
  tauto

lemma sourceClause_three {s : List Bool} {σ : Fin (varCount s) → Bool} {θ : ℕ → Bool}
    (h : Realizes s σ θ) (pre post : List Bool) (a b c : Literal)
    (hs : s=pre++literalBits a++literalBits b++literalBits c++post) :
    (sourceClause s pre.length 2).eval σ=true ↔
      θ a.name=a.positive ∨ θ b.name=b.positive ∨ θ c.name=c.positive := by
  have ha : s=pre++literalBits a++(literalBits b++literalBits c++post) := by
    simpa [List.append_assoc] using hs
  have hb : s=(pre++literalBits a)++literalBits b++(literalBits c++post) := by
    simpa [List.append_assoc] using hs
  have hc : s=(pre++literalBits a++literalBits b)++literalBits c++post := hs
  have hn : next s pre.length=(pre++literalBits a).length := by rw [ha,next_literal]
  have hn' : next s (pre++literalBits a).length=(pre++literalBits a++literalBits b).length := by
    rw [hb,next_literal]
  simp only [sourceClause,show (2 : Fin 3).val=2 from rfl,show 1≤2 by omega,le_refl,ite_true,
    triple_eval,hn,hn',dense_eval_iff h pre _ a ha,dense_eval_iff h _ _ b hb,
    dense_eval_iff h _ post c hc]

def PairSatisfied (s : List Bool) (p : ℕ) (σ : Fin (varCount s) → Bool) : Prop :=
  (row s p false).eval σ=true ∧ (row s p true).eval σ=true

lemma pair_first (s : List Bool) (p : ℕ) (σ : Fin (varCount s) → Bool) (r : Fin 3)
    (he : eventAt s p=some (.first r)) :
    PairSatisfied s p σ ↔ (sourceClause s p r).eval σ=true := by
  simp [PairSatisfied,row,he]

lemma pair_empty (s : List Bool) (p : ℕ) (σ : Fin (varCount s) → Bool)
    (he : eventAt s p=some .empty) : ¬ PairSatisfied s p σ := by
  simp [PairSatisfied,row,he]

lemma pair_none (s : List Bool) (p : ℕ) (σ : Fin (varCount s) → Bool)
    (he : eventAt s p=none) : PairSatisfied s p σ := by
  simp [PairSatisfied,row,he]

lemma atClause {s : List Bool} {σ : Fin (varCount s) → Bool} {θ : ℕ → Bool}
    (h : Realizes s σ θ) (pre post : List Bool) (C : List Literal) (hw : C.length ≤ 3)
    (hs : s=pre++clauseBits C++post)
    (he : eventAt s (pre.length+(clauseMark C).1)=some (clauseMark C).2) :
    PairSatisfied s (pre.length+(clauseMark C).1) σ ↔
      ∃ l ∈ C, θ l.name=l.positive := by
  cases C with
  | nil =>
    have hn := pair_empty s _ σ he
    simp only [List.not_mem_nil,false_and,exists_false,iff_false]
    exact hn
  | cons a C =>
    cases C with
    | nil =>
      have hp : pre.length+(clauseMark [a]).1=(pre++nameBits 1).length := by
        simp [clauseMark]
      have he' : eventAt s (pre.length+(clauseMark [a]).1)=some (.first 0) := he
      rw [pair_first _ _ _ _ he',hp]
      have hs' : s=(pre++nameBits 1)++literalBits a++post := by
        simpa [clauseBits,List.append_assoc] using hs
      simpa using sourceClause_one h (pre++nameBits 1) post a hs'
    | cons b C =>
      cases C with
      | nil =>
        have hp : pre.length+(clauseMark [a,b]).1=(pre++nameBits 2).length := by
          simp [clauseMark]
        have he' : eventAt s (pre.length+(clauseMark [a,b]).1)=some (.first 1) := he
        rw [pair_first _ _ _ _ he',hp]
        have hs' : s=(pre++nameBits 2)++literalBits a++literalBits b++post := by
          simpa [clauseBits,List.append_assoc] using hs
        simpa [List.mem_cons,or_and_right,exists_or] using
          sourceClause_two h (pre++nameBits 2) post a b hs'
      | cons c C =>
        have hc : C=[] := by
          apply List.length_eq_zero_iff.mp
          simp only [List.length_cons] at hw
          omega
        subst C
        have hp : pre.length+(clauseMark [a,b,c]).1=(pre++nameBits 3).length := by
          simp [clauseMark]
        have he' : eventAt s (pre.length+(clauseMark [a,b,c]).1)=some (.first 2) := he
        rw [pair_first _ _ _ _ he',hp]
        have hs' : s=(pre++nameBits 3)++literalBits a++literalBits b++literalBits c++post := by
          simpa [clauseBits,List.append_assoc] using hs
        simpa [List.mem_cons,or_and_right,exists_or,or_assoc] using
          sourceClause_three h (pre++nameBits 3) post a b c hs'

lemma pairs_iff (s : List Bool) (σ : Fin (varCount s) → Bool) :
    (∀ C ∈ (normalize s).clauses, C.eval σ=true) ↔
      ∀ p<s.length, PairSatisfied s p σ := by
  change (∀ C ∈ (List.range s.length).flatMap (fun p => [row s p false,row s p true]),
    C.eval σ=true) ↔ _
  constructor
  · intro h p hp
    have hm (b : Bool) : row s p b ∈ (normalize s).clauses := by
      apply List.mem_flatMap.mpr
      refine ⟨p,List.mem_range.mpr hp,?_⟩
      cases b <;> simp
    exact ⟨h _ (hm false),h _ (hm true)⟩
  · intro h C hC
    obtain ⟨p,hp,hC⟩ := List.mem_flatMap.mp hC
    have hh := h p (List.mem_range.mp hp)
    simp only [List.mem_cons,List.not_mem_nil,or_false] at hC
    rcases hC with rfl | rfl
    · exact hh.1
    · exact hh.2

lemma formula_atClause (F : Formula) {σ : Fin (varCount (formulaBits F)) → Bool}
    {θ : ℕ → Bool} (h : Realizes (formulaBits F) σ θ)
    (pre : List (List Literal)) (C : List Literal) (post : List (List Literal))
    (hF : F.clauses=pre++C::post) :
    let p := (nameBits F.clauses.length).length+(pre.flatMap clauseBits).length+(clauseMark C).1
    p < (formulaBits F).length ∧
      (PairSatisfied (formulaBits F) p σ ↔ ∃ l ∈ C, θ l.name=l.positive) := by
  dsimp only
  have hm := formula_clause_event F pre C post hF
  have hp := events_bound .headerMark (formulaBits F) _ _ hm
  refine ⟨hp,?_⟩
  have he := (eventAt_iff _ _ hp _).mpr hm
  have hh : F.clauses.length=(pre++C::post).length := congrArg List.length hF
  have hs : formulaBits F=(nameBits F.clauses.length++pre.flatMap clauseBits)++
      clauseBits C++post.flatMap clauseBits := by
    simp only [formulaBits,hF,List.flatMap_append,List.flatMap_cons,List.append_assoc]
  have hc : C ∈ F.clauses := by rw [hF]; simp
  simpa only [List.length_append] using atClause h
    (nameBits F.clauses.length++pre.flatMap clauseBits) (post.flatMap clauseBits) C
    (F.width C hc) hs (by simpa only [List.length_append] using he)

theorem satisfiable_iff (F : Formula) :
    (normalize (formulaBits F)).Satisfiable ↔ F.Satisfiable := by
  constructor
  · rintro ⟨σ,hσ⟩
    obtain ⟨θ,hθ⟩ := exists_realizes_backward (formulaBits F) σ
    refine ⟨θ,?_⟩
    intro C hC
    obtain ⟨pre,post,hF⟩ := List.mem_iff_append.mp hC
    have hp := formula_atClause F hθ pre C post hF
    exact hp.2.mp ((pairs_iff _ σ).mp hσ _ hp.1)
  · rintro ⟨θ,hθ⟩
    obtain ⟨σ,hσ⟩ := exists_realizes_forward (formulaBits F) θ
    refine ⟨σ,(pairs_iff _ σ).mpr ?_⟩
    intro p hp
    cases he : eventAt (formulaBits F) p with
    | none => exact pair_none _ _ _ he
    | some e =>
      obtain ⟨pre,C,post,hF,hp',he'⟩ := event_formula_location F p e
        ((eventAt_iff _ _ hp _).mp he)
      rw [hp']
      exact (formula_atClause F hσ pre C post hF).2.mpr
        (hθ C (by rw [hF]; simp))

end LargeIndependentSets.BinaryNormalize

end OAI