Download data/lean/OAI/Probability/FreeIsing/Trees/ClusterInputSampler.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 7.33 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Probability/FreeIsing/Trees/ClusterInputSampler.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Probability/FreeIsing/Trees/ClusterInputSampler.lean
-
curl -L -o ClusterInputSampler.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Probability/FreeIsing/Trees/ClusterInputSampler.lean
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 ( 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 ( 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 | |