import OAI.Probability.Ising.SpinCorrelation
import OAI.Probability.Ising.Marginals

namespace OAI

open scoped BigOperators Classical

namespace BufferedIsing

/-- The actual contracted marginal retains arbitrary fields and all effects
of the common pins. It is distinct from the zero-field comparison weight. -/
noncomputable def contractedPinnedWeight {n m : ℕ} (G : FiniteGraph n m)
    (h : Fin n → ℝ) (I J F : Finset (Fin n)) (τ : Spins n)
    (σ : KeptVertex F → Bool) : ℝ :=
  if Respects (comparisonSetoid G I J F ∅) σ then weight G h (pinExtension F τ σ) else 0

lemma respects_terminals_iff {n m : ℕ} (G : FiniteGraph n m)
    (I J F : Finset (Fin n)) (σ : KeptVertex F → Bool) :
    Respects (comparisonSetoid G I J F ∅) σ ↔
      (∀ x y, x.val ∈ I → y.val ∈ I → σ x = σ y) ∧
        (∀ x y, x.val ∈ J → y.val ∈ J → σ x = σ y) := by
  constructor
  · intro H
    exact ⟨fun x y hx hy => H x y (Relation.EqvGen.rel _ _ (Or.inl ⟨hx, hy⟩)),
      fun x y hx hy => H x y (Relation.EqvGen.rel _ _ (Or.inr (Or.inl ⟨hx, hy⟩)))⟩
  · rintro ⟨hI, hJ⟩ x y hxy
    induction hxy with
    | rel x y h =>
      rcases h with h | h | ⟨e, he, _⟩
      · exact hI x y h.1 h.2
      · exact hJ x y h.1 h.2
      · exact (Finset.notMem_empty e he).elim
    | refl => rfl
    | symm _ _ _ ih => exact ih.symm
    | trans _ _ _ _ _ ih ih' => exact ih.trans ih'

lemma contracted_prescription_iff {n m : ℕ} (G : FiniteGraph n m)
    (I J F : Finset (Fin n)) (hIF : Disjoint I F) (hJF : Disjoint J F)
    (i j : KeptVertex F) (hi : i.val ∈ I) (hj : j.val ∈ J)
    (τ : Spins n) (σ : KeptVertex F → Bool) (s t : Bool) :
    (σ i = s ∧ σ j = t ∧ Respects (comparisonSetoid G I J F ∅) σ) ↔
      AgreesOn I (pinExtension F τ σ) (fun _ => s) ∧
        AgreesOn J (pinExtension F τ σ) (fun _ => t) := by
  constructor
  · rintro ⟨his, hjt, hresp⟩
    obtain ⟨hI, hJ⟩ := (respects_terminals_iff G I J F σ).mp hresp
    constructor
    · intro v hv
      have hvF : v ∉ F := fun hvF => Finset.disjoint_left.mp hIF hv hvF
      exact (pinExtension_apply F τ σ ⟨v, hvF⟩).trans ((hI _ i hv hi).trans his)
    · intro v hv
      have hvF : v ∉ F := fun hvF => Finset.disjoint_left.mp hJF hv hvF
      exact (pinExtension_apply F τ σ ⟨v, hvF⟩).trans ((hJ _ j hv hj).trans hjt)
  · rintro ⟨hI, hJ⟩
    have hI' : ∀ v : KeptVertex F, v.val ∈ I → σ v = s := by
      intro v hv
      simpa only [pinExtension_apply] using hI v.val hv
    have hJ' : ∀ v : KeptVertex F, v.val ∈ J → σ v = t := by
      intro v hv
      simpa only [pinExtension_apply] using hJ v.val hv
    refine ⟨hI' i hi, hJ' j hj, (respects_terminals_iff G I J F σ).mpr ?_⟩
    exact ⟨fun x y hx hy => (hI' x hx).trans (hI' y hy).symm,
      fun x y hx hy => (hJ' x hx).trans (hJ' y hy).symm⟩

