math / data /lean /OAI /Probability /FreeIsing /Trees /ClusterInputSampler.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
7.33 kB
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