import OAI.Probability.RandomSAT.Binomial

namespace OAI

/-!
Deletion and erasure of a coordinate, permutation symmetry, and the integrated
forcing bound.
-/

namespace FixedClauseThreshold

open Finset

noncomputable section

attribute [local instance] Classical.propDecidable

abbrev SplitClause (v k : ℕ) := ProperClause v k ⊕ (ProperClause v (k - 1) × Bool)

def DeletedSatisfied {v k : ℕ} (σ : Assignment v) : SplitClause v k → Prop
  | .inl C => SatisfiesClause σ C
  | .inr _ => True

def ErasedSatisfied {v k : ℕ} (σ : Assignment v) : SplitClause v k → Prop
  | .inl C => SatisfiesClause σ C
  | .inr Q => SatisfiesClause σ Q.1

def deletedSolutions {v k m : ℕ} (S : Finset (Assignment v)) (F : Fin m → SplitClause v k) :
    Finset (Assignment v) := S.filter (fun σ => ∀ i, DeletedSatisfied σ (F i))

def erasedSolutions {v k m : ℕ} (S : Finset (Assignment v)) (F : Fin m → SplitClause v k) :
    Finset (Assignment v) := S.filter (fun σ => ∀ i, ErasedSatisfied σ (F i))

@[simp] theorem mem_deletedSolutions {v k m : ℕ} (S : Finset (Assignment v))
    (F : Fin m → SplitClause v k) (σ : Assignment v) :
    σ ∈ deletedSolutions S F ↔ σ ∈ S ∧ ∀ i, DeletedSatisfied σ (F i) := by
  simp [deletedSolutions]

@[simp] theorem mem_erasedSolutions {v k m : ℕ} (S : Finset (Assignment v))
    (F : Fin m → SplitClause v k) (σ : Assignment v) :
    σ ∈ erasedSolutions S F ↔ σ ∈ S ∧ ∀ i, ErasedSatisfied σ (F i) := by
  simp [erasedSolutions]

theorem erasedSolutions_subset {v k m : ℕ} (S : Finset (Assignment v))
    (F : Fin m → SplitClause v k) : erasedSolutions S F ⊆ deletedSolutions S F := by
  intro σ hσ
  rw [mem_erasedSolutions] at hσ
  rw [mem_deletedSolutions]
  refine ⟨hσ.1, fun i => ?_⟩
  have hi := hσ.2 i
  cases hFi : F i with
  | inl C => simpa [ErasedSatisfied, DeletedSatisfied, hFi] using hi
  | inr Q => trivial

theorem satisfies_head_split {v k : ℕ} (hk : 0 < k) (σ : Assignment v)
    (b : Bool) (X : SplitClause v k) :
    SatisfiesClause (Fin.cons b σ) ((clauseHeadEquiv hk).symm X) ↔
      match X with
      | .inl C => SatisfiesClause σ C
      | .inr Q => Q.2 = b ∨ SatisfiesClause σ Q.1 := by
  cases X with
  | inl C => exact satisfiesClause_prependAbsent σ b C
  | inr Q => exact satisfiesClause_prependPresent hk σ b Q.2 Q.1

theorem head_erasure_extension {v k m : ℕ} (hk : 0 < k)
    (F : Fin m → SplitClause v k) {σ : Assignment v}
    (hσ : σ ∈ erasedSolutions Finset.univ F) (b : Bool) :
    Satisfies (Fin.cons b σ) (fun i => (clauseHeadEquiv hk).symm (F i)) := by
  intro i
  rw [satisfies_head_split]
  have hi := ((mem_erasedSolutions _ _ _).mp hσ).2 i
  cases hFi : F i with
  | inl C => simpa [ErasedSatisfied, hFi] using hi
  | inr Q => exact Or.inr (by simpa [ErasedSatisfied, hFi] using hi)

