import OAI.Probability.SATComputability.RootEnergy
import OAI.Probability.RandomSAT.Transfer
import OAI.Probability.DilutedSpin.RootProductLaw

namespace OAI

namespace FixedClauseThreshold.Computability

open DilutedSpinGlass _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
open scoped Classical BigOperators NNReal

theorem finiteClauseAverage_iterate {n m : ℕ} {C : Type*} [Fintype C]
    (sat : C → Assignment n → Prop) (S : Finset (Assignment n)) :
    ((finiteClauseAverage sat)^[m] alive) S =
      uniformMean (fun F : Fin m → C => alive (S.filter (fun s => ∀ j, sat (F j) s))) := by
  induction m generalizing S with
  | zero =>
    simp only [Function.iterate_zero_apply, Fin.forall_fin_zero, Finset.filter_true]
    exact (uniformMean_const _).symm
  | succ m ih =>
    rw [Function.iterate_succ_apply', finiteClauseAverage, uniformMean_fin_succ]
    apply uniformMean_congr
    intro c
    rw [ih]
    apply uniformMean_congr
    intro F
    congr 1
    ext s
    simp only [Finset.mem_filter, Fin.forall_fin_succ, Fin.cons_zero, Fin.cons_succ]
    tauto

def relaxedClauseEquiv (n : ℕ) : RelaxedClause n ≃ AuxiliaryClause n 3 where
  toFun c j := (c.1 j, c.2 j)
  invFun c := (fun j => (c j).1, fun j => (c j).2)
  left_inv _ := rfl
  right_inv _ := rfl

theorem relaxedClauseEquiv_satisfies {n : ℕ} (c : RelaxedClause n) (s : Assignment n) :
    auxiliarySatisfies s (relaxedClauseEquiv n c) ↔
      relaxedClauseSatisfied s c.1 c.2 := by
  rfl

theorem clauseMinimum_zero_iff {n m : ℕ} (cs : Fin m → RelaxedClause n) :
    clauseMinimum cs = 0 ↔ ∃ s : Assignment n, ∀ j,
      relaxedClauseSatisfied s (cs j).1 (cs j).2 := by
  constructor
  · intro h
    obtain ⟨s, hs⟩ := relaxedMinimum_attained (fun j => (cs j).1) (fun j => (cs j).2)
    refine ⟨s, ?_⟩
    change relaxedViolations s _ _ = clauseMinimum cs at hs
    rw [h] at hs
    simpa only [relaxedViolations, Finset.card_eq_zero, Finset.filter_eq_empty_iff,
      Finset.mem_univ, true_implies, not_not] using hs
  · rintro ⟨s, hs⟩
    have h := relaxedMinimum_le (fun j => (cs j).1) (fun j => (cs j).2) s
    have hz : relaxedViolations s (fun j => (cs j).1) (fun j => (cs j).2) = 0 := by
      simp only [relaxedViolations, hs, not_true_eq_false, Finset.filter_false,
        Finset.card_empty]
    exact Nat.eq_zero_of_le_zero (hz ▸ h)

theorem auxiliaryProbability_eq_minimum (n m : ℕ) :
    auxiliaryProbability n 3 m =
      uniformMean (fun cs : Fin m → RelaxedClause n =>
        if clauseMinimum cs = 0 then 1 else 0) := by
  unfold auxiliaryProbability auxiliarySurvival auxiliaryAverage embeddedAverage
  rw [finiteClauseAverage_iterate]
  let e := Equiv.piCongrRight (fun _ : Fin m => relaxedClauseEquiv n)
  rw [← uniformMean_equiv e]
  apply uniformMean_congr
  intro cs
  unfold alive
  congr 1
  apply propext
  rw [clauseMinimum_zero_iff]
  simp only [Finset.filter_nonempty_iff, Finset.mem_univ, true_and]
  rfl

theorem integral_rootMinimum_zero (n m : ℕ) [NeZero n] :
    (∫ x : RootPath (RelaxedClause n) m,
      (if rootMinimum n m x = 0 then (1 : ℝ) else 0)
      ∂rootLaw m (fun _ => finiteUniform (RelaxedClause n))) = auxiliaryProbability n 3 m := by
  rw [auxiliaryProbability_eq_minimum]
  change (∫ x, (if (clauseMinimum (rootArray m x) : ℝ) = 0 then (1 : ℝ) else 0)
    ∂rootLaw m (fun _ => finiteUniform (RelaxedClause n))) = _
  simp only [Nat.cast_eq_zero]
  rw [integral_rootArray_eq_pi (finiteUniform (RelaxedClause n)) m
    (fun cs => if clauseMinimum cs = 0 then (1 : ℝ) else 0),
    finiteUniform_pi, integral_finiteUniform]
  simp only [uniformMean, smul_eq_mul, div_eq_mul_inv, mul_comm]

theorem rootSatisfiableProbability_eq_auxiliary (n : ℕ) [NeZero n] (r : ℝ≥0) :
    rootSatisfiableProbability n (finiteUniform (RelaxedClause n)) r =
      ∫ m : ℕ, auxiliaryProbability n 3 m ∂poissonMeasure r := by
  unfold rootSatisfiableProbability poissonRootAverage rootAverage
  simp only [integral_rootMinimum_zero]

noncomputable def relaxedFixedMinimum (n m : ℕ) : ℝ :=
  uniformMean (fun cs : Fin m → RelaxedClause n => (clauseMinimum cs : ℝ))

noncomputable def relaxedPoissonMinimum (n : ℕ) (a : ℝ≥0) : ℝ :=
  ∫ m : ℕ, relaxedFixedMinimum n m ∂poissonMeasure (a*n)

theorem relaxedFixedMinimum_nonneg (n m : ℕ) : 0 ≤ relaxedFixedMinimum n m :=
  uniformMean_nonneg (fun _ => Nat.cast_nonneg _)

theorem relaxedFixedMinimum_le (n m : ℕ) [NeZero n] : relaxedFixedMinimum n m ≤ m := by
  calc
    _ ≤ uniformMean (fun _cs : Fin m → RelaxedClause n => (m : ℝ)) :=
      uniformMean_mono (fun cs => by exact_mod_cast clauseMinimum_le_length cs)
    _ = _ := uniformMean_const _

theorem relaxedPoissonMinimum_nonneg (n : ℕ) (a : ℝ≥0) :
    0 ≤ relaxedPoissonMinimum n a := integral_nonneg (fun _ => relaxedFixedMinimum_nonneg _ _)

theorem integral_rootMinimum_eq (n m : ℕ) [NeZero n] :
    (∫ x : RootPath (RelaxedClause n) m, rootMinimum n m x
      ∂rootLaw m (fun _ => finiteUniform (RelaxedClause n))) = relaxedFixedMinimum n m := by
  simp only [rootMinimum]
  rw [integral_rootArray_eq_pi (finiteUniform (RelaxedClause n)) m
    (fun cs => (clauseMinimum cs : ℝ)), finiteUniform_pi, integral_finiteUniform]
  simp only [relaxedFixedMinimum, uniformMean, smul_eq_mul, div_eq_mul_inv, mul_comm]

theorem poissonRootAverage_minimum_eq (n : ℕ) [NeZero n] (a : ℝ≥0) :
    poissonRootAverage (finiteUniform (RelaxedClause n)) (a*n) (rootMinimum n) =
      relaxedPoissonMinimum n a := by
  unfold poissonRootAverage rootAverage relaxedPoissonMinimum
  simp only [integral_rootMinimum_eq]

end FixedClauseThreshold.Computability

end OAI