import OAI.Probability.SATComputability.PhysicalExpressions
import OAI.Probability.DilutedSpin.CavityBounds

namespace OAI

namespace FixedClauseThreshold.Computability.FiniteArithmetic

open Nat.Partrec DilutedSpinGlass RapidForcing.EffectiveArithmetic
open scoped BigOperators
local instance cavityExpressionsRatPrimcodable : Primcodable ℚ := PeriodicLattice.RecursiveArithmetic.ratPrimcodable

noncomputable def boltzmannAtom {p : ℕ} (θ : ℚ) (xs : Fin p → Code)
    (s : Fin p → Bool) : Code :=
  .pair (rationalExpression θ)
    (sumExpressions (List.ofFn (fun i => logQExpression (xs i) (s i))))

@[fun_prop] theorem boltzmannAtom_computable (p : ℕ) :
    Computable (fun a : ℚ × (Fin p → Code) × (Fin p → Bool) =>
      boltzmannAtom a.1 a.2.1 a.2.2) := by
  have hv : Computable (fun a : ℚ × (Fin p → Code) × (Fin p → Bool) =>
      List.ofFn (fun i => logQExpression (a.2.1 i) (a.2.2 i))) := by
    apply Computable.list_ofFn
    intro i
    fun_prop
  unfold boltzmannAtom
  fun_prop

theorem exp_boltzmannAtom {p : ℕ} (θ : ℚ) (xs : Fin p → Code) (s : Fin p → Bool) :
    Real.exp (expressionValue (boltzmannAtom θ xs s)) =
      Real.exp (θ : ℝ) * ∏ i, q (expressionValue (xs i)) (s i) := by
  simp only [boltzmannAtom, expressionValue, rationalExpression_value,
    sumExpressions_value, List.map_ofFn, List.sum_ofFn, Function.comp_def,
    Real.exp_add, Real.exp_sum, exp_logQExpression]

def clausePenalty (β : ℚ) (J s : Fin 3 → Bool) : ℚ :=
  if ∀ i, s i ≠ J i then -β else 0

@[fun_prop] theorem clausePenalty_computable :
    Computable (fun p : ℚ × (Fin 3 → Bool) × (Fin 3 → Bool) =>
      clausePenalty p.1 p.2.1 p.2.2) := by
  have h : Computable (fun p : ℚ × (Fin 3 → Bool) × (Fin 3 → Bool) =>
      if p.2.2 0 ≠ p.2.1 0 ∧ p.2.2 1 ≠ p.2.1 1 ∧ p.2.2 2 ≠ p.2.1 2
      then -p.1 else 0) := by fun_prop
  exact h.of_eq (fun p => by simp [clausePenalty, Fin.forall_fin_succ])

theorem clausePenalty_cast (β : ℚ) (J s : Fin 3 → Bool) :
    (clausePenalty β J s : ℝ) = satInteraction (β : ℝ) J s := by
  unfold clausePenalty satInteraction
  split <;> simp

theorem sum_bool_vector_succ {p : ℕ} (f : (Fin (p+1) → Bool) → ℝ) :
    (∑ s, f s) =
      (∑ t : Fin p → Bool, f (Fin.cons false t)) +
      ∑ t : Fin p → Bool, f (Fin.cons true t) := by
  rw [← (Fin.consEquiv (fun _ : Fin (p+1) => Bool)).sum_comp, Fintype.sum_prod_type]
  simp only [Fintype.sum_bool]
  exact add_comm _ _

noncomputable def edgeExpression (β : ℚ) (J : Fin 3 → Bool) (xs : Fin 3 → Code) : Code :=
  binaryLogSumExpression
    (binaryLogSumExpression
      (binaryLogSumExpression (boltzmannAtom (clausePenalty β J ![false,false,false]) xs ![false,false,false])
        (boltzmannAtom (clausePenalty β J ![false,false,true]) xs ![false,false,true]))
      (binaryLogSumExpression (boltzmannAtom (clausePenalty β J ![false,true,false]) xs ![false,true,false])
        (boltzmannAtom (clausePenalty β J ![false,true,true]) xs ![false,true,true])))
    (binaryLogSumExpression
      (binaryLogSumExpression (boltzmannAtom (clausePenalty β J ![true,false,false]) xs ![true,false,false])
        (boltzmannAtom (clausePenalty β J ![true,false,true]) xs ![true,false,true]))
      (binaryLogSumExpression (boltzmannAtom (clausePenalty β J ![true,true,false]) xs ![true,true,false])
        (boltzmannAtom (clausePenalty β J ![true,true,true]) xs ![true,true,true])))

