import OAI.NumberTheory.TwoPoint.Circuits.CircuitRestriction

namespace OAI

/-! Partial assignments and the consistent terms used in the canonical
decision tree of a DNF. Each term contains at most one literal per variable. -/

namespace TwoPointCorrelations

open Finset
open scoped Classical

abbrev PartialAssignment (n : ℕ) := Fin n → Option Bool

namespace PartialAssignment

def apply {n : ℕ} (ρ : PartialAssignment n) (x : BooleanCube n) : BooleanCube n :=
  fun i => (ρ i).getD (x i)

def Extends {n : ℕ} (ρ τ : PartialAssignment n) : Prop :=
  ∀ i b, ρ i = some b → τ i = some b

def assign {n : ℕ} (ρ : PartialAssignment n) (S : Finset (Fin n))
    (x : BooleanCube n) : PartialAssignment n := fun i => if i ∈ S then some (x i) else ρ i

def free {n : ℕ} (ρ : PartialAssignment n) : Finset (Fin n) :=
  univ.filter (fun i => ρ i = none)

@[simp] lemma assign_empty {n : ℕ} (ρ : PartialAssignment n) (x : BooleanCube n) :
    ρ.assign ∅ x = ρ := by funext i; simp [assign]

lemma assign_insert {n : ℕ} (ρ : PartialAssignment n) (S : Finset (Fin n))
    (x : BooleanCube n) (i : Fin n) :
    ρ.assign (insert i S) x = assign (Function.update ρ i (some (x i))) S x := by
  funext j
  by_cases hji : j = i <;> by_cases hj : j ∈ S <;> simp [assign, hji, hj]

lemma apply_assign_free {n : ℕ} (ρ : PartialAssignment n) (S : Finset (Fin n))
    (hS : S ⊆ ρ.free) (x : BooleanCube n) :
    (ρ.assign S x).apply x = ρ.apply x := by
  funext i
  by_cases hi : i ∈ S
  · have hρ : ρ i = none := (mem_filter.mp (hS hi)).2
    simp [assign, apply, hi, hρ]
  · simp [assign, apply, hi]

lemma assign_extends {n : ℕ} (ρ : PartialAssignment n) (S : Finset (Fin n))
    (hS : S ⊆ ρ.free) (x : BooleanCube n) : ρ.Extends (ρ.assign S x) := by
  intro i b hb
  have hi : i ∉ S := by
    intro hi
    have hn := (mem_filter.mp (hS hi)).2
    rw [hb] at hn
    cases hn
  simp [assign, hi, hb]

lemma extends_trans {n : ℕ} {ρ σ τ : PartialAssignment n}
    (hρσ : ρ.Extends σ) (hστ : σ.Extends τ) : ρ.Extends τ :=
  fun i b hb => hστ i b (hρσ i b hb)

end PartialAssignment

structure CubeTerm (n : ℕ) where
  support : Finset (Fin n)
  value : BooleanCube n

namespace CubeTerm

def eval {n : ℕ} (C : CubeTerm n) (x : BooleanCube n) : Bool :=
  decide (∀ i ∈ C.support, x i = C.value i)

def Compatible {n : ℕ} (C : CubeTerm n) (ρ : PartialAssignment n) : Prop :=
  ∀ i ∈ C.support, ρ i = none ∨ ρ i = some (C.value i)

def Satisfied {n : ℕ} (C : CubeTerm n) (ρ : PartialAssignment n) : Prop :=
  ∀ i ∈ C.support, ρ i = some (C.value i)

def live {n : ℕ} (C : CubeTerm n) (ρ : PartialAssignment n) : Finset (Fin n) :=
  C.support.filter (fun i => ρ i = none)

lemma live_subset_free {n : ℕ} (C : CubeTerm n) (ρ : PartialAssignment n) :
    C.live ρ ⊆ ρ.free := by
  intro i hi
  exact mem_filter.mpr ⟨mem_univ _, (mem_filter.mp hi).2⟩

lemma incompatible_mono {n : ℕ} (C : CubeTerm n) {ρ τ : PartialAssignment n}
    (hρ : ¬ C.Compatible ρ) (h : ρ.Extends τ) : ¬ C.Compatible τ := by
  intro hτ
  apply hρ
  intro i hi
  cases hri : ρ i with
  | none => exact Or.inl rfl
  | some b =>
    have hti := h i b hri
    rcases hτ i hi with hn | hv
    · rw [hti] at hn
      cases hn
    · have hb : b = C.value i := Option.some.inj (hti.symm.trans hv)
      exact Or.inr (congrArg some hb)

lemma eval_apply_of_incompatible {n : ℕ} (C : CubeTerm n)
    (ρ : PartialAssignment n) (hρ : ¬ C.Compatible ρ) (x : BooleanCube n) :
    C.eval (ρ.apply x) = false := by
  apply Bool.eq_false_iff.mpr
  intro he
  apply hρ
  have he : ∀ i ∈ C.support, ρ.apply x i = C.value i := of_decide_eq_true he
  intro i hi
  cases hr : ρ i with
  | none => exact Or.inl rfl
  | some b =>
    right
    have hb := he i hi
    simpa [PartialAssignment.apply, hr] using hb

lemma satisfied_assign_live_iff {n : ℕ} (C : CubeTerm n)
    (ρ : PartialAssignment n) (hρ : C.Compatible ρ) (x : BooleanCube n) :
    C.Satisfied (ρ.assign (C.live ρ) x) ↔ C.eval (ρ.apply x) = true := by
  simp only [Satisfied, eval, decide_eq_true_eq]
  constructor
  · intro hs i hi
    by_cases hl : i ∈ C.live ρ
    · have hn := (mem_filter.mp hl).2
      have hb := hs i hi
      simpa [PartialAssignment.assign, PartialAssignment.apply, hl, hn] using hb
    · have hn : ρ i ≠ none := fun hn => hl (mem_filter.mpr ⟨hi, hn⟩)
      have hv := (hρ i hi).resolve_left hn
      simp [PartialAssignment.apply, hv]
  · intro hx i hi
    by_cases hn : ρ i = none
    · have hl : i ∈ C.live ρ := mem_filter.mpr ⟨hi, hn⟩
      have hv := hx i hi
      simpa [PartialAssignment.assign, PartialAssignment.apply, hl, hn] using hv
    · have hl : i ∉ C.live ρ := fun hl => hn (mem_filter.mp hl).2
      simp [PartialAssignment.assign, hl, (hρ i hi).resolve_left hn]

lemma satisfied_assign_value {n : ℕ} (C : CubeTerm n)
    (ρ : PartialAssignment n) (hρ : C.Compatible ρ) :
    C.Satisfied (ρ.assign (C.live ρ) C.value) := by
  rw [C.satisfied_assign_live_iff ρ hρ]
  apply decide_eq_true
  intro i hi
  rcases hρ i hi with hn | hv
  · simp [PartialAssignment.apply, hn]
  · simp [PartialAssignment.apply, hv]

end CubeTerm

end TwoPointCorrelations

end OAI