theorem head_deletion_projection {v k m : ℕ} (hk : 0 < k)
    (F : Fin m → SplitClause v k) {σ : Assignment (v + 1)}
    (hσ : Satisfies σ (fun i => (clauseHeadEquiv hk).symm (F i))) :
    Fin.tail σ ∈ deletedSolutions Finset.univ F := by
  rw [mem_deletedSolutions]
  refine ⟨Finset.mem_univ _, fun i => ?_⟩
  have hi := hσ i
  rw [← Fin.cons_self_tail σ, satisfies_head_split] at hi
  cases hFi : F i with
  | inl C => simpa [DeletedSatisfied, hFi] using hi
  | inr Q => trivial

theorem head_forced_reduction {v k m : ℕ} (hk : 0 < k) (F : Fin m → SplitClause v k)
    (hf : (0 : Fin (v + 1)) ∈ forcedVariables
      (restrictSolutions Finset.univ (fun i => (clauseHeadEquiv hk).symm (F i)))) :
    (deletedSolutions Finset.univ F).Nonempty ∧ ¬ (erasedSolutions Finset.univ F).Nonempty := by
  simp only [forcedVariables, Finset.mem_filter, Finset.mem_univ, true_and] at hf
  obtain ⟨σ, hσ⟩ := hf.1
  have hsat : Satisfies σ (fun i => (clauseHeadEquiv hk).symm (F i)) :=
    ((mem_restrictSolutions _ _ _).mp hσ).2
  refine ⟨⟨Fin.tail σ, head_deletion_projection hk F hsat⟩, ?_⟩
  rintro ⟨τ, hτ⟩
  obtain ⟨b, hb⟩ := hf.2
  have hext (t : Bool) : Fin.cons t τ ∈
      restrictSolutions Finset.univ (fun i => (clauseHeadEquiv hk).symm (F i)) := by
    rw [mem_restrictSolutions]
    exact ⟨Finset.mem_univ _, head_erasure_extension hk F hτ t⟩
  have hfalse := hb _ (hext false)
  have htrue := hb _ (hext true)
  simp only [Fin.cons_zero] at hfalse htrue
  cases b <;> simp_all

theorem head_forced_indicator_le {v k m : ℕ} (hk : 0 < k) (F : Fin m → SplitClause v k) :
    (if (0 : Fin (v + 1)) ∈ forcedVariables
      (restrictSolutions Finset.univ (fun i => (clauseHeadEquiv hk).symm (F i)))
      then (1 : ℝ) else 0) ≤
      alive (deletedSolutions Finset.univ F) - alive (erasedSolutions Finset.univ F) := by
  split
  · rename_i h
    obtain ⟨hd, he⟩ := head_forced_reduction hk F h
    simp [alive, hd, he]
  · have h := alive_mono (erasedSolutions_subset Finset.univ F)
    linarith

theorem deletedSolutions_cons_inl {v k m : ℕ} (S : Finset (Assignment v))
    (C : ProperClause v k) (F : Fin m → SplitClause v k) :
    deletedSolutions S (Fin.cons (.inl C) F) = deletedSolutions (addClause S C) F := by
  ext σ
  simp only [mem_deletedSolutions, mem_addClause, Fin.forall_fin_succ,
    Fin.cons_zero, Fin.cons_succ, DeletedSatisfied]
  tauto

theorem deletedSolutions_cons_inr {v k m : ℕ} (S : Finset (Assignment v))
    (Q : ProperClause v (k - 1)) (b : Bool) (F : Fin m → SplitClause v k) :
    deletedSolutions S (Fin.cons (.inr (Q, b)) F) = deletedSolutions S F := by
  ext σ
  simp only [mem_deletedSolutions, Fin.forall_fin_succ,
    Fin.cons_zero, Fin.cons_succ, DeletedSatisfied, true_and]

theorem erasedSolutions_cons_inl {v k m : ℕ} (S : Finset (Assignment v))
    (C : ProperClause v k) (F : Fin m → SplitClause v k) :
    erasedSolutions S (Fin.cons (.inl C) F) = erasedSolutions (addClause S C) F := by
  ext σ
  simp only [mem_erasedSolutions, mem_addClause, Fin.forall_fin_succ,
    Fin.cons_zero, Fin.cons_succ, ErasedSatisfied]
  tauto