/-- Identifying each terminal set separately is *exactly* restriction to its
constant configurations; no new model comparison enters this identity. -/
lemma pairTable_contractedPinned {n m : ℕ} (G : FiniteGraph n m)
    (h : Fin n → ℝ) (I J F : Finset (Fin n))
    (hIF : Disjoint I F) (hJF : Disjoint J F)
    (i j : KeptVertex F) (hi : i.val ∈ I) (hj : j.val ∈ J)
    (τ : Spins n) (s t : Bool) :
    pairTable (contractedPinnedWeight G h I J F τ) i j s t =
      jointWeight G h I J F τ (fun _ => s) (fun _ => t) := by
  classical
  have hdel := constrainedSum_delete_variables G h F τ
    (fun ρ => AgreesOn I ρ (fun _ => s) ∧ AgreesOn J ρ (fun _ => t))
  have hswap : jointWeight G h I J F τ (fun _ => s) (fun _ => t) =
      constrainedSum G h (fun ρ => AgreesOn F ρ τ ∧
        (AgreesOn I ρ (fun _ => s) ∧ AgreesOn J ρ (fun _ => t))) := by
    unfold jointWeight constrainedSum
    apply Finset.sum_congr rfl
    intro ρ _
    congr 1
    exact propext and_rotate.symm
  rw [hswap, hdel]
  unfold pairTable
  apply Finset.sum_congr rfl
  intro σ _
  unfold contractedPinnedWeight
  have H := contracted_prescription_iff G I J F hIF hJF i j hi hj τ σ s t
  by_cases hc : σ i = s ∧ σ j = t
  · rw [ite_eq_left hc]
    by_cases hr : Respects (comparisonSetoid G I J F ∅) σ
    · rw [ite_eq_left hr, ite_eq_left (H.mp ⟨hc.1, hc.2, hr⟩)]
    · rw [ite_eq_right hr, ite_eq_right (fun hp => hr (H.mpr hp).2.2)]
  · rw [ite_eq_right hc, ite_eq_right (fun hp => hc ⟨(H.mpr hp).1, (H.mpr hp).2.1⟩)]

lemma extremeLogOdds_eq_effective {n m : ℕ} (G : FiniteGraph n m)
    (h : Fin n → ℝ) (I J F : Finset (Fin n))
    (hIF : Disjoint I F) (hJF : Disjoint J F)
    (i j : KeptVertex F) (hi : i.val ∈ I) (hj : j.val ∈ J) (τ : Spins n) :
    extremeLogOdds G h I J F τ =
      4 * tableCoupling (pairTable (contractedPinnedWeight G h I J F τ) i j) := by
  simp only [tableCoupling, pairTable_contractedPinned G h I J F hIF hJF i j hi hj]
  unfold extremeLogOdds
  change _ = 4 * ((Real.log (jointWeight G h I J F τ ⊤ ⊤) +
    Real.log (jointWeight G h I J F τ ⊥ ⊥) - Real.log (jointWeight G h I J F τ ⊤ ⊥) -
    Real.log (jointWeight G h I J F τ ⊥ ⊤)) / 4)
  ring

lemma sum_pin_incidence {n m : ℕ} (l r : Fin m → Fin n) (F : Finset (Fin n)) (f : Fin m → ℝ) (σ : Fin n → ℝ) :
    (∑ v : Fin n, if v ∉ F then (∑ e, if l e = v ∧ r e ∈ F then f e else 0) * σ v else 0) =
      ∑ e, if l e ∉ F ∧ r e ∈ F then f e * σ (l e) else 0 := by
  classical
  calc
    _ = ∑ v : Fin n, ∑ e, if v ∉ F ∧ l e = v ∧ r e ∈ F then f e * σ v else 0 := by
      apply Finset.sum_congr rfl
      intro v _
      by_cases hv : v ∈ F
      · simp [hv]
      · simp only [hv, not_false_eq_true, ite_true, true_and, Finset.sum_mul]
        apply Finset.sum_congr rfl
        intro e _
        split_ifs <;> simp
    _ = _ := by
      rw [Finset.sum_comm]
      apply Finset.sum_congr rfl
      intro e _
      have H : ∀ v : Fin n, (v ∉ F ∧ l e = v ∧ r e ∈ F) ↔
          (l e = v ∧ l e ∉ F ∧ r e ∈ F) := by
        intro v
        constructor
        · rintro ⟨hv, he, hr⟩
          exact ⟨he, he.symm ▸ hv, hr⟩
        · rintro ⟨he, hl, hr⟩
          exact ⟨he ▸ hl, he, hr⟩
      simp_rw [H]
      by_cases he : l e ∉ F ∧ r e ∈ F
      · simp [he]
      · simp [he]

