lean/OAI/Probability/FreeIsing/Trees/ClusterInputSampler.lean

import OAI.Probability.FreeIsing.Estimates.FairSpin
import OAI.Probability.FreeIsing.Estimates.IndependentLabelSampler

namespace OAI

noncomputable section

open MeasureTheory

namespace Problem367.ClusterInput

local instance (d : ℕ) : IsProbabilityMeasure (labelMeasure d) := by
  unfold labelMeasure
  infer_instance

abbrev Rows (d : ℕ) := TreeVertex d × ℕ → ℝ

abbrev Space (d : ℕ) :=
  (TreeVertex d → ℝ) × (Rows d × (TreeVertex d → ℝ))

def rowLaw (d : ℕ) : Measure (Rows d) :=
  Measure.infinitePi (fun _ : TreeVertex d × ℕ => uniform01)

def law (d : ℕ) : Measure (Space d) :=
  (labelMeasure d).prod ((rowLaw d).prod (labelMeasure d))

instance rowLaw_probability (d : ℕ) : IsProbabilityMeasure (rowLaw d) := by
  unfold rowLaw
  infer_instance

instance law_probability (d : ℕ) : IsProbabilityMeasure (law d) := by
  unfold law labelMeasure
  infer_instance

def relabelRows {d : ℕ} (g : TreeAut d) (Z : Rows d) : Rows d :=
  fun p => Z (g.toEquiv.symm p.1, p.2)

def relabelInputs {d : ℕ} (g : TreeAut d) (p : Space d) : Space d :=
  (relabel g p.1, relabelRows g p.2.1, relabel g p.2.2)

abbrev Seed := ℝ × ((ℕ → ℝ) × ℝ)

def seedLaw : Measure Seed :=
  uniform01.prod ((Measure.infinitePi (fun _ : ℕ => uniform01)).prod uniform01)

instance seedLaw_probability : IsProbabilityMeasure seedLaw := by
  unfold seedLaw
  infer_instance

def unpack {d : ℕ} (U : TreeVertex d → Seed) : Space d :=
  (fun v => (U v).1, (fun p => (U p.1).2.1 p.2), fun v => (U v).2.2)

lemma measurable_unpack (d : ℕ) : Measurable (@unpack d) := by
  unfold unpack
  fun_prop

@[simp] lemma unpack_relabel {d : ℕ} (g : TreeAut d) (U : TreeVertex d → Seed) :
    unpack (relabel g U) = relabelInputs g (unpack U) := rfl

lemma map_flatten_rows (d : ℕ) :
    (Measure.infinitePi (fun _ : TreeVertex d =>
      Measure.infinitePi (fun _ : ℕ => uniform01))).map
        (fun Z p => Z p.1 p.2) = rowLaw d := by
  exact Measure.infinitePi_map_curry_symm (fun (_ : TreeVertex d) (_ : ℕ) => uniform01)

lemma map_unpack (d : ℕ) :
    (Measure.infinitePi (fun _ : TreeVertex d => seedLaw)).map unpack = law d := by
  let split : (TreeVertex d → (ℕ → ℝ) × ℝ) →
      (TreeVertex d → ℕ → ℝ) × (TreeVertex d → ℝ) :=
    fun U => (fun v => (U v).1, fun v => (U v).2)
  have hsplit :
      (Measure.infinitePi (fun _ : TreeVertex d =>
        (Measure.infinitePi (fun _ : ℕ => uniform01)).prod uniform01)).map split =
        (Measure.infinitePi (fun _ : TreeVertex d =>
          Measure.infinitePi (fun _ : ℕ => uniform01))).prod (labelMeasure d) :=
    infinitePi_map_split_pairs (fun _ => Measure.infinitePi (fun _ : ℕ => uniform01))
      (fun _ => uniform01)
  let pack : (TreeVertex d → (ℕ → ℝ) × ℝ) → Rows d × (TreeVertex d → ℝ) :=
    fun U => (fun p => (U p.1).1 p.2, fun v => (U v).2)
  have hpack :
      (Measure.infinitePi (fun _ : TreeVertex d =>
        (Measure.infinitePi (fun _ : ℕ => uniform01)).prod uniform01)).map pack =
        (rowLaw d).prod (labelMeasure d) := by
    change (Measure.infinitePi _).map
      ((Prod.map (fun (Z : TreeVertex d → ℕ → ℝ) (p : TreeVertex d × ℕ) =>
        Z p.1 p.2) id) ∘ split) = _
    rw [← Measure.map_map (by fun_prop) (by fun_prop), hsplit,
      ← Measure.map_prod_map _ _ (by fun_prop) measurable_id,
      map_flatten_rows, Measure.map_id]
  change (Measure.infinitePi (fun _ : TreeVertex d =>
    uniform01.prod ((Measure.infinitePi (fun _ : ℕ => uniform01)).prod uniform01))).map
      ((Prod.map id pack) ∘ (fun U => (fun v => (U v).1, fun v => (U v).2))) = _
  rw [← Measure.map_map (by fun_prop) (by fun_prop),
    infinitePi_map_split_pairs,
    ← Measure.map_prod_map _ _ measurable_id (by fun_prop), Measure.map_id, hpack]
  rfl