theorem erasedSolutions_cons_inr {v k m : ℕ} (S : Finset (Assignment v))
    (Q : ProperClause v (k - 1)) (b : Bool) (F : Fin m → SplitClause v k) :
    erasedSolutions S (Fin.cons (.inr (Q, b)) F) = erasedSolutions (addClause S Q) F := by
  ext σ
  simp only [mem_erasedSolutions, mem_addClause, Fin.forall_fin_succ,
    Fin.cons_zero, Fin.cons_succ, ErasedSatisfied]
  tauto

def deletedMean {v k : ℕ} (hk : 0 < k) (m : ℕ) (S : Finset (Assignment v)) : ℝ :=
  uniformMean (fun F : Formula (v + 1) k m =>
    alive (deletedSolutions S (fun i => clauseHeadSplit hk (F i))))

def erasedMean {v k : ℕ} (hk : 0 < k) (m : ℕ) (S : Finset (Assignment v)) : ℝ :=
  uniformMean (fun F : Formula (v + 1) k m =>
    alive (erasedSolutions S (fun i => clauseHeadSplit hk (F i))))

@[simp] theorem deletedMean_zero {v k : ℕ} (hk : 0 < k) (S : Finset (Assignment v)) :
    deletedMean hk 0 S = alive S := by
  have h (F : Formula (v + 1) k 0) :
      deletedSolutions S (fun i => clauseHeadSplit hk (F i)) = S := by
    ext σ
    simp
  simp only [deletedMean, h, uniformMean_const]

@[simp] theorem erasedMean_zero {v k : ℕ} (hk : 0 < k) (S : Finset (Assignment v)) :
    erasedMean hk 0 S = alive S := by
  have h (F : Formula (v + 1) k 0) :
      erasedSolutions S (fun i => clauseHeadSplit hk (F i)) = S := by
    ext σ
    simp
  simp only [erasedMean, h, uniformMean_const]

theorem deletedMean_succ {v k m : ℕ} (hk : 0 < k) (hkv : k ≤ v)
    (S : Finset (Assignment v)) :
    deletedMean hk (m + 1) S =
      (1 - (k : ℝ) / (v + 1)) * clauseAverage k (deletedMean hk m) S +
      ((k : ℝ) / (v + 1)) * deletedMean hk m S := by
  let : Nonempty (ProperClause v (k - 1)) := nonempty_properClause (by omega)
  unfold deletedMean
  rw [uniformMean_fin_succ]
  have hcons (C : ProperClause (v + 1) k) (F : Formula (v + 1) k m) :
      (fun i : Fin (m + 1) => clauseHeadSplit hk ((Fin.cons C F : Formula (v + 1) k (m + 1)) i)) =
        Fin.cons (clauseHeadSplit hk C) (fun i => clauseHeadSplit hk (F i)) := by
    funext i
    refine Fin.cases ?_ (fun _ => ?_) i <;> rfl
  simp only [hcons]
  rw [clauseHead_mean hk hkv (fun X => uniformMean (fun F : Formula (v + 1) k m =>
    alive (deletedSolutions S (Fin.cons X (fun i => clauseHeadSplit hk (F i))))))]
  simp only [deletedSolutions_cons_inl, deletedSolutions_cons_inr,
    uniformMean_const]
  rfl

theorem erasedMean_succ {v k m : ℕ} (hk : 0 < k) (hkv : k ≤ v)
    (S : Finset (Assignment v)) :
    erasedMean hk (m + 1) S =
      (1 - (k : ℝ) / (v + 1)) * clauseAverage k (erasedMean hk m) S +
      ((k : ℝ) / (v + 1)) * clauseAverage (k - 1) (erasedMean hk m) S := by
  unfold erasedMean
  rw [uniformMean_fin_succ]
  have hcons (C : ProperClause (v + 1) k) (F : Formula (v + 1) k m) :
      (fun i : Fin (m + 1) => clauseHeadSplit hk ((Fin.cons C F : Formula (v + 1) k (m + 1)) i)) =
        Fin.cons (clauseHeadSplit hk C) (fun i => clauseHeadSplit hk (F i)) := by
    funext i
    refine Fin.cases ?_ (fun _ => ?_) i <;> rfl
  simp only [hcons]
  rw [clauseHead_mean hk hkv (fun X => uniformMean (fun F : Formula (v + 1) k m =>
    alive (erasedSolutions S (Fin.cons X (fun i => clauseHeadSplit hk (F i))))))]
  simp only [erasedSolutions_cons_inl, erasedSolutions_cons_inr,
    uniformMean_const]
  rfl