@[fun_prop] theorem edgeExpression_computable :
    Computable (fun p : ℚ × (Fin 3 → Bool) × (Fin 3 → Code) =>
      edgeExpression p.1 p.2.1 p.2.2) := by
  unfold edgeExpression
  fun_prop

theorem exp_edgeExpression (β : ℚ) (J : Fin 3 → Bool) (xs : Fin 3 → Code) :
    Real.exp (expressionValue (edgeExpression β J xs)) =
      edge (satInteraction (β : ℝ) J) (fun i => expressionValue (xs i)) := by
  unfold edgeExpression edge
  simp only [exp_binaryLogSumExpression, exp_boltzmannAtom, clausePenalty_cast]
  rw [sum_bool_vector_succ]
  simp_rw [sum_bool_vector_succ]
  simp only [Fintype.sum_unique]
  rfl

theorem edgeExpression_value (β : ℚ) (J : Fin 3 → Bool) (xs : Fin 3 → Code) :
    expressionValue (edgeExpression β J xs) =
      Real.log (edge (satInteraction (β : ℝ) J) (fun i => expressionValue (xs i))) := by
  rw [← exp_edgeExpression, Real.log_exp]

@[fun_prop] theorem spinsThree_computable :
    Computable (fun p : Bool × Bool × Bool => ![p.1,p.2.1,p.2.2]) := by
  apply computable_fin_lambda
  intro i
  fin_cases i <;> simp only [Matrix.cons_val_zero', Matrix.cons_val_succ']
  all_goals fun_prop

def extendSpins (a b ε : Bool) : Fin 3 → Bool := ![a,b,ε]

@[fun_prop] theorem extendSpins_computable :
    Computable (fun p : Bool × Bool × Bool => extendSpins p.1 p.2.1 p.2.2) :=
  spinsThree_computable

noncomputable def messageExpression (β : ℚ) (J : Fin 3 → Bool)
    (xs : Fin 2 → Code) (ε : Bool) : Code :=
  binaryLogSumExpression
    (binaryLogSumExpression
      (boltzmannAtom (clausePenalty β J (extendSpins false false ε)) xs ![false,false])
      (boltzmannAtom (clausePenalty β J (extendSpins false true ε)) xs ![false,true]))
    (binaryLogSumExpression
      (boltzmannAtom (clausePenalty β J (extendSpins true false ε)) xs ![true,false])
      (boltzmannAtom (clausePenalty β J (extendSpins true true ε)) xs ![true,true]))

@[fun_prop] theorem messageExpression_computable :
    Computable (fun p : ℚ × (Fin 3 → Bool) × (Fin 2 → Code) × Bool =>
      messageExpression p.1 p.2.1 p.2.2.1 p.2.2.2) := by
  unfold messageExpression
  fun_prop

theorem appendSpin_three (a b ε : Bool) :
    appendSpin (p := 3) ![a,b] ε = ![a,b,ε] := by
  funext i
  fin_cases i <;> rfl

theorem messageExpression_value (β : ℚ) (J : Fin 3 → Bool)
    (xs : Fin 2 → Code) (ε : Bool) :
    expressionValue (messageExpression β J xs ε) =
      message (satInteraction (β : ℝ) J) (fun i => expressionValue (xs i)) ε := by
  rw [← Real.log_exp (expressionValue (messageExpression β J xs ε))]
  unfold messageExpression message
  congr 1
  simp only [exp_binaryLogSumExpression, exp_boltzmannAtom, clausePenalty_cast]
  simp_rw [sum_bool_vector_succ]
  simp only [Fintype.sum_unique]
  have ht (a b : Bool) (t : Fin 0 → Bool) : Fin.cons a (Fin.cons b t) = ![a,b] := by
    funext i
    fin_cases i <;> rfl
  simp only [ht, appendSpin_three, extendSpins]