/-- The finite-field contribution induced by the actual prescribed spins.
Neither these induced fields nor the original fields survive in `qZero`. -/
noncomputable def pinField {n m : ℕ} (G : FiniteGraph n m)
    (h : Fin n → ℝ) (F : Finset (Fin n)) (τ : Spins n) (v : KeptVertex F) : ℝ :=
  h v + (∑ e, if G.left e = v.val ∧ G.right e ∈ F then
    G.coupling e * spin (τ (G.right e)) else 0) +
    ∑ e, if G.right e = v.val ∧ G.left e ∈ F then
      G.coupling e * spin (τ (G.left e)) else 0

/-- Field and bond terms depending only on fixed sites. They cancel from
all normalized laws, but recording them makes the elimination exact. -/
noncomputable def pinConstant {n m : ℕ} (G : FiniteGraph n m)
    (h : Fin n → ℝ) (F : Finset (Fin n)) (τ : Spins n) : ℝ :=
  (∑ e, if G.left e ∈ F ∧ G.right e ∈ F then
    G.coupling e * spin (τ (G.left e)) * spin (τ (G.right e)) else 0) +
    ∑ v ∈ F, h v * spin (τ v)

lemma energy_pin_expansion {n m : ℕ} (G : FiniteGraph n m)
    (h : Fin n → ℝ) (F : Finset (Fin n)) (τ ρ : Spins n) (hρ : AgreesOn F ρ τ) :
    energy G h ρ = pinConstant G h F τ +
      (∑ e, if G.left e ∉ F ∧ G.right e ∉ F then
        G.coupling e * spin (ρ (G.left e)) * spin (ρ (G.right e)) else 0) +
      ∑ v : Fin n, if v ∉ F then
        (h v + (∑ e, if G.left e = v ∧ G.right e ∈ F then
          G.coupling e * spin (τ (G.right e)) else 0) +
          ∑ e, if G.right e = v ∧ G.left e ∈ F then
            G.coupling e * spin (τ (G.left e)) else 0) * spin (ρ v) else 0 := by
  classical
  have hsplit : (∑ v : Fin n, if v ∉ F then
        (h v + (∑ e, if G.left e = v ∧ G.right e ∈ F then
          G.coupling e * spin (τ (G.right e)) else 0) +
          ∑ e, if G.right e = v ∧ G.left e ∈ F then
            G.coupling e * spin (τ (G.left e)) else 0) * spin (ρ v) else 0) =
      (∑ v : Fin n, if v ∉ F then h v * spin (ρ v) else 0) +
      (∑ e, if G.left e ∉ F ∧ G.right e ∈ F then
        (G.coupling e * spin (τ (G.right e))) * spin (ρ (G.left e)) else 0) +
      (∑ e, if G.right e ∉ F ∧ G.left e ∈ F then
        (G.coupling e * spin (τ (G.left e))) * spin (ρ (G.right e)) else 0) := by
    rw [← sum_pin_incidence G.left G.right F
      (fun e => G.coupling e * spin (τ (G.right e))) (fun v => spin (ρ v)),
      ← sum_pin_incidence G.right G.left F
        (fun e => G.coupling e * spin (τ (G.left e))) (fun v => spin (ρ v))]
    rw [← Finset.sum_add_distrib, ← Finset.sum_add_distrib]
    apply Finset.sum_congr rfl
    intro v _
    by_cases hv : v ∈ F <;> simp [hv, add_mul]
  rw [hsplit]
  unfold energy pinConstant
  have he : (∑ e, G.coupling e * spin (ρ (G.left e)) * spin (ρ (G.right e))) =
      (∑ e, if G.left e ∈ F ∧ G.right e ∈ F then
        G.coupling e * spin (τ (G.left e)) * spin (τ (G.right e)) else 0) +
      (∑ e, if G.left e ∉ F ∧ G.right e ∉ F then
        G.coupling e * spin (ρ (G.left e)) * spin (ρ (G.right e)) else 0) +
      (∑ e, if G.left e ∉ F ∧ G.right e ∈ F then
        (G.coupling e * spin (τ (G.right e))) * spin (ρ (G.left e)) else 0) +
      (∑ e, if G.right e ∉ F ∧ G.left e ∈ F then
        (G.coupling e * spin (τ (G.left e))) * spin (ρ (G.right e)) else 0) := by
    rw [← Finset.sum_add_distrib, ← Finset.sum_add_distrib, ← Finset.sum_add_distrib]
    apply Finset.sum_congr rfl
    intro e _
    by_cases hl : G.left e ∈ F <;> by_cases hr : G.right e ∈ F
    · simp [hl, hr, hρ _ hl, hρ _ hr]
    · simp [hl, hr, hρ _ hl]
    · simp [hl, hr, hρ _ hr, mul_comm, mul_left_comm]
    · simp [hl, hr]
  have hv : (∑ v, h v * spin (ρ v)) =
      (∑ v ∈ F, h v * spin (τ v)) +
      (∑ v : Fin n, if v ∉ F then h v * spin (ρ v) else 0) := by
    rw [← Fintype.sum_extend_by_zero F (fun v => h v * spin (τ v)),
      ← Finset.sum_add_distrib]
    apply Finset.sum_congr rfl
    intro v _
    by_cases hv : v ∈ F <;> simp [hv, hρ v]
  rw [he, hv]
  ring