theorem clauseAverage_binomialMean {v k : ℕ} (p : ℝ) (m : ℕ)
    (f : ℕ → Finset (Assignment v) → ℝ) (S : Finset (Assignment v)) :
    clauseAverage k (fun T => binomialMean p m (fun d => f d T)) S =
      binomialMean p m (fun d => clauseAverage k (f d) S) :=
  uniformMean_binomialMean p m _

theorem clauseAverage_survival {v k t : ℕ} (S : Finset (Assignment v)) :
    clauseAverage k (survival k t) S = survival k (t + 1) S :=
  (survival_succ S).symm

theorem clauseAverage_short_survival {n k t : ℕ} (hk : 3 ≤ k) (hn : k + 1 ≤ n)
    (S : Finset (Assignment (n - 1))) :
    survival k (t + replacementBlock n k) S - replacementError n k ≤
      clauseAverage (k - 1) (survival k t) S := by
  have h := clauseAverage_iterate_mono (k := k) (m := t)
    (shorter_survival_replacement hk hn) S
  rw [clauseAverage_iterate_sub_const (by omega)] at h
  dsimp only at h
  rw [survival_add] at h
  have he : clauseAverage (k - 1) (survival k t) S =
      ((clauseAverage k)^[t] (survival (k - 1) 1)) S :=
    survival_shift (m := 1) (d := t) S
  rw [he]
  simpa using h

theorem deletedMean_eq_binomial {v k m : ℕ} (hk : 0 < k) (hkv : k ≤ v)
    (S : Finset (Assignment v)) :
    deletedMean hk m S = binomialMean ((k : ℝ) / (v + 1)) m
      (fun d => survival k (m - d) S) := by
  induction m generalizing S with
  | zero => simp [binomialMean]
  | succ m ih =>
    rw [deletedMean_succ hk hkv]
    have hfun : deletedMean hk m =
        (fun T : Finset (Assignment v) => binomialMean ((k : ℝ) / (v + 1)) m
          (fun d => survival k (m - d) T)) := funext ih
    rw [hfun, clauseAverage_binomialMean]
    change _ = (1 - (k : ℝ) / (v + 1)) * _ + ((k : ℝ) / (v + 1)) * _
    congr 1
    · congr 1
      apply binomialMean_congr
      intro d hd
      rw [clauseAverage_survival]
      congr 1
      omega
    · congr 1
      apply binomialMean_congr
      intro d _
      congr 1
      omega