theorem exists_sampler (d : ℕ) :
    ∃ S : (TreeVertex d → ℝ) → Space d,
      Measurable S ∧ (labelMeasure d).map S = law d ∧
      ∀ (g : TreeAut d) U, S (relabel g U) = relabelInputs g (S U) := by
  obtain ⟨ξ, hξ, hξlaw⟩ := exists_uniform01_sampler seedLaw
  refine ⟨unpack ∘ vertexSampler ξ, (measurable_unpack d).comp
    (measurable_vertexSampler hξ), ?_, ?_⟩
  · rw [← Measure.map_map (measurable_unpack d) (measurable_vertexSampler hξ),
      map_vertexSampler_labelMeasure hξ, hξlaw]
    exact map_unpack d
  · intro g U
    rfl

abbrev SpinSpace (d : ℕ) :=
  ((TreeVertex d → ℝ) × Rows d) × (TreeVertex d → IsingSpin)

def spinLaw (d : ℕ) : Measure (SpinSpace d) :=
  ((labelMeasure d).prod (rowLaw d)).prod
    (Measure.infinitePi (fun _ : TreeVertex d => uniform01.map fairSpin))

def relabelSpinInputs {d : ℕ} (g : TreeAut d) (p : SpinSpace d) : SpinSpace d :=
  ((relabel g p.1.1, relabelRows g p.1.2), relabel g p.2)

def toSpinInputs {d : ℕ} (p : Space d) : SpinSpace d :=
  ((p.1, p.2.1), vertexSampler fairSpin p.2.2)

lemma measurable_toSpinInputs (d : ℕ) : Measurable (@toSpinInputs d) := by
  exact (measurable_fst.prodMk (measurable_fst.comp measurable_snd)).prodMk
    ((measurable_vertexSampler measurable_fairSpin).comp
      (measurable_snd.comp measurable_snd))

@[simp] lemma toSpinInputs_relabel {d : ℕ} (g : TreeAut d) (p : Space d) :
    toSpinInputs (relabelInputs g p) = relabelSpinInputs g (toSpinInputs p) := rfl

lemma map_toSpinInputs (d : ℕ) : (law d).map toSpinInputs = spinLaw d := by
  change ((labelMeasure d).prod ((rowLaw d).prod (labelMeasure d))).map
    ((Prod.map id (vertexSampler fairSpin)) ∘ MeasurableEquiv.prodAssoc.symm) = _
  rw [← Measure.map_map (measurable_id.prodMap
      (measurable_vertexSampler measurable_fairSpin))
      MeasurableEquiv.prodAssoc.symm.measurable,
    (measurePreserving_prodAssoc (labelMeasure d) (rowLaw d) (labelMeasure d)).symm.map_eq,
    ← Measure.map_prod_map _ _ measurable_id (measurable_vertexSampler measurable_fairSpin),
    Measure.map_id, map_vertexSampler_labelMeasure measurable_fairSpin]
  rfl

theorem exists_spin_sampler (d : ℕ) :
    ∃ S : (TreeVertex d → ℝ) → SpinSpace d,
      Measurable S ∧ (labelMeasure d).map S = spinLaw d ∧
      ∀ (g : TreeAut d) U, S (relabel g U) = relabelSpinInputs g (S U) := by
  obtain ⟨S, hS, hSlaw, hSeq⟩ := exists_sampler d
  refine ⟨toSpinInputs ∘ S, (measurable_toSpinInputs d).comp hS, ?_, ?_⟩
  · rw [← Measure.map_map (measurable_toSpinInputs d) hS, hSlaw, map_toSpinInputs]
  · intro g U
    change toSpinInputs (S (relabel g U)) = _
    rw [hSeq]
    rfl

theorem isFactorOfIID_of_spin_inputs {d : ℕ} {theta : ℝ}
    (H : SpinSpace d → (TreeVertex d → IsingSpin)) (hH : Measurable H)
    (hLaw : HasFreeIsingLaw theta ((spinLaw d).map H))
    (hEquiv : ∀ g : TreeAut d, ∀ᵐ p ∂spinLaw d,
      H (relabelSpinInputs g p) = relabel g (H p)) :
    IsFactorOfIID d theta := by
  obtain ⟨S, hS, hSlaw, hSeq⟩ := exists_spin_sampler d
  refine ⟨H ∘ S, hH.comp hS, ?_, ?_⟩
  · rw [← Measure.map_map hH hS, hSlaw]
    exact hLaw
  · intro g
    have h : ∀ᵐ p ∂(labelMeasure d).map S,
        H (relabelSpinInputs g p) = relabel g (H p) := by
      rw [hSlaw]
      exact hEquiv g
    filter_upwards [ae_of_ae_map hS.aemeasurable h] with U hU
    simpa only [Function.comp_apply, hSeq] using hU

end Problem367.ClusterInput

end

end OAI