abbrev SiteExpressionDatum := (Fin 3 → Bool) × (Fin 2 → Code)

noncomputable def siteExpression (β : ℚ) (data : List SiteExpressionDatum) : Code :=
  binaryLogMeanExpression
    (sumExpressions (data.map (fun z => messageExpression β z.1 z.2 false)))
    (sumExpressions (data.map (fun z => messageExpression β z.1 z.2 true)))

@[fun_prop] theorem siteExpression_computable :
    Computable (fun p : ℚ × List SiteExpressionDatum => siteExpression p.1 p.2) := by
  have hm (ε : Bool) : Computable (fun p : ℚ × List SiteExpressionDatum =>
      p.2.map (fun z => messageExpression p.1 z.1 z.2 ε)) := by
    apply computable_list_map Computable.snd
    unfold Computable₂
    fun_prop
  unfold siteExpression
  fun_prop

theorem siteExpression_value (β : ℚ) (data : List SiteExpressionDatum) :
    expressionValue (siteExpression β data) =
      siteLog (fun j : Fin data.length => satSample (β : ℝ) (data.get j).1) 0
        (fun i => expressionValue ((data.get i.1).2 i.2)) := by
  have hs (ε : Bool) : (data.map (fun z =>
      message (satInteraction (β : ℝ) z.1) (fun i => expressionValue (z.2 i)) ε)).sum =
      ∑ j : Fin data.length, message (satInteraction (β : ℝ) (data.get j).1)
        (fun i => expressionValue ((data.get j).2 i)) ε := by
    rw [← List.sum_ofFn]
    have h := congrArg (fun ds : List SiteExpressionDatum =>
      (ds.map (fun z => message (satInteraction (β : ℝ) z.1)
        (fun i => expressionValue (z.2 i)) ε)).sum) (List.ofFn_get data)
    simpa only [List.map_ofFn, Function.comp_def] using h.symm
  simp only [siteExpression, binaryLogMeanExpression_value, sumExpressions_value,
    List.map_map, Function.comp_def, messageExpression_value, hs]
  simp only [siteLog, zero_mul, zero_add, satSample, Fintype.sum_bool]
  congr 2
  exact add_comm _ _

attribute [local irreducible] edgeExpression siteExpression

theorem edgeExpression_comp {A : Type} [Primcodable A]
    (β : A → ℚ) (J : A → Fin 3 → Bool) (xs : A → Fin 3 → Code)
    (hβ : Computable β) (hJ : Computable J) (hx : Computable xs) :
    Computable (fun a => edgeExpression (β a) (J a) (xs a)) := by
  exact edgeExpression_computable.comp (hβ.pair (hJ.pair hx))

theorem siteExpression_comp {A : Type} [Primcodable A]
    (β : A → ℚ) (data : A → List SiteExpressionDatum)
    (hβ : Computable β) (hd : Computable data) :
    Computable (fun a => siteExpression (β a) (data a)) := by
  exact siteExpression_computable.comp (hβ.pair hd)

theorem siteExpression_ofFn_value {k : ℕ} (β : ℚ)
    (J : Fin k → Fin 3 → Bool) (xs : Fin k → Fin 2 → Code) :
    expressionValue (siteExpression β (List.ofFn (fun j => (J j,xs j)))) =
      siteLog (fun j => satSample (β : ℝ) (J j)) 0
        (fun i => expressionValue (xs i.1 i.2)) := by
  simp only [siteExpression, binaryLogMeanExpression_value, sumExpressions_value,
    List.map_ofFn, List.sum_ofFn, Function.comp_def, messageExpression_value]
  simp only [siteLog, zero_mul, zero_add, satSample, Fintype.sum_bool]
  congr 2
  exact add_comm _ _

end FixedClauseThreshold.Computability.FiniteArithmetic

end OAI