import OAI.Probability.FreeIsing.Trees.BroadcastLocality

namespace OAI

noncomputable section

open MeasureTheory

namespace Problem367.RootedBroadcast

theorem ofNoise_congr_cone {d : ℕ} (noise₁ noise₂ : TreeVertex d → IsingSpin)
    (c : TreeVertex d) (hbase : ofNoise noise₁ c = ofNoise noise₂ c)
    (hedge : ∀ w : TreeVertex d, c.1 <+: w.1 → w ≠ c → noise₁ w = noise₂ w)
    (v : TreeVertex d) (hcv : c.1 <+: v.1) :
    ofNoise noise₁ v = ofNoise noise₂ v := by
  have h : ∀ n : ℕ, ∀ v : TreeVertex d, v.1.length = n → c.1 <+: v.1 →
      ofNoise noise₁ v = ofNoise noise₂ v := by
    intro n
    induction n using Nat.strong_induction_on with
    | h n ih =>
      intro v hv hcv
      by_cases hvc : v = c
      · simpa only [hvc] using hbase
      · have hlt : c.1.length < v.1.length := by
          have hle := hcv.length_le
          have hne : c.1.length ≠ v.1.length := by
            intro heq
            exact hvc (Subtype.ext (hcv.eq_of_length heq).symm)
          omega
        have hnil : v.1 ≠ [] := by
          intro hh
          simp only [hh, List.length_nil] at hlt
          omega
        have hcp : c.1 <+: (parent v).1 := by
          apply List.prefix_of_prefix_length_le hcv (List.dropLast_prefix v.1)
          change c.1.length ≤ (parentVertex v).1.length
          rw [parentVertex_length]
          omega
        have hp : (parent v).1.length < n := by
          change (parentVertex v).1.length < n
          rw [parentVertex_length]
          omega
        rw [ofNoise_nonroot noise₁ v hnil, ofNoise_nonroot noise₂ v hnil]
        exact congrArg₂ spinMul (hedge v hcv hvc) (ih _ hp _ rfl hcp)
  exact h _ v rfl hcv

abbrev DescendantVertex {d : ℕ} (c : TreeVertex d) :=
  {v : TreeVertex d // c.1 <+: v.1}

abbrev StrictDescendantVertex {d : ℕ} (c : TreeVertex d) :=
  {v : TreeVertex d // c.1 <+: v.1 ∧ v ≠ c}

def coneNoise {d : ℕ} (theta : ℝ) (c : TreeVertex d)
    (s : IsingSpin) (Y : StrictDescendantVertex c → ℝ) (v : TreeVertex d) : IsingSpin :=
  if v.1 = [] then s
  else if hv : c.1 <+: v.1 ∧ v ≠ c then edgeNoise theta (Y ⟨v, hv⟩)
  else IsingSpin.pos

theorem measurable_coneNoise {d : ℕ} (theta : ℝ) (c : TreeVertex d) :
    Measurable (fun p : IsingSpin × (StrictDescendantVertex c → ℝ) =>
      coneNoise theta c p.1 p.2) := by
  apply Measurable.of_eval
  intro v
  by_cases hnil : v.1 = []
  · simpa only [coneNoise, ite_eq_left hnil] using
      (measurable_fst : Measurable (Prod.fst :
        IsingSpin × (StrictDescendantVertex c → ℝ) → IsingSpin))
  · by_cases hv : c.1 <+: v.1 ∧ v ≠ c
    · simpa only [coneNoise, ite_eq_right hnil, dite_eq_left hv, Function.comp_def] using
        (measurable_edgeNoise theta).comp
          ((measurable_pi_apply (X := fun _ : StrictDescendantVertex c => ℝ)
            ⟨v, hv⟩).comp measurable_snd)
    · simpa only [coneNoise, ite_eq_right hnil, dite_eq_right hv] using
        (measurable_const : Measurable (fun _ :
          IsingSpin × (StrictDescendantVertex c → ℝ) => IsingSpin.pos))

theorem ofNoise_coneNoise_at_root {d : ℕ} (theta : ℝ) (c : TreeVertex d)
    (s : IsingSpin) (Y : StrictDescendantVertex c → ℝ) :
    ofNoise (coneNoise theta c s Y) c = s := by
  calc
    ofNoise (coneNoise theta c s Y) c =
        ofNoise (noiseFromSpins (fun _ : TreeVertex d => s)) c := by
      apply ofNoise_congr_prefix
      intro w hw
      have hnot : ¬ (c.1 <+: w.1 ∧ w ≠ c) := by
        rintro ⟨hcw, hne⟩
        exact hne (Subtype.ext (hw.eq_of_length_le hcw.length_le))
      by_cases hnil : w.1 = [] <;>
        simp [coneNoise, noiseFromSpins, hnil, hnot]
    _ = s := congrFun (ofNoise_noiseFromSpins (fun _ : TreeVertex d => s)) c

def coneFactor {d : ℕ} (theta : ℝ) (c : TreeVertex d)
    (p : IsingSpin × (StrictDescendantVertex c → ℝ)) : DescendantVertex c → IsingSpin :=
  fun v => ofNoise (coneNoise theta c p.1 p.2) v.1

theorem measurable_coneFactor {d : ℕ} (theta : ℝ) (c : TreeVertex d) :
    Measurable (coneFactor theta c) := by
  apply Measurable.of_eval
  intro v
  exact (measurable_ofNoise_apply v.1).comp (measurable_coneNoise theta c)

theorem factor_cone_representation {d : ℕ} (theta : ℝ) (c : TreeVertex d)
    (U : TreeVertex d → ℝ) :
    (fun v : DescendantVertex c => factor theta U v.1) =
      coneFactor theta c (factor theta U c,
        fun w : StrictDescendantVertex c => U w.1) := by
  funext v
  apply ofNoise_congr_cone (inputNoise theta U) _ c
  · exact (ofNoise_coneNoise_at_root theta c (factor theta U c) _).symm
  · intro w hcw hne
    have hnil : w.1 ≠ [] := by
      intro hw
      have hc : c.1 = [] := by simpa only [hw, List.prefix_nil] using hcw
      exact hne (Subtype.ext (hw.trans hc.symm))
    simp [inputNoise, coneNoise, hnil, hcw, hne]
  · exact v.2

end Problem367.RootedBroadcast

end

end OAI