import OAI.Probability.SATComputability.ClauseRestoration

namespace OAI

namespace FixedClauseThreshold.Computability

open scoped Classical

abbrev Triple (A : Type*) := A × A × A
abbrev TripleClasses (A : Type*) :=
  Triple A ⊕ (Fin 3 × Bool × A × A) ⊕ (Fin 3 × Bool × Bool × A) ⊕ Triple Bool

def splitTriple {A : Type*} : Triple (Bool ⊕ A) → TripleClasses A
  | (.inr a,.inr b,.inr c) => .inl (a,b,c)
  | (.inl a,.inr b,.inr c) => .inr (.inl (0,a,b,c))
  | (.inr a,.inl b,.inr c) => .inr (.inl (1,b,a,c))
  | (.inr a,.inr b,.inl c) => .inr (.inl (2,c,a,b))
  | (.inr a,.inl b,.inl c) => .inr (.inr (.inl (0,b,c,a)))
  | (.inl a,.inr b,.inl c) => .inr (.inr (.inl (1,a,c,b)))
  | (.inl a,.inl b,.inr c) => .inr (.inr (.inl (2,a,b,c)))
  | (.inl a,.inl b,.inl c) => .inr (.inr (.inr (a,b,c)))

def joinTriple {A : Type*} : TripleClasses A → Triple (Bool ⊕ A)
  | .inl (a,b,c) => (.inr a,.inr b,.inr c)
  | .inr (.inl (i,b,a,c)) =>
      if i = 0 then (.inl b,.inr a,.inr c)
      else if i = 1 then (.inr a,.inl b,.inr c)
      else (.inr a,.inr c,.inl b)
  | .inr (.inr (.inl (i,a,b,c))) =>
      if i = 0 then (.inr c,.inl a,.inl b)
      else if i = 1 then (.inl a,.inr c,.inl b)
      else (.inl a,.inl b,.inr c)
  | .inr (.inr (.inr (a,b,c))) => (.inl a,.inl b,.inl c)

def tripleClassesEquiv (A : Type*) : Triple (Bool ⊕ A) ≃ TripleClasses A where
  toFun := splitTriple
  invFun := joinTriple
  left_inv := by
    rintro ⟨a,b,c⟩
    cases a <;> cases b <;> cases c <;> rfl
  right_inv := by
    rintro (⟨a,b,c⟩ | (⟨i,a,b,c⟩ | (⟨i,a,b,c⟩ | ⟨a,b,c⟩)))
    · rfl
    · fin_cases i <;> rfl
    · fin_cases i <;> rfl
    · rfl

def literalSplitEquiv (n : ℕ) : SignedLiteral (n+1) ≃ Bool ⊕ SignedLiteral n where
  toFun l := Fin.cases (.inl l.2) (fun j => .inr (j,l.2)) l.1
  invFun := fun l => match l with
    | .inl b => (0,b)
    | .inr (j,b) => (j.succ,b)
  left_inv := by
    rintro ⟨i,b⟩
    refine Fin.cases rfl (fun j => ?_) i
    rfl
  right_inv := by
    rintro (b | ⟨j,b⟩) <;> rfl

def tripleVectorEquiv (A : Type*) : (Fin 3 → A) ≃ Triple A where
  toFun f := (f 0,f 1,f 2)
  invFun t := ![t.1,t.2.1,t.2.2]
  left_inv := by intro f; funext i; fin_cases i <;> rfl
  right_inv := by rintro ⟨a,b,c⟩; rfl

def clauseClassesEquiv (n : ℕ) : (Fin 3 → SignedLiteral (n+1)) ≃ TripleClasses (SignedLiteral n) :=
  (Equiv.arrowCongr (Equiv.refl _) (literalSplitEquiv n)).trans
    ((tripleVectorEquiv _).trans (tripleClassesEquiv _))

theorem clauseClasses_base_card (n : ℕ) :
    Fintype.card (Triple (SignedLiteral n)) = 8*n^3 := by
  simp [Triple, SignedLiteral, Fintype.card_prod, Fintype.card_fin]
  ring

theorem clauseClasses_single_card (n : ℕ) :
    Fintype.card (Fin 3 × Bool × SignedLiteral n × SignedLiteral n) = 24*n^2 := by
  simp [SignedLiteral, Fintype.card_prod, Fintype.card_fin]
  ring

theorem clauseClasses_double_card (n : ℕ) :
    Fintype.card (Fin 3 × Bool × Bool × SignedLiteral n) = 24*n := by
  simp [SignedLiteral, Fintype.card_prod, Fintype.card_fin]
  ring

end FixedClauseThreshold.Computability

end OAI