theorem erasedMean_replacement {n k m : ℕ} (hk : 3 ≤ k) (hn : k + 1 ≤ n)
    (S : Finset (Assignment (n - 1))) :
    binomialMean ((k : ℝ) / n) m (fun d =>
      survival k (m - d + replacementBlock n k * d) S -
        (d : ℝ) * replacementError n k) ≤ erasedMean (by omega : 0 < k) m S := by
  have hkn : k ≤ n - 1 := by omega
  have hshort : k - 1 ≤ n - 1 := by omega
  have hn1 : n - 1 + 1 = n := by omega
  have hp0 : 0 ≤ (k : ℝ) / n := by positivity
  have hp1 : (k : ℝ) / n ≤ 1 := by
    apply (div_le_one (by exact_mod_cast (by omega : 0 < n))).mpr
    exact_mod_cast (by omega : k ≤ n)
  induction m generalizing S with
  | zero => simp [binomialMean]
  | succ m ih =>
    rw [erasedMean_succ (by omega) hkn]
    have hden : ((n - 1 : ℕ) : ℝ) + 1 = n := by exact_mod_cast hn1
    rw [hden]
    have hlong := clauseAverage_mono (k := k) ih S
    have hshorter := clauseAverage_mono (k := k - 1) ih S
    rw [clauseAverage_binomialMean] at hlong hshorter
    have ha : binomialMean ((k : ℝ) / n) m (fun d =>
        survival k (m + 1 - d + replacementBlock n k * d) S -
          (d : ℝ) * replacementError n k) ≤ clauseAverage k (erasedMean (by omega : 0 < k) m) S := by
      calc
        _ = binomialMean ((k : ℝ) / n) m (fun d => clauseAverage k
            (fun T => survival k (m - d + replacementBlock n k * d) T -
              (d : ℝ) * replacementError n k) S) := by
          apply binomialMean_congr
          intro d hd
          rw [clauseAverage_sub_const hkn, clauseAverage_survival]
          congr 2
          omega
        _ ≤ _ := hlong
    have hb : binomialMean ((k : ℝ) / n) m (fun d =>
        survival k (m + 1 - (d + 1) + replacementBlock n k * (d + 1)) S -
          ((d + 1 : ℕ) : ℝ) * replacementError n k) ≤
        clauseAverage (k - 1) (erasedMean (by omega : 0 < k) m) S := by
      apply le_trans _ hshorter
      apply binomialMean_mono hp0 hp1
      intro d _
      rw [clauseAverage_sub_const hshort]
      have h := clauseAverage_short_survival (t := m - d + replacementBlock n k * d) hk hn S
      have he : m + 1 - (d + 1) + replacementBlock n k * (d + 1) =
          m - d + replacementBlock n k * d + replacementBlock n k := by
        rw [Nat.mul_add, Nat.mul_one]
        omega
      rw [he]
      push_cast
      linarith
    exact add_le_add (mul_le_mul_of_nonneg_left ha (sub_nonneg.mpr hp1))
      (mul_le_mul_of_nonneg_left hb hp0)

theorem replacementBlock_pos {n k : ℕ} (hn : 0 < n) (hk : 0 < k) :
    1 ≤ replacementBlock n k := by
  have hp : 0 < 2 * (k : ℝ) * replacementScale n k :=
    mul_pos (mul_pos (by norm_num) (by exact_mod_cast hk)) (replacementScale_pos hn)
  exact Nat.ceil_pos.mpr hp

theorem replacementError_nonneg (n k : ℕ) : 0 ≤ replacementError n k := by
  unfold replacementError replacementScale
  positivity

def headForcedMean (v k m : ℕ) : ℝ :=
  uniformMean (fun F : Formula (v + 1) k m =>
    if (0 : Fin (v + 1)) ∈ forcedVariables (restrictSolutions Finset.univ F)
      then (1 : ℝ) else 0)

theorem headForcedMean_le_difference {v k m : ℕ} (hk : 0 < k) :
    headForcedMean v k m ≤ deletedMean (v := v) hk m Finset.univ - erasedMean (v := v) hk m Finset.univ := by
  unfold headForcedMean deletedMean erasedMean
  rw [← uniformMean_sub]
  apply uniformMean_mono
  intro F
  have he : (fun i => (clauseHeadEquiv hk).symm (clauseHeadSplit hk (F i))) = F := by
    funext i
    exact (clauseHeadEquiv hk).symm_apply_apply (F i)
  have h := head_forced_indicator_le hk (fun i => clauseHeadSplit hk (F i))
  simpa only [he] using h