lemma sum_kept {n : ℕ} (F : Finset (Fin n)) (f : Fin n → ℝ) :
    (∑ v : KeptVertex F, f v.val) = ∑ v : Fin n, if v ∉ F then f v else 0 := by
  classical
  rw [← Finset.sum_filter]
  exact (Finset.sum_subtype _ (fun v => by simp only [Finset.mem_filter,
    Finset.mem_univ, true_and]) f).symm

/-- Exact deletion of fixed sites: their incident bonds become finite real
fields, while only bonds with two free endpoints remain as interactions. -/
lemma energy_pinExtension {n m : ℕ} (G : FiniteGraph n m)
    (h : Fin n → ℝ) (F : Finset (Fin n)) (τ : Spins n) (σ : KeptVertex F → Bool) :
    energy G h (pinExtension F τ σ) = pinConstant G h F τ +
      deletedEnergy G F σ + ∑ v : KeptVertex F, pinField G h F τ v * spin (σ v) := by
  classical
  rw [energy_pin_expansion G h F τ _ (pinExtension_agrees F τ σ)]
  congr 1
  · congr 1
    unfold deletedEnergy keptEdges
    rw [Finset.sum_filter]
    apply Finset.sum_congr rfl
    intro e _
    split_ifs with he
    · simp only [pinExtension, extendKept, dite_eq_right he.1, dite_eq_right he.2, dite_eq_left he.1, dite_eq_left he.2]
    · rfl
  · have hs : (∑ v : KeptVertex F, pinField G h F τ v * spin (σ v)) =
        ∑ v : Fin n, if v ∉ F then
          (h v + (∑ e, if G.left e = v ∧ G.right e ∈ F then
            G.coupling e * spin (τ (G.right e)) else 0) +
            ∑ e, if G.right e = v ∧ G.left e ∈ F then
              G.coupling e * spin (τ (G.left e)) else 0) *
              spin (pinExtension F τ σ v) else 0 := by
      rw [← sum_kept]
      simp only [pinField, pinExtension_apply]
    exact hs.symm

lemma weight_pinExtension {n m : ℕ} (G : FiniteGraph n m)
    (h : Fin n → ℝ) (F : Finset (Fin n)) (τ : Spins n) (σ : KeptVertex F → Bool) :
    weight G h (pinExtension F τ σ) = Real.exp (pinConstant G h F τ) *
      Real.exp (deletedEnergy G F σ + ∑ v : KeptVertex F, pinField G h F τ v * spin (σ v)) := by
  unfold weight
  rw [energy_pinExtension]
  rw [← Real.exp_add]
  congr 1
  ring

end BufferedIsing

end OAI