| import Mathlib.MeasureTheory.Measure.Prod |
|
|
| namespace OAI |
|
|
| /-! Joint orbit laws from measure-preserving rotations and pointwise Haar |
| kernels. The proof avoids measurable eigenvector selections. -/ |
| noncomputable section |
| open MeasureTheory |
| namespace InvariantIsing |
|
|
| lemma paired_map_eq_of_comp {G D : Type*} [MeasurableSpace G] [MeasurableSpace D] |
| (H : Measure G) (d : D) (f Y : G → ℝ) (T : G → G) |
| (hf : Measurable f) (hT : Measurable T) (hmap : H.map T=H) |
| (hY : ∀ u, Y u=f (T u)) : |
| H.map (fun u => (d,Y u))=H.map (fun u => (d,f u)) := by |
| have he : (fun u => (d,Y u))=(fun u => (d,f u)) ∘ T := by |
| funext u |
| exact Prod.ext rfl (hY u) |
| rw [he,← Measure.map_map (measurable_const.prodMk hf) hT,hmap] |
|
|
| lemma map_prod_eq_of_fiber_maps {X G E : Type*} |
| [MeasurableSpace X] [MeasurableSpace G] [MeasurableSpace E] |
| (P : Measure X) (H : Measure G) [SFinite P] [SFinite H] |
| (f g : X × G → E) (hf : Measurable f) (hg : Measurable g) |
| (h : ∀ x, H.map (fun u => f (x,u))=H.map (fun u => g (x,u))) : |
| (P.prod H).map f=(P.prod H).map g := by |
| ext s hs |
| rw [Measure.map_apply hf hs,Measure.map_apply hg hs, |
| Measure.prod_apply (hf hs),Measure.prod_apply (hg hs)] |
| apply lintegral_congr_ae |
| exact Filter.Eventually.of_forall fun x => by |
| have hh := congrArg (fun Q : Measure E => Q s) (h x) |
| have hfx : Measurable (fun u => f (x,u)) := hf.comp (measurable_const.prodMk measurable_id) |
| have hgx : Measurable (fun u => g (x,u)) := hg.comp (measurable_const.prodMk measurable_id) |
| rw [Measure.map_apply hfx hs,Measure.map_apply hgx hs] at hh |
| exact hh |
|
|
| theorem invariant_joint_orbit_law {X G D : Type*} |
| [MeasurableSpace X] [MeasurableSpace G] [MeasurableSpace D] |
| (P : Measure X) [IsProbabilityMeasure P] (H : Measure G) [IsProbabilityMeasure H] |
| (act : G → X → X) (hact : Measurable (Function.uncurry act)) |
| (hpres : ∀ u, P.map (act u)=P) |
| (d : X → D) (Y : X → ℝ) (hd : Measurable d) (hY : Measurable Y) |
| (hinv : ∀ u x, d (act u x)=d x) |
| (orbit : D → G → ℝ) (horbit : Measurable (fun z : D × G => orbit z.1 z.2)) |
| (hkernel : ∀ x, H.map (fun u => (d x,Y (act u x)))= |
| H.map (fun u => (d x,orbit (d x) u))) : |
| P.map (fun x => (d x,Y x))= |
| ((P.map d).prod H).map (fun z => (z.1,orbit z.1 z.2)) := by |
| have hs := (MeasurePreserving.id H).skew_product hact |
| (Filter.Eventually.of_forall hpres) |
| have hp := ((show MeasurePreserving Prod.snd (H.prod P) P from measurePreserving_snd).comp hs).comp |
| (show MeasurePreserving Prod.swap (P.prod H) (H.prod P) from Measure.measurePreserving_swap) |
| have hf : Measurable (fun x => (d x,Y x)) := hd.prodMk hY |
| have he := congrArg (fun Q : Measure X => Q.map (fun x => (d x,Y x))) hp.map_eq |
| rw [Measure.map_map hf hp.measurable] at he |
| have hF : Measurable (fun z : X × G => (d z.1,Y (act z.2 z.1))) := |
| (hd.comp measurable_fst).prodMk (hY.comp (hact.comp measurable_swap)) |
| have hB : Measurable (fun z : X × G => (d z.1,orbit (d z.1) z.2)) := |
| (hd.comp measurable_fst).prodMk |
| (horbit.comp ((hd.comp measurable_fst).prodMk measurable_snd)) |
| have havg : P.map (fun x => (d x,Y x))= |
| (P.prod H).map (fun z : X × G => (d z.1,Y (act z.2 z.1))) := by |
| refine he.symm.trans ?_ |
| congr 1 |
| funext z |
| exact Prod.ext (hinv z.2 z.1) rfl |
| rw [havg,map_prod_eq_of_fiber_maps P H _ _ hF hB hkernel] |
| have hdp : MeasurePreserving d P (P.map d) := ⟨hd,rfl⟩ |
| have hprod := hdp.prod (MeasurePreserving.id H) |
| have ht := congrArg (fun Q : Measure (D × G) => |
| Q.map (fun z => (z.1,orbit z.1 z.2))) hprod.map_eq |
| rw [Measure.map_map (measurable_fst.prodMk horbit) hprod.measurable] at ht |
| exact ht |
|
|
| end InvariantIsing |
|
|
| end |
|
|
| end OAI |
|
|