theorem headForcedMean_replacement {v k m : ℕ} (hk : 3 ≤ k) (hkv : k ≤ v) :
    headForcedMean v k m ≤
      binomialMean ((k : ℝ) / (v + 1)) m
        (replacementDifference (properSATProbability v k) (replacementBlock (v + 1) k) m) +
      ((m : ℝ) * ((k : ℝ) / (v + 1))) * replacementError (v + 1) k := by
  have hdel := deletedMean_eq_binomial (m := m) (by omega : 0 < k) hkv Finset.univ
  have her := erasedMean_replacement (n := v + 1) (m := m) hk (by omega) Finset.univ
  simp only [Nat.cast_add, Nat.cast_one] at her
  have hforced := headForcedMean_le_difference (v := v) (m := m) (by omega : 0 < k)
  rw [hdel] at hforced
  have hsub : (binomialMean ((k : ℝ) / (v + 1)) m (fun d => survival k (m - d)
      (Finset.univ : Finset (Assignment v)))) -
      binomialMean ((k : ℝ) / (v + 1)) m (fun d =>
        survival k (m - d + replacementBlock (v + 1) k * d)
          (Finset.univ : Finset (Assignment v)) -
          (d : ℝ) * replacementError (v + 1) k) =
      binomialMean ((k : ℝ) / (v + 1)) m
        (replacementDifference (properSATProbability v k) (replacementBlock (v + 1) k) m) +
      ((m : ℝ) * ((k : ℝ) / (v + 1))) * replacementError (v + 1) k := by
    rw [← binomialMean_sub]
    have hg : 1 ≤ replacementBlock (v + 1) k := replacementBlock_pos (by omega) (by omega)
    calc
      _ = binomialMean ((k : ℝ) / (v + 1)) m (fun d =>
          replacementDifference (properSATProbability v k) (replacementBlock (v + 1) k) m d +
            (d : ℝ) * replacementError (v + 1) k) := by
        apply binomialMean_congr
        intro d hd
        unfold replacementDifference
        rw [properSATProbability_eq_survival, properSATProbability_eq_survival]
        have he : m - d + replacementBlock (v + 1) k * d =
            m + (replacementBlock (v + 1) k - 1) * d := by
          have hh := Nat.sub_add_cancel hg
          have := congrArg (fun a : ℕ => a * d) hh
          simp only [Nat.add_mul, Nat.one_mul] at this
          omega
        rw [he]
        ring
      _ = _ := by rw [binomialMean_add, binomialMean_mul_const, binomialMean_id]
  rw [← hsub]
  linarith

theorem integrated_head_forcing {v k : ℕ} (hk : 3 ≤ k) (hkv : k ≤ v) (M : ℕ) :
    ∑ j ∈ Finset.range (M + 1), headForcedMean v k j ≤
      (replacementBlock (v + 1) k : ℝ) * M * ((k : ℝ) / (v + 1)) +
      ((M + 1 : ℕ) : ℝ) * M * ((k : ℝ) / (v + 1)) * replacementError (v + 1) k := by
  have hp0 : 0 ≤ (k : ℝ) / (v + 1) := by positivity
  have hp1 : (k : ℝ) / (v + 1) ≤ 1 := by
    apply (div_le_one (by positivity)).mpr
    exact_mod_cast (by omega : k ≤ v + 1)
  calc
    _ ≤ ∑ j ∈ Finset.range (M + 1),
        (binomialMean ((k : ℝ) / (v + 1)) j
          (replacementDifference (properSATProbability v k) (replacementBlock (v + 1) k) j) +
        ((j : ℝ) * ((k : ℝ) / (v + 1))) * replacementError (v + 1) k) :=
      Finset.sum_le_sum (fun _ _ => headForcedMean_replacement hk hkv)
    _ = _ := Finset.sum_add_distrib
    _ ≤ _ := by
      apply add_le_add
      · exact binomial_replacement_sum_le hp0 hp1 (properSATProbability_antitone hkv)
          (fun j => properSATProbability_nonneg v k j) (fun j => properSATProbability_le_one v k j)
          (replacementBlock_pos (by omega) (by omega)) M
      · calc
          _ ≤ ∑ _j ∈ Finset.range (M + 1),
              ((M : ℝ) * ((k : ℝ) / (v + 1))) * replacementError (v + 1) k := by
            apply Finset.sum_le_sum
            intro j hj
            have hjM : (j : ℝ) ≤ M := by
              exact_mod_cast (Nat.le_of_lt_succ (Finset.mem_range.mp hj))
            exact mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_right hjM hp0)
              (replacementError_nonneg (v + 1) k)
          _ = _ := by simp; ring

def renameClause {n k : ℕ} (e : Fin n ≃ Fin n) (C : ProperClause n k) : ProperClause n k :=
  ⟨fun i => C.val (e i), by
    have h := Fintype.card_congr
      (e.subtypeEquivOfSubtype (p := fun i => (C.val i).isSome))
    simp only [Fintype.card_subtype] at h
    exact h.trans C.property⟩

def renameClauseEquiv {n k : ℕ} (e : Fin n ≃ Fin n) : ProperClause n k ≃ ProperClause n k where
  toFun := renameClause e
  invFun := renameClause e.symm
  left_inv C := by apply Subtype.ext; funext i; simp [renameClause]
  right_inv C := by apply Subtype.ext; funext i; simp [renameClause]

def renameAssignment {n : ℕ} (e : Fin n ≃ Fin n) (σ : Assignment n) : Assignment n :=
  fun i => σ (e i)

def renameFormula {n k m : ℕ} (e : Fin n ≃ Fin n) (F : Formula n k m) : Formula n k m :=
  fun i => renameClause e (F i)

def renameFormulaEquiv {n k m : ℕ} (e : Fin n ≃ Fin n) : Formula n k m ≃ Formula n k m :=
  Equiv.piCongrRight (fun _ => renameClauseEquiv e)

theorem renameFormulaEquiv_apply {n k m : ℕ} (e : Fin n ≃ Fin n) (F : Formula n k m) :
    renameFormulaEquiv e F = renameFormula e F := rfl

theorem satisfiesClause_rename {n k : ℕ} (e : Fin n ≃ Fin n) (σ : Assignment n)
    (C : ProperClause n k) :
    SatisfiesClause (renameAssignment e σ) (renameClause e C) ↔ SatisfiesClause σ C := by
  change (∃ i, C.val (e i) = some (σ (e i))) ↔ ∃ i, C.val i = some (σ i)
  constructor
  · rintro ⟨i, hi⟩
    exact ⟨e i, hi⟩
  · rintro ⟨i, hi⟩
    exact ⟨e.symm i, by simpa using hi⟩

theorem satisfies_rename {n k m : ℕ} (e : Fin n ≃ Fin n) (σ : Assignment n)
    (F : Formula n k m) :
    Satisfies (renameAssignment e σ) (renameFormula e F) ↔ Satisfies σ F := by
  simp only [Satisfies, renameFormula, satisfiesClause_rename]

theorem satisfies_rename_inverse {n k m : ℕ} (e : Fin n ≃ Fin n) (σ : Assignment n)
    (F : Formula n k m) :
    Satisfies σ (renameFormula e F) ↔ Satisfies (renameAssignment e.symm σ) F := by
  have h := satisfies_rename e (renameAssignment e.symm σ) F
  have he : renameAssignment e (renameAssignment e.symm σ) = σ := by
    funext i
    exact congrArg σ (e.symm_apply_apply i)
  rw [he] at h
  exact h

theorem satisfiable_rename {n k m : ℕ} (e : Fin n ≃ Fin n) (F : Formula n k m) :
    Satisfiable (renameFormula e F) ↔ Satisfiable F := by
  constructor
  · rintro ⟨σ, hσ⟩
    exact ⟨renameAssignment e.symm σ, (satisfies_rename_inverse e σ F).mp hσ⟩
  · rintro ⟨σ, hσ⟩
    exact ⟨renameAssignment e σ, (satisfies_rename e σ F).mpr hσ⟩

theorem mem_forced_formula {n k m : ℕ} (F : Formula n k m) (i : Fin n) :
    i ∈ forcedVariables (restrictSolutions Finset.univ F) ↔
      Satisfiable F ∧ ∃ b, ∀ σ, Satisfies σ F → σ i = b := by
  simp [forcedVariables, Finset.Nonempty, Satisfiable, Satisfies]

theorem forcedVariables_rename {n k m : ℕ} (e : Fin n ≃ Fin n) (F : Formula n k m) (i : Fin n) :
    i ∈ forcedVariables (restrictSolutions Finset.univ (renameFormula e F)) ↔
      e i ∈ forcedVariables (restrictSolutions Finset.univ F) := by
  rw [mem_forced_formula, mem_forced_formula, satisfiable_rename]
  constructor
  · rintro ⟨hS, b, hb⟩
    refine ⟨hS, b, fun σ hσ => ?_⟩
    exact hb (renameAssignment e σ) ((satisfies_rename e σ F).mpr hσ)
  · rintro ⟨hS, b, hb⟩
    refine ⟨hS, b, fun σ hσ => ?_⟩
    have h := hb (renameAssignment e.symm σ) ((satisfies_rename_inverse e σ F).mp hσ)
    simpa only [renameAssignment, Equiv.symm_apply_apply] using h

theorem forced_coordinate_mean {v k m : ℕ} (i : Fin (v + 1)) :
    uniformMean (fun F : Formula (v + 1) k m =>
      if i ∈ forcedVariables (restrictSolutions Finset.univ F) then (1 : ℝ) else 0) =
        headForcedMean v k m := by
  let e : Fin (v + 1) ≃ Fin (v + 1) := Equiv.swap 0 i
  calc
    _ = uniformMean (fun F : Formula (v + 1) k m =>
        if (0 : Fin (v + 1)) ∈ forcedVariables
          (restrictSolutions Finset.univ (renameFormula e F)) then (1 : ℝ) else 0) := by
      apply uniformMean_congr
      intro F
      simp only [forcedVariables_rename, e, Equiv.swap_apply_left]
    _ = _ := by
      have h := uniformMean_equiv (renameFormulaEquiv (n := v + 1) (k := k) (m := m) e)
        (fun F : Formula (v + 1) k m => if (0 : Fin (v + 1)) ∈ forcedVariables
          (restrictSolutions Finset.univ F) then (1 : ℝ) else 0)
      have heq : (fun F : Formula (v + 1) k m => if (0 : Fin (v + 1)) ∈ forcedVariables
          (restrictSolutions Finset.univ (renameFormula e F)) then (1 : ℝ) else 0) =
          (fun F : Formula (v + 1) k m => if (0 : Fin (v + 1)) ∈ forcedVariables
          (restrictSolutions Finset.univ (renameFormulaEquiv e F)) then (1 : ℝ) else 0) := by
        funext F
        apply ite_congr
        · rfl
        · intro _; rfl
        · intro _; rfl
      rw [heq]
      exact h

def forcedFractionMean (n k m : ℕ) : ℝ :=
  uniformMean (fun F : Formula n k m =>
    ((forcedVariables (restrictSolutions Finset.univ F)).card : ℝ) / n)

theorem forcedFractionMean_eq_head (v k m : ℕ) :
    forcedFractionMean (v + 1) k m = headForcedMean v k m := by
  have hc (F : Formula (v + 1) k m) :
      ((forcedVariables (restrictSolutions Finset.univ F)).card : ℝ) =
        ∑ i : Fin (v + 1), if i ∈ forcedVariables (restrictSolutions Finset.univ F)
          then (1 : ℝ) else 0 := by simp
  unfold forcedFractionMean
  simp_rw [hc, div_eq_mul_inv]
  rw [uniformMean_mul_const, uniformMean_sum]
  simp only [forced_coordinate_mean, Finset.sum_const, Finset.card_univ,
    Fintype.card_fin, nsmul_eq_mul]
  have hv : ((v + 1 : ℕ) : ℝ) ≠ 0 := by positivity
  field_simp

theorem integrated_forcing_finite {n k : ℕ} (hk : 3 ≤ k) (hn : k + 1 ≤ n) (M : ℕ) :
    ∑ j ∈ Finset.range (M + 1), forcedFractionMean n k j ≤
      (replacementBlock n k : ℝ) * M * ((k : ℝ) / n) +
      ((M + 1 : ℕ) : ℝ) * M * ((k : ℝ) / n) * replacementError n k := by
  cases n with
  | zero => omega
  | succ v =>
    simp only [forcedFractionMean_eq_head]
    simpa only [Nat.cast_add, Nat.cast_one] using integrated_head_forcing hk (by omega) M

end


end FixedClauseThreshold

end OAI