import OAI.Dynamics.MultipleMixing.Tensors namespace OAI noncomputable section namespace Rokhlin section open MeasureTheory open scoped ENNReal variable {E F J : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E] [NormedAddCommGroup F] [NormedSpace ℂ F] lemma closure_image_dense_span (A : E →L[ℂ] F) (v : J → E) (hv : (Submodule.span ℂ (Set.range v)).topologicalClosure = ⊤) : (Submodule.span ℂ (Set.range (fun j => A (v j)))).topologicalClosure = (LinearMap.range A.toLinearMap).topologicalClosure := by let S := (Submodule.span ℂ (Set.range (fun j => A (v j)))).topologicalClosure apply le_antisymm · apply Submodule.topologicalClosure_minimal · apply Submodule.span_le.mpr rintro _ ⟨j,rfl⟩ exact Submodule.le_topologicalClosure _ ⟨v j,rfl⟩ · exact Submodule.isClosed_topologicalClosure _ · apply Submodule.topologicalClosure_minimal · rintro _ ⟨x,rfl⟩ have hc : IsClosed (S.comap A.toLinearMap : Set E) := (Submodule.isClosed_topologicalClosure _).preimage A.continuous have hs : Submodule.span ℂ (Set.range v) ≤ S.comap A.toLinearMap := by apply Submodule.span_le.mpr rintro _ ⟨j,rfl⟩ exact Submodule.le_topologicalClosure _ (Submodule.subset_span ⟨j,rfl⟩) have hh : ⊤ ≤ S.comap A.toLinearMap := by rw [←hv] exact Submodule.topologicalClosure_minimal _ hs hc exact hh (show x ∈ (⊤ : Submodule ℂ E) from trivial) · exact Submodule.isClosed_topologicalClosure _ variable {Ω X : Type*} [mΩ : MeasurableSpace Ω] [MeasurableSpace X] {μ : Measure Ω} {ν : Measure X} {x : Ω → X} lemma pullback_dense_span (hx : MeasurePreserving x μ ν) (v : J → Lp ℂ 2 ν) (hv : (Submodule.span ℂ (Set.range v)).topologicalClosure = ⊤) : (Submodule.span ℂ (Set.range (fun j => JoiningOperator.pull hx (v j)))).topologicalClosure = lpMeas ℂ ℂ (MeasurableSpace.comap x inferInstance) 2 μ := by rw [closure_image_dense_span _ _ hv, JoiningOperator.pull_range] let : Fact (MeasurableSpace.comap x inferInstance ≤ mΩ) := ⟨hx.measurable.comap_le⟩ exact (isClosed_aestronglyMeasurable hx.measurable.comap_le).submodule_topologicalClosure_eq local instance : MeasurableSpace Circle := inferInstanceAs (MeasurableSpace (Submonoid.unitSphere ℂ)) local instance : BorelSpace Circle := inferInstanceAs (BorelSpace (Submonoid.unitSphere ℂ)) lemma torusWord_pullback_dense {I : Type*} [Countable I] [IsFiniteMeasure μ] (γ : Ω → I → Circle) (hγ : Measurable γ) : (Submodule.span ℂ (Set.range (fun w => JoiningOperator.pull (MeasurePreserving.mk hγ rfl) (ContinuousMap.toLp 2 (μ.map γ) ℂ (torusWord (I := I) w))))).topologicalClosure = lpMeas ℂ ℂ (MeasurableSpace.comap γ inferInstance) 2 μ := by exact pullback_dense_span (MeasurePreserving.mk hγ rfl) _ (torusWord_L2_dense (μ.map γ)) end namespace JoiningOperator open MeasureTheory ProbabilityTheory open scoped ENNReal section local instance : MeasurableSpace Circle := inferInstanceAs (MeasurableSpace (Submonoid.unitSphere ℂ)) local instance : BorelSpace Circle := inferInstanceAs (BorelSpace (Submonoid.unitSphere ℂ)) variable {Ω Z X Y I : Type*} [MeasurableSpace Ω] [MeasurableSpace Z] [MeasurableSpace X] [MeasurableSpace Y] [Countable I] {μ : Measure Ω} {ν : Measure X} {ρ : Measure Y} {η : Measure Z} [IsFiniteMeasure ν] [IsFiniteMeasure ρ] [IsFiniteMeasure η] {x : Ω → X} {y : Ω → Y} {z : Ω → Z} lemma torusWord_contraction (hz : MeasurePreserving z μ η) (hxy : MeasurePreserving (fun ω => (x ω,y ω)) μ (ν.prod ρ)) (a : X → I → Circle) (b : Y → I → Circle) (c : Z → I → Circle) (ha : Measurable a) (hb : Measurable b) (hc : Measurable c) (hr : ∀ᵐ ω ∂μ, c (z ω) = a (x ω) * (b (y ω))⁻¹) (w : FreeGroup I) : pull (MeasurePreserving.mk hc rfl) (ContinuousMap.toLp 2 (η.map c) ℂ (torusWord w)) = contraction hz hxy (pull (MeasurePreserving.mk ha rfl) (ContinuousMap.toLp 2 (ν.map a) ℂ (torusWord w))) (star (pull (MeasurePreserving.mk hb rfl) (ContinuousMap.toLp 2 (ρ.map b) ℂ (torusWord w)))) := by let f := ContinuousMap.toLp 2 (η.map c) ℂ (torusWord w) let g := ContinuousMap.toLp 2 (ν.map a) ℂ (torusWord w) let h := ContinuousMap.toLp 2 (ρ.map b) ℂ (torusWord w) let hc' : MeasurePreserving c η (η.map c) := ⟨hc,rfl⟩ let ha' : MeasurePreserving a ν (ν.map a) := ⟨ha,rfl⟩ let hb' : MeasurePreserving b ρ (ρ.map b) := ⟨hb,rfl⟩ have he : pull hz (pull hc' f) = pull hxy (tensorLp (pull ha' g) (star (pull hb' h))) := by apply Lp.ext filter_upwards [Lp.coeFn_compMeasurePreserving (pull hc' f) hz, hz.quasiMeasurePreserving.ae (Lp.coeFn_compMeasurePreserving f hc'), (hc'.comp hz).quasiMeasurePreserving.ae (ContinuousMap.coeFn_toLp (η.map c) (𝕜 := ℂ) (p := 2) (torusWord w)), Lp.coeFn_compMeasurePreserving (tensorLp (pull ha' g) (star (pull hb' h))) hxy, hxy.quasiMeasurePreserving.ae (coe_tensorLp (pull ha' g) (star (pull hb' h))), hxy.quasiMeasurePreserving.ae (Measure.quasiMeasurePreserving_fst.ae (Lp.coeFn_compMeasurePreserving g ha')), hxy.quasiMeasurePreserving.ae (Measure.quasiMeasurePreserving_snd.ae (Lp.coeFn_star (pull hb' h))), hxy.quasiMeasurePreserving.ae (Measure.quasiMeasurePreserving_snd.ae (Lp.coeFn_compMeasurePreserving h hb')), hxy.quasiMeasurePreserving.ae (Measure.quasiMeasurePreserving_fst.ae (ha'.quasiMeasurePreserving.ae (ContinuousMap.coeFn_toLp (ν.map a) (𝕜 := ℂ) (p := 2) (torusWord w)))), hxy.quasiMeasurePreserving.ae (Measure.quasiMeasurePreserving_snd.ae (hb'.quasiMeasurePreserving.ae (ContinuousMap.coeFn_toLp (ρ.map b) (𝕜 := ℂ) (p := 2) (torusWord w)))), hr] with ω hf1 hf2 hf3 ht1 ht2 hg1 hh1 hh2 hg2 hh3 hrω calc _ = torusWord w (c (z ω)) := hf1.trans (hf2.trans hf3) _ = torusWord w (a (x ω)) * star (torusWord w (b (y ω))) := by rw [hrω,torusWord_ratio] _ = (pull ha' g) (x ω) * star ((pull hb' h) (y ω)) := by rw [show (pull ha' g) (x ω) = torusWord w (a (x ω)) from hg1.trans hg2, show (pull hb' h) (y ω) = torusWord w (b (y ω)) from hh2.trans hh3] _ = _ := (ht1.trans (ht2.trans (congrArg (_ * ·) hh1))).symm have hh := congrArg (fun q => (pull hz).adjoint q) he have hid := congrArg (fun A : Lp ℂ 2 η →L[ℂ] Lp ℂ 2 η => A (pull hc' f)) (pull_adjoint_pull hz) change (pull hz).adjoint (pull hz (pull hc' f)) = pull hc' f at hid rw [hid] at hh exact hh end local instance : MeasurableSpace Circle := inferInstanceAs (MeasurableSpace (Submonoid.unitSphere ℂ)) local instance : BorelSpace Circle := inferInstanceAs (BorelSpace (Submonoid.unitSphere ℂ)) variable {Ω Z X Y I : Type*} [MeasurableSpace Ω] [MeasurableSpace Z] [MeasurableSpace X] [MeasurableSpace Y] [Countable I] {μ : Measure Ω} {ν : Measure X} {ρ : Measure Y} {η : Measure Z} [retained8 : IsFiniteMeasure μ] [IsFiniteMeasure ν] [IsFiniteMeasure ρ] [IsFiniteMeasure η] {x : Ω → X} {y : Ω → Y} {z : Ω → Z} include retained8 in lemma ratio_field_le_active (hz : MeasurePreserving z μ η) (hxy : MeasurePreserving (fun ω => (x ω,y ω)) μ (ν.prod ρ)) (a : X → I → Circle) (b : Y → I → Circle) (c : Z → I → Circle) (ha : Measurable a) (hb : Measurable b) (hc : Measurable c) (hr : ∀ᵐ ω ∂μ, c (z ω) = a (x ω) * (b (y ω))⁻¹) : lpMeas ℂ ℂ (MeasurableSpace.comap c inferInstance) 2 η ≤ (LinearMap.range (operator hz hxy).toLinearMap).topologicalClosure := by let _ := retained8 erw [←torusWord_pullback_dense (μ := η) c hc] apply Submodule.topologicalClosure_mono apply Submodule.span_le.mpr rintro _ ⟨w,rfl⟩ exact ⟨_, (torusWord_contraction hz hxy a b c ha hb hc hr w).symm⟩ end JoiningOperator namespace ConditionalFibres open MeasureTheory ProbabilityTheory lemma ae_kernel_joint {Ω Z V : Type*} [MeasurableSpace Ω] [MeasurableSpace Z] [MeasurableSpace V] {μ : Measure Ω} [SFinite μ] {z : Ω → Z} {v : Ω → V} {κ : Kernel Z V} [IsSFiniteKernel κ] (h : HasCondDistrib v z κ μ) {p : Z × V → Prop} (hp : MeasurableSet {q | p q}) (hv : ∀ᵐ ω ∂μ, p (z ω,v ω)) : ∀ᵐ a ∂μ.map z, ∀ᵐ b ∂κ a, p (a,b) := by apply Measure.ae_ae_of_ae_compProd rw [←h.map_eq] exact (ae_map_iff h.aemeasurable hp).mpr hv end ConditionalFibres namespace ArrayObjects.Object.Rolled open MeasureTheory ProbabilityTheory ContinuousLinearMap open scoped ENNReal local instance : Fact ((2 : ℝ≥0∞) ≠ ∞) := ⟨by norm_num⟩ local instance : MeasurableSpace Circle := inferInstanceAs (MeasurableSpace (Submonoid.unitSphere ℂ)) local instance : BorelSpace Circle := inferInstanceAs (BorelSpace (Submonoid.unitSphere ℂ)) universe u variable {I : Type u} [Fintype I] [DecidableEq I] {X : StandardSpace.{u}} {T : X ≃ᵐ X} {base : InitialLaws I X T} (M : Object I base) theorem grouped_torus_completeness (hM : M.IsSaturated) (rows cols : TriplePartition I) (n : ℕ) : ∀ᵐ e ∂(M.law (n+2)).map (amap M.par (n+2)), ∃ (J : Type u) (_ : Countable J) (A : (cols.P → rows.A → Arr I M.Y n) → J → Circle) (B : (cols.P → rows.B → Arr I M.Y n) → J → Circle) (P : (cols.A → rows.P → Arr I M.Y n) → J → Circle) (Q : (cols.B → rows.P → Arr I M.Y n) → J → Circle) (H : (cols.P → rows.P → Arr I M.Y n) → J → Circle), Measurable A ∧ Measurable B ∧ Measurable P ∧ Measurable Q ∧ Measurable H ∧ commonActive M rows.P rows.A rows.B cols.P cols.A cols.B n e = lpMeas ℂ ℂ (MeasurableSpace.comap H inferInstance) 2 (cellLaw M rows.P cols.P n e) ∧ (∀ᵐ y ∂M.ownKernel (n+2) e, H (cells M rows.P cols.P n y) = A (cells M rows.A cols.P n y) * (B (cells M rows.B cols.P n y))⁻¹) ∧ (∀ᵐ y ∂M.ownKernel (n+2) e, H (cells M rows.P cols.P n y) = P (cells M rows.P cols.A n y) * (Q (cells M rows.P cols.B n y))⁻¹) := by filter_upwards [grouped_polar_data M hM rows cols n, grouped_haar_normalization M hM rows cols n, grouped_polar_a_field M hM rows cols n,grouped_polar_b_field M hM rows cols n, pairPair_fixed_conditional M hM rows.P rows.A rows.B cols.P cols.A cols.B rows.cardP cols.properP n, columnPair_fixed_conditional M hM rows.P rows.A rows.B cols.P rows.cardP cols.properP n, rowPair_fixed_conditional M rows.P cols.P cols.A cols.B n, columnPair_fixed_marginals M hM rows.P rows.A rows.B cols.P rows.cardP cols.properP rows.properA rows.properB rows.disjointPA rows.disjointPB rows.properPA rows.properPB n, rowPair_fixed_marginals M hM rows.P cols.P cols.A cols.B rows.properP cols.disjointPA cols.disjointPB cols.properPA cols.properPB n, cells_fibre_marginal M hM rows.P cols.P rows.properP n, cells_fibre_marginal M hM rows.A cols.P rows.properA n, cells_fibre_marginal M hM rows.B cols.P rows.properB n, cells_fibre_marginal M hM rows.P cols.A rows.properP n, cells_fibre_marginal M hM rows.P cols.B rows.properP n, cells_indep_rows_fibre M hM rows.A rows.B cols.P cols.P rows.disjointAB rows.properAB n, cells_indep_columns_fibre M rows.P rows.P cols.A cols.B cols.disjointAB cols.properAB n, columnActive_eq_range M hM rows cols.P cols.properP n, rowActive_eq_range M hM rows.P rows.properP cols n, grouped_column_contraction_projection M hM rows cols n] with e hRd hHaar haField hbField hpair hκ hξ hκm hξm hz hx hy hc hd hxy hcd hcol hrow hproj obtain ⟨R⟩ := hRd obtain ⟨J,hJ,A,B,P,Q,H,hA,hB,hP,hQ,hH,hfa,hfb,hra,hrb⟩ := R.torus_coordinates (hHaar R) ((columnPairKernel M rows.P rows.A rows.B cols.P n).sectR e) ((rowPairKernel M rows.P cols.P cols.A cols.B n).sectR e) hκ hξ hpair (hκm.mono fun _ h => ⟨h.1.map_eq,h.2.map_eq⟩) (hξm.mono fun _ h => ⟨h.1.map_eq,h.2.map_eq⟩) let : Countable J := hJ let : Group (J → Circle) := (inferInstance : CommGroup (J → Circle)).toGroup let : MeasurableMul₂ (J → Circle) := inferInstance have haF := haField R have hbF := hbField R rw [hfa] at haF rw [hfb] at hbF let hXY : MeasurePreserving (fun y => (cells M rows.A cols.P n y,cells M rows.B cols.P n y)) (M.ownKernel (n+2) e) ((cellLaw M rows.A cols.P n e).prod (cellLaw M rows.B cols.P n e)) := ⟨hx.measurable.prodMk hy.measurable, by rw [←hx.map_eq,←hy.map_eq] exact hxy.map_prod_eq_prod_map_map hx.measurable.aemeasurable hy.measurable.aemeasurable⟩ let hPQ : MeasurePreserving (fun y => (cells M rows.P cols.A n y,cells M rows.P cols.B n y)) (M.ownKernel (n+2) e) ((cellLaw M rows.P cols.A n e).prod (cellLaw M rows.P cols.B n e)) := ⟨hc.measurable.prodMk hd.measurable, by rw [←hc.map_eq,←hd.map_eq] exact hcd.map_prod_eq_prod_map_map hc.measurable.aemeasurable hd.measurable.aemeasurable⟩ let α := ((columnPairKernel M rows.P rows.A rows.B cols.P n).sectR e).map (Prod.map A B) let : IsMarkovKernel α := Kernel.IsMarkovKernel.map _ (hA.prodMap hB) have hα : HasCondDistrib (fun y => (A (cells M rows.A cols.P n y),B (cells M rows.B cols.P n y))) (cells M rows.P cols.P n) α (M.ownKernel (n+2) e) := hκ.comp_left (hA.prodMap hB) let σ := (cellLaw M rows.B cols.P n e).map B let : IsProbabilityMeasure σ := (fun mapMeasurable => (Measure.isProbabilityMeasure_map_iff mapMeasurable).mpr inferInstance) hB.aemeasurable have hm : ∀ᵐ v ∂cellLaw M rows.P cols.P n e, (α v).map Prod.snd = σ := by rw [hz.map_eq] at hκm filter_upwards [hκm] with v hv dsimp only [α,σ] exact (kernel_map_pair_snd ((columnPairKernel M rows.P rows.A rows.B cols.P n).sectR e) v hA hB).trans (congrArg (fun m => m.map B) hv.2.map_eq) have hr : ∀ᵐ v ∂cellLaw M rows.P cols.P n e, ∀ᵐ w ∂α v, w.1*w.2⁻¹ = H v := by rw [←hz.map_eq] exact ConditionalFibres.ae_kernel_joint hα (measurableSet_eq_fun (Measurable.of_eval fun j => ((measurable_pi_apply j).comp measurable_snd.fst).mul (((measurable_pi_apply j).comp measurable_snd.snd).inv)) (hH.comp measurable_fst)) (hra.mono fun _ h => h.symm) refine ⟨J,hJ,A,B,P,Q,H,hA,hB,hP,hQ,hH,le_antisymm ?_ ?_,hra,hrb⟩ · apply JoiningOperator.common_space_le_ratio (G := J → Circle) (gG := inferInstance) (mG := inferInstance) (hG := inferInstance) (a := A) (b := B) (c := H) hz hXY hA hB hH hα σ hm hr _ (commonActive M rows.A rows.P rows.B cols.P cols.A cols.B n e).starProjection (commonActive M rows.B rows.P rows.A cols.P cols.A cols.B n e).starProjection · rw [←hcol hz hXY] exact inf_le_right · exact hproj hz hXY · intro g exact haF (Submodule.starProjection_apply_mem _ g) · intro h exact hbF (Submodule.starProjection_apply_mem _ h) · apply le_inf · rw [hrow hz hPQ] exact JoiningOperator.ratio_field_le_active hz hPQ P Q H hP hQ hH hrb · rw [hcol hz hXY] exact JoiningOperator.ratio_field_le_active hz hXY A B H hA hB hH hra end ArrayObjects.Object.Rolled section variable {I Ω Y : Type*} [MeasurableSpace Y] lemma field_finset_observation (f : I → Ω → Y) (s : Finset I) : MeasurableSpace.comap (fun ω (i : s) => f i ω) inferInstance = ⨆ i ∈ s, MeasurableSpace.comap (f i) inferInstance := by rw [MeasurableSpace.comap_process_pi] simp only [iSup_subtype] lemma field_pair_finset_union [DecidableEq I] (f : I → Ω → Y) (s t : Finset I) : MeasurableSpace.comap (fun ω => ((fun (i : s) => f i ω),(fun (i : t) => f i ω))) inferInstance = MeasurableSpace.comap (fun ω (i : ↥(s ∪ t)) => f i ω) inferInstance := by change ((inferInstance : MeasurableSpace (s → Y)).prod (inferInstance : MeasurableSpace (t → Y))).comap _ = _ rw [MeasurableSpace.comap_prodMk,field_finset_observation,field_finset_observation,field_finset_observation] simp only [Finset.mem_union,iSup_or] rw [iSup_sup_eq] lemma field_finset_grid {J : Type*} (f : I → J → Ω → Y) (s : Finset I) (t : Finset J) : MeasurableSpace.comap (fun ω (i : s) (j : t) => f i j ω) inferInstance = ⨆ i ∈ s, ⨆ j ∈ t, MeasurableSpace.comap (f i j) inferInstance := by rw [MeasurableSpace.comap_process_pi] simp_rw [MeasurableSpace.comap_process_pi] simp only [iSup_subtype] lemma field_grid_pair_inner_union {J : Type*} [DecidableEq J] (f : I → J → Ω → Y) (r : Finset I) (s t : Finset J) : MeasurableSpace.comap (fun ω => ((fun (i : r) (j : s) => f i j ω), (fun (i : r) (j : t) => f i j ω))) inferInstance = MeasurableSpace.comap (fun ω (i : r) (j : ↥(s ∪ t)) => f i j ω) inferInstance := by change ((inferInstance : MeasurableSpace (r → s → Y)).prod (inferInstance : MeasurableSpace (r → t → Y))).comap _ = _ rw [MeasurableSpace.comap_prodMk,field_finset_grid,field_finset_grid,field_finset_grid] simp only [Finset.mem_union,iSup_or] simp only [iSup_sup_eq] end section variable {I : Type*} [Fintype I] [DecidableEq I] @[ext] structure ComplementSplit (P : Finset I) where A : Finset I B : Finset I nonemptyP : P.Nonempty nonemptyA : A.Nonempty nonemptyB : B.Nonempty disjointPA : Disjoint P A disjointPB : Disjoint P B disjointAB : Disjoint A B cover : P ∪ A ∪ B = Finset.univ namespace ComplementSplit variable {P : Finset I} abbrev partition (s : ComplementSplit P) : TriplePartition I := ⟨P,s.A,s.B,s.nonemptyP,s.nonemptyA,s.nonemptyB,s.disjointPA,s.disjointPB,s.disjointAB,s.cover⟩ instance : Finite (ComplementSplit P) := Finite.of_injective (fun s : ComplementSplit P => (s.A,s.B)) (by intro s t h exact ComplementSplit.ext (congrArg Prod.fst h) (congrArg Prod.snd h)) lemma union_eq (s : ComplementSplit P) : s.A ∪ s.B = Pᶜ := by ext i constructor · intro hi refine Finset.mem_compl.mpr (fun hip => ?_) rcases Finset.mem_union.mp hi with h | h · exact Finset.disjoint_left.mp s.disjointPA hip h · exact Finset.disjoint_left.mp s.disjointPB hip h · intro hi have hp : i ∉ P := Finset.mem_compl.mp hi have hu : i ∈ P ∪ s.A ∪ s.B := s.cover ▸ Finset.mem_univ i simpa only [Finset.mem_union,hp,false_or] using hu def singleton (P : Finset I) (hP : P.Nonempty) (s : I) (hs : s ∉ P) (hb : (P ∪ {s})ᶜ.Nonempty) : ComplementSplit P where A := {s} B := (P ∪ {s})ᶜ nonemptyP := hP nonemptyA := Finset.singleton_nonempty s nonemptyB := hb disjointPA := Finset.disjoint_singleton_right.mpr hs disjointPB := Finset.disjoint_left.mpr (by intro i hi hh exact Finset.mem_compl.mp hh (Finset.mem_union_left _ hi)) disjointAB := Finset.disjoint_left.mpr (by intro i hi hh exact Finset.mem_compl.mp hh (Finset.mem_union_right _ hi)) cover := Finset.union_compl _ end ComplementSplit end namespace ArrayObjects.Object.Rolled open MeasureTheory ProbabilityTheory universe u variable {I : Type u} [Fintype I] [DecidableEq I] {X : StandardSpace.{u}} {T : X ≃ᵐ X} {base : InitialLaws I X T} (M : Object I base) omit [DecidableEq I] in lemma cells_pair_preserving {A B S D : Finset I} {n : ℕ} {e : Arr I M.U (n+2)} (ha : MeasurePreserving (cells M A S n) (M.ownKernel (n+2) e) (cellLaw M A S n e)) (hb : MeasurePreserving (cells M B D n) (M.ownKernel (n+2) e) (cellLaw M B D n e)) (hi : IndepFun (cells M A S n) (cells M B D n) (M.ownKernel (n+2) e)) : MeasurePreserving (fun y => (cells M A S n y,cells M B D n y)) (M.ownKernel (n+2) e) ((cellLaw M A S n e).prod (cellLaw M B D n e)) := by refine ⟨ha.measurable.prodMk hb.measurable,?_⟩ rw [←ha.map_eq,←hb.map_eq] exact hi.map_prod_eq_prod_map_map ha.measurable.aemeasurable hb.measurable.aemeasurable lemma rowActive_complement_invariant (hM : M.IsSaturated) (P R : Finset I) (hP : P ≠ Finset.univ) (s t : ComplementSplit R) (n : ℕ) : ∀ᵐ e ∂(M.law (n+2)).map (amap M.par (n+2)), rowActive M P R s.A s.B n e = rowActive M P R t.A t.B n e := by filter_upwards [rowActive_eq_range M hM P hP s.partition n, rowActive_eq_range M hM P hP t.partition n, cells_fibre_marginal M hM P R hP n, cells_fibre_marginal M hM P s.A hP n,cells_fibre_marginal M hM P s.B hP n, cells_fibre_marginal M hM P t.A hP n,cells_fibre_marginal M hM P t.B hP n, cells_indep_columns_fibre M P P s.A s.B s.disjointAB s.partition.properAB n, cells_indep_columns_fibre M P P t.A t.B t.disjointAB t.partition.properAB n] with e hs ht hz hsa hsb hta htb his hit let hS := cells_pair_preserving M hsa hsb his let hT := cells_pair_preserving M hta htb hit rw [hs hz hS,ht hz hT] apply JoiningOperator.active_observation_eq hz hS hT change MeasurableSpace.comap (fun y => ((fun (j : s.A) (a : P) => missingRow M n j a y), (fun (j : s.B) (a : P) => missingRow M n j a y))) inferInstance = MeasurableSpace.comap (fun y => ((fun (j : t.A) (a : P) => missingRow M n j a y), (fun (j : t.B) (a : P) => missingRow M n j a y))) inferInstance rw [field_pair_finset_union (fun j y (a : P) => missingRow M n j a y) s.A s.B, field_pair_finset_union (fun j y (a : P) => missingRow M n j a y) t.A t.B,s.union_eq,t.union_eq] lemma columnActive_complement_invariant (hM : M.IsSaturated) (P R : Finset I) (hR : R ≠ Finset.univ) (s t : ComplementSplit P) (n : ℕ) : ∀ᵐ e ∂(M.law (n+2)).map (amap M.par (n+2)), columnActive M P s.A s.B R n e = columnActive M P t.A t.B R n e := by filter_upwards [columnActive_eq_range M hM s.partition R hR n, columnActive_eq_range M hM t.partition R hR n, cells_fibre_marginal M hM P R s.partition.properP n, cells_fibre_marginal M hM s.A R s.partition.properA n, cells_fibre_marginal M hM s.B R s.partition.properB n, cells_fibre_marginal M hM t.A R t.partition.properA n, cells_fibre_marginal M hM t.B R t.partition.properB n, cells_indep_rows_fibre M hM s.A s.B R R s.disjointAB s.partition.properAB n, cells_indep_rows_fibre M hM t.A t.B R R t.disjointAB t.partition.properAB n] with e hs ht hz hsa hsb hta htb his hit let hS := cells_pair_preserving M hsa hsb his let hT := cells_pair_preserving M hta htb hit rw [hs hz hS,ht hz hT] apply JoiningOperator.active_observation_eq hz hS hT change MeasurableSpace.comap (fun y => ((fun (j : R) (a : s.A) => missingRow M n j a y), (fun (j : R) (a : s.B) => missingRow M n j a y))) inferInstance = MeasurableSpace.comap (fun y => ((fun (j : R) (a : t.A) => missingRow M n j a y), (fun (j : R) (a : t.B) => missingRow M n j a y))) inferInstance rw [field_grid_pair_inner_union,field_grid_pair_inner_union,s.union_eq,t.union_eq] lemma commonActive_complement_invariant (hM : M.IsSaturated) (P R : Finset I) (s s' : ComplementSplit P) (t t' : ComplementSplit R) (n : ℕ) : ∀ᵐ e ∂(M.law (n+2)).map (amap M.par (n+2)), commonActive M P s.A s.B R t.A t.B n e = commonActive M P s'.A s'.B R t'.A t'.B n e := by filter_upwards [rowActive_complement_invariant M hM P R s.partition.properP t t' n, columnActive_complement_invariant M hM P R t.partition.properP s s' n] with e hr hc exact congrArg₂ (· ⊓ ·) hr hc end ArrayObjects.Object.Rolled section open MeasureTheory ProbabilityTheory open scoped ComplexConjugate local instance : MeasurableSpace Circle := inferInstanceAs (MeasurableSpace (Submonoid.unitSphere ℂ)) local instance : BorelSpace Circle := inferInstanceAs (BorelSpace (Submonoid.unitSphere ℂ)) variable {Ω X Y Z : Type*} [MeasurableSpace Ω] [MeasurableSpace X] [MeasurableSpace Y] [MeasurableSpace Z] {μ : Measure Ω} [IsProbabilityMeasure μ] {x : Ω → X} {y : Ω → Y} {z : Ω → Z} lemma ternary_unit_const_of_nonzero_mean (f : Z → Circle) (g : X → Circle) (h : Y → Circle) (hf : Measurable f) (hg : Measurable g) (hh : Measurable h) (hx : AEMeasurable x μ) (hy : AEMeasurable y μ) (hz : AEMeasurable z μ) (hxy : IndepFun x y μ) (hxz : IndepFun x z μ) (hyz : IndepFun y z μ) (he : ∀ᵐ ω ∂μ, f (z ω) = g (x ω) * h (y ω)) (hne : (∫ ω, (f (z ω) : ℂ) ∂μ) ≠ 0) : ∃ a : Circle, ∀ᵐ ω ∂μ, f (z ω) = a := by let F := fun ω => (f (z ω) : ℂ) let G := fun ω => (g (x ω) : ℂ) let H := fun ω => (h (y ω) : ℂ) have hf' : Measurable (fun q => (f q : ℂ)) := measurable_subtype_coe.comp hf have hg' : Measurable (fun q => (g q : ℂ)) := measurable_subtype_coe.comp hg have hh' : Measurable (fun q => (h q : ℂ)) := measurable_subtype_coe.comp hh have hfm : AEStronglyMeasurable F μ := (hf'.comp_aemeasurable hz).aestronglyMeasurable have hgm : AEStronglyMeasurable G μ := (hg'.comp_aemeasurable hx).aestronglyMeasurable have hhm : AEStronglyMeasurable H μ := (hh'.comp_aemeasurable hy).aestronglyMeasurable have heF : F =ᵐ[μ] fun ω => G ω * H ω := he.mono fun ω hω => congrArg ((↑) : Circle → ℂ) hω have heG : G =ᵐ[μ] fun ω => F ω * conj (H ω) := by filter_upwards [heF] with ω hω rw [hω, mul_assoc,←Complex.inv_eq_conj (Circle.norm_coe _),mul_inv_cancel₀ (Circle.coe_ne_zero _),mul_one] have heH : H =ᵐ[μ] fun ω => F ω * conj (G ω) := by filter_upwards [heF] with ω hω rw [hω,mul_comm (G ω),mul_assoc,←Complex.inv_eq_conj (Circle.norm_coe _),mul_inv_cancel₀ (Circle.coe_ne_zero _),mul_one] have ha : ‖∫ ω, F ω ∂μ‖ = ‖∫ ω, G ω ∂μ‖ * ‖∫ ω, H ω ∂μ‖ := by rw [integral_congr_ae heF,show (∫ ω, G ω * H ω ∂μ) = (∫ ω, G ω ∂μ) * (∫ ω, H ω ∂μ) from (hxy.comp hg' hh').integral_fun_mul_eq_mul_integral hgm hhm,norm_mul] have hb : ‖∫ ω, G ω ∂μ‖ = ‖∫ ω, F ω ∂μ‖ * ‖∫ ω, H ω ∂μ‖ := by rw [integral_congr_ae heG,show (∫ ω, F ω * conj (H ω) ∂μ) = (∫ ω, F ω ∂μ) * (∫ ω, conj (H ω) ∂μ) from (hyz.symm.comp hf' (Complex.continuous_conj.measurable.comp hh')).integral_fun_mul_eq_mul_integral hfm hhm.star, integral_conj,norm_mul,Complex.norm_conj] have hc : ‖∫ ω, H ω ∂μ‖ = ‖∫ ω, F ω ∂μ‖ * ‖∫ ω, G ω ∂μ‖ := by rw [integral_congr_ae heH,show (∫ ω, F ω * conj (G ω) ∂μ) = (∫ ω, F ω ∂μ) * (∫ ω, conj (G ω) ∂μ) from (hxz.symm.comp hf' (Complex.continuous_conj.measurable.comp hg')).integral_fun_mul_eq_mul_integral hfm hgm.star, integral_conj,norm_mul,Complex.norm_conj] have hA : 0 < ‖∫ ω, F ω ∂μ‖ := norm_pos_iff.mpr hne have hB : 0 ≤ ‖∫ ω, G ω ∂μ‖ := norm_nonneg _ have hC : 0 ≤ ‖∫ ω, H ω ∂μ‖ := norm_nonneg _ have hBpos : 0 < ‖∫ ω, G ω ∂μ‖ := by nlinarith [ha] have hCone : ‖∫ ω, H ω ∂μ‖ = 1 := by nlinarith [ha,hb] have hBone : ‖∫ ω, G ω ∂μ‖ = 1 := by nlinarith [ha,hc,hCone] have hAone : ‖∫ ω, F ω ∂μ‖ = 1 := by rw [ha,hBone,hCone,mul_one] let a : Circle := ⟨∫ ω, F ω ∂μ, by exact mem_sphere_zero_iff_norm.mpr hAone⟩ have hconst := ae_eq_mean_of_norm_mean_eq_one F (Filter.Eventually.of_forall fun ω => Circle.norm_coe _) hAone exact ⟨a,hconst.mono fun _ ht => Circle.ext ht⟩ lemma ternary_line_dichotomy (f f' : Z → Circle) (g g' : X → Circle) (h h' : Y → Circle) (hf : Measurable f) (hf' : Measurable f') (hg : Measurable g) (hg' : Measurable g') (hh : Measurable h) (hh' : Measurable h') (hx : AEMeasurable x μ) (hy : AEMeasurable y μ) (hz : AEMeasurable z μ) (hxy : IndepFun x y μ) (hxz : IndepFun x z μ) (hyz : IndepFun y z μ) (he : ∀ᵐ ω ∂μ, f (z ω) = g (x ω) * h (y ω)) (he' : ∀ᵐ ω ∂μ, f' (z ω) = g' (x ω) * h' (y ω)) : (∫ ω, (f (z ω) : ℂ) * conj (f' (z ω) : ℂ) ∂μ) = 0 ∨ ∃ a : Circle, ∀ᵐ ω ∂μ, f (z ω) = a * f' (z ω) := by by_cases hn : (∫ ω, (f (z ω) : ℂ) * conj (f' (z ω) : ℂ) ∂μ) = 0 · exact Or.inl hn right have hp : ∀ᵐ ω ∂μ, f (z ω)*(f' (z ω))⁻¹ = (g (x ω)*(g' (x ω))⁻¹) * (h (y ω)*(h' (y ω))⁻¹) := by filter_upwards [he,he'] with ω hω hω' rw [hω,hω',mul_inv_rev] ac_rfl obtain ⟨a,ha⟩ := ternary_unit_const_of_nonzero_mean (fun q => f q*(f' q)⁻¹) (fun q => g q*(g' q)⁻¹) (fun q => h q*(h' q)⁻¹) (hf.mul hf'.inv) (hg.mul hg'.inv) (hh.mul hh'.inv) hx hy hz hxy hxz hyz hp (by simpa only [Circle.coe_mul,Circle.coe_inv_eq_conj] using hn) exact ⟨a,ha.mono fun _ he => mul_inv_eq_iff_eq_mul.mp he⟩ end namespace JoiningOperator open MeasureTheory ProbabilityTheory open scoped ENNReal InnerProductSpace ComplexConjugate attribute [local instance] Rokhlin.instMeasurableSpaceCircle_circleLp Rokhlin.instBorelSpaceCircle_circleLp variable {Ω Z X Y : Type*} [MeasurableSpace Ω] [MeasurableSpace Z] [MeasurableSpace X] [MeasurableSpace Y] (μ : Measure Ω) (η : Measure Z) [IsFiniteMeasure η] (x : Ω → X) (y : Ω → Y) (z : Ω → Z) def splitExact : Set (Lp ℂ 2 η) := {v | ∃ (f : Z → Circle) (g : X → Circle) (h : Y → Circle) (hf : Measurable f) (_ : Measurable g) (_ : Measurable h) (c : ℂ), v = c • circleLp η f hf ∧ ∀ᵐ ω ∂μ, f (z ω) = g (x ω) * h (y ω)} lemma zero_mem_splitExact : (0 : Lp ℂ 2 η) ∈ splitExact μ η x y z := by exact ⟨1,1,1,measurable_const,measurable_const,measurable_const,0,by simp, Filter.Eventually.of_forall fun _ => (one_mul (1 : Circle)).symm⟩ lemma smul_mem_splitExact (c : ℂ) {v : Lp ℂ 2 η} (hv : v ∈ splitExact μ η x y z) : c • v ∈ splitExact μ η x y z := by obtain ⟨f,g,h,hf,hg,hh,d,hv,he⟩ := hv exact ⟨f,g,h,hf,hg,hh,c*d,by rw [hv,mul_smul],he⟩ lemma circle_mem_splitExact (f : Z → Circle) (g : X → Circle) (h : Y → Circle) (hf : Measurable f) (hg : Measurable g) (hh : Measurable h) (he : ∀ᵐ ω ∂μ, f (z ω) = g (x ω) * h (y ω)) : circleLp η f hf ∈ splitExact μ η x y z := ⟨f,g,h,hf,hg,hh,1,(one_smul _ _).symm,he⟩ variable {μ η x y z} lemma circleLp_dichotomy [IsProbabilityMeasure μ] (hz : MeasurePreserving z μ η) (hx : AEMeasurable x μ) (hy : AEMeasurable y μ) (hxy : IndepFun x y μ) (hxz : IndepFun x z μ) (hyz : IndepFun y z μ) (f f' : Z → Circle) (g g' : X → Circle) (h h' : Y → Circle) (hf : Measurable f) (hf' : Measurable f') (hg : Measurable g) (hg' : Measurable g') (hh : Measurable h) (hh' : Measurable h') (he : ∀ᵐ ω ∂μ, f (z ω) = g (x ω) * h (y ω)) (he' : ∀ᵐ ω ∂μ, f' (z ω) = g' (x ω) * h' (y ω)) : inner ℂ (circleLp η f hf) (circleLp η f' hf') = 0 ∨ ∃ a : Circle, circleLp η f hf = (a : ℂ) • circleLp η f' hf' := by rcases ternary_line_dichotomy f f' g g' h h' hf hf' hg hg' hh hh' hx hy hz.measurable.aemeasurable hxy hxz hyz he he' with ho | ⟨a,ha⟩ · left apply inner_eq_zero_symm.mp rw [circleLp_inner] have hi : (∫ v, conj (f' v : ℂ) * (f v : ℂ) ∂η) = ∫ ω, conj (f' (z ω) : ℂ) * (f (z ω) : ℂ) ∂μ := by rw [←hz.map_eq] exact integral_map hz.measurable.aemeasurable (by fun_prop) rw [hi] simpa only [mul_comm] using ho · right have ha' : f =ᵐ[η] fun v => a*f' v := by rw [←hz.map_eq] exact (ae_map_iff hz.measurable.aemeasurable (measurableSet_eq_fun hf (measurable_const.mul hf'))).mpr ha exact ⟨a,(circleLp_congr η hf (measurable_const.mul hf') ha').trans (circleLp_phase η a f' hf')⟩ lemma splitExact_dichotomy [IsProbabilityMeasure μ] (hz : MeasurePreserving z μ η) (hx : AEMeasurable x μ) (hy : AEMeasurable y μ) (hxy : IndepFun x y μ) (hxz : IndepFun x z μ) (hyz : IndepFun y z μ) {v w : Lp ℂ 2 η} (hv : v ∈ splitExact μ η x y z) (hw : w ∈ splitExact μ η x y z) : inner ℂ v w = 0 ∨ ∃ c : ℂ, v = c • w := by obtain ⟨f,g,h,hf,hg,hh,c,rfl,he⟩ := hv obtain ⟨f',g',h',hf',hg',hh',d,rfl,he'⟩ := hw rcases circleLp_dichotomy hz hx hy hxy hxz hyz f f' g g' h h' hf hf' hg hg' hh hh' he he' with ho | ⟨a,ha⟩ · left simp only [inner_smul_left,inner_smul_right,ho,mul_zero] · by_cases hd : d = 0 · left simp only [hd,zero_smul,inner_zero_right] · right refine ⟨c*(a : ℂ)*d⁻¹,?_⟩ rw [ha,smul_smul,smul_smul,mul_assoc,mul_assoc,inv_mul_cancel₀ hd,mul_one] lemma circleLp_contraction {ν : Measure X} {ρ : Measure Y} [IsProbabilityMeasure ν] [IsProbabilityMeasure ρ] (hz : MeasurePreserving z μ η) (hxy : MeasurePreserving (fun ω => (x ω,y ω)) μ (ν.prod ρ)) (f : Z → Circle) (g : X → Circle) (h : Y → Circle) (hf : Measurable f) (hg : Measurable g) (hh : Measurable h) (he : ∀ᵐ ω ∂μ, f (z ω) = g (x ω)*h (y ω)) : circleLp η f hf = contraction hz hxy (circleLp ν g hg) (circleLp ρ h hh) := by have hx := (measurePreserving_fst (μ := ν) (ν := ρ)).comp hxy have hy := (measurePreserving_snd (μ := ν) (ν := ρ)).comp hxy have hp : pull hz (circleLp η f hf) = pull hxy (tensorLp (circleLp ν g hg) (circleLp ρ h hh)) := by apply Lp.ext filter_upwards [Lp.coeFn_compMeasurePreserving (circleLp η f hf) hz, hz.quasiMeasurePreserving.ae (circleLp_coe η f hf), Lp.coeFn_compMeasurePreserving (tensorLp (circleLp ν g hg) (circleLp ρ h hh)) hxy, hxy.quasiMeasurePreserving.ae (coe_tensorLp (circleLp ν g hg) (circleLp ρ h hh)), hx.quasiMeasurePreserving.ae (circleLp_coe ν g hg), hy.quasiMeasurePreserving.ae (circleLp_coe ρ h hh),he] with ω h1 h2 h3 h4 h5 h6 h7 calc _ = (f (z ω) : ℂ) := h1.trans h2 _ = (g (x ω) : ℂ)*(h (y ω) : ℂ) := congrArg ((↑) : Circle → ℂ) h7 _ = _ := (h3.trans (h4.trans (congrArg₂ (·*·) h5 h6))).symm have hid := congrArg (fun A : Lp ℂ 2 η →L[ℂ] Lp ℂ 2 η => A (circleLp η f hf)) (pull_adjoint_pull hz) exact hid.symm.trans (congrArg (fun q => (pull hz).adjoint q) hp) lemma splitExact_le_active {ν : Measure X} {ρ : Measure Y} [IsProbabilityMeasure ν] [IsProbabilityMeasure ρ] (hz : MeasurePreserving z μ η) (hxy : MeasurePreserving (fun ω => (x ω,y ω)) μ (ν.prod ρ)) : splitExact μ η x y z ⊆ (LinearMap.range (operator hz hxy).toLinearMap).topologicalClosure := by rintro v ⟨f,g,h,hf,hg,hh,c,rfl,he⟩ exact (LinearMap.range (operator hz hxy).toLinearMap).topologicalClosure.smul_mem c (Submodule.le_topologicalClosure _ ⟨_,(circleLp_contraction hz hxy f g h hf hg hh he).symm⟩) end JoiningOperator section open MeasureTheory open scoped ENNReal attribute [local instance] Rokhlin.instMeasurableSpaceCircle_circleLp Rokhlin.instBorelSpaceCircle_circleLp variable {Ω J : Type*} [MeasurableSpace Ω] [Countable J] (μ : Measure Ω) [IsFiniteMeasure μ] (γ : Ω → J → Circle) (hγ : Measurable γ) lemma torus_circle_pull (w : FreeGroup J) : circleLp μ (fun x => torusWordCircle w (γ x)) ((torusWordCircle w).continuous.measurable.comp hγ) = JoiningOperator.pull (MeasurePreserving.mk hγ rfl) (ContinuousMap.toLp 2 (μ.map γ) ℂ (torusWord w)) := by apply Lp.ext filter_upwards [circleLp_coe μ (fun x => torusWordCircle w (γ x)) ((torusWordCircle w).continuous.measurable.comp hγ), Lp.coeFn_compMeasurePreserving (ContinuousMap.toLp 2 (μ.map γ) ℂ (torusWord w)) (MeasurePreserving.mk hγ rfl), (MeasurePreserving.mk hγ rfl).quasiMeasurePreserving.ae (ContinuousMap.coeFn_toLp (μ.map γ) (𝕜 := ℂ) (p := 2) (torusWord w))] with x h1 h2 h3 exact h1.trans (h2.trans h3).symm lemma torus_circle_dense : (Submodule.span ℂ (Set.range (fun w => circleLp μ (fun x => torusWordCircle w (γ x)) ((torusWordCircle w).continuous.measurable.comp hγ)))).topologicalClosure = lpMeas ℂ ℂ (MeasurableSpace.comap γ inferInstance) 2 μ := by simp_rw [torus_circle_pull μ γ hγ] exact torusWord_pullback_dense γ hγ end namespace JoiningOperator open MeasureTheory open scoped ENNReal attribute [local instance] Rokhlin.instMeasurableSpaceCircle_circleLp Rokhlin.instBorelSpaceCircle_circleLp variable {Ω Z X Y P Q J : Type*} [MeasurableSpace Ω] [MeasurableSpace Z] [MeasurableSpace X] [MeasurableSpace Y] [MeasurableSpace P] [MeasurableSpace Q] [Countable J] (μ : Measure Ω) (η : Measure Z) [IsFiniteMeasure η] (x : Ω → X) (y : Ω → Y) (p : Ω → P) (q : Ω → Q) (z : Ω → Z) lemma torus_exact_split (A : X → J → Circle) (B : Y → J → Circle) (H : Z → J → Circle) (hA : Measurable A) (hB : Measurable B) (hH : Measurable H) (he : ∀ᵐ ω ∂μ, H (z ω) = A (x ω) * (B (y ω))⁻¹) (w : FreeGroup J) : circleLp η (fun v => torusWordCircle w (H v)) ((torusWordCircle w).continuous.measurable.comp hH) ∈ splitExact μ η x y z := by apply circle_mem_splitExact μ η x y z _ (fun v => torusWordCircle w (A v)) (fun v => (torusWordCircle w (B v))⁻¹) _ ((torusWordCircle w).continuous.measurable.comp hA) (((torusWordCircle w).continuous.measurable.comp hB).inv) filter_upwards [he] with ω hω rw [hω,torusWordCircle_mul,torusWordCircle_inv] lemma torus_split_inter_span (A : X → J → Circle) (B : Y → J → Circle) (C : P → J → Circle) (D : Q → J → Circle) (H : Z → J → Circle) (hA : Measurable A) (hB : Measurable B) (hC : Measurable C) (hD : Measurable D) (hH : Measurable H) (he : ∀ᵐ ω ∂μ, H (z ω) = A (x ω) * (B (y ω))⁻¹) (hf : ∀ᵐ ω ∂μ, H (z ω) = C (p ω) * (D (q ω))⁻¹) (V : Submodule ℂ (Lp ℂ 2 η)) (hV : IsClosed (V : Set (Lp ℂ 2 η))) (hsub : splitExact μ η x y z ∩ splitExact μ η p q z ⊆ V) (hfield : V = lpMeas ℂ ℂ (MeasurableSpace.comap H inferInstance) 2 η) : (Submodule.span ℂ (splitExact μ η x y z ∩ splitExact μ η p q z)).topologicalClosure = V := by apply le_antisymm · exact Submodule.topologicalClosure_minimal _ (Submodule.span_le.mpr hsub) hV · rw [hfield,←torus_circle_dense η H hH] apply Submodule.topologicalClosure_mono apply Submodule.span_mono rintro v ⟨w,rfl⟩ exact ⟨torus_exact_split μ η x y z A B H hA hB hH he w, torus_exact_split μ η p q z C D H hC hD hH hf w⟩ end JoiningOperator section open scoped InnerProductSpace variable {H A B : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] lemma nonzero_inner_in_closedSpan (S : Set H) (v : H) (hv : v ≠ 0) (hmem : v ∈ (Submodule.span ℂ S).topologicalClosure) : ∃ w ∈ S, inner ℂ v w ≠ 0 := by by_contra! h have ho : v ∈ (Submodule.span ℂ S)ᗮ := by rw [Submodule.mem_orthogonal'] intro w hw induction hw using Submodule.span_induction with | mem w hw => exact h w hw | zero => simp | add x y hx hy ihx ihy => simp only [inner_add_right,ihx,ihy,add_zero] | smul c x hx ih => simp only [inner_smul_right,ih,mul_zero] have ht : v ∈ ((Submodule.span ℂ S).topologicalClosure)ᗮ := by simpa only [Submodule.orthogonal_closure] using ho exact hv (inner_self_eq_zero.mp (((Submodule.mem_orthogonal' _ v).mp ht) v hmem)) theorem common_exact_all_splits (P : A → Set H) (Q : B → Set H) (D : Submodule ℂ H) (hP0 : ∀ a, (0 : H) ∈ P a) (hQ0 : ∀ b, (0 : H) ∈ Q b) (hPs : ∀ a (c : ℂ) v, v ∈ P a → c • v ∈ P a) (hQs : ∀ b (c : ℂ) v, v ∈ Q b → c • v ∈ Q b) (hPo : ∀ a v, v ∈ P a → ∀ w, w ∈ P a → inner ℂ v w = 0 ∨ ∃ c : ℂ, v = c • w) (hQo : ∀ b v, v ∈ Q b → ∀ w, w ∈ Q b → inner ℂ v w = 0 ∨ ∃ c : ℂ, v = c • w) (hspan : ∀ a b, (Submodule.span ℂ (P a ∩ Q b)).topologicalClosure = D) (a₀ : A) (b₀ : B) : (Submodule.span ℂ {v | (∀ a, v ∈ P a) ∧ (∀ b, v ∈ Q b)}).topologicalClosure = D := by apply le_antisymm · rw [←hspan a₀ b₀] exact Submodule.topologicalClosure_mono (Submodule.span_mono (fun v hv => ⟨hv.1 a₀,hv.2 b₀⟩)) · rw [←hspan a₀ b₀] apply Submodule.topologicalClosure_mono apply Submodule.span_mono rintro v ⟨hp,hq⟩ by_cases hz : v = 0 · subst v exact ⟨hP0,hQ0⟩ have hv : v ∈ D := by rw [←hspan a₀ b₀] exact Submodule.le_topologicalClosure _ (Submodule.subset_span ⟨hp,hq⟩) constructor · intro a obtain ⟨w,hw,hn⟩ := nonzero_inner_in_closedSpan (P a ∩ Q b₀) v hz (by rwa [hspan]) obtain ⟨c,hc⟩ := (hQo b₀ v hq w hw.2).resolve_left hn rw [hc] exact hPs a c w hw.1 · intro b obtain ⟨w,hw,hn⟩ := nonzero_inner_in_closedSpan (P a₀ ∩ Q b) v hz (by rwa [hspan]) obtain ⟨c,hc⟩ := (hPo a₀ v hp w hw.1).resolve_left hn rw [hc] exact hQs b c w hw.2 end namespace ArrayObjects.Object.Rolled open MeasureTheory ProbabilityTheory open scoped ENNReal InnerProductSpace universe u variable {I : Type u} [Fintype I] [DecidableEq I] {X : StandardSpace.{u}} {T : X ≃ᵐ X} {base : InitialLaws I X T} (M : Object I base) def rowSplitExact (P R : Finset I) (s : ComplementSplit R) (n : ℕ) (e : Arr I M.U (n+2)) := JoiningOperator.splitExact (M.ownKernel (n+2) e) (cellLaw M P R n e) (cells M P s.A n) (cells M P s.B n) (cells M P R n) def columnSplitExact (P R : Finset I) (s : ComplementSplit P) (n : ℕ) (e : Arr I M.U (n+2)) := JoiningOperator.splitExact (M.ownKernel (n+2) e) (cellLaw M P R n e) (cells M s.A R n) (cells M s.B R n) (cells M P R n) lemma grouped_exact_split_span (hM : M.IsSaturated) (P R : Finset I) (s : ComplementSplit P) (t : ComplementSplit R) (n : ℕ) : ∀ᵐ e ∂(M.law (n+2)).map (amap M.par (n+2)), (Submodule.span ℂ (rowSplitExact M P R t n e ∩ columnSplitExact M P R s n e)).topologicalClosure = commonActive M P s.A s.B R t.A t.B n e := by filter_upwards [grouped_torus_completeness M hM s.partition t.partition n, rowActive_eq_range M hM P s.partition.properP t.partition n, columnActive_eq_range M hM s.partition R t.partition.properP n, cells_fibre_marginal M hM P R s.partition.properP n, cells_fibre_marginal M hM P t.A s.partition.properP n, cells_fibre_marginal M hM P t.B s.partition.properP n, cells_fibre_marginal M hM s.A R s.partition.properA n, cells_fibre_marginal M hM s.B R s.partition.properB n, cells_indep_columns_fibre M P P t.A t.B t.disjointAB t.partition.properAB n, cells_indep_rows_fibre M hM s.A s.B R R s.disjointAB s.partition.properAB n] with e he hr hc hz hpa hpb hap hbp hri hci obtain ⟨J,hJ,A,B,C,D,H,hA,hB,hC,hD,hH,hF,hAB,hCD⟩ := he let : Countable J := hJ let hrow := cells_pair_preserving M hpa hpb hri let hcol := cells_pair_preserving M hap hbp hci apply JoiningOperator.torus_split_inter_span _ _ _ _ _ _ _ C D A B H hC hD hA hB hH hCD hAB _ _ _ hF · exact IsClosed.inter (essentialRange.isClosed (cellLaw M P t.A n e) (fibreRowEdge M P t.A R t.B n e)) (essentialRange.isClosed (cellLaw M s.A R n e) (fibreColumnEdge M s.A P s.B R n e)) · rintro v ⟨hv,hw⟩ constructor · rw [hr hz hrow] exact JoiningOperator.splitExact_le_active hz hrow hv · rw [hc hz hcol] exact JoiningOperator.splitExact_le_active hz hcol hw lemma rowSplitExact_dichotomy (hM : M.IsSaturated) (P R : Finset I) (hP : P ≠ Finset.univ) (s : ComplementSplit R) (n : ℕ) : ∀ᵐ e ∂(M.law (n+2)).map (amap M.par (n+2)), ∀ v ∈ rowSplitExact M P R s n e, ∀ w ∈ rowSplitExact M P R s n e, inner ℂ v w = 0 ∨ ∃ c : ℂ, v = c • w := by filter_upwards [cells_fibre_marginal M hM P R hP n, cells_indep_columns_fibre M P P s.A s.B s.disjointAB s.partition.properAB n, cells_indep_columns_fibre M P P s.A R s.disjointPA.symm (by simpa only [Finset.union_comm] using s.partition.properPA) n, cells_indep_columns_fibre M P P s.B R s.disjointPB.symm (by simpa only [Finset.union_comm] using s.partition.properPB) n] with e hz hxy hxz hyz exact fun v hv w hw => JoiningOperator.splitExact_dichotomy hz (measurable_cells M P s.A n).aemeasurable (measurable_cells M P s.B n).aemeasurable hxy hxz hyz hv hw lemma columnSplitExact_dichotomy (hM : M.IsSaturated) (P R : Finset I) (s : ComplementSplit P) (n : ℕ) : ∀ᵐ e ∂(M.law (n+2)).map (amap M.par (n+2)), ∀ v ∈ columnSplitExact M P R s n e, ∀ w ∈ columnSplitExact M P R s n e, inner ℂ v w = 0 ∨ ∃ c : ℂ, v = c • w := by filter_upwards [cells_fibre_marginal M hM P R s.partition.properP n, cells_indep_rows_fibre M hM s.A s.B R R s.disjointAB s.partition.properAB n, cells_indep_rows_fibre M hM s.A P R R s.disjointPA.symm (by simpa only [Finset.union_comm] using s.partition.properPA) n, cells_indep_rows_fibre M hM s.B P R R s.disjointPB.symm (by simpa only [Finset.union_comm] using s.partition.properPB) n] with e hz hxy hxz hyz exact fun v hv w hw => JoiningOperator.splitExact_dichotomy hz (measurable_cells M s.A R n).aemeasurable (measurable_cells M s.B R n).aemeasurable hxy hxz hyz hv hw def allSplitExact (P R : Finset I) (n : ℕ) (e : Arr I M.U (n+2)) := {v | (∀ s : ComplementSplit R, v ∈ rowSplitExact M P R s n e) ∧ (∀ t : ComplementSplit P, v ∈ columnSplitExact M P R t n e)} lemma allSplitExact_span (hM : M.IsSaturated) (P R : Finset I) (s₀ : ComplementSplit P) (t₀ : ComplementSplit R) (n : ℕ) : ∀ᵐ e ∂(M.law (n+2)).map (amap M.par (n+2)), (Submodule.span ℂ (allSplitExact M P R n e)).topologicalClosure = commonActive M P s₀.A s₀.B R t₀.A t₀.B n e := by have hspan := (ae_all_iff.mpr fun s : ComplementSplit P => ae_all_iff.mpr fun t : ComplementSplit R => grouped_exact_split_span M hM P R s t n) have hinv := (ae_all_iff.mpr fun s : ComplementSplit P => ae_all_iff.mpr fun t : ComplementSplit R => commonActive_complement_invariant M hM P R s s₀ t t₀ n) have hrow := ae_all_iff.mpr fun t : ComplementSplit R => rowSplitExact_dichotomy M hM P R s₀.partition.properP t n have hcol := ae_all_iff.mpr fun s : ComplementSplit P => columnSplitExact_dichotomy M hM P R s n filter_upwards [hspan,hinv,hrow,hcol] with e hs hi hr hc apply common_exact_all_splits (rowSplitExact M P R · n e) (columnSplitExact M P R · n e) _ (fun _ => JoiningOperator.zero_mem_splitExact _ _ _ _ _) (fun _ => JoiningOperator.zero_mem_splitExact _ _ _ _ _) (fun _ c v hv => JoiningOperator.smul_mem_splitExact _ _ _ _ _ c hv) (fun _ c v hv => JoiningOperator.smul_mem_splitExact _ _ _ _ _ c hv) hr hc (fun t s => (hs s t).trans (hi s t)) t₀ s₀ def oneColumn (P : Finset I) (n : ℕ) (j : I) (y : Arr I M.Y (n+2)) : P → Arr I M.Y n := fun i => missingRow M n j i y def oneRow (R : Finset I) (n : ℕ) (i : I) (y : Arr I M.Y (n+2)) : R → Arr I M.Y n := fun j => missingRow M n j i y omit [DecidableEq I] in @[fun_prop] lemma measurable_oneColumn (P : Finset I) (n : ℕ) (j : I) : Measurable (oneColumn M P n j) := by exact Measurable.of_eval fun _ => measurable_missingRow M _ _ _ omit [DecidableEq I] in @[fun_prop] lemma measurable_oneRow (R : Finset I) (n : ℕ) (i : I) : Measurable (oneRow M R n i) := by exact Measurable.of_eval fun _ => measurable_missingRow M _ _ _ def columnCellLaw (P : Finset I) (n : ℕ) (e : Arr I M.U (n+2)) (j : I) : Measure (P → Arr I M.Y n) := (M.ownKernel (n+1) (plane (n+1) (Fin.last (n+1)) j e)).map (fun y (i : P) => plane n 0 i y) def rowCellLaw (R : Finset I) (n : ℕ) (e : Arr I M.U (n+2)) (i : I) : Measure (R → Arr I M.Y n) := (M.ownKernel (n+1) (plane (n+1) 0 i e)).map (fun y (j : R) => plane n (Fin.last n) j y) instance (P : Finset I) (n : ℕ) (e : Arr I M.U (n+2)) (j : I) : IsProbabilityMeasure (columnCellLaw M P n e j) := (fun mapMeasurable => (Measure.isProbabilityMeasure_map_iff mapMeasurable).mpr inferInstance) (by fun_prop) instance (R : Finset I) (n : ℕ) (e : Arr I M.U (n+2)) (i : I) : IsProbabilityMeasure (rowCellLaw M R n e i) := (fun mapMeasurable => (Measure.isProbabilityMeasure_map_iff mapMeasurable).mpr inferInstance) (by fun_prop) omit [DecidableEq I] in lemma proper_columns_product (P S : Finset I) (hS : S ≠ Finset.univ) (n : ℕ) : ∀ᵐ e ∂(M.law (n+2)).map (amap M.par (n+2)), MeasurePreserving (fun y (j : S) => oneColumn M P n j y) (M.ownKernel (n+2) e) (Measure.pi (fun j : S => columnCellLaw M P n e j)) := by have hp := ConditionalFibres.marginal (measurable_planes (n+1) S) (M.ownKernel_conditional (n+2)) (M.planes_conditional (n+1) S hS) filter_upwards [hp] with e he have hg := measurePreserving_pi (fun j : S => M.ownKernel (n+1) (plane (n+1) (Fin.last (n+1)) j e)) (fun j : S => columnCellLaw M P n e j) (f := fun _ y (i : P) => plane n 0 i y) (fun _ => MeasurePreserving.mk (by fun_prop) rfl) have hm := hg.comp he convert hm using 1 funext y j i exact (congrFun (plane_first_last M n i j) y).symm lemma proper_rows_product (hM : M.IsSaturated) (R A : Finset I) (hA : A ≠ Finset.univ) (n : ℕ) : ∀ᵐ e ∂(M.law (n+2)).map (amap M.par (n+2)), MeasurePreserving (fun y (i : A) => oneRow M R n i y) (M.ownKernel (n+2) e) (Measure.pi (fun i : A => rowCellLaw M R n e i)) := by have hp := ConditionalFibres.marginal (measurable_parents M A (n+1)) (M.ownKernel_conditional (n+2)) (rows_conditional M hM A hA n) filter_upwards [hp] with e he have hg := measurePreserving_pi (fun i : A => M.ownKernel (n+1) (plane (n+1) 0 i e)) (fun i : A => rowCellLaw M R n e i) (f := fun _ y (j : R) => plane n (Fin.last n) j y) (fun _ => MeasurePreserving.mk (by fun_prop) rfl) exact hg.comp he end ArrayObjects.Object.Rolled namespace ComplementSplit variable {I : Type*} [Fintype I] [DecidableEq I] {R : Finset I} lemma two_le_card_compl (s : ComplementSplit R) : 2 ≤ Rᶜ.card := by have h := s.partition.cardP change R.card + 2 ≤ Fintype.card I at h have hc := Finset.card_compl R omega lemma rest_nonempty (s : ComplementSplit R) (i : ↥(Rᶜ)) : (R ∪ {(i : I)})ᶜ.Nonempty := by obtain ⟨j,hj,hji⟩ := Finset.exists_mem_ne (by have := two_le_card_compl s; omega : 1 < Rᶜ.card) (i : I) refine ⟨j,?_⟩ simp only [Finset.mem_compl,Finset.mem_union,Finset.mem_singleton,not_or] at * exact ⟨hj,hji⟩ abbrev singletonFor (s : ComplementSplit R) (i : ↥(Rᶜ)) : ComplementSplit R := ComplementSplit.singleton R s.nonemptyP i (Finset.mem_compl.mp i.property) (rest_nonempty s i) def restIndex (i : ↥(Rᶜ)) (j : ↥((R ∪ {(i : I)})ᶜ)) : {j : ↥(Rᶜ) // j ≠ i} := ⟨⟨j,Finset.mem_compl.mpr (fun hj => Finset.mem_compl.mp j.property (Finset.mem_union_left _ hj))⟩, by intro h have he : (j : I) = i := congrArg Subtype.val h exact Finset.mem_compl.mp j.property (Finset.mem_union_right _ (Finset.mem_singleton.mpr he))⟩ end ComplementSplit section open MeasureTheory ProbabilityTheory open scoped BigOperators variable {I A B : Type*} [Fintype I] [DecidableEq I] [MeasurableSpace A] (μ : I → Measure A) [∀ i, IsProbabilityMeasure (μ i)] def hybrid (s : Finset I) (x : I → A × A) : I → A := fun i => if i ∈ s then (x i).1 else (x i).2 lemma measurePreserving_hybrid (s : Finset I) : MeasurePreserving (hybrid s) (Measure.pi (fun i => (μ i).prod (μ i))) (Measure.pi μ) := by exact measurePreserving_pi (fun i => (μ i).prod (μ i)) μ (f := fun i p => if i ∈ s then p.1 else p.2) (by intro i by_cases hi : i ∈ s · simpa only [hybrid,hi,ite_true] using (measurePreserving_fst (μ := μ i) (ν := μ i)) · simpa only [hybrid,hi,ite_false] using (measurePreserving_snd (μ := μ i) (ν := μ i))) lemma ae_eq_const_of_omit (f : (I → A) → B) (g : ∀ i, (({j : I // j ≠ i}) → A) → B) (h : ∀ i, ∀ᵐ x ∂Measure.pi μ, f x = g i (fun j => x j)) : ∃ b, ∀ᵐ x ∂Measure.pi μ, f x = b := by have hh (s : Finset I) : ∀ᵐ x ∂Measure.pi (fun i => (μ i).prod (μ i)), f (hybrid s x) = f (hybrid ∅ x) := by induction s using Finset.induction_on with | empty => exact Filter.Eventually.of_forall fun _ => rfl | @insert i s hi hs => filter_upwards [(measurePreserving_hybrid μ (insert i s)).quasiMeasurePreserving.ae (h i), (measurePreserving_hybrid μ s).quasiMeasurePreserving.ae (h i),hs] with x h1 h2 h3 rw [h1,←h3,h2] congr 1 funext j simp only [hybrid,Finset.mem_insert, j.property, false_or] have he : ∀ᵐ x ∂(Measure.pi μ).prod (Measure.pi μ), f x.1 = f x.2 := by have hp := (measurePreserving_arrowProdEquivProdArrow A A I μ μ).symm (MeasurableEquiv.arrowProdEquivProdArrow A A I) filter_upwards [hp.quasiMeasurePreserving.ae (hh Finset.univ)] with x hx change f (fun i => if i ∈ Finset.univ then x.1 i else x.2 i) = f (fun i => if i ∈ (∅ : Finset I) then x.1 i else x.2 i) at hx simpa only [Finset.mem_univ,ite_true,Finset.notMem_empty,ite_false] using hx obtain ⟨x,hx⟩ := (Measure.ae_ae_of_ae_prod he).exists exact ⟨f x,hx.mono fun _ he => he.symm⟩ lemma pure_product_of_singleton_splits {G : Type*} [CommGroup G] (f : (I → A) → G) (a : I → A → G) (b : ∀ i, (({j : I // j ≠ i}) → A) → G) (h : ∀ i, ∀ᵐ x ∂Measure.pi μ, f x = a i (x i) * b i (fun j => x j)) : ∃ c, ∀ᵐ x ∂Measure.pi μ, f x = c * ∏ i, a i (x i) := by let F (x : I → A) := f x * (∏ i, a i (x i))⁻¹ let B (i : I) (x : ({j : I // j ≠ i}) → A) := b i x * (∏ j : ({j : I // j ≠ i}), a j (x j))⁻¹ have hi : ∀ i, ∀ᵐ x ∂Measure.pi μ, F x = B i (fun j => x j) := by intro i filter_upwards [h i] with x hx dsimp only [F,B] rw [hx,←Finset.prod_erase_mul Finset.univ (fun j => a j (x j)) (Finset.mem_univ i)] have hp : (∏ j : ({j : I // j ≠ i}), a j (x j)) = ∏ j ∈ Finset.univ.erase i, a j (x j) := by classical exact (Finset.prod_subtype (p := fun j => j ≠ i) (Finset.univ.erase i) (fun j => by simp only [Finset.mem_erase, Finset.mem_univ, and_true]) (fun j => a j (x j))).symm rw [hp] simp only [mul_inv_rev] simp only [mul_assoc, mul_left_comm, mul_inv_cancel_left] obtain ⟨c,hc⟩ := ae_eq_const_of_omit μ F B hi refine ⟨c,hc.mono fun x hx => ?_⟩ exact (mul_inv_eq_iff_eq_mul.mp hx) end section open MeasureTheory ProbabilityTheory open scoped ENNReal BigOperators attribute [local instance] Rokhlin.instMeasurableSpaceCircle_circleLp Rokhlin.instBorelSpaceCircle_circleLp variable {Ω Z X Y : Type*} [MeasurableSpace Ω] [retained9 : MeasurableSpace Z] [MeasurableSpace X] [MeasurableSpace Y] {μ : Measure Ω} {η : Measure Z} [IsProbabilityMeasure η] {x : Ω → X} {y : Ω → Y} {z : Ω → Z} lemma circle_split_witness (hz : MeasurePreserving z μ η) (f : Z → Circle) (hf : Measurable f) (hv : circleLp η f hf ∈ JoiningOperator.splitExact μ η x y z) : ∃ (g : X → Circle) (h : Y → Circle), Measurable g ∧ Measurable h ∧ ∀ᵐ ω ∂μ, f (z ω) = g (x ω) * h (y ω) := by obtain ⟨f',g,h,hf',hg,hh,c,hv,he⟩ := hv have hn : ‖c‖ = 1 := by have hh := congrArg norm hv simpa only [circleLp_norm,norm_smul,mul_one] using hh.symm let a : Circle := ⟨c,mem_sphere_zero_iff_norm.mpr hn⟩ have hfg : ∀ᵐ v ∂η, f v = a*f' v := by filter_upwards [circleLp_coe η f hf,circleLp_coe η f' hf',Lp.coeFn_smul c (circleLp η f' hf')] with v h1 h2 h3 apply Subtype.ext change (f v : ℂ) = c * (f' v : ℂ) rw [←h1,hv,h3] change c * circleLp η f' hf' v = c * (f' v : ℂ) rw [h2] refine ⟨fun u => a*g u,h,measurable_const.mul hg,hh,?_⟩ filter_upwards [hz.quasiMeasurePreserving.ae hfg,he] with ω h1 h2 rw [h1,h2,mul_assoc] variable {I A : Type*} [Fintype I] [DecidableEq I] [Nonempty I] [MeasurableSpace A] (ν : I → Measure A) [∀ i, IsProbabilityMeasure (ν i)] include retained9 in lemma full_product_of_exact_splits (u : Ω → I → A) (hu : MeasurePreserving u μ (Measure.pi ν)) (f : Z → Circle) (a : I → A → Circle) (b : ∀ i, ({j : I // j ≠ i} → A) → Circle) (ha : ∀ i, Measurable (a i)) (hb : ∀ i, Measurable (b i)) (he : ∀ i, ∀ᵐ ω ∂μ, f (z ω) = a i (u ω i) * b i (fun j => u ω j)) : ∃ c : Circle, ∀ᵐ ω ∂μ, f (z ω) = c * ∏ i, a i (u ω i) := by let _ := retained9 let i₀ : I := Classical.choice inferInstance let F (v : I → A) := a i₀ (v i₀) * b i₀ (fun j => v j) have hF : Measurable F := (ha i₀ |>.comp (measurable_pi_apply i₀)).mul (hb i₀ |>.comp (Measurable.of_eval (fun _ => measurable_pi_apply _))) have hs : ∀ i, ∀ᵐ v ∂Measure.pi ν, F v = a i (v i) * b i (fun j => v j) := by intro i rw [←hu.map_eq] apply (ae_map_iff hu.measurable.aemeasurable (measurableSet_eq_fun hF ((ha i |>.comp (measurable_pi_apply i)).mul (hb i |>.comp (Measurable.of_eval (fun _ => measurable_pi_apply _)))))).mpr filter_upwards [he i₀,he i] with ω h0 hi exact h0.symm.trans hi obtain ⟨c,hc⟩ := pure_product_of_singleton_splits ν F a b hs refine ⟨c,?_⟩ filter_upwards [he i₀,hu.quasiMeasurePreserving.ae hc] with ω h0 hc exact h0.trans hc end namespace ArrayObjects.Object.Rolled open MeasureTheory ProbabilityTheory open scoped ENNReal BigOperators section attribute [local instance] Rokhlin.instMeasurableSpaceCircle_circleLp Rokhlin.instBorelSpaceCircle_circleLp universe u variable {I : Type u} [Fintype I] [DecidableEq I] {X : StandardSpace.{u}} {T : X ≃ᵐ X} {base : InitialLaws I X T} (M : Object I base) lemma complement_proper {P : Finset I} (hP : P.Nonempty) : Pᶜ ≠ Finset.univ := by obtain ⟨i,hi⟩ := hP intro h have := Finset.mem_compl.mp (h.symm ▸ Finset.mem_univ i) exact this hi lemma row_all_splits_product (hM : M.IsSaturated) (P R : Finset I) (s : ComplementSplit P) (t : ComplementSplit R) (n : ℕ) : ∀ᵐ e ∂(M.law (n+2)).map (amap M.par (n+2)), ∀ (f : (R → P → Arr I M.Y n) → Circle) (hf : Measurable f), (∀ t' : ComplementSplit R, circleLp (cellLaw M P R n e) f hf ∈ rowSplitExact M P R t' n e) → ∃ (a : ↥(Rᶜ) → (P → Arr I M.Y n) → Circle) (c : Circle), (∀ i, Measurable (a i)) ∧ ∀ᵐ y ∂M.ownKernel (n+2) e, f (cells M P R n y) = c * ∏ i : ↥(Rᶜ), a i (oneColumn M P n i y) := by let : Nonempty ↥(Rᶜ) := Finset.Nonempty.to_subtype (by have := t.two_le_card_compl exact Finset.card_pos.mp (by omega)) filter_upwards [cells_fibre_marginal M hM P R s.partition.properP n, proper_columns_product M P Rᶜ (complement_proper t.nonemptyP) n] with e hz hp intro f hf h have hw (i : ↥(Rᶜ)) := circle_split_witness hz f hf (h (t.singletonFor i)) choose g b hg hb he using hw let a (i : ↥(Rᶜ)) (v : P → Arr I M.Y n) : Circle := g i (fun _ p => v p) let d (i : ↥(Rᶜ)) (v : {j : ↥(Rᶜ) // j ≠ i} → (P → Arr I M.Y n)) : Circle := b i (fun j p => v (ComplementSplit.restIndex i j) p) have ha : ∀ i, Measurable (a i) := by intro i; exact (hg i).comp (by fun_prop) have hd : ∀ i, Measurable (d i) := by intro i; exact (hb i).comp (by fun_prop) have he' (i : ↥(Rᶜ)) : ∀ᵐ y ∂M.ownKernel (n+2) e, f (cells M P R n y) = a i (oneColumn M P n i y) * d i (fun j => oneColumn M P n j.val y) := by filter_upwards [he i] with y hy convert hy using 2 · dsimp only [a] apply congrArg (g i) funext j p have hj : (j : I) = i := Finset.mem_singleton.mp j.property simp only [cells,oneColumn,hj] · rfl obtain ⟨c,hc⟩ := full_product_of_exact_splits (fun i : ↥(Rᶜ) => columnCellLaw M P n e i) (fun y (j : ↥(Rᶜ)) => oneColumn M P n j y) hp f a d ha hd he' exact ⟨a,c,ha,hc⟩ lemma column_all_splits_product (hM : M.IsSaturated) (P R : Finset I) (s : ComplementSplit P) (_t : ComplementSplit R) (n : ℕ) : ∀ᵐ e ∂(M.law (n+2)).map (amap M.par (n+2)), ∀ (f : (R → P → Arr I M.Y n) → Circle) (hf : Measurable f), (∀ s' : ComplementSplit P, circleLp (cellLaw M P R n e) f hf ∈ columnSplitExact M P R s' n e) → ∃ (a : ↥(Pᶜ) → (R → Arr I M.Y n) → Circle) (c : Circle), (∀ i, Measurable (a i)) ∧ ∀ᵐ y ∂M.ownKernel (n+2) e, f (cells M P R n y) = c * ∏ i : ↥(Pᶜ), a i (oneRow M R n i y) := by let : Nonempty ↥(Pᶜ) := Finset.Nonempty.to_subtype (by have := s.two_le_card_compl exact Finset.card_pos.mp (by omega)) filter_upwards [cells_fibre_marginal M hM P R s.partition.properP n, proper_rows_product M hM R Pᶜ (complement_proper s.nonemptyP) n] with e hz hp intro f hf h have hw (i : ↥(Pᶜ)) := circle_split_witness hz f hf (h (s.singletonFor i)) choose g b hg hb he using hw let a (i : ↥(Pᶜ)) (v : R → Arr I M.Y n) : Circle := g i (fun j _ => v j) let d (i : ↥(Pᶜ)) (v : {j : ↥(Pᶜ) // j ≠ i} → (R → Arr I M.Y n)) : Circle := b i (fun p j => v (ComplementSplit.restIndex i j) p) have ha : ∀ i, Measurable (a i) := by intro i; exact (hg i).comp (by fun_prop) have hd : ∀ i, Measurable (d i) := by intro i; exact (hb i).comp (by fun_prop) have he' (i : ↥(Pᶜ)) : ∀ᵐ y ∂M.ownKernel (n+2) e, f (cells M P R n y) = a i (oneRow M R n i y) * d i (fun j => oneRow M R n j.val y) := by filter_upwards [he i] with y hy convert hy using 2 · dsimp only [a] apply congrArg (g i) funext p j have hj : (j : I) = i := Finset.mem_singleton.mp j.property simp only [cells,oneRow,hj] · rfl obtain ⟨c,hc⟩ := full_product_of_exact_splits (fun i : ↥(Pᶜ) => rowCellLaw M R n e i) (fun y (j : ↥(Pᶜ)) => oneRow M R n j y) hp f a d ha hd he' exact ⟨a,c,ha,hc⟩ end attribute [local instance] Rokhlin.instMeasurableSpaceCircle_circleLp Rokhlin.instBorelSpaceCircle_circleLp universe u variable {I : Type u} [Fintype I] [DecidableEq I] {X : StandardSpace.{u}} {T : X ≃ᵐ X} {base : InitialLaws I X T} (M : Object I base) def fullExact (P R : Finset I) (n : ℕ) (e : Arr I M.U (n+2)) : Set (Lp ℂ 2 (cellLaw M P R n e)) := {v | ∃ (f : (R → P → Arr I M.Y n) → Circle) (hf : Measurable f) (d : ℂ), v = d • circleLp (cellLaw M P R n e) f hf ∧ (∃ (a : ↥(Rᶜ) → (P → Arr I M.Y n) → Circle) (c : Circle), (∀ i, Measurable (a i)) ∧ ∀ᵐ y ∂M.ownKernel (n+2) e, f (cells M P R n y) = c * ∏ i : ↥(Rᶜ), a i (oneColumn M P n i y)) ∧ (∃ (a : ↥(Pᶜ) → (R → Arr I M.Y n) → Circle) (c : Circle), (∀ i, Measurable (a i)) ∧ ∀ᵐ y ∂M.ownKernel (n+2) e, f (cells M P R n y) = c * ∏ i : ↥(Pᶜ), a i (oneRow M R n i y))} lemma zero_mem_fullExact (P R : Finset I) (n : ℕ) (e : Arr I M.U (n+2)) : (0 : Lp ℂ 2 (cellLaw M P R n e)) ∈ fullExact M P R n e := by refine ⟨1,measurable_const,0,by simp,?_,?_⟩ <;> exact ⟨1,1,fun _ => measurable_const,Filter.Eventually.of_forall (by intro y; simp)⟩ lemma allSplitExact_subset_fullExact (hM : M.IsSaturated) (P R : Finset I) (s : ComplementSplit P) (t : ComplementSplit R) (n : ℕ) : ∀ᵐ e ∂(M.law (n+2)).map (amap M.par (n+2)), allSplitExact M P R n e ⊆ fullExact M P R n e := by filter_upwards [row_all_splits_product M hM P R s t n,column_all_splits_product M hM P R s t n] with e hr hc intro v hv obtain ⟨f,g,h,hf,hg,hh,c,hv',he⟩ := hv.1 t by_cases hz : c = 0 · rw [hz,zero_smul] at hv' rw [hv'] exact zero_mem_fullExact M P R n e have hrow : ∀ t' : ComplementSplit R, circleLp (cellLaw M P R n e) f hf ∈ rowSplitExact M P R t' n e := by intro t' have h := JoiningOperator.smul_mem_splitExact _ _ _ _ _ c⁻¹ (hv.1 t') rwa [hv',smul_smul,inv_mul_cancel₀ hz,one_smul] at h have hcol : ∀ s' : ComplementSplit P, circleLp (cellLaw M P R n e) f hf ∈ columnSplitExact M P R s' n e := by intro s' have h := JoiningOperator.smul_mem_splitExact _ _ _ _ _ c⁻¹ (hv.2 s') rwa [hv',smul_smul,inv_mul_cancel₀ hz,one_smul] at h exact ⟨f,hf,c,hv',hr f hf hrow,hc f hf hcol⟩ lemma commonActive_le_fullExact_span (hM : M.IsSaturated) (P R : Finset I) (s : ComplementSplit P) (t : ComplementSplit R) (n : ℕ) : ∀ᵐ e ∂(M.law (n+2)).map (amap M.par (n+2)), commonActive M P s.A s.B R t.A t.B n e ≤ (Submodule.span ℂ (fullExact M P R n e)).topologicalClosure := by filter_upwards [allSplitExact_span M hM P R s t n, allSplitExact_subset_fullExact M hM P R s t n] with e he hs rw [←he] exact Submodule.topologicalClosure_mono (Submodule.span_mono hs) end ArrayObjects.Object.Rolled section open MeasureTheory ProbabilityTheory Set theorem ae_map_descent {Ω S : Type*} [MeasurableSpace Ω] [MeasurableSpace S] [StandardBorelSpace Ω] [StandardBorelSpace S] (μ : Measure Ω) [IsProbabilityMeasure μ] {f : Ω → S} (hf : Measurable f) {P : S → Prop} (hP : ∀ᵐ ω ∂μ, P (f ω)) : ∀ᵐ s ∂μ.map f, P s := by let : Nonempty Ω := nonempty_of_isProbabilityMeasure μ let κ := condDistrib id f μ have hnull : NullMeasurableSet {ω | P (f ω)} μ := by exact NullMeasurableSet.congr (nullMeasurableSet_univ (μ := μ)) (by filter_upwards [hP] with ω hω; exact propext (iff_of_true trivial hω)) obtain ⟨t,ht,htm,hte⟩ := hnull.exists_measurable_subset_ae_eq have hta : ∀ᵐ ω ∂μ, ω ∈ t := by filter_upwards [hP,hte] with ω hω he exact he.mpr hω have hgood : ∀ᵐ s ∂μ.map f, ∀ᵐ ω ∂κ s, ω ∈ t ∧ f ω = s := by apply Measure.ae_ae_of_ae_compProd (p := fun p : S × Ω => p.2 ∈ t ∧ f p.2 = p.1) change ∀ᵐ p ∂μ.map f ⊗ₘ condDistrib id f μ, p.2 ∈ t ∧ f p.2 = p.1 rw [compProd_map_condDistrib hf.aemeasurable aemeasurable_id] apply (ae_map_iff (hf.prodMk measurable_id).aemeasurable ((htm.preimage measurable_snd).inter (measurableSet_eq_fun (hf.comp measurable_snd) measurable_fst))).mpr filter_upwards [hta] with ω hω exact ⟨hω,rfl⟩ filter_upwards [hgood] with s hs obtain ⟨ω,hω,he⟩ := hs.exists rw [←he] exact ht hω end section open MeasureTheory ContinuousLinearMap open scoped InnerProductSpace variable {P H : Type*} [MeasurableSpace P] [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] [SecondCountableTopology H] lemma random_projection_exactness (μ : Measure P) [SFinite μ] (V C : P → Submodule ℂ H) [∀ p, (V p).HasOrthogonalProjection] (hC : ∀ p, IsClosed (C p : Set H)) (hCV : ∀ p, C p ≤ V p) (hm : ∀ᵐ pair ∂μ.prod μ, (V pair.1).starProjection ∘L (V pair.2).starProjection = (V pair.2).starProjection ∘L (V pair.1).starProjection ∧ V pair.1 ⊓ V pair.2 ≤ C pair.1) : ∀ᵐ p ∂μ, V p = C p := by let F := fun p => (V p).starProjection filter_upwards [essentialRange.ae_range_le μ F, Measure.ae_ae_of_ae_prod hm] with p hp hpm apply le_antisymm _ (hCV p) have hc : essentialRange μ F ≤ (C p).comap (F p).toLinearMap := by apply essentialRange.le_comap_of_ae_comp μ F (F p) (C p) (hC p) filter_upwards [hpm] with q hq rintro _ ⟨v,rfl⟩ apply hq.2 constructor · exact (V p).starProjection_apply_mem _ · change F p (F q v) ∈ V q rw [show F p (F q v) = F q (F p v) from congrArg (fun A : H →L[ℂ] H => A v) hq.1] exact (V q).starProjection_apply_mem _ intro v hv have hv' : v ∈ essentialRange μ F := hp ⟨v,(V p).starProjection_eq_self_iff.mpr hv⟩ have hh := hc hv' change (V p).starProjection v ∈ C p at hh rwa [(V p).starProjection_eq_self_iff.mpr hv] at hh omit [SecondCountableTopology H] in lemma essential_projection_not_ae_zero (μ : Measure P) (V : P → Submodule ℂ H) [∀ p, (V p).HasOrthogonalProjection] (v : H) (hv : v ∈ essentialRange μ (fun p => (V p).starProjection)) (hne : v ≠ 0) : ¬ ∀ᵐ p ∂μ, (V p).starProjection v = 0 := by intro hz have hk : v ∈ essentialKernel μ (fun p => (V p).starProjection.adjoint) := by change ∀ᵐ p ∂μ, (V p).starProjection.adjoint v = 0 simpa only [(isSelfAdjoint_starProjection _).adjoint_eq] using hz exact hne ((inner_self_eq_zero (𝕜 := ℂ)).mp ((Submodule.mem_orthogonal _ _).mp hv v hk)) lemma active_projection_not_ae_zero (μ : Measure P) (V : P → Submodule ℂ H) [∀ p, (V p).HasOrthogonalProjection] : ∀ᵐ p ∂μ, ∀ v ∈ V p, v ≠ 0 → ¬ ∀ᵐ q ∂μ, (V q).starProjection v = 0 := by filter_upwards [essentialRange.ae_range_le μ (fun p => (V p).starProjection)] with p hp intro v hv hne exact essential_projection_not_ae_zero μ V v (hp ⟨v,(V p).starProjection_eq_self_iff.mpr hv⟩) hne end namespace ArrayObjects.Object.Rolled open MeasureTheory ProbabilityTheory open scoped ENNReal universe u variable {I : Type u} [Fintype I] [retained10 : DecidableEq I] {X : StandardSpace.{u}} {T : X ≃ᵐ X} {base : InitialLaws I X T} (M : Object I base) abbrev Cell (i : I) := ({i} : Finset I) → ({i} : Finset I) → Arr I M.Y 0 def padCell (i : I) (y : Arr I M.Y 0) : Cell M i := fun _ _ => y omit [DecidableEq I] in @[fun_prop] lemma measurable_padCell (i : I) : Measurable (padCell M i) := by exact Measurable.of_eval fun _ => Measurable.of_eval fun _ => measurable_id def slotCell (i : I) : Arr I M.Y 1 → Cell M i := padCell M i ∘ plane 0 0 i include retained10 in @[fun_prop] lemma measurable_slotCell (i : I) : Measurable (slotCell M i) := by let _ := retained10 exact (measurable_padCell M i).comp (measurable_plane _ _ _) def slotRest (i : I) (y : Arr I M.Y 1) : ↥(({i} : Finset I)ᶜ) → Arr I M.Y 0 := fun j => plane 0 0 j y @[fun_prop] lemma measurable_slotRest (i : I) : Measurable (slotRest M i) := by exact Measurable.of_eval fun _ => measurable_plane _ _ _ def slotLocal (i : I) : Kernel (Arr I M.U 0) (Cell M i) := (M.ownKernel 0).map (padCell M i) instance (i : I) : IsMarkovKernel (slotLocal M i) := Kernel.IsMarkovKernel.map _ (measurable_padCell M i) def slotActive (i : I) (ν : Measure (Cell M i)) (p : Arr I M.U 1) : Submodule ℂ (Lp ℂ 2 ν) := by classical exact if h : MeasurePreserving (slotCell M i) (M.ownKernel 1 p) ν then (LinearMap.range (JoiningOperator.operator h (MeasurePreserving.mk (measurable_slotRest M i) rfl)).toLinearMap).topologicalClosure else ⊥ lemma slotActive_eq (i : I) (ν : Measure (Cell M i)) (p : Arr I M.U 1) (h : MeasurePreserving (slotCell M i) (M.ownKernel 1 p) ν) : slotActive M i ν p = (LinearMap.range (JoiningOperator.operator h (MeasurePreserving.mk (measurable_slotRest M i) rfl)).toLinearMap).topologicalClosure := by rw [slotActive,dite_eq_left h] lemma slotActive_closed (i : I) (ν : Measure (Cell M i)) (p : Arr I M.U 1) : IsClosed (slotActive M i ν p : Set (Lp ℂ 2 ν)) := by unfold slotActive split · exact Submodule.isClosed_topologicalClosure _ · exact isClosed_singleton instance (i : I) (ν : Measure (Cell M i)) (p : Arr I M.U 1) : CompleteSpace (slotActive M i ν p) := (slotActive_closed M i ν p).completeSpace_coe omit [DecidableEq I] in lemma cells_single_row (i : I) : cells M {i} {i} 0 = slotCell M i ∘ plane 1 0 i := by funext y j a have hj : (j : I) = i := Finset.mem_singleton.mp j.property have ha : (a : I) = i := Finset.mem_singleton.mp a.property simp only [cells,slotCell,padCell,Function.comp_apply,hj,ha] rfl include retained10 in lemma cells_single_column (i : I) : cells M {i} {i} 0 = slotCell M i ∘ plane 1 (Fin.last 1) i := by let _ := retained10 funext y j a have hj : (j : I) = i := Finset.mem_singleton.mp j.property have ha : (a : I) = i := Finset.mem_singleton.mp a.property simp only [cells,slotCell,padCell,Function.comp_apply,hj,ha] exact (congrFun (plane_first_last M 0 i i) y).symm include retained10 in lemma slotCell_marginal (hI : 2 ≤ Fintype.card I) (i : I) : ∀ᵐ p ∂M.parameterLaw 1, MeasurePreserving (slotCell M i) (M.ownKernel 1 p) (slotLocal M i (plane 0 0 i p)) := by let _ := retained10 have h := ConditionalFibres.marginal (measurable_plane 0 0 i) (M.ownKernel_conditional 1) (M.plane_conditional hI 0 i) filter_upwards [h] with p hp exact (MeasurePreserving.mk (measurable_padCell M i) (Kernel.map_apply _ (measurable_padCell M i) _).symm).comp hp lemma row_marginal_fibre (hM : M.IsSaturated) (hI : 2 ≤ Fintype.card I) (i : I) : ∀ᵐ e ∂M.parameterLaw 2, MeasurePreserving (plane 1 0 i) (M.ownKernel 2 e) (M.ownKernel 1 (plane 1 0 i e)) := by have hproper : ({i} : Finset I) ≠ Finset.univ := by intro he have := congrArg Finset.card he simp only [Finset.card_singleton,Finset.card_univ] at this omega have h := (rows_conditional M hM {i} hproper 0).comp_left (measurable_pi_apply (⟨i,Finset.mem_singleton_self i⟩ : ({i} : Finset I))) rw [FiniteKernel.map_eval] at h exact ConditionalFibres.marginal (measurable_plane _ _ _) (M.ownKernel_conditional 2) h omit [DecidableEq I] in lemma column_marginal_fibre (hI : 2 ≤ Fintype.card I) (i : I) : ∀ᵐ e ∂M.parameterLaw 2, MeasurePreserving (plane 1 (Fin.last 1) i) (M.ownKernel 2 e) (M.ownKernel 1 (plane 1 (Fin.last 1) i e)) := by exact ConditionalFibres.marginal (measurable_plane _ _ _) (M.ownKernel_conditional 2) (M.plane_conditional hI 1 i) lemma singleton_cellLaw (hM : M.IsSaturated) (hI : 2 ≤ Fintype.card I) (i : I) : ∀ᵐ e ∂M.parameterLaw 2, cellLaw M {i} {i} 0 e = slotLocal M i (plane 0 0 i (plane 1 0 i e)) := by have hproper : ({i} : Finset I) ≠ Finset.univ := by intro he have := congrArg Finset.card he simp only [Finset.card_singleton,Finset.card_univ] at this omega let hparam : MeasurePreserving (plane 1 0 i) (M.parameterLaw 2) (M.parameterLaw 1) := ⟨measurable_plane _ _ _,M.parameterLaw_consistent 1 0 i⟩ filter_upwards [cells_fibre_marginal M hM {i} {i} hproper 0, row_marginal_fibre M hM hI i, hparam.quasiMeasurePreserving.ae (slotCell_marginal M hI i)] with e hc hr hs have hh := hs.comp hr rw [←cells_single_row] at hh exact hc.map_eq.symm.trans hh.map_eq end ArrayObjects.Object.Rolled section open MeasureTheory ProbabilityTheory Set section lemma iIndepFun_map_iff_measurable {A B J C : Type*} [MeasurableSpace A] [MeasurableSpace B] [MeasurableSpace C] [Fintype J] (μ : Measure A) [IsProbabilityMeasure μ] (f : B → J → C) (g : A → B) (hf : ∀ j, Measurable (fun b => f b j)) (hg : Measurable g) : iIndepFun (fun j b => f b j) (μ.map g) ↔ iIndepFun (fun j a => f (g a) j) μ := by let : IsProbabilityMeasure (μ.map g) := (fun mapMeasurable => (Measure.isProbabilityMeasure_map_iff mapMeasurable).mpr inferInstance) hg.aemeasurable rw [iIndepFun_iff_map_fun_eq_pi_map (fun j => (hf j).aemeasurable), iIndepFun_iff_map_fun_eq_pi_map (f := fun j a => f (g a) j) (fun j => ((hf j).comp hg).aemeasurable)] simp only [Measure.map_map (Measurable.of_eval hf) hg, Measure.map_map (hf _) hg] rfl end namespace ArrayObjects.Object.Rolled universe u variable {I : Type u} [Fintype I] [DecidableEq I] {X : StandardSpace.{u}} {T : X ≃ᵐ X} {base : InitialLaws I X T} (M : Object I base) def slotTuple (r : I) (y : Arr I M.Y 1) : I → Cell M r := fun j => padCell M r (plane 0 0 j y) omit [DecidableEq I] in @[fun_prop] lemma measurable_slotTuple (r : I) : Measurable (slotTuple M r) := Measurable.of_eval fun _ => (measurable_padCell M r).comp (measurable_plane _ _ _) def slotTupleKernel (r : I) : Kernel (Arr I M.U 1) (I → Cell M r) := (M.ownKernel 1).map (slotTuple M r) instance (r : I) : IsMarkovKernel (slotTupleKernel M r) := Kernel.IsMarkovKernel.map _ (measurable_slotTuple M r) def tupleParameter (p : Arr I M.U 1) : I → Arr I M.U 0 := fun j => plane 0 0 j p omit [DecidableEq I] in @[fun_prop] lemma measurable_tupleParameter : Measurable (tupleParameter M) := Measurable.of_eval fun _ => measurable_plane _ _ _ omit [DecidableEq I] in lemma slotTuple_marginal (hI : 2 ≤ Fintype.card I) (r : I) : ∀ᵐ p ∂M.parameterLaw 1, ∀ j, MeasurePreserving (fun z : I → Cell M r => z j) (slotTupleKernel M r p) (slotLocal M r (tupleParameter M p j)) := by have h (j : I) := ConditionalFibres.marginal (measurable_plane 0 0 j) (M.ownKernel_conditional 1) (M.plane_conditional hI 0 j) filter_upwards [ae_all_iff.mpr h] with p hp j refine ⟨measurable_pi_apply j,?_⟩ rw [slotTupleKernel,Kernel.map_apply _ (measurable_slotTuple M r), Measure.map_map (measurable_pi_apply j) (measurable_slotTuple M r)] change (M.ownKernel 1 p).map (padCell M r ∘ plane 0 0 j) = _ rw [←Measure.map_map (measurable_padCell M r) (measurable_plane 0 0 j),(hp j).map_eq] change ((M.ownKernel 0) (plane 0 0 j p)).map (padCell M r) = (slotLocal M r) (tupleParameter M p j) exact (Kernel.map_apply (M.ownKernel 0) (measurable_padCell M r) _).symm lemma tuple_planes_product (j : I) : ∀ᵐ p ∂M.parameterLaw 1, MeasurePreserving (planes 0 (Finset.univ.erase j)) (M.ownKernel 1 p) (Measure.pi (fun t : (Finset.univ.erase j : Finset I) => M.ownKernel 0 (plane 0 0 t p))) := by have hproper : Finset.univ.erase j ≠ (Finset.univ : Finset I) := by intro he have := congrArg (fun s : Finset I => j ∈ s) he simp at this exact ConditionalFibres.marginal (measurable_planes _ _) (M.ownKernel_conditional 1) (M.planes_conditional 0 _ hproper) lemma slotTuple_proper (r : I) : ∀ᵐ p ∂M.parameterLaw 1, ∀ j, iIndepFun (fun t : (Finset.univ.erase j : Finset I) => fun z : I → Cell M r => z t) (slotTupleKernel M r p) := by filter_upwards [ae_all_iff.mpr (tuple_planes_product M)] with p hp j rw [slotTupleKernel,Kernel.map_apply _ (measurable_slotTuple M r)] apply (iIndepFun_map_iff_measurable (J := ↥(Finset.univ.erase j)) _ _ _ (fun t => measurable_pi_apply (t : I)) (measurable_slotTuple M r)).mpr have h := iIndepFun_pi (μ := fun t : (Finset.univ.erase j : Finset I) => M.ownKernel 0 (plane 0 0 t p)) (fun _ : (Finset.univ.erase j : Finset I) => (measurable_padCell M r).aemeasurable) rw [←(hp j).map_eq] at h exact (iIndepFun_map_iff_measurable (M.ownKernel 1 p) (fun (b : ↥(Finset.univ.erase j : Finset I) → Arr I M.Y 0) t => padCell M r (b t)) (planes 0 (Finset.univ.erase j)) (fun t => (measurable_padCell M r).comp (measurable_pi_apply t)) (measurable_planes 0 _)).mp h lemma exists_good_tuple_set (hI : 2 ≤ Fintype.card I) (r : I) : ∃ D : Set (Arr I M.U 1), MeasurableSet D ∧ (∀ᵐ p ∂M.parameterLaw 1, p ∈ D) ∧ (∀ p ∈ D, ∀ j, MeasurePreserving (fun z : I → Cell M r => z j) (slotTupleKernel M r p) (slotLocal M r (tupleParameter M p j))) ∧ (∀ p ∈ D, ∀ j, iIndepFun (fun t : (Finset.univ.erase j : Finset I) => fun z : I → Cell M r => z t) (slotTupleKernel M r p)) := by let P := fun p => (∀ j, MeasurePreserving (fun z : I → Cell M r => z j) (slotTupleKernel M r p) (slotLocal M r (tupleParameter M p j))) ∧ (∀ j, iIndepFun (fun t : (Finset.univ.erase j : Finset I) => fun z : I → Cell M r => z t) (slotTupleKernel M r p)) have hp : ∀ᵐ p ∂M.parameterLaw 1, P p := (slotTuple_marginal M hI r).and (slotTuple_proper M r) have hn : NullMeasurableSet {p | P p} (M.parameterLaw 1) := by exact NullMeasurableSet.congr (nullMeasurableSet_univ (μ := M.parameterLaw 1)) (by filter_upwards [hp] with p h; exact propext (iff_of_true trivial h)) obtain ⟨D,hD,hDm,he⟩ := hn.exists_measurable_subset_ae_eq refine ⟨D,hDm,?_,fun p h => (hD h).1,fun p h => (hD h).2⟩ filter_upwards [hp,he] with p hp he exact he.mpr hp end ArrayObjects.Object.Rolled end section open MeasureTheory ProbabilityTheory Set variable {P U Y I : Type*} [MeasurableSpace P] [MeasurableSpace U] [MeasurableSpace Y] [Fintype I] [DecidableEq I] (κ : Kernel U Y) [IsMarkovKernel κ] (Λ : Kernel P (I → Y)) [IsMarkovKernel Λ] (u : P → I → U) (hu : Measurable u) def productTupleKernel : Kernel P (I → Y) := FiniteKernel.pi (fun i => κ.comap (fun p => u p i) ((measurable_pi_apply i).comp hu)) instance : IsMarkovKernel (productTupleKernel κ u hu) := inferInstanceAs (IsMarkovKernel (FiniteKernel.pi _)) include hu in lemma exists_good_tuple_kernel (μ : Measure P) (hm : ∀ᵐ p ∂μ, ∀ i, MeasurePreserving (fun y : I → Y => y i) (Λ p) (κ (u p i))) (hind : ∀ᵐ p ∂μ, ∀ i, iIndepFun (fun j : (Finset.univ.erase i : Finset I) => fun y : I → Y => y j) (Λ p)) : ∃ Λ' : Kernel P (I → Y), IsMarkovKernel Λ' ∧ Λ' =ᵐ[μ] Λ ∧ (∀ p i, MeasurePreserving (fun y : I → Y => y i) (Λ' p) (κ (u p i))) ∧ (∀ p i, iIndepFun (fun j : (Finset.univ.erase i : Finset I) => fun y : I → Y => y j) (Λ' p)) := by classical let Q := fun p => (∀ i, MeasurePreserving (fun y : I → Y => y i) (Λ p) (κ (u p i))) ∧ (∀ i, iIndepFun (fun j : (Finset.univ.erase i : Finset I) => fun y : I → Y => y j) (Λ p)) have hq : ∀ᵐ p ∂μ, Q p := hm.and hind have hn : NullMeasurableSet {p | Q p} μ := NullMeasurableSet.congr (nullMeasurableSet_univ (μ := μ)) (by filter_upwards [hq] with p h; exact propext (iff_of_true trivial h)) obtain ⟨D,hD,hDm,he⟩ := hn.exists_measurable_subset_ae_eq let L := Kernel.piecewise hDm Λ (productTupleKernel κ u hu) have hlm (p) (i) : MeasurePreserving (fun y : I → Y => y i) (L p) (κ (u p i)) := by by_cases hp : p ∈ D · simpa only [L,Kernel.piecewise_apply,ite_eq_left hp] using (hD hp).1 i · simpa only [L,Kernel.piecewise_apply,ite_eq_right hp,productTupleKernel,FiniteKernel.pi_apply, Kernel.comap_apply] using (measurePreserving_eval (fun i => κ (u p i)) i) have hli (p) (i) : iIndepFun (fun j : (Finset.univ.erase i : Finset I) => fun y : I → Y => y j) (L p) := by by_cases hp : p ∈ D · simpa only [L,Kernel.piecewise_apply,ite_eq_left hp] using (hD hp).2 i · simp only [L,Kernel.piecewise_apply,ite_eq_right hp,productTupleKernel,FiniteKernel.pi_apply,Kernel.comap_apply] exact (iIndepFun_pi (μ := fun i => κ (u p i)) (fun _ => measurable_id.aemeasurable)).precomp Subtype.val_injective refine ⟨L,inferInstance,?_,hlm,hli⟩ filter_upwards [hq,he] with p hp he exact (Kernel.piecewise_apply p).trans (ite_eq_left (he.mpr hp)) end namespace ArrayObjects.Object.Rolled open MeasureTheory ProbabilityTheory Set section universe u variable {I : Type u} [Fintype I] [DecidableEq I] {X : StandardSpace.{u}} {T : X ≃ᵐ X} {base : InitialLaws I X T} (M : Object I base) def rawTuple (y : Arr I M.Y 1) : I → Arr I M.Y 0 := fun j => plane 0 0 j y omit [DecidableEq I] in @[fun_prop] lemma measurable_rawTuple : Measurable (rawTuple M) := Measurable.of_eval fun _ => measurable_plane _ _ _ def rawTupleKernel : Kernel (Arr I M.U 1) (I → Arr I M.Y 0) := (M.ownKernel 1).map (rawTuple M) instance : IsMarkovKernel (rawTupleKernel M) := Kernel.IsMarkovKernel.map _ (measurable_rawTuple M) omit [DecidableEq I] in lemma rawTuple_marginal (hI : 2 ≤ Fintype.card I) : ∀ᵐ p ∂M.parameterLaw 1, ∀ j, MeasurePreserving (fun z : I → Arr I M.Y 0 => z j) (rawTupleKernel M p) (M.ownKernel 0 (tupleParameter M p j)) := by have h (j : I) := ConditionalFibres.marginal (measurable_plane 0 0 j) (M.ownKernel_conditional 1) (M.plane_conditional hI 0 j) filter_upwards [ae_all_iff.mpr h] with p hp j refine ⟨measurable_pi_apply j,?_⟩ rw [rawTupleKernel,Kernel.map_apply _ (measurable_rawTuple M), Measure.map_map (measurable_pi_apply j) (measurable_rawTuple M)] exact (hp j).map_eq lemma rawTuple_proper : ∀ᵐ p ∂M.parameterLaw 1, ∀ j, iIndepFun (fun t : (Finset.univ.erase j : Finset I) => fun z : I → Arr I M.Y 0 => z t) (rawTupleKernel M p) := by filter_upwards [ae_all_iff.mpr (tuple_planes_product M)] with p hp j rw [rawTupleKernel,Kernel.map_apply _ (measurable_rawTuple M)] apply (iIndepFun_map_iff_measurable (J := ↥(Finset.univ.erase j)) _ _ _ (fun t => measurable_pi_apply (t : I)) (measurable_rawTuple M)).mpr have h := iIndepFun_pi (μ := fun t : (Finset.univ.erase j : Finset I) => M.ownKernel 0 (plane 0 0 t p)) (fun _ : (Finset.univ.erase j : Finset I) => measurable_id.aemeasurable) rw [←(hp j).map_eq] at h exact (iIndepFun_map_iff_measurable (M.ownKernel 1 p) (fun (b : ↥(Finset.univ.erase j : Finset I) → Arr I M.Y 0) t => b t) (planes 0 (Finset.univ.erase j)) (fun t => measurable_pi_apply t) (measurable_planes 0 _)).mp h lemma raw_good_tuple_kernel (hI : 2 ≤ Fintype.card I) : ∃ Λ : Kernel (Arr I M.U 1) (I → Arr I M.Y 0), IsMarkovKernel Λ ∧ Λ =ᵐ[M.parameterLaw 1] rawTupleKernel M ∧ (∀ p j, MeasurePreserving (fun y : I → Arr I M.Y 0 => y j) (Λ p) (M.ownKernel 0 (tupleParameter M p j))) ∧ (∀ p j, iIndepFun (fun t : (Finset.univ.erase j : Finset I) => fun y : I → Arr I M.Y 0 => y t) (Λ p)) := exists_good_tuple_kernel (M.ownKernel 0) (rawTupleKernel M) (tupleParameter M) (measurable_tupleParameter M) (M.parameterLaw 1) (rawTuple_marginal M hI) (rawTuple_proper M) end universe u variable {I : Type u} [Fintype I] {X : StandardSpace.{u}} {T : X ≃ᵐ X} {base : InitialLaws I X T} (M : Object I base) lemma rawTuple_time_commute : rawTuple M ∘ amap M.timeY 1 = (fun y : I → Arr I M.Y 0 => fun i => amap M.timeY 0 (y i)) ∘ rawTuple M := rfl lemma rawTuple_time_preserving : ∀ᵐ p ∂M.parameterLaw 1, MeasurePreserving (fun y : I → Arr I M.Y 0 => fun i => amap M.timeY 0 (y i)) (rawTupleKernel M p) (rawTupleKernel M (amap M.timeU 1 p)) := by filter_upwards [M.ownKernel_time_preserving 1] with p hp have htime : Measurable (fun y : I → Arr I M.Y 0 => fun i => amap M.timeY 0 (y i)) := Measurable.of_eval fun i => (measurable_amap M.timeY.measurable 0).comp (measurable_pi_apply i) refine ⟨htime,?_⟩ rw [rawTupleKernel,Kernel.map_apply _ (measurable_rawTuple M), Kernel.map_apply _ (measurable_rawTuple M),Measure.map_map htime (measurable_rawTuple M), ←rawTuple_time_commute M,←Measure.map_map (measurable_rawTuple M) (measurable_amap M.timeY.measurable 1),hp.map_eq] lemma tupleParameter_time (p : Arr I M.U 1) (i : I) : tupleParameter M (amap M.timeU 1 p) i = amap M.timeU 0 (tupleParameter M p i) := rfl lemma goodTuple_time_preserving (Λ : Kernel (Arr I M.U 1) (I → Arr I M.Y 0)) [IsMarkovKernel Λ] (hL : Λ =ᵐ[M.parameterLaw 1] rawTupleKernel M) : ∀ᵐ p ∂M.parameterLaw 1, MeasurePreserving (fun y : I → Arr I M.Y 0 => fun i => amap M.timeY 0 (y i)) (Λ p) (Λ (amap M.timeU 1 p)) := by filter_upwards [rawTuple_time_preserving M,hL, (M.parameterLaw_invariant 1).quasiMeasurePreserving.ae hL] with p hp h1 h2 rw [h1,h2]; exact hp lemma exactCode_time (Λ : Kernel (Arr I M.U 1) (I → Arr I M.Y 0)) [IsMarkovKernel Λ] (hL : Λ =ᵐ[M.parameterLaw 1] rawTupleKernel M) (hm : ∀ p j, MeasurePreserving (fun y : I → Arr I M.Y 0 => y j) (Λ p) (M.ownKernel 0 (tupleParameter M p j))) : ∀ᵐ p ∂M.parameterLaw 1, ∀ q : I → HilbertCode (M.ownKernel 0), (p,q) ∈ exactCodeSet (M.ownKernel 0) Λ (tupleParameter M) → (amap M.timeU 1 p,fun i => HilbertCode.transport (amap M.timeU 0) (amapEquiv M.timeY 0) (q i)) ∈ exactCodeSet (M.ownKernel 0) Λ (tupleParameter M) := by have hk (i : I) : ∀ᵐ p ∂M.parameterLaw 1, MeasurePreserving (amap M.timeY 0) (M.ownKernel 0 (tupleParameter M p i)) (M.ownKernel 0 (amap M.timeU 0 (tupleParameter M p i))) := (show MeasurePreserving (plane 0 0 i) (M.parameterLaw 1) (M.parameterLaw 0) from ⟨measurable_plane _ _ _,M.parameterLaw_consistent _ _ _⟩).quasiMeasurePreserving.ae (M.ownKernel_time_preserving 0) filter_upwards [ae_all_iff.mpr hk,goodTuple_time_preserving M Λ hL] with p hp hΛ q hq exact exactCode_transport (M.ownKernel 0) Λ (tupleParameter M) (amap M.timeU 0) (amapEquiv M.timeY 0) p (amap M.timeU 1 p) (tupleParameter_time M p) hp hΛ (hm p) q hq end ArrayObjects.Object.Rolled section open MeasureTheory ProbabilityTheory Set variable {P U Y I : Type*} [MeasurableSpace P] [MeasurableSpace U] [MeasurableSpace Y] [MeasurableSpace.CountablyGenerated Y] [Fintype I] (κ : Kernel U Y) [IsMarkovKernel κ] (Λ : Kernel P (I → Y)) (u : P → I → U) def exactCodeEquivTransport (F : U ≃ᵐ U) (E : Y ≃ᵐ Y) (p p' : P) (hu : ∀ i, u p' i = F (u p i)) (hκ : ∀ i, MeasurePreserving E (κ (u p i)) (κ (F (u p i)))) (hΛ : MeasurePreserving (fun y : I → Y => fun i => E (y i)) (Λ p) (Λ p')) (hm : ∀ i, MeasurePreserving (fun y : I → Y => y i) (Λ p) (κ (u p i))) (hm' : ∀ i, MeasurePreserving (fun y : I → Y => y i) (Λ p') (κ (u p' i))) : {q : I → HilbertCode κ // (p,q) ∈ exactCodeSet κ Λ u} ≃ {q : I → HilbertCode κ // (p',q) ∈ exactCodeSet κ Λ u} := by have hu' (i) : u p i = F.symm (u p' i) := by rw [hu i,F.symm_apply_apply] have hκ' (i) : MeasurePreserving E.symm (κ (u p' i)) (κ (F.symm (u p' i))) := by rw [hu i,F.symm_apply_apply] exact MeasurePreserving.symm E (hκ i) have hΛ' : MeasurePreserving (fun y : I → Y => fun i => E.symm (y i)) (Λ p') (Λ p) := MeasurePreserving.symm (MeasurableEquiv.piCongrRight (fun _ : I => E)) hΛ refine { toFun := fun q => ⟨fun i => HilbertCode.transport F E (q.val i), exactCode_transport κ Λ u F E p p' hu hκ hΛ hm q.val q.property⟩ invFun := fun q => ⟨fun i => HilbertCode.transport F.symm E.symm (q.val i), exactCode_transport κ Λ u F.symm E.symm p' p hu' hκ' hΛ' hm' q.val q.property⟩ left_inv := ?_ right_inv := ?_ } · intro q apply Subtype.ext funext i apply HilbertCode.transport_inverse F E (q.val i) (q.property.2.1 i).2 (q.property.2.1 i).1 rw [q.property.1 i] exact hκ i · intro q apply Subtype.ext funext i have h := HilbertCode.transport_inverse F.symm E.symm (q.val i) (q.property.2.1 i).2 (q.property.2.1 i).1 apply h rw [q.property.1 i] exact hκ' i end section open MeasureTheory Set attribute [local instance] instMeasurableSpaceCircle_circleLp instBorelSpaceCircle_circleLp variable (Y : Type*) [MeasurableSpace Y] def measurableCircleSubgroup : Subgroup (Y → Circle) where carrier := {f | Measurable f} one_mem' := measurable_const mul_mem' := fun hf hg => hf.mul hg inv_mem' := fun hf => hf.inv abbrev MeasurableCircle := measurableCircleSubgroup Y instance measurableCircleCoeFun : CoeFun (MeasurableCircle Y) (fun _ => Y → Circle) := ⟨fun f => f.val⟩ lemma measurableCircle_measurable (f : MeasurableCircle Y) : Measurable (f : Y → Circle) := f.property variable {Y} (μ : Measure Y) def phaseSubgroup : Subgroup (MeasurableCircle Y) where carrier := {f | ∃ c : Circle, (f : Y → Circle) =ᵐ[μ] fun _ => c} one_mem' := ⟨1,Filter.Eventually.of_forall fun _ => rfl⟩ mul_mem' := by rintro f g ⟨a,ha⟩ ⟨b,hb⟩ refine ⟨a*b,?_⟩ filter_upwards [ha,hb] with y hfy hgy exact congrArg₂ (·*·) hfy hgy inv_mem' := by rintro f ⟨a,ha⟩ refine ⟨a⁻¹,?_⟩ filter_upwards [ha] with y hy exact congrArg Inv.inv hy abbrev ProjectiveCircle := MeasurableCircle Y ⧸ phaseSubgroup μ def projectiveCircle (f : Y → Circle) (hf : Measurable f) : ProjectiveCircle μ := QuotientGroup.mk (⟨f,hf⟩ : MeasurableCircle Y) lemma projectiveCircle_eq_iff (f g : Y → Circle) (hf : Measurable f) (hg : Measurable g) : projectiveCircle μ f hf = projectiveCircle μ g hg ↔ ∃ c : Circle, f =ᵐ[μ] fun y => c*g y := by change (QuotientGroup.mk (⟨f,hf⟩ : MeasurableCircle Y) = QuotientGroup.mk (⟨g,hg⟩ : MeasurableCircle Y)) ↔ _ rw [QuotientGroup.eq] change (∃ c : Circle, (fun y => (f y)⁻¹ * g y) =ᵐ[μ] fun _ => c) ↔ _ constructor · rintro ⟨c,hc⟩ refine ⟨c⁻¹,?_⟩ filter_upwards [hc] with y hy apply eq_inv_mul_iff_mul_eq.mpr exact (mul_comm c (f y)).trans (inv_mul_eq_iff_eq_mul.mp hy).symm · rintro ⟨c,hc⟩ refine ⟨c⁻¹,?_⟩ filter_upwards [hc] with y hy rw [hy,mul_inv_rev] simp [mul_comm] lemma projectiveCircle_mul (f g : Y → Circle) (hf : Measurable f) (hg : Measurable g) : projectiveCircle μ (fun y => f y * g y) (hf.mul hg) = projectiveCircle μ f hf * projectiveCircle μ g hg := rfl lemma projectiveCircle_one : projectiveCircle μ (fun _ : Y => 1) measurable_const = 1 := rfl lemma projectiveCircle_inv (f : Y → Circle) (hf : Measurable f) : projectiveCircle μ (fun y => (f y)⁻¹) hf.inv = (projectiveCircle μ f hf)⁻¹ := rfl end section open MeasureTheory ProbabilityTheory Set open scoped BigOperators attribute [local instance] instMeasurableSpaceCircle_circleLp instBorelSpaceCircle_circleLp variable {Y I : Type*} [MeasurableSpace Y] [Fintype I] def exactCircleTuples (μ : Measure (I → Y)) : Subgroup (I → MeasurableCircle Y) where carrier := {f | ∃ c : Circle, ∀ᵐ y ∂μ, ∏ i, f i (y i) = c} one_mem' := ⟨1,Filter.Eventually.of_forall fun _ => by simp⟩ mul_mem' := by rintro f g ⟨c,hc⟩ ⟨d,hd⟩ refine ⟨c*d,?_⟩ filter_upwards [hc,hd] with y hy hz change (∏ i, f i (y i) * g i (y i)) = c*d rw [Finset.prod_mul_distrib,hy,hz] inv_mem' := by rintro f ⟨c,hc⟩ refine ⟨c⁻¹,?_⟩ filter_upwards [hc] with y hy change (∏ i, (f i (y i))⁻¹) = c⁻¹ rw [Finset.prod_inv_distrib,hy] def tupleProjectivize (ν : I → Measure Y) : (I → MeasurableCircle Y) →* (∀ i, ProjectiveCircle (ν i)) where toFun := fun f i => QuotientGroup.mk (f i) map_one' := rfl map_mul' := fun _ _ => rfl def exactProjectiveTuples (μ : Measure (I → Y)) (ν : I → Measure Y) : Subgroup (∀ i, ProjectiveCircle (ν i)) := (exactCircleTuples μ).map (tupleProjectivize ν) def exactProjectiveSlot (μ : Measure (I → Y)) (ν : I → Measure Y) (i : I) : exactProjectiveTuples μ ν →* ProjectiveCircle (ν i) where toFun := fun a => a.val i map_one' := rfl map_mul' := fun _ _ => rfl variable [DecidableEq I] lemma exactCircleTuples_constant_of_slot (hk : 3 ≤ Fintype.card I) (μ : Measure (I → Y)) [IsProbabilityMeasure μ] (ν : I → Measure Y) (hm : ∀ i, MeasurePreserving (fun y : I → Y => y i) μ (ν i)) (hind : ∀ i, iIndepFun (fun j : (Finset.univ.erase i : Finset I) => fun y : I → Y => y j) μ) (f : I → MeasurableCircle Y) (hf : f ∈ exactCircleTuples μ) (i : I) (hi : projectiveCircle (ν i) (f i) (measurableCircle_measurable Y (f i)) = 1) : ∀ j, projectiveCircle (ν j) (f j) (measurableCircle_measurable Y (f j)) = 1 := by have hpm (j : I) : Measurable (fun y : I → Y => (f j (y j) : ℂ)) := measurable_subtype_coe.comp ((measurableCircle_measurable Y (f j)).comp (measurable_pi_apply j)) have hpn (j : I) : ∀ᵐ y ∂μ, ‖(f j (y j) : ℂ)‖ = 1 := Filter.Eventually.of_forall fun _ => Circle.norm_coe _ have hpi (j : I) : iIndepFun (fun t : (Finset.univ.erase j : Finset I) => fun y : I → Y => (f t (y t) : ℂ)) μ := (hind j).comp (fun t y => (f t y : ℂ)) (fun t => measurable_subtype_coe.comp (measurableCircle_measurable Y (f t))) obtain ⟨c,hc⟩ := hf have hc' : ∀ᵐ y ∂μ, ∏ j, (f j (y j) : ℂ) = (c : ℂ) := by filter_upwards [hc] with y hy exact (map_prod Circle.coeHom _ _).symm.trans (congrArg (fun a : Circle => (a : ℂ)) hy) have hx := exact_tuple_dichotomy hk (fun j (y : I → Y) => (f j (y j) : ℂ)) (fun j => (hpm j).aestronglyMeasurable) hpn hpi (c : ℂ) (Circle.norm_coe c) hc' have hi' : ∃ d : Circle, (f i : Y → Circle) =ᵐ[ν i] fun _ => d := by rw [←projectiveCircle_one (ν i),projectiveCircle_eq_iff] at hi simpa only [mul_one] using hi obtain ⟨d,hd⟩ := hi' have hdi : (fun y : I → Y => (f i (y i) : ℂ)) =ᵐ[μ] fun _ => (d : ℂ) := ((hm i).quasiMeasurePreserving.ae_eq_comp hd).mono fun _ h => congrArg (fun a : Circle => (a : ℂ)) h rcases hx with hz | he · have hh := hz i rw [integral_congr_ae hdi,integral_const,probReal_univ,one_smul] at hh have hn := Circle.norm_coe d rw [hh,norm_zero] at hn norm_num at hn · intro j let a : Circle := ⟨∫ y, (f j (y j) : ℂ) ∂μ,mem_sphere_zero_iff_norm.mpr (he j).2⟩ have hj : ∀ᵐ y ∂μ, f j (y j) = a := (he j).1.mono fun _ h => Circle.coe_injective h have hj' : (f j : Y → Circle) =ᵐ[ν j] fun _ => a := by rw [←(hm j).map_eq] apply (ae_map_iff (hm j).measurable.aemeasurable (measurableSet_eq_fun (measurableCircle_measurable Y (f j)) measurable_const)).mpr exact hj rw [←projectiveCircle_one (ν j),projectiveCircle_eq_iff] exact ⟨a,by simpa only [mul_one] using hj'⟩ lemma exactProjectiveSlot_injective (hk : 3 ≤ Fintype.card I) (μ : Measure (I → Y)) [IsProbabilityMeasure μ] (ν : I → Measure Y) (hm : ∀ i, MeasurePreserving (fun y : I → Y => y i) μ (ν i)) (hind : ∀ i, iIndepFun (fun j : (Finset.univ.erase i : Finset I) => fun y : I → Y => y j) μ) (i : I) : Function.Injective (exactProjectiveSlot μ ν i) := by apply (injective_iff_map_eq_one _).mpr intro a ha obtain ⟨f,hf,hfa⟩ := a.property have hi : projectiveCircle (ν i) (f i) (measurableCircle_measurable Y (f i)) = 1 := by change tupleProjectivize ν f i = 1 rw [hfa] exact ha apply Subtype.ext funext j have hj := exactCircleTuples_constant_of_slot hk μ ν hm hind f hf i hi j change (a : ∀ j, ProjectiveCircle (ν j)) j = 1 rw [←hfa] exact hj def exactProjectiveMatching (hk : 3 ≤ Fintype.card I) (μ : Measure (I → Y)) [IsProbabilityMeasure μ] (ν : I → Measure Y) (hm : ∀ i, MeasurePreserving (fun y : I → Y => y i) μ (ν i)) (hind : ∀ i, iIndepFun (fun j : (Finset.univ.erase i : Finset I) => fun y : I → Y => y j) μ) (i j : I) : (exactProjectiveSlot μ ν i).range ≃* (exactProjectiveSlot μ ν j).range := (MonoidHom.ofInjective (exactProjectiveSlot_injective hk μ ν hm hind i)).symm.trans (MonoidHom.ofInjective (exactProjectiveSlot_injective hk μ ν hm hind j)) end section open MeasureTheory ProbabilityTheory Set open scoped BigOperators attribute [local instance] instMeasurableSpaceCircle_circleLp instBorelSpaceCircle_circleLp variable {P U Y I : Type*} [MeasurableSpace P] [MeasurableSpace U] [MeasurableSpace Y] [MeasurableSpace.CountablyGenerated Y] [Fintype I] [DecidableEq I] (κ : Kernel U Y) [IsMarkovKernel κ] (Λ : Kernel P (I → Y)) [IsMarkovKernel Λ] (u : P → I → U) namespace HilbertCode variable {κ} def projective (u : U) (q : HilbertCode κ) : ProjectiveCircle (κ u) := projectiveCircle (κ u) (circleRep q) (measurable_circleRep_fixed q) lemma projective_injective {u : U} {q r : HilbertCode κ} (hbq : q.base = u) (hbr : r.base = u) (hcq : q.IsCanonical) (hcr : r.IsCanonical) (huq : q.IsUnimodular) (hur : r.IsUnimodular) (he : projective u q = projective u r) : q = r := by obtain ⟨c,hc⟩ := (projectiveCircle_eq_iff (κ u) _ _ _ _).mp he have hq := circleRep_ae q huq have hr := circleRep_ae r hur rw [hbq] at hq rw [hbr] at hr apply eq_of_decode_smul (hbq.trans hbr.symm) hcq hcr (Circle.norm_coe c) rw [hbq] filter_upwards [hc,hq,hr] with y hy hqy hry rw [←hqy,hy] change (c : ℂ) * (circleRep r y : ℂ) = (c : ℂ) * representative (r,y) rw [hry] lemma projective_encode_phase {u : U} (f : Y → Circle) (hf : Measurable f) (d : ℂ) (hd : ‖d‖ = 1) (q : HilbertCode κ) (he : q = encode u (d • circleLp (κ u) f hf)) (hu : q.IsUnimodular) : projective u q = projectiveCircle (κ u) f hf := by let c : Circle := ⟨d,mem_sphere_zero_iff_norm.mpr hd⟩ apply (projectiveCircle_eq_iff (κ u) _ _ _ _).mpr refine ⟨c,?_⟩ have hb : q.base = u := by rw [he]; rfl have hr := representative_eq_decode (encode u (d • circleLp (κ u) f hf)) change (fun y => representative (encode u (d • circleLp (κ u) f hf),y)) =ᵐ[κ u] fun y => (decode (encode u (d • circleLp (κ u) f hf)) : Lp ℂ 2 (κ u)) y at hr rw [decode_encode] at hr have hcircle := circleRep_ae q hu rw [hb] at hcircle filter_upwards [hcircle,hr,Lp.coeFn_smul d (circleLp (κ u) f hf),circleLp_coe (κ u) f hf] with y h1 h2 h3 h4 apply Circle.coe_injective change (circleRep q y : ℂ) = d * (f y : ℂ) exact h1.trans ((congrArg (fun z : HilbertCode κ => representative (z,y)) he).trans (h2.trans (h3.trans (congrArg (d * ·) h4)))) end HilbertCode omit [DecidableEq I] in lemma exact_code_projective_mem {p : P} {a : I → HilbertCode κ} (hm : ∀ i, MeasurePreserving (fun y : I → Y => y i) (Λ p) (κ (u p i))) (ha : (p,a) ∈ exactCodeSet κ Λ u) : (fun i => HilbertCode.projective (u p i) (a i)) ∈ exactProjectiveTuples (Λ p) (fun i => κ (u p i)) := by obtain ⟨c,hc⟩ := exactCode_circle_tuple κ Λ u hm ha refine ⟨(fun i => ⟨HilbertCode.circleRep (a i),HilbertCode.measurable_circleRep_fixed (a i)⟩),?_,rfl⟩ exact ⟨c,hc⟩ omit [DecidableEq I] in lemma exact_projective_has_codes (p : P) (hm : ∀ i, MeasurePreserving (fun y : I → Y => y i) (Λ p) (κ (u p i))) (v : exactProjectiveTuples (Λ p) (fun i => κ (u p i))) : ∃ a : I → HilbertCode κ, (p,a) ∈ exactCodeSet κ Λ u ∧ ∀ i, HilbertCode.projective (u p i) (a i) = v.val i := by obtain ⟨f,hf,hfv⟩ := v.property obtain ⟨c,hc⟩ := hf obtain ⟨a,d,ha,hd⟩ := normalized_exact_codes κ Λ u p hm (fun i => f i) (fun i => (measurableCircle_measurable Y (f i))) c hc refine ⟨a,ha,?_⟩ intro i have he := HilbertCode.projective_encode_phase (κ := κ) (f i) (measurableCircle_measurable Y (f i)) (d i) (hd i).1 (a i) (hd i).2 (ha.2.1 i).2 exact he.trans (congrFun hfv i) end section open MeasureTheory ProbabilityTheory Set variable {P U Y I : Type*} [MeasurableSpace P] [StandardBorelSpace P] [MeasurableSpace U] [StandardBorelSpace U] [MeasurableSpace Y] [MeasurableSpace.CountablyGenerated Y] [Fintype I] [DecidableEq I] (κ : Kernel U Y) [IsMarkovKernel κ] (Λ : Kernel P (I → Y)) [IsMarkovKernel Λ] (u : P → I → U) omit [StandardBorelSpace U] in lemma HilbertCode.distance_self (q : HilbertCode κ) : HilbertCode.distance q q = 0 := by rw [←HilbertCode.encode_decode q,HilbertCode.distance_encode,dist_self] omit [StandardBorelSpace P] [StandardBorelSpace U] in lemma exactCode_unique_slot (hk : 3 ≤ Fintype.card I) (hm : ∀ p i, MeasurePreserving (fun y : I → Y => y i) (Λ p) (κ (u p i))) (hind : ∀ p i, iIndepFun (fun j : (Finset.univ.erase i : Finset I) => fun y : I → Y => y j) (Λ p)) {p : P} {a b : I → HilbertCode κ} (ha : (p,a) ∈ exactCodeSet κ Λ u) (hb : (p,b) ∈ exactCodeSet κ Λ u) (i : I) (hi : a i = b i) : a = b := by rcases HilbertCode.exact_codes_dichotomy hk (Λ p) a b (fun j => (ha.1 j).trans (hb.1 j).symm) ha.2.1 hb.2.1 (fun j => by simpa only [ha.1 j] using hm p j) (hind p) ha.2.2 hb.2.2 with h | h · exact h · have h := h i rw [hi,HilbertCode.distance_self] at h norm_num at h lemma exactCode_slot_embedding (hu : Measurable u) (hk : 3 ≤ Fintype.card I) (hm : ∀ p i, MeasurePreserving (fun y : I → Y => y i) (Λ p) (κ (u p i))) (hind : ∀ p i, iIndepFun (fun j : (Finset.univ.erase i : Finset I) => fun y : I → Y => y j) (Λ p)) (i : I) : MeasurableEmbedding (fun t : ExactCodeTuple κ Λ u => (t.1.1,t.1.2 i)) := by let : StandardBorelSpace (ExactCodeTuple κ Λ u) := (measurableSet_exactCodeSet κ Λ u hu).standardBorel apply Measurable.measurableEmbedding (measurable_subtype_coe.fst.prodMk ((measurable_pi_apply i).comp measurable_subtype_coe.snd)) intro a b hab have hp : a.1.1 = b.1.1 := congrArg (fun x : P × HilbertCode κ => x.1) hab have hi : a.1.2 i = b.1.2 i := congrArg (fun x : P × HilbertCode κ => x.2) hab have hb : (a.1.1,b.1.2) ∈ exactCodeSet κ Λ u := by rw [hp]; exact b.property exact Subtype.ext (Prod.ext hp (exactCode_unique_slot κ Λ u hk hm hind a.property hb i hi)) def exactMatching (i : I) : P × HilbertCode κ → I → HilbertCode κ := Function.extend (fun t : ExactCodeTuple κ Λ u => (t.1.1,t.1.2 i)) (fun t => t.1.2) (fun pq j => HilbertCode.encode (u pq.1 j) 0) lemma measurable_exactMatching (hu : Measurable u) (hk : 3 ≤ Fintype.card I) (hm : ∀ p i, MeasurePreserving (fun y : I → Y => y i) (Λ p) (κ (u p i))) (hind : ∀ p i, iIndepFun (fun j : (Finset.univ.erase i : Finset I) => fun y : I → Y => y j) (Λ p)) (i : I) : Measurable (exactMatching κ Λ u i) := by apply (exactCode_slot_embedding κ Λ u hu hk hm hind i).measurable_extend measurable_subtype_coe.snd apply Measurable.of_eval intro j exact MeasurableSection.zero (((measurable_pi_apply j).comp hu).comp measurable_fst) lemma exactMatching_exact (hu : Measurable u) (hk : 3 ≤ Fintype.card I) (hm : ∀ p i, MeasurePreserving (fun y : I → Y => y i) (Λ p) (κ (u p i))) (hind : ∀ p i, iIndepFun (fun j : (Finset.univ.erase i : Finset I) => fun y : I → Y => y j) (Λ p)) (i : I) {p : P} {a : I → HilbertCode κ} (ha : (p,a) ∈ exactCodeSet κ Λ u) : exactMatching κ Λ u i (p,a i) = a := (exactCode_slot_embedding κ Λ u hu hk hm hind i).injective.extend_apply _ _ ⟨(p,a),ha⟩ end section open MeasureTheory ProbabilityTheory Set attribute [local instance] instMeasurableSpaceCircle_circleLp instBorelSpaceCircle_circleLp variable {P U Y I : Type*} [MeasurableSpace P] [MeasurableSpace U] [MeasurableSpace Y] [MeasurableSpace.CountablyGenerated Y] [Fintype I] [DecidableEq I] (κ : Kernel U Y) [IsMarkovKernel κ] (Λ : Kernel P (I → Y)) [IsMarkovKernel Λ] (u : P → I → U) abbrev ExactCodeSlot (p : P) (i : I) := {q : HilbertCode κ // ∃ a : I → HilbertCode κ, (p,a) ∈ exactCodeSet κ Λ u ∧ a i = q} omit [DecidableEq I] in lemma codeSlot_projective_range (p : P) (hm : ∀ i, MeasurePreserving (fun y : I → Y => y i) (Λ p) (κ (u p i))) (i : I) : {g : ProjectiveCircle (κ (u p i)) | ∃ q : ExactCodeSlot κ Λ u p i, HilbertCode.projective (u p i) q.val = g} = (exactProjectiveSlot (Λ p) (fun j => κ (u p j)) i).range := by ext g constructor · rintro ⟨q,hq⟩ obtain ⟨a,ha,hai⟩ := q.property let v : exactProjectiveTuples (Λ p) (fun j => κ (u p j)) := ⟨fun j => HilbertCode.projective (u p j) (a j),exact_code_projective_mem κ Λ u hm ha⟩ exact ⟨v,by change HilbertCode.projective (u p i) (a i) = g; rw [hai,hq]⟩ · rintro ⟨v,hv⟩ obtain ⟨a,ha,he⟩ := exact_projective_has_codes κ Λ u p hm v exact ⟨⟨a i,a,ha,rfl⟩,(he i).trans hv⟩ omit [DecidableEq I] [IsMarkovKernel Λ] in lemma codeSlot_projective_injective (p : P) (i : I) : Function.Injective (fun q : ExactCodeSlot κ Λ u p i => HilbertCode.projective (u p i) q.val) := by intro q r he obtain ⟨a,ha,hai⟩ := q.property obtain ⟨b,hb,hbi⟩ := r.property apply Subtype.ext change HilbertCode.projective (u p i) q.val = HilbertCode.projective (u p i) r.val at he rw [←hai,←hbi] at he ⊢ exact HilbertCode.projective_injective (ha.1 i) (hb.1 i) (ha.2.1 i).1 (hb.2.1 i).1 (ha.2.1 i).2 (hb.2.1 i).2 he def codeSlotEquivProjective (p : P) (hm : ∀ i, MeasurePreserving (fun y : I → Y => y i) (Λ p) (κ (u p i))) (i : I) : ExactCodeSlot κ Λ u p i ≃ (exactProjectiveSlot (Λ p) (fun j => κ (u p j)) i).range := by let f : ExactCodeSlot κ Λ u p i → (exactProjectiveSlot (Λ p) (fun j => κ (u p j)) i).range := fun q => ⟨HilbertCode.projective (u p i) q.val,by exact (Set.ext_iff.mp (codeSlot_projective_range κ Λ u p hm i) _).mp ⟨q,rfl⟩⟩ apply Equiv.ofBijective f constructor · intro q r he exact codeSlot_projective_injective κ Λ u p i (congrArg Subtype.val he) · intro v have hv := v.property have hv := (Set.ext_iff.mp (codeSlot_projective_range κ Λ u p hm i) v.val).mpr hv obtain ⟨q,hq⟩ := hv exact ⟨q,Subtype.ext hq⟩ def codeSlotMatching (hk : 3 ≤ Fintype.card I) (p : P) (hm : ∀ j, MeasurePreserving (fun y : I → Y => y j) (Λ p) (κ (u p j))) (hind : ∀ j, iIndepFun (fun t : (Finset.univ.erase j : Finset I) => fun y : I → Y => y t) (Λ p)) (i j : I) : ExactCodeSlot κ Λ u p i ≃ ExactCodeSlot κ Λ u p j := (codeSlotEquivProjective κ Λ u p hm i).trans ((exactProjectiveMatching hk (Λ p) (fun j => κ (u p j)) hm hind i j).toEquiv.trans (codeSlotEquivProjective κ Λ u p hm j).symm) end section open MeasureTheory ProbabilityTheory Set variable {P U Y I : Type*} [MeasurableSpace P] [MeasurableSpace U] [MeasurableSpace Y] [MeasurableSpace.CountablyGenerated Y] [Fintype I] (κ : Kernel U Y) [IsMarkovKernel κ] (Λ : Kernel P (I → Y)) (u : P → I → U) lemma exactSlot_transport (F : U → U) (E : Y ≃ᵐ Y) (p p' : P) (hu : ∀ i, u p' i = F (u p i)) (hκ : ∀ i, MeasurePreserving E (κ (u p i)) (κ (F (u p i)))) (hΛ : MeasurePreserving (fun y : I → Y => fun i => E (y i)) (Λ p) (Λ p')) (hm : ∀ i, MeasurePreserving (fun y : I → Y => y i) (Λ p) (κ (u p i))) (i : I) (q : HilbertCode κ) (hq : ∃ a : I → HilbertCode κ, (p,a) ∈ exactCodeSet κ Λ u ∧ a i = q) : ∃ a : I → HilbertCode κ, (p',a) ∈ exactCodeSet κ Λ u ∧ a i = HilbertCode.transport F E q := by obtain ⟨a,ha,hai⟩ := hq exact ⟨fun j => HilbertCode.transport F E (a j), exactCode_transport κ Λ u F E p p' hu hκ hΛ hm a ha,congrArg _ hai⟩ def localGraphTimeEquiv (F : U ≃ᵐ U) (E : Y ≃ᵐ Y) (p p' : P) (hu : ∀ i, u p' i = F (u p i)) (hκ : ∀ i, MeasurePreserving E (κ (u p i)) (κ (F (u p i)))) (hΛ : MeasurePreserving (fun y : I → Y => fun i => E (y i)) (Λ p) (Λ p')) (hm : ∀ p i, MeasurePreserving (fun y : I → Y => y i) (Λ p) (κ (u p i))) (S : Set (U × HilbertCode κ)) (i : I) (hS : ∀ q, (u p i,q) ∈ S ↔ ∃ a : I → HilbertCode κ, (p,a) ∈ exactCodeSet κ Λ u ∧ a i = q) (hS' : ∀ q, (F (u p i),q) ∈ S ↔ ∃ a : I → HilbertCode κ, (p',a) ∈ exactCodeSet κ Λ u ∧ a i = q) : {q : HilbertCode κ // (u p i,q) ∈ S} ≃ {q : HilbertCode κ // (F (u p i),q) ∈ S} := by have hu' (i) : u p i = F.symm (u p' i) := by rw [hu i,F.symm_apply_apply] have hκ' (i) : MeasurePreserving E.symm (κ (u p' i)) (κ (F.symm (u p' i))) := by rw [hu i,F.symm_apply_apply]; exact MeasurePreserving.symm E (hκ i) have hΛ' : MeasurePreserving (fun y : I → Y => fun i => E.symm (y i)) (Λ p') (Λ p) := MeasurePreserving.symm (MeasurableEquiv.piCongrRight (fun _ : I => E)) hΛ refine { toFun := fun q => ⟨HilbertCode.transport F E q.val, (hS' _).mpr (exactSlot_transport κ Λ u F E p p' hu hκ hΛ (hm p) i q.val ((hS _).mp q.property))⟩ invFun := fun q => ⟨HilbertCode.transport F.symm E.symm q.val, (hS _).mpr (exactSlot_transport κ Λ u F.symm E.symm p' p hu' hκ' hΛ' (hm p') i q.val ((hS' _).mp q.property))⟩ left_inv := ?_ right_inv := ?_ } · intro q obtain ⟨a,ha,hai⟩ := (hS _).mp q.property apply Subtype.ext apply HilbertCode.transport_inverse F E q.val · rw [←hai]; exact (ha.2.1 i).2 · rw [←hai]; exact (ha.2.1 i).1 · rw [←hai,ha.1 i]; exact hκ i · intro q obtain ⟨a,ha,hai⟩ := (hS' _).mp q.property apply Subtype.ext apply HilbertCode.transport_inverse F.symm E.symm q.val · rw [←hai]; exact (ha.2.1 i).2 · rw [←hai]; exact (ha.2.1 i).1 · rw [←hai,ha.1 i]; exact hκ' i end section open MeasureTheory ContinuousLinearMap open scoped InnerProductSpace variable {Ω X Y C D H₁ H₂ H₃ H₄ : Type*} [MeasurableSpace Ω] [MeasurableSpace X] [MeasurableSpace Y] [MeasurableSpace C] [MeasurableSpace D] [NormedAddCommGroup H₁] [InnerProductSpace ℂ H₁] [CompleteSpace H₁] [SecondCountableTopology H₁] [NormedAddCommGroup H₂] [InnerProductSpace ℂ H₂] [CompleteSpace H₂] [SecondCountableTopology H₂] [NormedAddCommGroup H₃] [InnerProductSpace ℂ H₃] [CompleteSpace H₃] [SecondCountableTopology H₃] [NormedAddCommGroup H₄] [InnerProductSpace ℂ H₄] [CompleteSpace H₄] [SecondCountableTopology H₄] {μ : Measure Ω} {μX : Measure X} {μY : Measure Y} {μC : Measure C} {μD : Measure D} [SFinite μX] [SFinite μY] [SFinite μC] [SFinite μD] {x : Ω → X} {y : Ω → Y} {c : Ω → C} {d : Ω → D} {F : X → H₂ →L[ℂ] H₁} {G : Y → H₄ →L[ℂ] H₃} {K : C → H₃ →L[ℂ] H₁} {N : D → H₄ →L[ℂ] H₂} lemma rectangle_first_commutes (hx : MeasurePreserving x μ μX) (hy : MeasurePreserving y μ μY) (hc : MeasurePreserving c μ μC) (hd : MeasurePreserving d μ μD) (hcy : MeasurePreserving (fun ω => (c ω, y ω)) μ (μC.prod μY)) (hcx : MeasurePreserving (fun ω => (c ω, x ω)) μ (μC.prod μX)) (hdy : MeasurePreserving (fun ω => (d ω, y ω)) μ (μD.prod μY)) (hdx : MeasurePreserving (fun ω => (d ω, x ω)) μ (μD.prod μX)) (hF : VectorMeasurable F) (hG : VectorMeasurable G) (hK : VectorMeasurable K) (hN : VectorMeasurable N) (h1 : ∀ᵐ ω ∂μ, F (x ω) ∘L N (d ω) = K (c ω) ∘L G (y ω)) (h2 : ∀ᵐ ω ∂μ, (F (x ω)).adjoint ∘L K (c ω) = N (d ω) ∘L (G (y ω)).adjoint) : (essentialRange μX F).starProjection ∘L (essentialRange μC K).starProjection = (essentialRange μC K).starProjection ∘L (essentialRange μX F).starProjection := by have h := rectangle_all_intertwines hx hy hc hd hcy hcx hdy hdx hF hG hK hN h1 h2 exact essentialRange.projection_commutes μX F (essentialRange μD N) (essentialRange μC K) h.2.2.1 end namespace ArrayObjects.Object.Rolled open MeasureTheory ProbabilityTheory ContinuousLinearMap open scoped ENNReal local instance : Fact ((2 : ℝ≥0∞) ≠ ∞) := ⟨by norm_num⟩ universe u variable {I : Type u} [Fintype I] [DecidableEq I] {X : StandardSpace.{u}} {T : X ≃ᵐ X} {base : InitialLaws I X T} (M : Object I base) theorem grouped_active_commutes_corner (hM : M.IsSaturated) (rows cols : TriplePartition I) (n : ℕ) : ∀ᵐ e ∂(M.law (n+2)).map (amap M.par (n+2)), (rowActive M rows.A cols.A cols.P cols.B n e).starProjection ∘L (columnActive M rows.A rows.P rows.B cols.A n e).starProjection = (columnActive M rows.A rows.P rows.B cols.A n e).starProjection ∘L (rowActive M rows.A cols.A cols.P cols.B n e).starProjection := by filter_upwards [grouped_fibre_rectangle M hM rows.P rows.A rows.B cols.P cols.A cols.B rows.cardP rows.disjointPA rows.disjointPB rows.cardPA rows.cardPB rows.properPA rows.properPB cols.disjointPA cols.disjointPB cols.disjointAB cols.cover cols.nonemptyA cols.nonemptyB n, cells_fibre_marginal M hM rows.A cols.P rows.properA n, cells_fibre_marginal M hM rows.B cols.P rows.properB n, cells_fibre_marginal M hM rows.P cols.A rows.properP n, cells_fibre_marginal M hM rows.P cols.B rows.properP n, cells_indep_rows_fibre M hM rows.P rows.A cols.A cols.P rows.disjointPA rows.properPA n, cells_indep_rows_fibre M hM rows.P rows.B cols.A cols.P rows.disjointPB rows.properPB n, cells_indep_rows_fibre M hM rows.P rows.A cols.B cols.P rows.disjointPA rows.properPA n, cells_indep_rows_fibre M hM rows.P rows.B cols.B cols.P rows.disjointPB rows.properPB n] with e hr hx hy hc hd hcx hcy hdx hdy have h := rectangle_first_commutes (F := fibreRowEdge M rows.A cols.P cols.A cols.B n e) (G := fibreRowEdge M rows.B cols.P cols.A cols.B n e) (K := fibreColumnEdge M rows.P rows.A rows.B cols.A n e) (N := fibreColumnEdge M rows.P rows.A rows.B cols.B n e) hx hy hc hd ⟨hc.measurable.prodMk hy.measurable, by rw [←hc.map_eq,←hy.map_eq] exact hcy.map_prod_eq_prod_map_map hc.measurable.aemeasurable hy.measurable.aemeasurable⟩ ⟨hc.measurable.prodMk hx.measurable, by rw [←hc.map_eq,←hx.map_eq] exact hcx.map_prod_eq_prod_map_map hc.measurable.aemeasurable hx.measurable.aemeasurable⟩ ⟨hd.measurable.prodMk hy.measurable, by rw [←hd.map_eq,←hy.map_eq] exact hdy.map_prod_eq_prod_map_map hd.measurable.aemeasurable hy.measurable.aemeasurable⟩ ⟨hd.measurable.prodMk hx.measurable, by rw [←hd.map_eq,←hx.map_eq] exact hdx.map_prod_eq_prod_map_map hd.measurable.aemeasurable hx.measurable.aemeasurable⟩ (fibreRowEdge_measurable M rows.A cols.P cols.A cols.B n e) (fibreRowEdge_measurable M rows.B cols.P cols.A cols.B n e) (fibreColumnEdge_measurable M rows.P rows.A rows.B cols.A n e) (fibreColumnEdge_measurable M rows.P rows.A rows.B cols.B n e) (hr.mono fun _ h => h.1) (hr.mono fun _ h => h.2) exact h lemma grouped_active_commutes (hM : M.IsSaturated) (rows cols : TriplePartition I) (n : ℕ) : ∀ᵐ e ∂(M.law (n+2)).map (amap M.par (n+2)), (rowActive M rows.P cols.P cols.A cols.B n e).starProjection ∘L (columnActive M rows.P rows.A rows.B cols.P n e).starProjection = (columnActive M rows.P rows.A rows.B cols.P n e).starProjection ∘L (rowActive M rows.P cols.P cols.A cols.B n e).starProjection := by exact grouped_active_commutes_corner M hM rows.swapPA cols.swapPA n end ArrayObjects.Object.Rolled section open scoped InnerProductSpace variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] lemma orthogonal_line_projection (S C : Set H) (V : Submodule ℂ H) [V.HasOrthogonalProjection] (hCV : (Submodule.span ℂ C).topologicalClosure = V) (hCS : C ⊆ S) (horth : ∀ v ∈ S, ∀ w ∈ S, inner ℂ v w = 0 ∨ ∃ c : ℂ, v = c • w) {v : H} (hv : v ∈ S) : V.starProjection v = 0 ∨ V.starProjection v = v := by by_cases hm : v ∈ V · exact Or.inr (V.starProjection_eq_self_iff.mpr hm) · left apply V.starProjection_apply_eq_zero_iff.mpr rw [←hCV,Submodule.orthogonal_closure,Submodule.mem_orthogonal'] intro w hw induction hw using Submodule.span_induction with | mem w hw => rcases horth v hv w (hCS hw) with ho | ⟨c,hc⟩ · exact ho · exact (hm (hc.symm ▸ V.smul_mem c (hCV ▸ Submodule.le_topologicalClosure _ (Submodule.subset_span hw)))).elim | zero => simp | add x y hx hy ihx ihy => simp only [inner_add_right,ihx,ihy,add_zero] | smul c x hx ih => simp only [inner_smul_right,ih,mul_zero] lemma inf_projection_on_left (A B : Submodule ℂ H) [A.HasOrthogonalProjection] [B.HasOrthogonalProjection] [(A ⊓ B).HasOrthogonalProjection] (hc : A.starProjection ∘L B.starProjection = B.starProjection ∘L A.starProjection) {v : H} (hv : v ∈ A) : (A ⊓ B).starProjection v = B.starProjection v := by have hin : B.starProjection v ∈ A ⊓ B := by refine ⟨A.starProjection_eq_self_iff.mp ?_,B.starProjection_apply_mem _⟩ have h := congrArg (fun T : H →L[ℂ] H => T v) hc simpa only [ContinuousLinearMap.comp_apply,A.starProjection_eq_self_iff.mpr hv] using h apply (A ⊓ B).eq_starProjection_of_mem_of_inner_eq_zero hin intro w hw exact B.starProjection_inner_eq_zero _ _ hw.2 lemma common_lines_projection (S C : Set H) (A B : Submodule ℂ H) [A.HasOrthogonalProjection] [B.HasOrthogonalProjection] [(A ⊓ B).HasOrthogonalProjection] (hspan : (Submodule.span ℂ C).topologicalClosure = A ⊓ B) (hCS : C ⊆ S) (horth : ∀ v ∈ S, ∀ w ∈ S, inner ℂ v w = 0 ∨ ∃ c : ℂ, v = c • w) (hc : A.starProjection ∘L B.starProjection = B.starProjection ∘L A.starProjection) {v : H} (hv : v ∈ S) (hva : v ∈ A) : B.starProjection v = 0 ∨ B.starProjection v = v := by have hin : B.starProjection v ∈ A ⊓ B := by refine ⟨A.starProjection_eq_self_iff.mp ?_,B.starProjection_apply_mem _⟩ have h := congrArg (fun T : H →L[ℂ] H => T v) hc simpa only [ContinuousLinearMap.comp_apply,A.starProjection_eq_self_iff.mpr hva] using h have he : (A ⊓ B).starProjection v = B.starProjection v := by apply (A ⊓ B).eq_starProjection_of_mem_of_inner_eq_zero hin intro w hw exact B.starProjection_inner_eq_zero _ _ hw.2 rw [←he] exact orthogonal_line_projection S C _ hspan hCS horth hv end namespace ArrayObjects.Object.Rolled open MeasureTheory ProbabilityTheory open scoped InnerProductSpace universe u variable {I : Type u} [Fintype I] [DecidableEq I] {X : StandardSpace.{u}} {T : X ≃ᵐ X} {base : InitialLaws I X T} (M : Object I base) lemma grouped_row_line_projection (hM : M.IsSaturated) (P R : Finset I) (s : ComplementSplit P) (t : ComplementSplit R) (n : ℕ) : ∀ᵐ e ∂M.parameterLaw (n+2), ∀ v ∈ rowSplitExact M P R t n e, (columnActive M P s.A s.B R n e).starProjection v = 0 ∨ (columnActive M P s.A s.B R n e).starProjection v = v := by filter_upwards [grouped_exact_split_span M hM P R s t n, rowSplitExact_dichotomy M hM P R s.partition.properP t n, grouped_active_commutes M hM s.partition t.partition n, rowActive_eq_range M hM P s.partition.properP t.partition n, cells_fibre_marginal M hM P R s.partition.properP n, cells_fibre_marginal M hM P t.A s.partition.properP n, cells_fibre_marginal M hM P t.B s.partition.properP n, cells_indep_columns_fibre M P P t.A t.B t.disjointAB t.partition.properAB n] with e hspan horth hc hr hz ha hb hab intro v hv apply common_lines_projection (rowSplitExact M P R t n e) (rowSplitExact M P R t n e ∩ columnSplitExact M P R s n e) (rowActive M P R t.A t.B n e) (columnActive M P s.A s.B R n e) hspan Set.inter_subset_left horth hc hv let hpair := cells_pair_preserving M ha hb hab rw [hr hz hpair] exact JoiningOperator.splitExact_le_active hz hpair hv lemma grouped_full_row_column_exact (hM : M.IsSaturated) (P R : Finset I) (s : ComplementSplit P) (t : ComplementSplit R) (n : ℕ) : ∀ᵐ e ∂M.parameterLaw (n+2), ∀ v, (∀ t' : ComplementSplit R, v ∈ rowSplitExact M P R t' n e) → v ∈ columnActive M P s.A s.B R n e → v ∈ fullExact M P R n e := by have hspans := ae_all_iff.mpr fun s' : ComplementSplit P => grouped_exact_split_span M hM P R s' t n have hinvs := ae_all_iff.mpr fun s' : ComplementSplit P => commonActive_complement_invariant M hM P R s' s t t n filter_upwards [hspans,hinvs,rowSplitExact_dichotomy M hM P R s.partition.properP t n, allSplitExact_subset_fullExact M hM P R s t n, rowActive_eq_range M hM P s.partition.properP t.partition n, cells_fibre_marginal M hM P R s.partition.properP n, cells_fibre_marginal M hM P t.A s.partition.properP n, cells_fibre_marginal M hM P t.B s.partition.properP n, cells_indep_columns_fibre M P P t.A t.B t.disjointAB t.partition.properAB n] with e hspan hinv horth hfull hr hz ha hb hab intro v hrow hcol by_cases hv0 : v = 0 · subst v exact zero_mem_fullExact M P R n e have hactive : v ∈ rowActive M P R t.A t.B n e := by let hpair := cells_pair_preserving M ha hb hab rw [hr hz hpair] exact JoiningOperator.splitExact_le_active hz hpair (hrow t) apply hfull refine ⟨hrow,?_⟩ intro s' have hv : v ∈ (Submodule.span ℂ (rowSplitExact M P R t n e ∩ columnSplitExact M P R s' n e)).topologicalClosure := by rw [hspan s',hinv s'] exact ⟨hactive,hcol⟩ obtain ⟨w,hw,hn⟩ := nonzero_inner_in_closedSpan _ v hv0 hv obtain ⟨c,hc⟩ := (horth v (hrow t) w hw.1).resolve_left hn rw [hc] exact JoiningOperator.smul_mem_splitExact _ _ _ _ _ c hw.2 end ArrayObjects.Object.Rolled section open MeasureTheory open scoped InnerProductSpace ENNReal ComplexConjugate variable {X : Type*} [MeasurableSpace X] {μ : Measure X} lemma lp_star_zero : star (0 : Lp ℂ 2 μ) = 0 := by apply Lp.ext filter_upwards [Lp.coeFn_star (0 : Lp ℂ 2 μ),Lp.coeFn_zero ℂ 2 μ] with x hs hz simp only [Pi.zero_apply,Pi.star_apply] at hs hz ⊢ rw [hs,hz,star_zero] lemma lp_star_sub (f g : Lp ℂ 2 μ) : star (f-g) = star f-star g := by apply Lp.ext filter_upwards [Lp.coeFn_star (f-g),Lp.coeFn_star f,Lp.coeFn_star g, Lp.coeFn_sub f g,Lp.coeFn_sub (star f) (star g)] with x hs hf hg hd hd' simp only [Pi.star_apply,Pi.sub_apply] at hs hf hg hd hd' rw [hs,hd,star_sub,hd',hf,hg] lemma lp_star_smul (c : ℂ) (f : Lp ℂ 2 μ) : star (c • f) = star c • star f := by apply Lp.ext filter_upwards [Lp.coeFn_star (c • f),Lp.coeFn_star f,Lp.coeFn_smul c f, Lp.coeFn_smul (star c) (star f)] with x hs hf hc hc' simpa only [Pi.star_apply,hc,hc',Pi.smul_apply,star_smul,hf] using hs lemma lp_inner_star_star (f g : Lp ℂ 2 μ) : inner ℂ (star f) (star g) = star (inner ℂ f g) := by rw [L2.inner_def,L2.inner_def] change _ = conj (∫ x, inner ℂ (f x) (g x) ∂μ) rw [←integral_conj] apply integral_congr_ae filter_upwards [Lp.coeFn_star f,Lp.coeFn_star g] with x hf hg simp only [Pi.star_apply] at hf hg rw [hf,hg] simp only [RCLike.inner_apply,starRingEnd_apply,star_mul,star_star,mul_comm] lemma lp_inner_star_right (f g : Lp ℂ 2 μ) : inner ℂ f (star g) = star (inner ℂ (star f) g) := by simpa only [star_star] using lp_inner_star_star (star f) g lemma lp_star_projection (V : Submodule ℂ (Lp ℂ 2 μ)) [V.HasOrthogonalProjection] (hV : ∀ v ∈ V, star v ∈ V) (f : Lp ℂ 2 μ) : V.starProjection (star f) = star (V.starProjection f) := by apply V.eq_starProjection_of_mem_of_inner_eq_zero (hV _ (V.starProjection_apply_mem f)) intro w hw rw [←lp_star_sub] have h := V.starProjection_inner_eq_zero f (star w) (hV w hw) have hs := lp_inner_star_star (f - V.starProjection f) (star w) simpa only [star_star,h,star_zero] using hs end namespace JoiningOperator open MeasureTheory ProbabilityTheory open scoped InnerProductSpace ComplexConjugate variable {Ω X Y U : Type*} [MeasurableSpace Ω] [MeasurableSpace X] [MeasurableSpace Y] [MeasurableSpace U] {μ : Measure Ω} {ν : Measure X} {ρ : Measure Y} {x : Ω → X} {y : Ω → Y} lemma operator_star (hx : MeasurePreserving x μ ν) (hy : MeasurePreserving y μ ρ) (h : Lp ℂ 2 ρ) : operator hx hy (star h) = star (operator hx hy h) := by apply ext_inner_left ℂ intro g rw [inner_operator,lp_inner_star_right,inner_operator] change _ = conj (∫ ω, inner ℂ (star g (x ω)) (h (y ω)) ∂μ) rw [←integral_conj] apply integral_congr_ae filter_upwards [hx.quasiMeasurePreserving.ae (Lp.coeFn_star g), hy.quasiMeasurePreserving.ae (Lp.coeFn_star h)] with ω hg hh simp only [Pi.star_apply] at hg hh rw [hg,hh] simp only [RCLike.inner_apply,starRingEnd_apply,star_mul,star_star,mul_comm] lemma family_star (κ : Kernel U (X × Y)) (ν : Measure X) (ρ : Measure Y) (u : U) (h : Lp ℂ 2 ρ) : family κ ν ρ u (star h) = star (family κ ν ρ u h) := by classical unfold family split_ifs with hp · exact operator_star hp.1 hp.2 h · simpa only [zero_apply] using lp_star_zero.symm lemma family_adjoint_star (κ : Kernel U (X × Y)) (ν : Measure X) (ρ : Measure Y) (u : U) (h : Lp ℂ 2 ν) : (family κ ν ρ u).adjoint (star h) = star ((family κ ν ρ u).adjoint h) := by classical unfold family split_ifs with hp · rw [operator_adjoint] exact operator_star hp.2 hp.1 h · simpa only [map_zero,zero_apply] using lp_star_zero.symm lemma family_active_star (κ : Kernel U (X × Y)) (ν : Measure X) (ρ : Measure Y) (m : Measure U) {v : Lp ℂ 2 ν} (hv : v ∈ essentialRange m (family κ ν ρ)) : star v ∈ essentialRange m (family κ ν ρ) := by apply (Submodule.mem_orthogonal _ _).mpr intro k hk have hs : star k ∈ essentialKernel m (fun u => (family κ ν ρ u).adjoint) := by change ∀ᵐ u ∂m, (family κ ν ρ u).adjoint (star k) = 0 change ∀ᵐ u ∂m, (family κ ν ρ u).adjoint k = 0 at hk filter_upwards [hk] with u hu rw [family_adjoint_star,hu,lp_star_zero] rw [lp_inner_star_right,(Submodule.mem_orthogonal _ _).mp hv (star k) hs,star_zero] lemma family_active_projection_star (κ : Kernel U (X × Y)) (ν : Measure X) (ρ : Measure Y) (m : Measure U) (v : Lp ℂ 2 ν) : (essentialRange m (family κ ν ρ)).starProjection (star v) = star ((essentialRange m (family κ ν ρ)).starProjection v) := lp_star_projection _ (fun _ hv => family_active_star κ ν ρ m hv) v attribute [local instance] Rokhlin.instMeasurableSpaceCircle_circleLp Rokhlin.instBorelSpaceCircle_circleLp lemma operator_circle_exact [IsFiniteMeasure ν] [IsFiniteMeasure ρ] (hx : MeasurePreserving x μ ν) (hy : MeasurePreserving y μ ρ) (f : X → Circle) (g : Y → Circle) (hf : Measurable f) (hg : Measurable g) (c : Circle) (he : ∀ᵐ ω ∂μ, g (y ω) = c * f (x ω)) : operator hx hy (circleLp ρ g hg) = (c : ℂ) • circleLp ν f hf := by have hp : pull hy (circleLp ρ g hg) = (c : ℂ) • pull hx (circleLp ν f hf) := by apply Lp.ext filter_upwards [Lp.coeFn_compMeasurePreserving (circleLp ρ g hg) hy, Lp.coeFn_compMeasurePreserving (circleLp ν f hf) hx, hy.quasiMeasurePreserving.ae (circleLp_coe ρ g hg), hx.quasiMeasurePreserving.ae (circleLp_coe ν f hf), Lp.coeFn_smul (c : ℂ) (pull hx (circleLp ν f hf)),he] with ω h1 h2 h3 h4 h5 he calc _ = (g (y ω) : ℂ) := h1.trans h3 _ = (c : ℂ) * (f (x ω) : ℂ) := congrArg ((↑) : Circle → ℂ) he _ = _ := (h5.trans (congrArg (fun z : ℂ => (c : ℂ)*z) (h2.trans h4))).symm change (pull hx).adjoint (pull hy (circleLp ρ g hg)) = _ rw [hp,map_smul] congr 1 exact congrArg (fun A : Lp ℂ 2 ν →L[ℂ] Lp ℂ 2 ν => A (circleLp ν f hf)) (pull_adjoint_pull hx) end JoiningOperator namespace ArrayObjects.Object.Rolled open MeasureTheory ProbabilityTheory universe u variable {I : Type u} [Fintype I] [DecidableEq I] {X : StandardSpace.{u}} {T : X ≃ᵐ X} {base : InitialLaws I X T} (M : Object I base) omit [DecidableEq I] in lemma rowActive_star (A R S D : Finset I) (n : ℕ) (e : Arr I M.U (n+2)) {v : Lp ℂ 2 (cellLaw M A R n e)} (hv : v ∈ rowActive M A R S D n e) : star v ∈ rowActive M A R S D n e := by unfold rowActive at * rw [fibreRowEdge_eq] at * exact JoiningOperator.family_active_star _ _ _ _ hv omit [DecidableEq I] in lemma columnActive_star (P A B R : Finset I) (n : ℕ) (e : Arr I M.U (n+2)) {v : Lp ℂ 2 (cellLaw M P R n e)} (hv : v ∈ columnActive M P A B R n e) : star v ∈ columnActive M P A B R n e := by unfold columnActive at * rw [fibreColumnEdge_eq] at * exact JoiningOperator.family_active_star _ _ _ _ hv omit [DecidableEq I] in lemma commonActive_star (P A B R S D : Finset I) (n : ℕ) (e : Arr I M.U (n+2)) {v : Lp ℂ 2 (cellLaw M P R n e)} (hv : v ∈ commonActive M P A B R S D n e) : star v ∈ commonActive M P A B R S D n e := ⟨rowActive_star M _ _ _ _ _ _ hv.1,columnActive_star M _ _ _ _ _ _ hv.2⟩ end ArrayObjects.Object.Rolled section open MeasureTheory ProbabilityTheory variable {Ω S Z : Type*} [MeasurableSpace Ω] [MeasurableSpace S] [MeasurableSpace Z] [StandardBorelSpace Ω] [StandardBorelSpace S] [StandardBorelSpace Z] {μ : Measure Ω} [IsProbabilityMeasure μ] {s : Ω → S} {z : Ω → Z} {κ : Kernel S Z} [IsSFiniteKernel κ] lemma conditional_ae_descent (hs : Measurable s) (hz : Measurable z) (hκ : HasCondDistrib z s κ μ) {P : S → Z → Prop} (hP : ∀ᵐ ω ∂μ, P (s ω) (z ω)) : ∀ᵐ a ∂μ.map s, ∀ᵐ b ∂κ a, P a b := by apply Measure.ae_ae_of_ae_compProd (p := fun p : S × Z => P p.1 p.2) rw [←hκ.map_eq] exact ae_map_descent μ (hs.prodMk hz) hP end namespace JoiningOperator open MeasureTheory ProbabilityTheory attribute [local instance] Rokhlin.instMeasurableSpaceCircle_circleLp Rokhlin.instBorelSpaceCircle_circleLp variable {Ω X Y R : Type*} [MeasurableSpace Ω] [MeasurableSpace X] [MeasurableSpace Y] [MeasurableSpace R] [StandardBorelSpace Ω] [StandardBorelSpace X] [StandardBorelSpace Y] [StandardBorelSpace R] {μ : Measure Ω} [IsProbabilityMeasure μ] {ν : Measure X} {ρ : Measure Y} [IsFiniteMeasure ν] [IsFiniteMeasure ρ] {x : Ω → X} {y : Ω → Y} {r : Ω → R} {κ : Kernel R (X × Y)} [IsSFiniteKernel κ] lemma family_circle_exact (hx : Measurable x) (hy : Measurable y) (hr : Measurable r) (hκ : HasCondDistrib (fun ω => (x ω,y ω)) r κ μ) (hm : ∀ᵐ a ∂μ.map r, MeasurePreserving Prod.fst (κ a) ν ∧ MeasurePreserving Prod.snd (κ a) ρ) (f : X → Circle) (g : Y → Circle) (c : R → Circle) (hf : Measurable f) (hg : Measurable g) (he : ∀ᵐ ω ∂μ, g (y ω) = c (r ω) * f (x ω)) : ∀ᵐ a ∂μ.map r, family κ ν ρ a (circleLp ρ g hg) = (c a : ℂ) • circleLp ν f hf := by have h := conditional_ae_descent (κ := κ) (P := fun a p => g p.2 = c a * f p.1) hr (hx.prodMk hy) hκ he filter_upwards [h,hm] with a ha hm rw [family_eq κ ν ρ a hm.1 hm.2] exact operator_circle_exact hm.1 hm.2 f g hf hg (c a) ha end JoiningOperator section open MeasureTheory variable {X Y : Type*} [MeasurableSpace X] [MeasurableSpace Y] {ν : Measure X} {ρ : Measure Y} lemma binary_projection_transfer (D : Submodule ℂ (Lp ℂ 2 ν)) (E : Submodule ℂ (Lp ℂ 2 ρ)) [D.HasOrthogonalProjection] [E.HasOrthogonalProjection] (hE : ∀ w ∈ E, star w ∈ E) (F : Lp ℂ 2 ρ →L[ℂ] Lp ℂ 2 ν) (hF : D.starProjection ∘L F = F ∘L E.starProjection) (v : Lp ℂ 2 ν) (w : Lp ℂ 2 ρ) (c : ℂ) (hc : c ≠ 0) (hv : v ≠ 0) (he : F (star w) = c • v) (hw : E.starProjection w = 0 ∨ E.starProjection w = w) : D.starProjection v = v ↔ E.starProjection w = w := by have hi := congrArg (fun A : Lp ℂ 2 ρ →L[ℂ] Lp ℂ 2 ν => A (star w)) hF simp only [ContinuousLinearMap.comp_apply,he,map_smul,lp_star_projection E hE] at hi constructor · intro hd rcases hw with hz | hid · rw [hz,lp_star_zero,map_zero,hd] at hi exact (hv ((smul_eq_zero.mp hi).resolve_left hc)).elim · exact hid · intro hid rw [hid,he] at hi exact (smul_right_injective _ hc) hi end section open MeasureTheory attribute [local instance] Rokhlin.instMeasurableSpaceCircle_circleLp Rokhlin.instBorelSpaceCircle_circleLp variable {X : Type*} [MeasurableSpace X] (μ : Measure X) [IsFiniteMeasure μ] lemma circleLp_inv (f : X → Circle) (hf : Measurable f) : circleLp μ (fun x => (f x)⁻¹) hf.inv = star (circleLp μ f hf) := by apply Lp.ext filter_upwards [circleLp_coe μ (fun x => (f x)⁻¹) hf.inv,circleLp_coe μ f hf, Lp.coeFn_star (circleLp μ f hf)] with x h1 h2 h3 rw [h1,h3] change (↑((f x)⁻¹) : ℂ) = star (circleLp μ f hf x) rw [h2,Circle.coe_inv_eq_conj] rfl end namespace TriplePartition variable {I : Type*} [Fintype I] [DecidableEq I] abbrev split (s : TriplePartition I) : ComplementSplit s.P := ⟨s.A,s.B,s.nonemptyP,s.nonemptyA,s.nonemptyB,s.disjointPA,s.disjointPB,s.disjointAB,s.cover⟩ end TriplePartition namespace ArrayObjects.Object.Rolled open MeasureTheory ProbabilityTheory attribute [local instance] Rokhlin.instMeasurableSpaceCircle_circleLp Rokhlin.instBorelSpaceCircle_circleLp universe u variable {I : Type u} [Fintype I] [DecidableEq I] {X : StandardSpace.{u}} {T : X ≃ᵐ X} {base : InitialLaws I X T} (M : Object I base) lemma rowSplitExact_le_rowActive (hM : M.IsSaturated) (P R : Finset I) (hP : P ≠ Finset.univ) (t : ComplementSplit R) (n : ℕ) : ∀ᵐ e ∂M.parameterLaw (n+2), rowSplitExact M P R t n e ⊆ rowActive M P R t.A t.B n e := by filter_upwards [rowActive_eq_range M hM P hP t.partition n, cells_fibre_marginal M hM P R hP n, cells_fibre_marginal M hM P t.A hP n, cells_fibre_marginal M hM P t.B hP n, cells_indep_columns_fibre M P P t.A t.B t.disjointAB t.partition.properAB n] with e hr hz ha hb hab rw [hr hz (cells_pair_preserving M ha hb hab)] exact JoiningOperator.splitExact_le_active hz (cells_pair_preserving M ha hb hab) lemma grouped_row_membership_transfer (hM : M.IsSaturated) (rows cols : TriplePartition I) (n : ℕ) : ∀ᵐ e ∂M.parameterLaw (n+2), ∀ (f : (cols.A → rows.A → Arr I M.Y n) → Circle) (g : (cols.B → rows.A → Arr I M.Y n) → Circle) (c : (cols.P → rows.A → Arr I M.Y n) → Circle) (hf : Measurable f) (hg : Measurable g) (_hc : Measurable c), (∀ᵐ y ∂M.ownKernel (n+2) e, (g (cells M rows.A cols.B n y))⁻¹ = c (cells M rows.A cols.P n y) * f (cells M rows.A cols.A n y)) → (circleLp (cellLaw M rows.A cols.A n e) f hf ∈ columnActive M rows.A rows.P rows.B cols.A n e ↔ circleLp (cellLaw M rows.A cols.B n e) g hg ∈ columnActive M rows.A rows.P rows.B cols.B n e) := by filter_upwards [grouped_active_intersections M hM rows cols n, grouped_exact_split_span M hM rows.A cols.B rows.swapPA.split cols.swapPB.swapAB.split n, rowSplitExact_dichotomy M hM rows.A cols.B rows.properA cols.swapPB.swapAB.split n, rowSplitExact_le_rowActive M hM rows.A cols.A rows.properA cols.swapPA.split n, rowSplitExact_le_rowActive M hM rows.A cols.B rows.properA cols.swapPB.swapAB.split n, rowPair_fixed_conditional M rows.A cols.P cols.A cols.B n, rowPair_fixed_marginals M hM rows.A cols.P cols.A cols.B rows.properA cols.disjointPA cols.disjointPB cols.properPA cols.properPB n, cells_fibre_marginal M hM rows.A cols.P rows.properA n] with e hi hs ho hra hrb hk hm hp intro f g c hf hg hc he have hfex : circleLp (cellLaw M rows.A cols.A n e) f hf ∈ rowSplitExact M rows.A cols.A cols.swapPA.split n e := by apply JoiningOperator.circle_mem_splitExact _ _ _ _ _ f (fun z => (c z)⁻¹) (fun z => (g z)⁻¹) hf hc.inv hg.inv filter_upwards [he] with y hy rw [hy] simp only [inv_mul_cancel_left] have hgex : circleLp (cellLaw M rows.A cols.B n e) g hg ∈ rowSplitExact M rows.A cols.B cols.swapPB.swapAB.split n e := by apply JoiningOperator.circle_mem_splitExact _ _ _ _ _ g (fun z => (c z)⁻¹) (fun z => (f z)⁻¹) hg hc.inv hf.inv filter_upwards [he] with y hy have h := congrArg Inv.inv hy simpa only [inv_inv,mul_inv_rev,mul_comm] using h have hw := orthogonal_line_projection (rowSplitExact M rows.A cols.B cols.swapPB.swapAB.split n e) (rowSplitExact M rows.A cols.B cols.swapPB.swapAB.split n e ∩ columnSplitExact M rows.A cols.B rows.swapPA.split n e) (commonActive M rows.A rows.P rows.B cols.B cols.P cols.A n e) hs Set.inter_subset_left ho hgex have heq := JoiningOperator.family_circle_exact (measurable_cells M rows.A cols.A n) (measurable_cells M rows.A cols.B n) (measurable_cells M rows.A cols.P n) hk hm f (fun z => (g z)⁻¹) c hf hg.inv he rw [←hp.map_eq] at hi have ht : ∀ᵐ r ∂(M.ownKernel (n+2) e).map (cells M rows.A cols.P n), (commonActive M rows.A rows.P rows.B cols.A cols.P cols.B n e).starProjection (circleLp (cellLaw M rows.A cols.A n e) f hf) = circleLp (cellLaw M rows.A cols.A n e) f hf ↔ (commonActive M rows.A rows.P rows.B cols.B cols.P cols.A n e).starProjection (circleLp (cellLaw M rows.A cols.B n e) g hg) = circleLp (cellLaw M rows.A cols.B n e) g hg := by filter_upwards [hi.1,heq] with r hir her apply binary_projection_transfer _ _ (fun _ hv => commonActive_star M _ _ _ _ _ _ _ _ hv) (fibreRowEdge M rows.A cols.P cols.A cols.B n e r) hir _ _ (c r : ℂ) (Circle.coe_ne_zero _) (circleLp_ne_zero _ f hf) _ hw rw [fibreRowEdge_eq] rwa [circleLp_inv] at her rw [hp.map_eq] at ht obtain ⟨r,hr⟩ := ht.exists have hfa : circleLp (cellLaw M rows.A cols.A n e) f hf ∈ rowActive M rows.A cols.A cols.P cols.B n e := hra hfex have hgb : circleLp (cellLaw M rows.A cols.B n e) g hg ∈ rowActive M rows.A cols.B cols.P cols.A n e := hrb hgex simpa only [Submodule.starProjection_eq_self_iff,commonActive,Submodule.mem_inf, hfa,hgb,true_and] using hr end ArrayObjects.Object.Rolled namespace JoiningOperator open MeasureTheory variable {Ω Ω' X Y : Type*} [MeasurableSpace Ω] [MeasurableSpace Ω'] [MeasurableSpace X] [MeasurableSpace Y] {μ : Measure Ω} {μ' : Measure Ω'} {ν : Measure X} {f : Ω' → Ω} {x : Ω → X} {y : Ω → Y} lemma measurePreserving_of_comp (hf : MeasurePreserving f μ' μ) (hx : Measurable x) (hxf : MeasurePreserving (x ∘ f) μ' ν) : MeasurePreserving x μ ν := by refine ⟨hx,?_⟩ rw [←hf.map_eq,Measure.map_map hx hf.measurable] exact hxf.map_eq lemma active_pullback (hf : MeasurePreserving f μ' μ) (hx : MeasurePreserving x μ ν) (hy : Measurable y) : (LinearMap.range (operator (hx.comp hf) ((MeasurePreserving.mk hy rfl).comp hf)).toLinearMap).topologicalClosure = (LinearMap.range (operator hx (MeasurePreserving.mk hy rfl)).toLinearMap).topologicalClosure := by rw [operator_pullback hf hx (MeasurePreserving.mk hy rfl)] end JoiningOperator namespace ArrayObjects.Object.Rolled open MeasureTheory ProbabilityTheory open scoped ENNReal universe u variable {I : Type u} [Fintype I] [DecidableEq I] {X : StandardSpace.{u}} {T : X ≃ᵐ X} {base : InitialLaws I X T} (M : Object I base) omit [DecidableEq I] in lemma cells_field (A J : Finset I) (n : ℕ) : MeasurableSpace.comap (cells M A J n) inferInstance = ⨆ j ∈ J, ⨆ a ∈ A, MeasurableSpace.comap (missingRow M n j a) inferInstance := by exact field_finset_grid (fun j a y => missingRow M n j a y) J A lemma row_rest_field (i : I) (s : ComplementSplit ({i} : Finset I)) : MeasurableSpace.comap (fun y => (cells M {i} s.A 0 y,cells M {i} s.B 0 y)) inferInstance = MeasurableSpace.comap (slotRest M i ∘ plane 1 0 i) inferInstance := by change ((inferInstance : MeasurableSpace (s.A → ({i} : Finset I) → Arr I M.Y 0)).prod (inferInstance : MeasurableSpace (s.B → ({i} : Finset I) → Arr I M.Y 0))).comap _ = _ rw [MeasurableSpace.comap_prodMk] rw [cells_field, cells_field] simp only [Finset.mem_singleton,iSup_iSup_eq_left] change (⨆ j ∈ s.A, MeasurableSpace.comap (fun y => plane 0 0 j (plane 1 0 i y)) inferInstance) ⊔ (⨆ j ∈ s.B, MeasurableSpace.comap (fun y => plane 0 0 j (plane 1 0 i y)) inferInstance) = _ have h := field_finset_observation (fun j (y : Arr I M.Y 2) => plane 0 0 j (plane 1 0 i y)) (s.A ∪ s.B) simp only [Finset.mem_union,iSup_or,iSup_sup_eq] at h rw [s.union_eq] at h exact h.symm lemma column_rest_field (i : I) (s : ComplementSplit ({i} : Finset I)) : MeasurableSpace.comap (fun y => (cells M s.A {i} 0 y,cells M s.B {i} 0 y)) inferInstance = MeasurableSpace.comap (slotRest M i ∘ plane 1 (Fin.last 1) i) inferInstance := by change ((inferInstance : MeasurableSpace (({i} : Finset I) → s.A → Arr I M.Y 0)).prod (inferInstance : MeasurableSpace (({i} : Finset I) → s.B → Arr I M.Y 0))).comap _ = _ rw [MeasurableSpace.comap_prodMk] rw [cells_field, cells_field] simp only [Finset.mem_singleton,iSup_iSup_eq_left] have he (j : I) : missingRow M 0 i j = plane 0 0 j ∘ plane 1 (Fin.last 1) i := by exact (plane_first_last M 0 j i).symm simp_rw [he] have h := field_finset_observation (fun j (y : Arr I M.Y 2) => plane 0 0 j (plane 1 (Fin.last 1) i y)) (s.A ∪ s.B) simp only [Finset.mem_union,iSup_or,iSup_sup_eq] at h rw [s.union_eq] at h exact h.symm lemma rowActive_single_slot (hM : M.IsSaturated) (hI : 2 ≤ Fintype.card I) (i : I) (s : ComplementSplit ({i} : Finset I)) : ∀ᵐ e ∂M.parameterLaw 2, rowActive M {i} {i} s.A s.B 0 e = slotActive M i (cellLaw M {i} {i} 0 e) (plane 1 0 i e) := by filter_upwards [rowActive_eq_range M hM {i} s.partition.properP s.partition 0, cells_fibre_marginal M hM {i} {i} s.partition.properP 0, cells_fibre_marginal M hM {i} s.A s.partition.properP 0, cells_fibre_marginal M hM {i} s.B s.partition.properP 0, cells_indep_columns_fibre M {i} {i} s.A s.B s.disjointAB s.partition.properAB 0, row_marginal_fibre M hM hI i] with e hv hx ha hb hab hr have hs : MeasurePreserving (slotCell M i) (M.ownKernel 1 (plane 1 0 i e)) (cellLaw M {i} {i} 0 e) := JoiningOperator.measurePreserving_of_comp hr (measurable_slotCell M i) (by rwa [←cells_single_row]) have hst : MeasurePreserving (fun y => (cells M {i} s.A 0 y,cells M {i} s.B 0 y)) (M.ownKernel 2 e) ((cellLaw M {i} s.A 0 e).prod (cellLaw M {i} s.B 0 e)) := by refine ⟨ha.measurable.prodMk hb.measurable,?_⟩ rw [←ha.map_eq,←hb.map_eq] exact hab.map_prod_eq_prod_map_map ha.measurable.aemeasurable hb.measurable.aemeasurable rw [hv hx hst,slotActive_eq M i _ _ hs] have h := JoiningOperator.active_observation_eq hx hst ((MeasurePreserving.mk (measurable_slotRest M i) rfl).comp hr) (row_rest_field M i s) rw [h] have hh := JoiningOperator.operator_pullback hr hs (MeasurePreserving.mk (measurable_slotRest M i) rfl) simp only [←cells_single_row] at hh rw [hh] lemma columnActive_single_slot (hM : M.IsSaturated) (hI : 2 ≤ Fintype.card I) (i : I) (s : ComplementSplit ({i} : Finset I)) : ∀ᵐ e ∂M.parameterLaw 2, columnActive M {i} s.A s.B {i} 0 e = slotActive M i (cellLaw M {i} {i} 0 e) (plane 1 (Fin.last 1) i e) := by filter_upwards [columnActive_eq_range M hM s.partition {i} s.partition.properP 0, cells_fibre_marginal M hM {i} {i} s.partition.properP 0, cells_fibre_marginal M hM s.A {i} s.partition.properA 0, cells_fibre_marginal M hM s.B {i} s.partition.properB 0, cells_indep_rows_fibre M hM s.A s.B {i} {i} s.disjointAB s.partition.properAB 0, column_marginal_fibre M hI i] with e hv hx ha hb hab hr have hs : MeasurePreserving (slotCell M i) (M.ownKernel 1 (plane 1 (Fin.last 1) i e)) (cellLaw M {i} {i} 0 e) := JoiningOperator.measurePreserving_of_comp hr (measurable_slotCell M i) (by rwa [←cells_single_column]) have hst : MeasurePreserving (fun y => (cells M s.A {i} 0 y,cells M s.B {i} 0 y)) (M.ownKernel 2 e) ((cellLaw M s.A {i} 0 e).prod (cellLaw M s.B {i} 0 e)) := by refine ⟨ha.measurable.prodMk hb.measurable,?_⟩ rw [←ha.map_eq,←hb.map_eq] exact hab.map_prod_eq_prod_map_map ha.measurable.aemeasurable hb.measurable.aemeasurable rw [hv hx hst,slotActive_eq M i _ _ hs] have h := JoiningOperator.active_observation_eq hx hst ((MeasurePreserving.mk (measurable_slotRest M i) rfl).comp hr) (column_rest_field M i s) rw [h] have hh := JoiningOperator.operator_pullback hr hs (MeasurePreserving.mk (measurable_slotRest M i) rfl) simp only [←cells_single_column] at hh rw [hh] end ArrayObjects.Object.Rolled namespace JoiningOperator open MeasureTheory ContinuousLinearMap variable {Ω X Y Z : Type*} [MeasurableSpace Ω] [MeasurableSpace X] [MeasurableSpace Y] [MeasurableSpace Z] {μ : Measure Ω} {ν : Measure X} {ρ : Measure Y} {τ : Measure Z} {x : Ω → X} {y : Ω → Y} omit [MeasurableSpace Ω] [MeasurableSpace Y] in noncomputable def pullEquiv (e : X ≃ᵐ Z) (he : MeasurePreserving e ν τ) : Lp ℂ 2 τ ≃ₗᵢ[ℂ] Lp ℂ 2 ν where __ := Lp.compMeasurePreservingₗᵢ ℂ e he invFun := Lp.compMeasurePreserving e.symm (he.symm e) left_inv f := by change Lp.compMeasurePreserving e.symm (he.symm e) (Lp.compMeasurePreserving e he f) = f rw [←Lp.compMeasurePreserving_comp_apply] simpa only [MeasurableEquiv.self_comp_symm] using Lp.compMeasurePreserving_id_apply f right_inv f := by change Lp.compMeasurePreserving e he (Lp.compMeasurePreserving e.symm (he.symm e) f) = f rw [←Lp.compMeasurePreserving_comp_apply] simpa only [MeasurableEquiv.symm_comp_self] using Lp.compMeasurePreserving_id_apply f omit [MeasurableSpace Ω] [MeasurableSpace Y] in lemma pullEquiv_coe (e : X ≃ᵐ Z) (he : MeasurePreserving e ν τ) : (pullEquiv e he : Lp ℂ 2 τ →L[ℂ] Lp ℂ 2 ν) = pull he := rfl lemma operator_reparam (e : X ≃ᵐ Z) (he : MeasurePreserving e ν τ) (hx : MeasurePreserving x μ ν) (hy : MeasurePreserving y μ ρ) : pull he ∘L operator (he.comp hx) hy = operator hx hy := by have hh : pull he ∘L (pull he).adjoint = ContinuousLinearMap.id ℂ (Lp ℂ 2 ν) := by rw [←pullEquiv_coe e he] rw [LinearIsometryEquiv.adjoint_eq_symm] apply ContinuousLinearMap.ext intro f exact (pullEquiv e he).apply_symm_apply f calc pull he ∘L operator (he.comp hx) hy = (pull he ∘L (pull he).adjoint) ∘L operator hx hy := by unfold operator rw [pull_comp hx he,adjoint_comp] simp only [comp_assoc] _ = operator hx hy := by rw [hh,id_comp] lemma active_reparam (e : X ≃ᵐ Z) (he : MeasurePreserving e ν τ) (hx : MeasurePreserving x μ ν) (hy : MeasurePreserving y μ ρ) (v : Lp ℂ 2 τ) : v ∈ (LinearMap.range (operator (he.comp hx) hy).toLinearMap).topologicalClosure ↔ pull he v ∈ (LinearMap.range (operator hx hy).toLinearMap).topologicalClosure := by let E := pullEquiv e he have hr : E '' Set.range (operator (he.comp hx) hy) = Set.range (operator hx hy) := by rw [←Set.range_comp] have hcomp := operator_reparam e he hx hy exact congrArg (fun f : Lp ℂ 2 ρ →L[ℂ] Lp ℂ 2 ν => Set.range f) hcomp have hc := E.toHomeomorph.image_closure (s := Set.range (operator (he.comp hx) hy)) change E '' closure (Set.range (operator (he.comp hx) hy)) = closure (E '' Set.range (operator (he.comp hx) hy)) at hc rw [hr] at hc change v ∈ closure (Set.range (operator (he.comp hx) hy)) ↔ E v ∈ closure (Set.range (operator hx hy)) rw [←hc] constructor · exact fun hv => ⟨v,hv,rfl⟩ · rintro ⟨w,hw,hwe⟩ exact E.injective hwe ▸ hw end JoiningOperator section open MeasureTheory ProbabilityTheory section attribute [local instance] Rokhlin.instMeasurableSpaceCircle_circleLp Rokhlin.instBorelSpaceCircle_circleLp variable {X Y : Type*} [MeasurableSpace X] [MeasurableSpace Y] {μ : Measure X} {ν : Measure Y} [IsFiniteMeasure μ] [IsFiniteMeasure ν] lemma circleLp_pull {e : X → Y} (he : MeasurePreserving e μ ν) (f : Y → Circle) (hf : Measurable f) : JoiningOperator.pull he (circleLp ν f hf) = circleLp μ (f ∘ e) (hf.comp he.measurable) := by apply Lp.ext filter_upwards [Lp.coeFn_compMeasurePreserving (circleLp ν f hf) he, he.quasiMeasurePreserving.ae (circleLp_coe ν f hf), circleLp_coe μ (f ∘ e) (hf.comp he.measurable)] with x h1 h2 h3 exact h1.trans (h2.trans h3.symm) end namespace ArrayObjects.Object.Rolled universe u variable {I : Type u} [Fintype I] [DecidableEq I] {X : StandardSpace.{u}} {T : X ≃ᵐ X} {base : InitialLaws I X T} (M : Object I base) abbrev CellAt (a j : I) := ({j} : Finset I) → ({a} : Finset I) → Arr I M.Y 0 def collapseCell (a j : I) : CellAt M a j ≃ᵐ Arr I M.Y 0 where toFun y := y ⟨j,Finset.mem_singleton_self j⟩ ⟨a,Finset.mem_singleton_self a⟩ invFun y := fun _ _ => y left_inv y := by funext s t have hs : s = ⟨j,Finset.mem_singleton_self j⟩ := Subtype.ext (Finset.mem_singleton.mp s.property) have ht : t = ⟨a,Finset.mem_singleton_self a⟩ := Subtype.ext (Finset.mem_singleton.mp t.property) subst s; subst t; rfl right_inv _ := rfl measurable_toFun := (measurable_pi_apply _).comp (measurable_pi_apply _) measurable_invFun := Measurable.of_eval fun _ => Measurable.of_eval fun _ => measurable_id omit [DecidableEq I] in lemma collapse_cell_row (a j : I) : collapseCell M a j ∘ cells M {a} {j} 0 = plane 0 0 j ∘ plane 1 0 a := rfl omit [DecidableEq I] in lemma collapse_cell_column (a j : I) : collapseCell M a j ∘ cells M {a} {j} 0 = plane 0 0 a ∘ plane 1 (Fin.last 1) j := (plane_first_last M 0 a j).symm def rawSlotActive (i : I) (ν : Measure (Arr I M.Y 0)) (p : Arr I M.U 1) : Submodule ℂ (Lp ℂ 2 ν) := by classical exact if h : MeasurePreserving (plane 0 0 i) (M.ownKernel 1 p) ν then (LinearMap.range (JoiningOperator.operator h (MeasurePreserving.mk (measurable_slotRest M i) rfl)).toLinearMap).topologicalClosure else ⊥ lemma rawSlotActive_eq (i : I) (ν : Measure (Arr I M.Y 0)) (p : Arr I M.U 1) (h : MeasurePreserving (plane 0 0 i) (M.ownKernel 1 p) ν) : rawSlotActive M i ν p = (LinearMap.range (JoiningOperator.operator h (MeasurePreserving.mk (measurable_slotRest M i) rfl)).toLinearMap).topologicalClosure := by rw [rawSlotActive,dite_eq_left h] lemma rawSlotActive_closed (i : I) (ν : Measure (Arr I M.Y 0)) (p : Arr I M.U 1) : IsClosed (rawSlotActive M i ν p : Set (Lp ℂ 2 ν)) := by unfold rawSlotActive split · exact Submodule.isClosed_topologicalClosure _ · exact isClosed_singleton instance (i : I) (ν : Measure (Arr I M.Y 0)) (p : Arr I M.U 1) : CompleteSpace (rawSlotActive M i ν p) := (rawSlotActive_closed M i ν p).completeSpace_coe lemma row_rest_field_mixed (a j : I) (s : ComplementSplit ({j} : Finset I)) : MeasurableSpace.comap (fun y => (cells M {a} s.A 0 y,cells M {a} s.B 0 y)) inferInstance = MeasurableSpace.comap (slotRest M j ∘ plane 1 0 a) inferInstance := by change ((inferInstance : MeasurableSpace (s.A → ({a} : Finset I) → Arr I M.Y 0)).prod (inferInstance : MeasurableSpace (s.B → ({a} : Finset I) → Arr I M.Y 0))).comap _ = _ rw [MeasurableSpace.comap_prodMk,cells_field,cells_field] simp only [Finset.mem_singleton,iSup_iSup_eq_left] change (⨆ t ∈ s.A, MeasurableSpace.comap (fun y => plane 0 0 t (plane 1 0 a y)) inferInstance) ⊔ (⨆ t ∈ s.B, MeasurableSpace.comap (fun y => plane 0 0 t (plane 1 0 a y)) inferInstance) = _ have h := field_finset_observation (fun t (y : Arr I M.Y 2) => plane 0 0 t (plane 1 0 a y)) (s.A ∪ s.B) simp only [Finset.mem_union,iSup_or,iSup_sup_eq] at h rw [s.union_eq] at h exact h.symm lemma column_rest_field_mixed (a j : I) (s : ComplementSplit ({a} : Finset I)) : MeasurableSpace.comap (fun y => (cells M s.A {j} 0 y,cells M s.B {j} 0 y)) inferInstance = MeasurableSpace.comap (slotRest M a ∘ plane 1 (Fin.last 1) j) inferInstance := by change ((inferInstance : MeasurableSpace (({j} : Finset I) → s.A → Arr I M.Y 0)).prod (inferInstance : MeasurableSpace (({j} : Finset I) → s.B → Arr I M.Y 0))).comap _ = _ rw [MeasurableSpace.comap_prodMk,cells_field,cells_field] simp only [Finset.mem_singleton,iSup_iSup_eq_left] have he (t : I) : missingRow M 0 j t = plane 0 0 t ∘ plane 1 (Fin.last 1) j := by exact (plane_first_last M 0 t j).symm simp_rw [he] have h := field_finset_observation (fun t (y : Arr I M.Y 2) => plane 0 0 t (plane 1 (Fin.last 1) j y)) (s.A ∪ s.B) simp only [Finset.mem_union,iSup_or,iSup_sup_eq] at h rw [s.union_eq] at h exact h.symm lemma singleton_collapse_preserving (hM : M.IsSaturated) (hI : 2 ≤ Fintype.card I) (a j : I) : ∀ᵐ e ∂M.parameterLaw 2, MeasurePreserving (collapseCell M a j) (cellLaw M {a} {j} 0 e) (M.ownKernel 0 (plane 0 0 j (plane 1 0 a e))) := by have ha : ({a} : Finset I) ≠ Finset.univ := by intro he have := congrArg Finset.card he simp only [Finset.card_singleton,Finset.card_univ] at this omega let hr : MeasurePreserving (plane 1 0 a) (M.parameterLaw 2) (M.parameterLaw 1) := ⟨measurable_plane _ _ _,M.parameterLaw_consistent 1 0 a⟩ have hm := ConditionalFibres.marginal (measurable_plane 0 0 j) (M.ownKernel_conditional 1) (M.plane_conditional hI 0 j) filter_upwards [cells_fibre_marginal M hM {a} {j} ha 0,row_marginal_fibre M hM hI a, hr.quasiMeasurePreserving.ae hm] with e hc hr hm exact JoiningOperator.measurePreserving_of_comp hc (collapseCell M a j).measurable (by rw [collapse_cell_row]; exact hm.comp hr) lemma rowActive_mixed_slot (hM : M.IsSaturated) (hI : 2 ≤ Fintype.card I) (a j : I) (ha : ({a} : Finset I) ≠ Finset.univ) (s : ComplementSplit ({j} : Finset I)) : ∀ᵐ e ∂M.parameterLaw 2, ∀ (ν : Measure (Arr I M.Y 0)) (he : MeasurePreserving (collapseCell M a j) (cellLaw M {a} {j} 0 e) ν) (v : Lp ℂ 2 ν), v ∈ rawSlotActive M j ν (plane 1 0 a e) ↔ JoiningOperator.pull he v ∈ rowActive M {a} {j} s.A s.B 0 e := by filter_upwards [rowActive_eq_range M hM {a} ha s.partition 0, cells_fibre_marginal M hM {a} {j} ha 0, cells_fibre_marginal M hM {a} s.A ha 0, cells_fibre_marginal M hM {a} s.B ha 0, cells_indep_columns_fibre M {a} {a} s.A s.B s.disjointAB s.partition.properAB 0, row_marginal_fibre M hM hI a] with e hv hx hA hB hAB hr intro ν he v let hst := cells_pair_preserving M hA hB hAB have hs : MeasurePreserving (plane 0 0 j) (M.ownKernel 1 (plane 1 0 a e)) ν := JoiningOperator.measurePreserving_of_comp hr (measurable_plane _ _ _) (he.comp hx) rw [hv hx hst,←JoiningOperator.active_reparam (collapseCell M a j) he hx hst] have h := JoiningOperator.active_observation_eq (he.comp hx) hst ((MeasurePreserving.mk (measurable_slotRest M j) rfl).comp hr) (row_rest_field_mixed M a j s) rw [h,rawSlotActive_eq M j ν _ hs] have hh : JoiningOperator.operator (he.comp hx) ((MeasurePreserving.mk (measurable_slotRest M j) rfl).comp hr) = JoiningOperator.operator hs (MeasurePreserving.mk (measurable_slotRest M j) rfl) := by exact JoiningOperator.operator_pullback hr hs (MeasurePreserving.mk (measurable_slotRest M j) rfl) rw [hh] lemma columnActive_mixed_slot (hM : M.IsSaturated) (hI : 2 ≤ Fintype.card I) (a j : I) (hj : ({j} : Finset I) ≠ Finset.univ) (s : ComplementSplit ({a} : Finset I)) : ∀ᵐ e ∂M.parameterLaw 2, ∀ (ν : Measure (Arr I M.Y 0)) (he : MeasurePreserving (collapseCell M a j) (cellLaw M {a} {j} 0 e) ν) (v : Lp ℂ 2 ν), v ∈ rawSlotActive M a ν (plane 1 (Fin.last 1) j e) ↔ JoiningOperator.pull he v ∈ columnActive M {a} s.A s.B {j} 0 e := by filter_upwards [columnActive_eq_range M hM s.partition {j} hj 0, cells_fibre_marginal M hM {a} {j} s.partition.properP 0, cells_fibre_marginal M hM s.A {j} s.partition.properA 0, cells_fibre_marginal M hM s.B {j} s.partition.properB 0, cells_indep_rows_fibre M hM s.A s.B {j} {j} s.disjointAB s.partition.properAB 0, column_marginal_fibre M hI j] with e hv hx hA hB hAB hr intro ν he v let hst := cells_pair_preserving M hA hB hAB have hraw := he.comp hx rw [collapse_cell_column] at hraw have hs : MeasurePreserving (plane 0 0 a) (M.ownKernel 1 (plane 1 (Fin.last 1) j e)) ν := JoiningOperator.measurePreserving_of_comp hr (measurable_plane _ _ _) hraw rw [hv hx hst,←JoiningOperator.active_reparam (collapseCell M a j) he hx hst] have h := JoiningOperator.active_observation_eq (he.comp hx) hst ((MeasurePreserving.mk (measurable_slotRest M a) rfl).comp hr) (column_rest_field_mixed M a j s) rw [h,rawSlotActive_eq M a ν _ hs] have hh : JoiningOperator.operator (he.comp hx) ((MeasurePreserving.mk (measurable_slotRest M a) rfl).comp hr) = JoiningOperator.operator hs (MeasurePreserving.mk (measurable_slotRest M a) rfl) := by have hc := collapse_cell_column M a j have hop : JoiningOperator.operator (he.comp hx) ((MeasurePreserving.mk (measurable_slotRest M a) rfl).comp hr) = JoiningOperator.operator (hs.comp hr) ((MeasurePreserving.mk (measurable_slotRest M a) rfl).comp hr) := by congr 1 exact hop.trans (JoiningOperator.operator_pullback hr hs (MeasurePreserving.mk (measurable_slotRest M a) rfl)) rw [hh] end ArrayObjects.Object.Rolled end section variable {I : Type*} [Fintype I] [DecidableEq I] omit [DecidableEq I] in lemma singleton_proper (hk : 2 ≤ Fintype.card I) (i : I) : ({i} : Finset I) ≠ Finset.univ := by intro h have := congrArg Finset.card h simp only [Finset.card_singleton,Finset.card_univ] at this omega lemma pair_complement_nonempty (hk : 3 ≤ Fintype.card I) (i j : I) : (({i,j} : Finset I)ᶜ).Nonempty := by apply Finset.card_pos.mp have hc := Finset.card_compl ({i,j} : Finset I) have hp : ({i,j} : Finset I).card ≤ 2 := by by_cases h : i = j · simp [h] · simp [Finset.card_pair h] omega noncomputable def singletonSplit (hk : 3 ≤ Fintype.card I) (i : I) : ComplementSplit ({i} : Finset I) := by have hi : (({i} : Finset I)ᶜ).Nonempty := by apply Finset.card_pos.mp have hc := Finset.card_compl ({i} : Finset I) simp only [Finset.card_singleton] at hc omega let j := hi.choose have hj : j ∉ ({i} : Finset I) := Finset.mem_compl.mp hi.choose_spec exact ComplementSplit.singleton {i} (Finset.singleton_nonempty i) j hj (by simpa only [Finset.singleton_union] using pair_complement_nonempty hk i j) abbrev pairPartition (hk : 3 ≤ Fintype.card I) (j t : I) (hjt : j ≠ t) : TriplePartition I := (ComplementSplit.singleton {j} (Finset.singleton_nonempty j) t (by simpa only [Finset.mem_singleton] using Ne.symm hjt) (by simpa only [Finset.singleton_union] using pair_complement_nonempty hk j t)).partition.swapPB.swapAB lemma pairPartition_P (hk : 3 ≤ Fintype.card I) (j t : I) (hjt : j ≠ t) : (pairPartition hk j t hjt).P = ({j,t} : Finset I)ᶜ := rfl lemma pairPartition_A (hk : 3 ≤ Fintype.card I) (j t : I) (hjt : j ≠ t) : (pairPartition hk j t hjt).A = ({j} : Finset I) := rfl lemma pairPartition_B (hk : 3 ≤ Fintype.card I) (j t : I) (hjt : j ≠ t) : (pairPartition hk j t hjt).B = ({t} : Finset I) := rfl end section open MeasureTheory open scoped BigOperators variable {I Y : Type*} [Fintype I] [DecidableEq I] [MeasurableSpace Y] local instance : MeasurableSpace Circle := inferInstanceAs (MeasurableSpace (Submonoid.unitSphere ℂ)) local instance : BorelSpace Circle := inferInstanceAs (BorelSpace (Submonoid.unitSphere ℂ)) def circleComplete (i : I) (f : Y → Circle) (a : ↥(({i} : Finset I)ᶜ) → Y → Circle) (j : I) (y : Y) : Circle := if h : j = i then f y else (a ⟨j,by simpa using h⟩ y)⁻¹ omit [MeasurableSpace Y] in lemma circleComplete_self (i : I) (f : Y → Circle) (a : ↥(({i} : Finset I)ᶜ) → Y → Circle) : circleComplete i f a i = f := by funext y; simp [circleComplete] lemma measurable_circleComplete (i : I) (f : Y → Circle) (a : ↥(({i} : Finset I)ᶜ) → Y → Circle) (hf : Measurable f) (ha : ∀ j, Measurable (a j)) (j : I) : Measurable (circleComplete i f a j) := by unfold circleComplete by_cases h : j = i · simpa only [dite_eq_left h] using hf · simp only [dite_eq_right h] exact measurable_inv.comp (ha ⟨j,by simpa using h⟩) lemma prod_complement (i : I) (g : I → Circle) : (∏ j, g j) = g i * ∏ j : ↥(({i} : Finset I)ᶜ), g j := by rw [Fintype.prod_eq_mul_prod_compl i g,Finset.prod_coe_sort] omit [MeasurableSpace Y] in lemma circleComplete_prod (i : I) (f : Y → Circle) (a : ↥(({i} : Finset I)ᶜ) → Y → Circle) (y : I → Y) (c : Circle) (h : f (y i) = c * ∏ j, a j (y j)) : ∏ j, circleComplete i f a j (y j) = c := by rw [prod_complement i,circleComplete_self] have ht (j : ↥(({i} : Finset I)ᶜ)) : circleComplete i f a j (y j) = (a j (y j))⁻¹ := by have hj : (j : I) ≠ i := fun h => (Finset.mem_compl.mp j.property) (Finset.mem_singleton.mpr h) simp only [circleComplete,dite_eq_right hj] simp only [ht,Finset.prod_inv_distrib,h,mul_assoc,mul_inv_cancel,mul_one] lemma prod_equation_solve (i : I) (g : I → Circle) (c : Circle) (h : ∏ j, g j = c) : g i = c * ∏ j : ↥(({i} : Finset I)ᶜ), (g j)⁻¹ := by rw [Finset.prod_inv_distrib,←h,prod_complement i,mul_assoc,mul_inv_cancel,mul_one] end section open MeasureTheory ProbabilityTheory open scoped BigOperators section variable {I : Type*} [Fintype I] [DecidableEq I] lemma prod_pair_solve (j t : I) (hjt : j ≠ t) (g : I → Circle) (c : Circle) (h : ∏ s, g s = c) : (g t)⁻¹ = c⁻¹ * (∏ s : ↥(({j,t} : Finset I)ᶜ), g s) * g j := by have ht : (g j * g t) * (∏ s : ↥(({j,t} : Finset I)ᶜ), g s) = c := by rw [Finset.prod_coe_sort, ←Finset.prod_pair hjt, Finset.prod_mul_prod_compl] exact h rw [←ht] simp [mul_inv_rev,mul_assoc,mul_comm,mul_left_comm] end namespace ArrayObjects.Object.Rolled attribute [local instance] Rokhlin.instMeasurableSpaceCircle_circleLp Rokhlin.instBorelSpaceCircle_circleLp universe u variable {I : Type u} [Fintype I] [DecidableEq I] {X : StandardSpace.{u}} {T : X ≃ᵐ X} {base : InitialLaws I X T} (M : Object I base) lemma raw_row_membership_transfer (hM : M.IsSaturated) (hk : 3 ≤ Fintype.card I) (a j t : I) (hjt : j ≠ t) : ∀ᵐ e ∂M.parameterLaw 2, ∀ (f : I → Arr I M.Y 0 → Circle) (hf : ∀ i, Measurable (f i)) (c : Circle), (∀ᵐ y ∂M.ownKernel 1 (plane 1 0 a e), ∏ i, f i (plane 0 0 i y) = c) → (circleLp (M.ownKernel 0 (plane 0 0 j (plane 1 0 a e))) (f j) (hf j) ∈ rawSlotActive M a (M.ownKernel 0 (plane 0 0 j (plane 1 0 a e))) (plane 1 (Fin.last 1) j e) ↔ circleLp (M.ownKernel 0 (plane 0 0 t (plane 1 0 a e))) (f t) (hf t) ∈ rawSlotActive M a (M.ownKernel 0 (plane 0 0 t (plane 1 0 a e))) (plane 1 (Fin.last 1) t e)) := by have hI : 2 ≤ Fintype.card I := by omega let s := singletonSplit hk a let rows := s.partition.swapPA let cols := pairPartition hk j t hjt filter_upwards [grouped_row_membership_transfer M hM rows cols 0, columnActive_mixed_slot M hM hI a j (singleton_proper hI j) s, columnActive_mixed_slot M hM hI a t (singleton_proper hI t) s, singleton_collapse_preserving M hM hI a j, singleton_collapse_preserving M hM hI a t, row_marginal_fibre M hM hI a] with e he hj ht hmj hmt hr intro f hf c hc rw [hj _ hmj,ht _ hmt,circleLp_pull,circleLp_pull] let r : (cols.P → rows.A → Arr I M.Y 0) → Circle := fun z => c⁻¹ * ∏ i : cols.P, f i (z i ⟨a,Finset.mem_singleton_self a⟩) have hmr : Measurable r := measurable_const.mul (Finset.measurable_prod _ fun i _ => (hf i).comp ((measurable_pi_apply _).comp (measurable_pi_apply i))) apply he (f j ∘ collapseCell M a j) (f t ∘ collapseCell M a t) r ((hf j).comp (collapseCell M a j).measurable) ((hf t).comp (collapseCell M a t).measurable) hmr filter_upwards [hr.quasiMeasurePreserving.ae hc] with y hy exact prod_pair_solve j t hjt (fun i => f i (plane 0 0 i (plane 1 0 a y))) c hy end ArrayObjects.Object.Rolled end section open scoped InnerProductSpace variable {H K : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [NormedAddCommGroup K] [InnerProductSpace ℂ K] lemma projection_transport (E : H ≃ₗᵢ[ℂ] K) (D : Submodule ℂ H) (C : Submodule ℂ K) [D.HasOrthogonalProjection] [C.HasOrthogonalProjection] (h : ∀ v, v ∈ D ↔ E v ∈ C) (v : H) : E (D.starProjection v) = C.starProjection (E v) := by have he : D.map E.toLinearEquiv.toLinearMap = C := by ext w constructor · rintro ⟨v,hv,rfl⟩ exact (h v).mp hv · intro hw exact ⟨E.symm w,(h _).mpr (by simpa using hw),E.apply_symm_apply w⟩ have hh := Submodule.starProjection_map_apply E D (E v) simpa only [he, E.symm_apply_apply] using hh.symm lemma binary_projection_transport (E : H ≃ₗᵢ[ℂ] K) (D : Submodule ℂ H) (C : Submodule ℂ K) [D.HasOrthogonalProjection] [C.HasOrthogonalProjection] (h : ∀ v, v ∈ D ↔ E v ∈ C) (v : H) (hb : C.starProjection (E v) = 0 ∨ C.starProjection (E v) = E v) : D.starProjection v = 0 ∨ D.starProjection v = v := by rw [←projection_transport E D C h] at hb rcases hb with h0 | h1 · exact Or.inl (E.injective (h0.trans E.map_zero.symm)) · exact Or.inr (E.injective h1) end namespace JoiningOperator open MeasureTheory attribute [local instance] Rokhlin.instMeasurableSpaceCircle_circleLp Rokhlin.instBorelSpaceCircle_circleLp variable {Ω X Y : Type*} [MeasurableSpace Ω] [MeasurableSpace X] [MeasurableSpace Y] {μ : Measure Ω} {ν : Measure X} {ρ : Measure Y} [IsFiniteMeasure ν] [IsFiniteMeasure ρ] {x : Ω → X} {y : Ω → Y} lemma circleLp_operator (hx : MeasurePreserving x μ ν) (hy : MeasurePreserving y μ ρ) (f : X → Circle) (g : Y → Circle) (hf : Measurable f) (hg : Measurable g) (he : ∀ᵐ ω ∂μ, f (x ω) = g (y ω)) : operator hx hy (circleLp ρ g hg) = circleLp ν f hf := by have hp : pull hx (circleLp ν f hf) = pull hy (circleLp ρ g hg) := by apply Lp.ext filter_upwards [Lp.coeFn_compMeasurePreserving (circleLp ν f hf) hx, Lp.coeFn_compMeasurePreserving (circleLp ρ g hg) hy, hx.quasiMeasurePreserving.ae (circleLp_coe ν f hf), hy.quasiMeasurePreserving.ae (circleLp_coe ρ g hg),he] with ω h1 h2 h3 h4 h5 exact (h1.trans h3).trans ((congrArg ((↑) : Circle → ℂ) h5).trans (h2.trans h4).symm) change (pull hx).adjoint (pull hy (circleLp ρ g hg)) = _ rw [←hp] exact congrArg (fun A : Lp ℂ 2 ν →L[ℂ] Lp ℂ 2 ν => A (circleLp ν f hf)) (pull_adjoint_pull hx) end JoiningOperator section open MeasureTheory ProbabilityTheory open scoped BigOperators section variable {I : Type*} [Fintype I] [DecidableEq I] lemma prod_complement_split (i : I) (s : ComplementSplit ({i} : Finset I)) (g : I → Circle) : (∏ j : ↥(({i} : Finset I)ᶜ), g j) = (∏ j : s.A, g j) * ∏ j : s.B, g j := by rw [Finset.prod_coe_sort,Finset.prod_coe_sort,Finset.prod_coe_sort,←s.union_eq, Finset.prod_union s.disjointAB] end namespace ArrayObjects.Object.Rolled section attribute [local instance] Rokhlin.instMeasurableSpaceCircle_circleLp Rokhlin.instBorelSpaceCircle_circleLp universe u variable {I : Type u} [Fintype I] [DecidableEq I] {X : StandardSpace.{u}} {T : X ≃ᵐ X} {base : InitialLaws I X T} (M : Object I base) lemma raw_tuple_active (i : I) (p : Arr I M.U 1) (ν : Measure (Arr I M.Y 0)) [IsFiniteMeasure ν] (hm : MeasurePreserving (plane 0 0 i) (M.ownKernel 1 p) ν) (f : I → Arr I M.Y 0 → Circle) (hf : ∀ i, Measurable (f i)) (c : Circle) (he : ∀ᵐ y ∂M.ownKernel 1 p, ∏ j, f j (plane 0 0 j y) = c) : circleLp ν (f i) (hf i) ∈ rawSlotActive M i ν p := by rw [rawSlotActive_eq M i ν p hm] apply Submodule.le_topologicalClosure let g : (↥(({i} : Finset I)ᶜ) → Arr I M.Y 0) → Circle := fun z => c * ∏ j : ↥(({i} : Finset I)ᶜ), (f j (z j))⁻¹ have hg : Measurable g := measurable_const.mul (Finset.measurable_prod _ fun j _ => ((hf j).comp (measurable_pi_apply j)).inv) refine ⟨circleLp ((M.ownKernel 1 p).map (slotRest M i)) g hg,?_⟩ apply JoiningOperator.circleLp_operator hm (MeasurePreserving.mk (measurable_slotRest M i) rfl) (f i) g (hf i) hg exact he.mono fun y hy => prod_equation_solve i (fun j => f j (plane 0 0 j y)) c hy lemma raw_tuple_rowSplitExact (a j : I) (s : ComplementSplit ({j} : Finset I)) (e : Arr I M.U 2) (hr : MeasurePreserving (plane 1 0 a) (M.ownKernel 2 e) (M.ownKernel 1 (plane 1 0 a e))) (f : I → Arr I M.Y 0 → Circle) (hf : ∀ i, Measurable (f i)) (c : Circle) (he : ∀ᵐ y ∂M.ownKernel 1 (plane 1 0 a e), ∏ i, f i (plane 0 0 i y) = c) : circleLp (cellLaw M {a} {j} 0 e) (f j ∘ collapseCell M a j) ((hf j).comp (collapseCell M a j).measurable) ∈ rowSplitExact M {a} {j} s 0 e := by let g : (s.A → ({a} : Finset I) → Arr I M.Y 0) → Circle := fun z => c * ∏ i : s.A, (f i (z i ⟨a,Finset.mem_singleton_self a⟩))⁻¹ let h : (s.B → ({a} : Finset I) → Arr I M.Y 0) → Circle := fun z => ∏ i : s.B, (f i (z i ⟨a,Finset.mem_singleton_self a⟩))⁻¹ have hg : Measurable g := measurable_const.mul (Finset.measurable_prod _ fun i _ => ((hf i).comp ((measurable_pi_apply (⟨a,Finset.mem_singleton_self a⟩ : ({a} : Finset I))).comp (measurable_pi_apply i))).inv) have hh : Measurable h := Finset.measurable_prod _ fun i _ => ((hf i).comp ((measurable_pi_apply (⟨a,Finset.mem_singleton_self a⟩ : ({a} : Finset I))).comp (measurable_pi_apply i))).inv apply JoiningOperator.circle_mem_splitExact _ _ _ _ _ (f j ∘ collapseCell M a j) g h ((hf j).comp (collapseCell M a j).measurable) hg hh filter_upwards [hr.quasiMeasurePreserving.ae he] with y hy have ht := prod_equation_solve j (fun i => f i (plane 0 0 i (plane 1 0 a y))) c hy rw [prod_complement_split j s (fun i => (f i (plane 0 0 i (plane 1 0 a y)))⁻¹)] at ht change f j (plane 0 0 j (plane 1 0 a y)) = (c * ∏ i : s.A, (f i (plane 0 0 i (plane 1 0 a y)))⁻¹) * ∏ i : s.B, (f i (plane 0 0 i (plane 1 0 a y)))⁻¹ simpa only [mul_assoc] using ht lemma raw_row_line_projection (hM : M.IsSaturated) (hk : 3 ≤ Fintype.card I) (a j : I) : ∀ᵐ e ∂M.parameterLaw 2, ∀ (f : I → Arr I M.Y 0 → Circle) (hf : ∀ i, Measurable (f i)) (c : Circle), (∀ᵐ y ∂M.ownKernel 1 (plane 1 0 a e), ∏ i, f i (plane 0 0 i y) = c) → let ν := M.ownKernel 0 (plane 0 0 j (plane 1 0 a e)) let v := circleLp ν (f j) (hf j) (rawSlotActive M a ν (plane 1 (Fin.last 1) j e)).starProjection v = 0 ∨ (rawSlotActive M a ν (plane 1 (Fin.last 1) j e)).starProjection v = v := by have hI : 2 ≤ Fintype.card I := by omega let s := singletonSplit hk a let t := singletonSplit hk j filter_upwards [grouped_row_line_projection M hM {a} {j} s t 0, columnActive_mixed_slot M hM hI a j (singleton_proper hI j) s, singleton_collapse_preserving M hM hI a j,row_marginal_fibre M hM hI a] with e hbin hcol hmp hr intro f hf c he have hfex := raw_tuple_rowSplitExact M a j t e hr f hf c he have hb := hbin _ hfex rw [←circleLp_pull hmp (f j) (hf j)] at hb exact binary_projection_transport (JoiningOperator.pullEquiv (collapseCell M a j) hmp) _ _ (hcol _ hmp) _ hb end attribute [local instance] Rokhlin.instMeasurableSpaceCircle_circleLp Rokhlin.instBorelSpaceCircle_circleLp universe u variable {I : Type u} [Fintype I] [DecidableEq I] {X : StandardSpace.{u}} {T : X ≃ᵐ X} {base : InitialLaws I X T} (M : Object I base) def rawExactCone (i : I) (ν : Measure (Arr I M.Y 0)) [IsFiniteMeasure ν] (p : Arr I M.U 1) : Set (Lp ℂ 2 ν) := {v | ∃ (f : I → Arr I M.Y 0 → Circle) (hf : ∀ j, Measurable (f j)) (c : Circle) (d : ℂ), v = d • circleLp ν (f i) (hf i) ∧ ∀ᵐ y ∂M.ownKernel 1 p, ∏ j, f j (plane 0 0 j y) = c} omit [DecidableEq I] in lemma rawExactCone_smul (i : I) (ν : Measure (Arr I M.Y 0)) [IsFiniteMeasure ν] (p : Arr I M.U 1) (c : ℂ) (v : Lp ℂ 2 ν) (hv : v ∈ rawExactCone M i ν p) : c • v ∈ rawExactCone M i ν p := by obtain ⟨f,hf,a,d,rfl,he⟩ := hv exact ⟨f,hf,a,c*d,by rw [smul_smul],he⟩ omit [DecidableEq I] in lemma oneRow_single_column (a j : I) (y : Arr I M.Y 2) : oneRow M {j} 0 a y = fun _ => plane 0 0 a (plane 1 (Fin.last 1) j y) := by funext t have ht : (t : I) = j := Finset.mem_singleton.mp t.property simp only [oneRow,ht] exact (congrFun (plane_first_last M 0 a j) y).symm lemma fullExact_raw_column (a j : I) (e : Arr I M.U 2) (ν : Measure (Arr I M.Y 0)) [IsFiniteMeasure ν] (hm : MeasurePreserving (collapseCell M a j) (cellLaw M {a} {j} 0 e) ν) (hc : MeasurePreserving (plane 1 (Fin.last 1) j) (M.ownKernel 2 e) (M.ownKernel 1 (plane 1 (Fin.last 1) j e))) (v : Lp ℂ 2 ν) (hv : JoiningOperator.pull hm v ∈ fullExact M {a} {j} 0 e) : v ∈ rawExactCone M a ν (plane 1 (Fin.last 1) j e) := by obtain ⟨f,hf,d,he,_,b,c,hb,hprod⟩ := hv let g : Arr I M.Y 0 → Circle := f ∘ (collapseCell M a j).symm have hg : Measurable g := hf.comp (collapseCell M a j).symm.measurable have hvg : v = d • circleLp ν g hg := by apply (JoiningOperator.pullEquiv (collapseCell M a j) hm).injective change JoiningOperator.pull hm v = JoiningOperator.pull hm (d • circleLp ν g hg) rw [map_smul,circleLp_pull] have hgf : g ∘ collapseCell M a j = f := by funext z exact congrArg f ((collapseCell M a j).symm_apply_apply z) simpa only [hgf] using he let B : ↥(({a} : Finset I)ᶜ) → Arr I M.Y 0 → Circle := fun t y => b t (fun _ => y) have hB (t) : Measurable (B t) := (hb t).comp (Measurable.of_eval fun _ => measurable_id) refine ⟨circleComplete a g B,measurable_circleComplete a g B hg hB,c,d,?_,?_⟩ · simpa only [circleComplete_self] using hvg · rw [←hc.map_eq] apply ae_map_descent _ hc.measurable filter_upwards [hprod] with y hy apply circleComplete_prod a g B _ c have hcell : (collapseCell M a j).symm (plane 0 0 a (plane 1 (Fin.last 1) j y)) = cells M {a} {j} 0 y := by apply (collapseCell M a j).injective rw [(collapseCell M a j).apply_symm_apply] exact (congrFun (collapse_cell_column M a j) y).symm simpa only [g,Function.comp_apply,hcell,B,oneRow_single_column] using hy lemma raw_row_active_to_column_exact (hM : M.IsSaturated) (hk : 3 ≤ Fintype.card I) (a j : I) : ∀ᵐ e ∂M.parameterLaw 2, ∀ (f : I → Arr I M.Y 0 → Circle) (hf : ∀ i, Measurable (f i)) (c : Circle), (∀ᵐ y ∂M.ownKernel 1 (plane 1 0 a e), ∏ i, f i (plane 0 0 i y) = c) → let ν := M.ownKernel 0 (plane 0 0 j (plane 1 0 a e)) let v := circleLp ν (f j) (hf j) v ∈ rawSlotActive M a ν (plane 1 (Fin.last 1) j e) → v ∈ rawExactCone M a ν (plane 1 (Fin.last 1) j e) := by let s := singletonSplit hk a let t := singletonSplit hk j have hI : 2 ≤ Fintype.card I := by omega filter_upwards [grouped_full_row_column_exact M hM {a} {j} s t 0, row_marginal_fibre M hM hI a,column_marginal_fibre M hI j, singleton_collapse_preserving M hM hI a j, columnActive_mixed_slot M hM hI a j (singleton_proper hI j) s] with e hfull hr hc hm hcol intro f hf c he dsimp only intro hv apply fullExact_raw_column M a j e _ hm hc apply hfull · intro t' rw [circleLp_pull] exact raw_tuple_rowSplitExact M a j t' e hr f hf c he · exact (hcol _ hm _).mp hv end ArrayObjects.Object.Rolled end section open MeasureTheory ProbabilityTheory Set open scoped BigOperators attribute [local instance] Rokhlin.instMeasurableSpaceCircle_circleLp Rokhlin.instBorelSpaceCircle_circleLp lemma HilbertCode.encode_injective {U Y : Type*} [MeasurableSpace U] [MeasurableSpace Y] [MeasurableSpace.CountablyGenerated Y] {κ : Kernel U Y} [IsMarkovKernel κ] (u : U) : Function.Injective (HilbertCode.encode (κ := κ) u) := by intro v w h apply distance_code_injective (hilbertTests_dense (κ u)) funext n exact congrArg (fun a : HilbertCode κ => a.code n) h variable {P U Y I : Type*} [MeasurableSpace P] [MeasurableSpace U] [MeasurableSpace Y] [MeasurableSpace.CountablyGenerated Y] [Fintype I] [DecidableEq I] (κ : Kernel U Y) [IsMarkovKernel κ] (Λ : Kernel P (I → Y)) [IsMarkovKernel Λ] (u : P → I → U) def exactCodeVectors (p : P) (i : I) : Set (Lp ℂ 2 (κ (u p i))) := {v | ∃ a : I → HilbertCode κ, (p,a) ∈ exactCodeSet κ Λ u ∧ a i = HilbertCode.encode (u p i) v} def exactCodeSpan (p : P) (i : I) : Submodule ℂ (Lp ℂ 2 (κ (u p i))) := (Submodule.span ℂ (exactCodeVectors κ Λ u p i)).topologicalClosure omit [DecidableEq I] [IsMarkovKernel Λ] in lemma exactCodeSpan_congr_kernel (Λ' : Kernel P (I → Y)) [IsMarkovKernel Λ'] (p : P) (i : I) (he : Λ p = Λ' p) : exactCodeSpan κ Λ u p i = exactCodeSpan κ Λ' u p i := by have hs : exactCodeVectors κ Λ u p i = exactCodeVectors κ Λ' u p i := by ext v simp only [exactCodeVectors, exactCodeSet, exactCodeMean, Set.mem_ofPred_eq, he] unfold exactCodeSpan rw [hs] omit [DecidableEq I] in lemma exactCircle_mem_codeSpan (p : P) (i : I) (hm : ∀ j, MeasurePreserving (fun y : I → Y => y j) (Λ p) (κ (u p j))) (f : I → Y → Circle) (hf : ∀ j, Measurable (f j)) (c : Circle) (he : ∀ᵐ y ∂Λ p, ∏ j, f j (y j) = c) (d : ℂ) : d • circleLp (κ (u p i)) (f i) (hf i) ∈ exactCodeSpan κ Λ u p i := by obtain ⟨a,b,ha,hb⟩ := normalized_exact_codes κ Λ u p hm f hf c he have hv : b i • circleLp (κ (u p i)) (f i) (hf i) ∈ exactCodeSpan κ Λ u p i := Submodule.le_topologicalClosure _ (Submodule.subset_span ⟨a,ha,(hb i).2⟩) have hn : b i ≠ 0 := by intro hz; simpa only [hz,norm_zero,zero_ne_one] using (hb i).1 convert (exactCodeSpan κ Λ u p i).smul_mem (d * (b i)⁻¹) hv using 1 rw [smul_smul,mul_assoc,inv_mul_cancel₀ hn,mul_one] omit [DecidableEq I] in lemma exactVector_circle_tuple (p : P) (i : I) (hm : ∀ j, MeasurePreserving (fun y : I → Y => y j) (Λ p) (κ (u p j))) {v : Lp ℂ 2 (κ (u p i))} (hv : v ∈ exactCodeVectors κ Λ u p i) : ∃ (f : I → Y → Circle) (hf : ∀ j, Measurable (f j)) (c : Circle), v = circleLp (κ (u p i)) (f i) (hf i) ∧ ∀ᵐ y ∂Λ p, ∏ j, f j (y j) = c := by obtain ⟨a,ha,hv⟩ := hv obtain ⟨c,hc⟩ := exactCode_circle_tuple κ Λ u hm ha refine ⟨fun j => HilbertCode.circleRep (a j), fun j => HilbertCode.measurable_circleRep_fixed (a j),c,?_,hc⟩ dsimp only simp only [hv] have hq : HilbertCode.IsUnimodular (HilbertCode.encode (u p i) v) := by rw [←hv] exact (ha.2.1 i).2 exact (HilbertCode.decode_encode (u p i) v).symm.trans (HilbertCode.circleLp_circleRep (HilbertCode.encode (u p i) v) hq).symm variable [StandardBorelSpace P] [StandardBorelSpace U] lemma exactCodeSpan_sections (hu : Measurable u) (hk : 3 ≤ Fintype.card I) (hm : ∀ p i, MeasurePreserving (fun y : I → Y => y i) (Λ p) (κ (u p i))) (hind : ∀ p i, iIndepFun (fun j : (Finset.univ.erase i : Finset I) => fun y : I → Y => y j) (Λ p)) (i : I) : ∃ s : ℕ → ∀ p, Lp ℂ 2 (κ (u p i)), (∀ n, MeasurableSection (s n)) ∧ ∀ p, exactCodeSpan κ Λ u p i = (Submodule.span ℂ (Set.range (fun n => s n p))).topologicalClosure := by obtain ⟨D,a,_,ha,hbase,hmem,hzero,hcover⟩ := exactCode_sections κ Λ u hu hk hm hind let s : ℕ → ∀ p, Lp ℂ 2 (κ (u p i)) := fun n p => HilbertCode.atBase (a n p i) (u p i) (hbase n p i) have hs (n p) : HilbertCode.encode (u p i) (s n p) = a n p i := HilbertCode.encode_atBase _ _ _ refine ⟨s,?_,?_⟩ · intro n change Measurable (fun p => HilbertCode.encode (u p i) (s n p)) simp only [hs] exact (measurable_pi_apply i).comp (ha n) · intro p apply le_antisymm · apply Submodule.topologicalClosure_mono apply Submodule.span_le.mpr rintro v ⟨b,hb,hv⟩ obtain ⟨n,_,hn⟩ := hcover (p,b) hb have he : s n p = v := by apply HilbertCode.encode_injective (u p i) rw [hs,hn] exact hv exact Submodule.subset_span ⟨n,he⟩ · apply Submodule.topologicalClosure_mono apply Submodule.span_le.mpr rintro _ ⟨n,rfl⟩ by_cases hp : p ∈ D n · exact Submodule.subset_span ⟨a n p,hmem n p hp,(hs n p).symm⟩ · have he : s n p = 0 := by apply HilbertCode.encode_injective (u p i) rw [hs,hzero n p hp] dsimp only rw [he] exact Submodule.zero_mem _ end section open MeasureTheory ProbabilityTheory Set attribute [local instance] Rokhlin.instMeasurableSpaceCircle_circleLp Rokhlin.instBorelSpaceCircle_circleLp variable {P U Y I : Type*} [MeasurableSpace P] [MeasurableSpace U] [MeasurableSpace Y] [MeasurableSpace.CountablyGenerated Y] [Fintype I] [DecidableEq I] (κ : Kernel U Y) [IsMarkovKernel κ] (Λ : Kernel P (I → Y)) [IsMarkovKernel Λ] (u : P → I → U) omit [DecidableEq I] in lemma canonical_smul_exact_tuple (p : P) (i : I) (hm : ∀ j, MeasurePreserving (fun y : I → Y => y j) (Λ p) (κ (u p j))) (v : Lp ℂ 2 (κ (u p i))) (hv : RayCanonical (hilbertTests (κ (u p i))) v) (hn : ‖v‖ = 1) (f : I → Y → Circle) (hf : ∀ j, Measurable (f j)) (c : Circle) (d : ℂ) (he : ∀ᵐ y ∂Λ p, ∏ j, f j (y j) = c) (hvd : v = d • circleLp (κ (u p i)) (f i) (hf i)) : ∃ a : I → HilbertCode κ, (p,a) ∈ exactCodeSet κ Λ u ∧ a i = HilbertCode.encode (u p i) v := by obtain ⟨a,b,ha,hb⟩ := normalized_exact_codes κ Λ u p hm f hf c he have hdn : ‖d‖ = 1 := by rw [hvd,norm_smul,circleLp_norm,mul_one] at hn exact hn let w := b i • circleLp (κ (u p i)) (f i) (hf i) have hc : RayCanonical (hilbertTests (κ (u p i))) w := by have h := (ha.2.1 i).1 change HilbertCode.IsCanonical (a i) at h rw [(hb i).2] at h change RayCanonical (hilbertTests (κ (u p i))) (HilbertCode.decode (HilbertCode.encode (u p i) w)) at h simpa only [HilbertCode.decode_encode] using h have hb0 : b i ≠ 0 := by intro hz simpa only [hz,norm_zero,zero_ne_one] using (hb i).1 have heq : v = (d * (b i)⁻¹) • w := by dsimp only [w] rw [smul_smul,mul_assoc,inv_mul_cancel₀ hb0,mul_one] exact hvd have hwn : ‖d * (b i)⁻¹‖ = 1 := by rw [norm_mul,norm_inv,hdn,(hb i).1,inv_one,mul_one] have hwv := rayCanonical_unique hv hc hwn heq exact ⟨a,ha,(hb i).2.trans (congrArg (HilbertCode.encode (u p i)) hwv.symm)⟩ end namespace ArrayObjects.Object.Rolled open MeasureTheory ProbabilityTheory Set open scoped BigOperators attribute [local instance] Rokhlin.instMeasurableSpaceCircle_circleLp Rokhlin.instBorelSpaceCircle_circleLp universe u variable {I : Type u} [Fintype I] [retained11 : DecidableEq I] {X : StandardSpace.{u}} {T : X ≃ᵐ X} {base : InitialLaws I X T} (M : Object I base) def rawLineGraph (Λ : Kernel (Arr I M.U 1) (I → Arr I M.Y 0)) : I → Set (Arr I M.U 1 × HilbertCode (M.ownKernel 0)) := fun i => {pz | ∃ a : I → HilbertCode (M.ownKernel 0), (pz.1,a) ∈ exactCodeSet (M.ownKernel 0) Λ (tupleParameter M) ∧ a i = pz.2} include retained11 in lemma rawCode_of_cone (Λ : Kernel (Arr I M.U 1) (I → Arr I M.Y 0)) [IsMarkovKernel Λ] (p : Arr I M.U 1) (i : I) (hL : Λ p = rawTupleKernel M p) (hm : ∀ j, MeasurePreserving (fun y : I → Arr I M.Y 0 => y j) (Λ p) (M.ownKernel 0 (tupleParameter M p j))) (q : HilbertCode (M.ownKernel 0)) (hb : q.base = tupleParameter M p i) (hc : q.IsCanonical) (hu : q.IsUnimodular) (he : circleLp (M.ownKernel 0 (tupleParameter M p i)) (HilbertCode.circleRep q) (HilbertCode.measurable_circleRep_fixed q) ∈ rawExactCone M i (M.ownKernel 0 (tupleParameter M p i)) p) : (p,q) ∈ rawLineGraph M Λ i := by let _ := retained11 have hq : HilbertCode.encode (tupleParameter M p i) (circleLp (M.ownKernel 0 (tupleParameter M p i)) (HilbertCode.circleRep q) (HilbertCode.measurable_circleRep_fixed q)) = q := by rw [←hb,HilbertCode.circleLp_circleRep q hu,HilbertCode.encode_decode] have hcan : RayCanonical (hilbertTests (M.ownKernel 0 (tupleParameter M p i))) (circleLp (M.ownKernel 0 (tupleParameter M p i)) (HilbertCode.circleRep q) (HilbertCode.measurable_circleRep_fixed q)) := by rw [←hq] at hc change RayCanonical (hilbertTests (M.ownKernel 0 (tupleParameter M p i))) (HilbertCode.decode (HilbertCode.encode (tupleParameter M p i) _)) at hc simpa only [HilbertCode.decode_encode] using hc obtain ⟨f,hf,c,d,hd,he⟩ := he have he' : ∀ᵐ y ∂Λ p, ∏ j, f j (y j) = c := by rw [hL,rawTupleKernel,Kernel.map_apply _ (measurable_rawTuple M)] exact ae_map_descent _ (measurable_rawTuple M) he obtain ⟨a,ha,hai⟩ := canonical_smul_exact_tuple (M.ownKernel 0) Λ (tupleParameter M) p i hm _ hcan (circleLp_norm _ _ _) f hf c d he' hd exact ⟨a,ha,hai.trans hq⟩ end ArrayObjects.Object.Rolled section open MeasureTheory ProbabilityTheory Set variable {P Ω X Y U : Type*} [MeasurableSpace P] [MeasurableSpace Ω] [MeasurableSpace X] [MeasurableSpace Y] [MeasurableSpace U] [retained12 : StandardBorelSpace Ω] [StandardBorelSpace X] [StandardBorelSpace Y] [Nonempty Y] (Λ : Kernel P Ω) [IsMarkovKernel Λ] (x : Ω → X) (y : Ω → Y) (hx : Measurable x) (hy : Measurable y) def joiningPosterior : Kernel (P × X) Y := (Λ.map (fun ω => (x ω,y ω))).condKernel instance : IsMarkovKernel (joiningPosterior Λ x y) := inferInstanceAs (IsMarkovKernel (Λ.map (fun ω => (x ω,y ω))).condKernel) omit [StandardBorelSpace Ω] in include hx hy in lemma joiningPosterior_conditional (p : P) : HasCondDistrib y x ((joiningPosterior Λ x y).sectR p) (Λ p) := by let K := Λ.map (fun ω => (x ω,y ω)) let : IsMarkovKernel K := Kernel.IsMarkovKernel.map _ (hx.prodMk hy) have h := congrArg (fun K : Kernel P (X × Y) => K p) (Kernel.disintegrate K K.condKernel) rw [Kernel.compProd_apply_eq_compProd_sectR,Kernel.fst_apply,Kernel.map_apply _ (hx.prodMk hy)] at h refine ⟨(hx.prodMk hy).aemeasurable,?_⟩ rw [Measure.map_map measurable_fst (hx.prodMk hy)] at h exact h.symm variable (κ : Kernel U X) [IsMarkovKernel κ] (u : P → U) (f : Y → ℂ) (hf : Measurable f) (B : ℝ) (hB : ∀ z, ‖f z‖ ≤ B) omit [StandardBorelSpace Ω] in include hf B hB in lemma posterior_memLp (p : P) : MemLp (fun a => ∫ z, f z ∂joiningPosterior Λ x y (p,a)) 2 (κ (u p)) := by refine MemLp.of_bound (by exact (hf.stronglyMeasurable.integral_kernel (κ := joiningPosterior Λ x y)).comp_measurable measurable_prodMk_left |>.aestronglyMeasurable) B ?_ exact Filter.Eventually.of_forall fun a => by simpa only [probReal_univ,mul_one] using (norm_integral_le_of_norm_le_const (μ := joiningPosterior Λ x y (p,a)) (Filter.Eventually.of_forall hB)) def posteriorVector (p : P) : Lp ℂ 2 (κ (u p)) := (posterior_memLp Λ x y κ u f hf B hB p).toLp _ include retained12 in lemma measurableSection_posteriorVector (hu : Measurable u) : MeasurableSection (posteriorVector Λ x y κ u f hf B hB) := by let _ := retained12 exact measurable_hilbert_encode u hu _ (fun pa => ∫ z, f z ∂joiningPosterior Λ x y pa) (hf.stronglyMeasurable.integral_kernel (κ := joiningPosterior Λ x y)).measurable (fun p => (posterior_memLp Λ x y κ u f hf B hB p).coeFn_toLp) lemma posteriorVector_eq_operator (p : P) (hxm : MeasurePreserving x (Λ p) (κ (u p))) : posteriorVector Λ x y κ u f hf B hB p = JoiningOperator.operator hxm (MeasurePreserving.mk hy rfl) ((MemLp.of_bound hf.aestronglyMeasurable B (Filter.Eventually.of_forall hB) : MemLp f 2 ((Λ p).map y)).toLp f) := by let g := (MemLp.of_bound hf.aestronglyMeasurable B (Filter.Eventually.of_forall hB) : MemLp f 2 ((Λ p).map y)).toLp f have he : (fun ω => g (y ω)) =ᵐ[Λ p] (fun ω => f (y ω)) := (MeasurePreserving.mk hy rfl).quasiMeasurePreserving.ae_eq_comp (MemLp.coeFn_toLp _) have hl : Integrable (fun ω => f (y ω)) (Λ p) := (MemLp.of_bound (hf.comp hy).aestronglyMeasurable B (Filter.Eventually.of_forall (fun ω => hB (y ω))) : MemLp (fun ω => f (y ω)) 2 (Λ p)).integrable (by norm_num) have hop := JoiningOperator.operator_ae_eq_condExp hxm (MeasurePreserving.mk hy rfl) g have hce := JoiningOperator.condExp_of_kernel hxm.measurable (joiningPosterior_conditional Λ x y hxm.measurable hy p) f hf.stronglyMeasurable hl have hop' : (fun ω => JoiningOperator.operator hxm (MeasurePreserving.mk hy rfl) g (x ω)) =ᵐ[Λ p] (fun ω => ∫ z, f z ∂joiningPosterior Λ x y (p,x ω)) := hop.trans ((condExp_congr_ae he).trans hce) have hh : ∀ᵐ z ∂(Λ p).map x, posteriorVector Λ x y κ u f hf B hB p z = JoiningOperator.operator hxm (MeasurePreserving.mk hy rfl) g z := by apply ae_map_descent _ hxm.measurable filter_upwards [hxm.quasiMeasurePreserving.ae_eq_comp (posterior_memLp Λ x y κ u f hf B hB p).coeFn_toLp,hop'] with ω hv ho exact hv.trans ho.symm rw [hxm.map_eq] at hh exact Lp.ext hh end section open MeasureTheory ProbabilityTheory Set variable {Y : Type*} [MeasurableSpace Y] [MeasurableSpace.CountablyGenerated Y] lemma hilbertTestFunction_bounded (t : HilbertTestKey Y) : ∃ B : ℝ, ∀ y, ‖hilbertTestFunction t y‖ ≤ B := by induction t with | nil => exact ⟨0,fun _ => by simp [hilbertTestFunction]⟩ | cons p t ih => obtain ⟨B,hB⟩ := ih refine ⟨‖(p.1.1 : ℂ) + p.1.2 * Complex.I‖ + B,fun y => ?_⟩ change ‖((p.1.1 : ℂ) + p.1.2 * Complex.I) * (p.2.val.indicator (fun _ => (1 : ℂ))) y + hilbertTestFunction t y‖ ≤ _ apply (norm_add_le _ _).trans apply add_le_add _ (hB y) by_cases h : y ∈ p.2.val · simp only [Set.indicator_of_mem h,mul_one,le_refl] · simp only [Set.indicator_of_notMem h,mul_zero,norm_zero] exact norm_nonneg _ variable {P Ω X U : Type*} [MeasurableSpace P] [MeasurableSpace Ω] [MeasurableSpace X] [MeasurableSpace U] [StandardBorelSpace Ω] [StandardBorelSpace X] [StandardBorelSpace Y] [Nonempty Y] (Λ : Kernel P Ω) [IsMarkovKernel Λ] (x : Ω → X) (y : Ω → Y) (κ : Kernel U X) [IsMarkovKernel κ] (u : P → U) def posteriorTest (n : ℕ) (p : P) : Lp ℂ 2 (κ (u p)) := posteriorVector Λ x y κ u (hilbertTestFunction (hilbertTestKeys n)) (hilbertTestFunction_measurable _) (hilbertTestFunction_bounded _).choose (hilbertTestFunction_bounded _).choose_spec p lemma measurableSection_posteriorTest (hu : Measurable u) (n : ℕ) : MeasurableSection (posteriorTest Λ x y κ u n) := measurableSection_posteriorVector Λ x y κ u _ (hilbertTestFunction_measurable _) (hilbertTestFunction_bounded (hilbertTestKeys n)).choose (hilbertTestFunction_bounded (hilbertTestKeys n)).choose_spec hu lemma posteriorTest_eq_operator (hy : Measurable y) (p : P) (hxm : MeasurePreserving x (Λ p) (κ (u p))) (n : ℕ) : posteriorTest Λ x y κ u n p = JoiningOperator.operator hxm (MeasurePreserving.mk hy rfl) (hilbertTests ((Λ p).map y) n) := by rw [posteriorTest,posteriorVector_eq_operator Λ x y hy κ u _ _ _ _ p hxm] congr 1 apply Lp.ext exact (MemLp.coeFn_toLp _).trans (hilbertTestVector_coe _ _).symm lemma operator_range_le_iff_tests {A B : Type*} [NormedAddCommGroup A] [NormedSpace ℂ A] [NormedAddCommGroup B] [NormedSpace ℂ B] (L : A →L[ℂ] B) (v : ℕ → A) (hv : DenseRange v) (S : Submodule ℂ B) (hS : IsClosed (S : Set B)) : (LinearMap.range L.toLinearMap).topologicalClosure ≤ S ↔ ∀ n, L (v n) ∈ S := by constructor · intro h n exact h (Submodule.le_topologicalClosure _ ⟨v n,rfl⟩) · intro h apply Submodule.topologicalClosure_minimal _ _ hS rintro _ ⟨a,rfl⟩ exact hv.induction_on a (hS.preimage L.continuous) h end section open MeasureTheory ProbabilityTheory section attribute [local instance] Rokhlin.instMeasurableSpaceCircle_circleLp Rokhlin.instBorelSpaceCircle_circleLp lemma operator_range_eq_span_tests {A B : Type*} [NormedAddCommGroup A] [NormedSpace ℂ A] [NormedAddCommGroup B] [NormedSpace ℂ B] (L : A →L[ℂ] B) (v : ℕ → A) (hv : DenseRange v) : (LinearMap.range L.toLinearMap).topologicalClosure = (Submodule.span ℂ (Set.range (fun n => L (v n)))).topologicalClosure := by apply le_antisymm · apply (operator_range_le_iff_tests L v hv _ (Submodule.isClosed_topologicalClosure _)).mpr intro n exact Submodule.le_topologicalClosure _ (Submodule.subset_span ⟨n,rfl⟩) · apply Submodule.topologicalClosure_mono apply Submodule.span_le.mpr rintro _ ⟨n,rfl⟩ exact ⟨v n,rfl⟩ variable {P U Y : Type*} [MeasurableSpace P] [MeasurableSpace U] [MeasurableSpace Y] [MeasurableSpace.CountablyGenerated Y] {κ : Kernel U Y} [IsMarkovKernel κ] lemma MeasurableSection.circle (u : P → U) (hu : Measurable u) (f : P → Y → Circle) (hf : Measurable (Function.uncurry f)) : MeasurableSection (fun p => circleLp (κ (u p)) (f p) (hf.comp (measurable_const.prodMk measurable_id))) := by apply measurable_hilbert_encode u hu _ (fun py : P × Y => (f py.1 py.2 : ℂ)) (measurable_subtype_coe.comp hf) intro p exact circleLp_coe _ _ _ lemma MeasurableSection.comp {Q : Type*} [MeasurableSpace Q] {u : P → U} {v : ∀ p, Lp ℂ 2 (κ (u p))} (hv : MeasurableSection v) (g : Q → P) (hg : Measurable g) : MeasurableSection (fun q => v (g q)) := Measurable.comp hv hg end namespace ArrayObjects.Object.Rolled attribute [local instance] Rokhlin.instMeasurableSpaceCircle_circleLp Rokhlin.instBorelSpaceCircle_circleLp universe u variable {I : Type u} [Fintype I] [DecidableEq I] {X : StandardSpace.{u}} {T : X ≃ᵐ X} {base : InitialLaws I X T} (M : Object I base) def rawSlotTest (i : I) (n : ℕ) (p : Arr I M.U 1) : Lp ℂ 2 (M.ownKernel 0 (plane 0 0 i p)) := posteriorTest (M.ownKernel 1) (plane 0 0 i) (slotRest M i) (M.ownKernel 0) (plane 0 0 i) n p def rawSlotTestSpan (i : I) (p : Arr I M.U 1) : Submodule ℂ (Lp ℂ 2 (M.ownKernel 0 (plane 0 0 i p))) := (Submodule.span ℂ (Set.range (fun n => rawSlotTest M i n p))).topologicalClosure lemma measurableSection_rawSlotTest (i : I) (n : ℕ) : MeasurableSection (rawSlotTest M i n) := measurableSection_posteriorTest _ _ _ _ _ (measurable_plane _ _ _) n lemma rawSlotTest_eq_operator (i : I) (p : Arr I M.U 1) (hp : MeasurePreserving (plane 0 0 i) (M.ownKernel 1 p) (M.ownKernel 0 (plane 0 0 i p))) (n : ℕ) : rawSlotTest M i n p = JoiningOperator.operator hp (MeasurePreserving.mk (measurable_slotRest M i) rfl) (hilbertTests ((M.ownKernel 1 p).map (slotRest M i)) n) := posteriorTest_eq_operator _ _ _ _ _ (measurable_slotRest M i) p hp n lemma rawSlotActive_eq_testSpan (hI : 2 ≤ Fintype.card I) (i : I) : ∀ᵐ p ∂M.parameterLaw 1, rawSlotActive M i (M.ownKernel 0 (plane 0 0 i p)) p = rawSlotTestSpan M i p := by have hm := ConditionalFibres.marginal (measurable_plane 0 0 i) (M.ownKernel_conditional 1) (M.plane_conditional hI 0 i) filter_upwards [hm] with p hp have hp' : MeasurePreserving (plane 0 0 i) (M.ownKernel 1 p) (M.ownKernel 0 (plane 0 0 i p)) := hp rw [rawSlotActive_eq M i _ p hp',rawSlotTestSpan] have ht : (fun n => rawSlotTest M i n p) = (fun n => JoiningOperator.operator hp' (MeasurePreserving.mk (measurable_slotRest M i) rfl) (hilbertTests ((M.ownKernel 1 p).map (slotRest M i)) n)) := funext (rawSlotTest_eq_operator M i p hp') rw [ht] exact operator_range_eq_span_tests _ _ (hilbertTests_dense _) variable {P : Type*} [MeasurableSpace P] lemma measurableSet_rawSlot_mem (i : I) (f : P → Arr I M.Y 0 → Circle) (hf : Measurable (Function.uncurry f)) : MeasurableSet {pq : P × Arr I M.U 1 | circleLp (M.ownKernel 0 (plane 0 0 i pq.2)) (f pq.1) (hf.comp (measurable_const.prodMk measurable_id)) ∈ rawSlotTestSpan M i pq.2} := by apply measurableSet_section_mem_span ((measurable_plane _ _ _).comp measurable_snd) (fun n => (measurableSection_rawSlotTest M i n).comp Prod.snd measurable_snd) exact MeasurableSection.circle _ ((measurable_plane _ _ _).comp measurable_snd) (fun pq => f pq.1) (hf.comp ((measurable_fst.comp measurable_fst).prodMk measurable_snd)) def rawSlotIndicator (i : I) (f : P → Arr I M.Y 0 → Circle) (hf : Measurable (Function.uncurry f)) (p : P) (q : Arr I M.U 1) : Bool := by classical exact decide (circleLp (M.ownKernel 0 (plane 0 0 i q)) (f p) (hf.comp (measurable_const.prodMk measurable_id)) ∈ rawSlotTestSpan M i q) lemma measurable_rawSlotIndicator (i : I) (f : P → Arr I M.Y 0 → Circle) (hf : Measurable (Function.uncurry f)) : Measurable (Function.uncurry (rawSlotIndicator M i f hf)) := by classical change Measurable (fun pq : P × Arr I M.U 1 => decide (circleLp (M.ownKernel 0 (plane 0 0 i pq.2)) (f pq.1) (hf.comp (measurable_const.prodMk measurable_id)) ∈ rawSlotTestSpan M i pq.2)) apply measurable_to_bool simpa only [Set.preimage,Set.mem_singleton_iff,decide_eq_true_eq] using measurableSet_rawSlot_mem M i f hf lemma rawSlotIndicator_eq_true_iff (i : I) (f : P → Arr I M.Y 0 → Circle) (hf : Measurable (Function.uncurry f)) (p : P) (q : Arr I M.U 1) : rawSlotIndicator M i f hf p q = true ↔ circleLp (M.ownKernel 0 (plane 0 0 i q)) (f p) (hf.comp (measurable_const.prodMk measurable_id)) ∈ rawSlotTestSpan M i q := by classical exact decide_eq_true_iff end ArrayObjects.Object.Rolled end section open MeasureTheory ProbabilityTheory Set open scoped ENNReal variable {Ω : Type*} [MeasurableSpace Ω] {μ : Measure Ω} [IsProbabilityMeasure μ] lemma independent_equal_indicators {f g : Ω → Bool} (hf : Measurable f) (hfg : IndepFun f g μ) (he : f =ᵐ[μ] g) : (∀ᵐ ω ∂μ, f ω = false) ∨ ∀ᵐ ω ∂μ, f ω = true := by have hi : IndepFun f f μ := hfg.congr Filter.EventuallyEq.rfl he.symm have hp := hi.measure_inter_preimage_eq_mul ({true} : Set Bool) ({true} : Set Bool) (measurableSet_singleton _) (measurableSet_singleton _) simp only [inter_self] at hp let p := μ (f ⁻¹' ({true} : Set Bool)) have hfin : p ≠ ∞ := measure_ne_top _ _ have hz : p = 0 ∨ p = 1 := by by_cases h : p = 0 · exact Or.inl h · right apply (ENNReal.mul_right_inj h hfin).mp simpa only [p,mul_one] using hp.symm rcases hz with hz | ho · left have ha : ∀ᵐ ω ∂μ, ω ∉ f ⁻¹' ({true} : Set Bool) := by exact ae_iff.mpr (by simpa only [p,not_not,Set.ofPred_mem_eq] using hz) filter_upwards [ha] with ω hω cases h : f ω <;> simp_all · right exact (mem_ae_iff_prob_eq_one ((measurableSet_singleton true).preimage hf)).mpr ho end section open MeasureTheory ProbabilityTheory variable {X Y : Type*} [MeasurableSpace X] [MeasurableSpace Y] {μ : Measure X} {ν : Measure Y} [IsProbabilityMeasure μ] [IsProbabilityMeasure ν] lemma product_equal_positive_indicators (f : X → Bool) (g : Y → Bool) (hf : Measurable f) (hg : Measurable g) (he : ∀ᵐ p ∂μ.prod ν, f p.1 = g p.2) (hp : μ {x | f x = true} ≠ 0) : (∀ᵐ x ∂μ, f x = true) ∧ ∀ᵐ y ∂ν, g y = true := by have h := independent_equal_indicators (hf.comp measurable_fst) (indepFun_prod hf hg) he have htrue : ∀ᵐ p ∂μ.prod ν, f p.1 = true := by rcases h with hz | ht · have hfalse : ∀ᵐ x ∂μ, f x = false := by rw [←(measurePreserving_fst (μ := μ) (ν := ν)).map_eq] exact (ae_map_iff measurable_fst.aemeasurable (measurableSet_eq_fun hf measurable_const)).mpr hz apply False.elim apply hp simpa only [Bool.not_eq_false] using (ae_iff.mp hfalse) · exact ht constructor · rw [←(measurePreserving_fst (μ := μ) (ν := ν)).map_eq] exact (ae_map_iff measurable_fst.aemeasurable (measurableSet_eq_fun hf measurable_const)).mpr htrue · rw [←(measurePreserving_snd (μ := μ) (ν := ν)).map_eq] apply (ae_map_iff measurable_snd.aemeasurable (measurableSet_eq_fun hg measurable_const)).mpr filter_upwards [htrue,he] with p hp he exact he ▸ hp variable {Ω S : Type*} [MeasurableSpace Ω] [MeasurableSpace S] [StandardBorelSpace Ω] [StandardBorelSpace S] [StandardBorelSpace X] [StandardBorelSpace Y] {ρ : Measure Ω} [IsProbabilityMeasure ρ] {s : Ω → S} {x : Ω → X} {y : Ω → Y} {κ : Kernel S X} {l : Kernel S Y} [IsMarkovKernel κ] [IsMarkovKernel l] omit [StandardBorelSpace Ω] [StandardBorelSpace S] [StandardBorelSpace X] in lemma conditional_joint_ae_lift (hs : Measurable s) (hx : Measurable x) (hκ : HasCondDistrib x s κ ρ) {P : S → X → Prop} (hPm : MeasurableSet {p : S × X | P p.1 p.2}) (hP : ∀ᵐ a ∂ρ.map s, ∀ᵐ b ∂κ a, P a b) : ∀ᵐ ω ∂ρ, P (s ω) (x ω) := by have h : ∀ᵐ p ∂(ρ.map s) ⊗ₘ κ, P p.1 p.2 := (Measure.ae_compProd_iff hPm).mpr hP rw [←hκ.map_eq] at h exact ae_of_ae_map (hs.prodMk hx).aemeasurable h lemma conditional_equal_positive_indicators (hs : Measurable s) (hx : Measurable x) (hy : Measurable y) (hκ : HasCondDistrib (fun ω => (x ω,y ω)) s (κ ×ₖ l) ρ) (f : S → X → Bool) (g : S → Y → Bool) (hf : Measurable (Function.uncurry f)) (hg : Measurable (Function.uncurry g)) (he : ∀ᵐ ω ∂ρ, f (s ω) (x ω) = g (s ω) (y ω)) (hp : ∀ᵐ a ∂ρ.map s, κ a {z | f a z = true} ≠ 0) : ∀ᵐ ω ∂ρ, f (s ω) (x ω) = true ∧ g (s ω) (y ω) = true := by have hd := conditional_ae_descent (κ := κ ×ₖ l) (P := fun a p => f a p.1 = g a p.2) hs (hx.prodMk hy) hκ he have ht : ∀ᵐ a ∂ρ.map s, ∀ᵐ p ∂(κ ×ₖ l) a, f a p.1 = true ∧ g a p.2 = true := by filter_upwards [hd,hp] with a ha hp rw [Kernel.prod_apply] at ha ⊢ have h := product_equal_positive_indicators (f a) (g a) (hf.comp (measurable_const.prodMk measurable_id)) (hg.comp (measurable_const.prodMk measurable_id)) ha hp exact (measurePreserving_fst.quasiMeasurePreserving.ae h.1).and (measurePreserving_snd.quasiMeasurePreserving.ae h.2) apply conditional_joint_ae_lift hs (hx.prodMk hy) hκ _ ht exact ((measurableSet_eq_fun (hf.comp (measurable_fst.prodMk (measurable_fst.comp measurable_snd))) measurable_const).inter (measurableSet_eq_fun (hg.comp (measurable_fst.prodMk (measurable_snd.comp measurable_snd))) measurable_const)) end section open MeasureTheory ProbabilityTheory variable {Ω S Z : Type*} [MeasurableSpace Ω] [MeasurableSpace S] [MeasurableSpace Z] {μ : Measure Ω} [IsProbabilityMeasure μ] {s : Ω → S} {z : Ω → Z} {κ : Kernel S Z} [IsSFiniteKernel κ] lemma conditional_ae_lift (hs : Measurable s) (hz : Measurable z) (hκ : HasCondDistrib z s κ μ) {P : Z → Prop} (hPm : MeasurableSet {z | P z}) (hP : ∀ᵐ a ∂μ.map s, ∀ᵐ b ∂κ a, P b) : ∀ᵐ ω ∂μ, P (z ω) := by have h : ∀ᵐ sb ∂(μ.map s) ⊗ₘ κ, P sb.2 := (Measure.ae_compProd_iff (hPm.preimage measurable_snd)).mpr hP rw [←hκ.map_eq] at h exact ae_of_ae_map (hs.prodMk hz).aemeasurable h end namespace ArrayObjects.Object.Rolled open MeasureTheory ProbabilityTheory open scoped BigOperators ENNReal local instance : Fact ((2 : ℝ≥0∞) ≠ ∞) := ⟨by norm_num⟩ attribute [local instance] Rokhlin.instMeasurableSpaceCircle_circleLp Rokhlin.instBorelSpaceCircle_circleLp universe u variable {I : Type u} [Fintype I] [DecidableEq I] {X : StandardSpace.{u}} {T : X ≃ᵐ X} {base : InitialLaws I X T} (M : Object I base) omit [DecidableEq I] in lemma parameterCoordinate_conditional (i : I) : HasCondDistrib (id : Arr I M.U 1 → Arr I M.U 1) (plane 0 0 i) (M.parameterCoordinateKernel i) (M.parameterLaw 1) := ⟨((measurable_plane _ _ _).prodMk measurable_id).aemeasurable, (compProd_map_condDistrib (by fun_prop) measurable_id.aemeasurable).symm⟩ omit [DecidableEq I] in lemma coordinate_conditional_descent (i : I) {P : Arr I M.U 0 → Arr I M.U 1 → Prop} (hP : ∀ᵐ p ∂M.parameterLaw 1, P (plane 0 0 i p) p) : ∀ᵐ u ∂M.parameterLaw 0, ∀ᵐ p ∂M.parameterCoordinateKernel i u, P u p := by have h := conditional_ae_descent (κ := M.parameterCoordinateKernel i) (measurable_plane _ _ _) measurable_id (parameterCoordinate_conditional M i) hP rwa [M.parameterLaw_consistent 0 0 i] at h lemma raw_diagonal_binary (hM : M.IsSaturated) (hk : 3 ≤ Fintype.card I) (i : I) : ∀ᵐ u ∂M.parameterLaw 0, ∀ᵐ pq ∂(M.parameterCoordinateKernel i u).prod (M.parameterCoordinateKernel i u), ∀ (f : I → Arr I M.Y 0 → Circle) (hf : ∀ j, Measurable (f j)) (c : Circle), (∀ᵐ y ∂M.ownKernel 1 pq.1, ∏ j, f j (plane 0 0 j y) = c) → let v := circleLp (M.ownKernel 0 u) (f i) (hf i) (rawSlotActive M i (M.ownKernel 0 u) pq.2).starProjection v = 0 ∨ (rawSlotActive M i (M.ownKernel 0 u) pq.2).starProjection v = v := by let P : Arr I M.U 0 → (Arr I M.U 1 × Arr I M.U 1) → Prop := fun u pq => ∀ (f : I → Arr I M.Y 0 → Circle) (hf : ∀ j, Measurable (f j)) (c : Circle), (∀ᵐ y ∂M.ownKernel 1 pq.1, ∏ j, f j (plane 0 0 j y) = c) → let v := circleLp (M.ownKernel 0 u) (f i) (hf i) (rawSlotActive M i (M.ownKernel 0 u) pq.2).starProjection v = 0 ∨ (rawSlotActive M i (M.ownKernel 0 u) pq.2).starProjection v = v have h := conditional_ae_descent (P := P) ((measurable_plane 0 0 i).comp (measurable_plane 1 0 i)) ((measurable_plane _ _ _).prodMk (measurable_plane _ _ _)) (M.diagonal_parameter_product hM (by omega) i) (raw_row_line_projection M hM hk i i) rw [←Measure.map_map (measurable_plane 0 0 i) (measurable_plane 1 0 i), M.parameterLaw_consistent 1 0 i,M.parameterLaw_consistent 0 0 i] at h simpa only [Kernel.prod_apply] using h omit [DecidableEq I] in lemma raw_coordinate_marginal (hI : 2 ≤ Fintype.card I) (i : I) : ∀ᵐ u ∂M.parameterLaw 0, ∀ᵐ p ∂M.parameterCoordinateKernel i u, MeasurePreserving (plane 0 0 i) (M.ownKernel 1 p) (M.ownKernel 0 u) := by exact coordinate_conditional_descent M i (ConditionalFibres.marginal (measurable_plane 0 0 i) (M.ownKernel_conditional 1) (M.plane_conditional hI 0 i)) lemma raw_slot_mem_parameter_congr (i : I) (u v : Arr I M.U 0) (h : u = v) (p : Arr I M.U 1) (f : Arr I M.Y 0 → Circle) (hf : Measurable f) : (circleLp (M.ownKernel 0 u) f hf ∈ rawSlotActive M i (M.ownKernel 0 u) p) ↔ (circleLp (M.ownKernel 0 v) f hf ∈ rawSlotActive M i (M.ownKernel 0 v) p) := by subst v rfl lemma raw_diagonal_positive (hM : M.IsSaturated) (hk : 3 ≤ Fintype.card I) (i : I) (f : Arr I M.U 1 → I → Arr I M.Y 0 → Circle) (hf : ∀ j, Measurable (fun py : Arr I M.U 1 × Arr I M.Y 0 => f py.1 j py.2)) (he : ∀ᵐ p ∂M.parameterLaw 1, ∃ c : Circle, ∀ᵐ y ∂M.ownKernel 1 p, ∏ j, f p j (plane 0 0 j y) = c) : ∀ᵐ p ∂M.parameterLaw 1, M.parameterCoordinateKernel i (plane 0 0 i p) {q | rawSlotIndicator M i (fun p => f p i) (hf i) p q = true} ≠ 0 := by have hI : 2 ≤ Fintype.card I := by omega have hq := coordinate_conditional_descent M i (P := fun u p => plane 0 0 i p = u) (Filter.Eventually.of_forall fun _ => rfl) have ht := coordinate_conditional_descent M i (P := fun _ p => rawSlotActive M i (M.ownKernel 0 (plane 0 0 i p)) p = rawSlotTestSpan M i p) (rawSlotActive_eq_testSpan M hI i) have hex := coordinate_conditional_descent M i (P := fun _ p => ∃ c : Circle, ∀ᵐ y ∂M.ownKernel 1 p, ∏ j, f p j (plane 0 0 j y) = c) he have hp : ∀ᵐ u ∂M.parameterLaw 0, ∀ᵐ p ∂M.parameterCoordinateKernel i u, M.parameterCoordinateKernel i (plane 0 0 i p) {q | rawSlotIndicator M i (fun p => f p i) (hf i) p q = true} ≠ 0 := by filter_upwards [raw_diagonal_binary M hM hk i,raw_coordinate_marginal M hI i,hq,ht,hex] with u hbin hm hq ht hex have hnon := active_projection_not_ae_zero (M.parameterCoordinateKernel i u) (fun p => rawSlotActive M i (M.ownKernel 0 u) p) filter_upwards [Measure.ae_ae_of_ae_prod hbin,hm,hq,hex,hnon] with p hbin hm hpu hex hnon obtain ⟨c, hc⟩ := hex let hf' : ∀ j, Measurable (f p j) := fun j => (hf j).comp (measurable_const.prodMk measurable_id) let v := circleLp (M.ownKernel 0 u) (f p i) (hf' i) have hva : v ∈ rawSlotActive M i (M.ownKernel 0 u) p := raw_tuple_active M i p _ hm (f p) hf' c hc have hne : v ≠ 0 := circleLp_ne_zero _ _ _ intro hz rw [hpu] at hz have hnmem : ∀ᵐ q ∂M.parameterCoordinateKernel i u, rawSlotIndicator M i (fun p => f p i) (hf i) p q ≠ true := by apply ae_iff.mpr simpa only [not_not] using hz apply hnon v hva hne filter_upwards [hbin,hq,ht,hnmem] with q hbin hqu ht hnmem rcases hbin (f p) hf' c hc with hzero | hself · exact hzero · apply False.elim apply hnmem apply (rawSlotIndicator_eq_true_iff M i (fun p => f p i) (hf i) p q).mpr rw [←ht] have hmem := (rawSlotActive M i (M.ownKernel 0 u) q).starProjection_eq_self_iff.mp hself exact (raw_slot_mem_parameter_congr M i u _ hqu.symm q (f p i) (hf' i)).mp hmem have hmeas : MeasurableSet {p : Arr I M.U 1 | M.parameterCoordinateKernel i (plane 0 0 i p) {q | rawSlotIndicator M i (fun p => f p i) (hf i) p q = true} ≠ 0} := by have h := Kernel.measurable_kernel_prodMk_left (κ := (M.parameterCoordinateKernel i).comap (plane 0 0 i) (measurable_plane _ _ _)) (measurableSet_eq_fun (measurable_rawSlotIndicator M i (fun p => f p i) (hf i)) (measurable_const (a := true))) exact (measurableSet_eq_fun h (measurable_const (a := (0 : ℝ≥0∞)))).compl apply conditional_ae_lift (κ := M.parameterCoordinateKernel i) (measurable_plane _ _ _) measurable_id (parameterCoordinate_conditional M i) hmeas rwa [M.parameterLaw_consistent 0 0 i] end ArrayObjects.Object.Rolled section open MeasureTheory ProbabilityTheory namespace FiniteKernel variable {ι S Y : Type*} [Fintype ι] [MeasurableSpace S] [MeasurableSpace Y] lemma map_pair (κ : ι → Kernel S Y) [∀ i, IsMarkovKernel (κ i)] (i j : ι) (hij : i ≠ j) : (pi κ).map (fun y => (y i,y j)) = κ i ×ₖ κ j := by ext s : 1 rw [Kernel.map_apply _ ((measurable_pi_apply i).prodMk (measurable_pi_apply j)),pi_apply,Kernel.prod_apply] have hi : iIndepFun (fun i : ι => Function.eval i) (Measure.pi (fun i => κ i s)) := iIndepFun_pi (fun _ => measurable_id.aemeasurable) rw [(hi.indepFun hij).map_prod_eq_prod_map_map (measurable_pi_apply i).aemeasurable (measurable_pi_apply j).aemeasurable, (measurePreserving_eval (fun i => κ i s) i).map_eq, (measurePreserving_eval (fun i => κ i s) j).map_eq] end FiniteKernel namespace ArrayObjects.Object.Rolled universe u variable {I : Type u} [Fintype I] [DecidableEq I] {X : StandardSpace.{u}} {T : X ≃ᵐ X} {base : InitialLaws I X T} (M : Object I base) lemma parameter_pair_geometry (hM : M.IsSaturated) (hk : 3 ≤ Fintype.card I) (a j t : I) (hjt : j ≠ t) : HasCondDistrib (fun e => (plane 1 (Fin.last 1) j e,plane 1 (Fin.last 1) t e)) (plane 1 0 a) ((M.parameterCoordinateKernel a).comap (plane 0 0 j) (measurable_plane _ _ _) ×ₖ (M.parameterCoordinateKernel a).comap (plane 0 0 t) (measurable_plane _ _ _)) (M.parameterLaw 2) := by have hpair : ({j,t} : Finset I) ≠ Finset.univ := by intro h have := pair_complement_nonempty hk j t simp only [h,Finset.compl_univ,Finset.not_nonempty_empty] at this let j' : ({j,t} : Finset I) := ⟨j,by simp⟩ let t' : ({j,t} : Finset I) := ⟨t,by simp⟩ have hne : j' ≠ t' := fun h => hjt (congrArg Subtype.val h) have h := (parameter_geometry M hM (by omega) a {j,t} hpair).comp_left ((measurable_pi_apply j').prodMk (measurable_pi_apply t')) rw [FiniteKernel.map_pair _ j' t' hne] at h exact h end ArrayObjects.Object.Rolled end namespace ArrayObjects.Object.Rolled open MeasureTheory ProbabilityTheory Set open scoped BigOperators section CircleSlotIndicators attribute [local instance] Rokhlin.instMeasurableSpaceCircle_circleLp Rokhlin.instBorelSpaceCircle_circleLp universe u variable {I : Type u} [Fintype I] [DecidableEq I] {X : StandardSpace.{u}} {T : X ≃ᵐ X} {base : InitialLaws I X T} (M : Object I base) lemma rawSlotIndicator_on_square (hI : 2 ≤ Fintype.card I) (a j : I) (f : Arr I M.U 1 → Arr I M.Y 0 → Circle) (hf : Measurable (Function.uncurry f)) : ∀ᵐ e ∂M.parameterLaw 2, rawSlotIndicator M a f hf (plane 1 0 a e) (plane 1 (Fin.last 1) j e) = true ↔ circleLp (M.ownKernel 0 (plane 0 0 j (plane 1 0 a e))) (f (plane 1 0 a e)) (hf.comp (measurable_const.prodMk measurable_id)) ∈ rawSlotActive M a (M.ownKernel 0 (plane 0 0 j (plane 1 0 a e))) (plane 1 (Fin.last 1) j e) := by have hmp : MeasurePreserving (plane 1 (Fin.last 1) j) (M.parameterLaw 2) (M.parameterLaw 1) := ⟨measurable_plane _ _ _,M.parameterLaw_consistent _ _ _⟩ filter_upwards [hmp.quasiMeasurePreserving.ae (rawSlotActive_eq_testSpan M hI a)] with e he rw [rawSlotIndicator_eq_true_iff,←he] have hloc : plane 0 0 j (plane 1 0 a e) = plane 0 0 a (plane 1 (Fin.last 1) j e) := by funext x simp only [plane] congr 1 funext t fin_cases t <;> rfl rw [hloc] lemma raw_row_indicators_equal (hM : M.IsSaturated) (hk : 3 ≤ Fintype.card I) (a j t : I) (hjt : j ≠ t) (f : Arr I M.U 1 → I → Arr I M.Y 0 → Circle) (hf : ∀ i, Measurable (fun py : Arr I M.U 1 × Arr I M.Y 0 => f py.1 i py.2)) (he : ∀ᵐ p ∂M.parameterLaw 1, ∃ c : Circle, ∀ᵐ y ∂M.ownKernel 1 p, ∏ i, f p i (plane 0 0 i y) = c) : ∀ᵐ e ∂M.parameterLaw 2, rawSlotIndicator M a (fun p => f p j) (hf j) (plane 1 0 a e) (plane 1 (Fin.last 1) j e) = rawSlotIndicator M a (fun p => f p t) (hf t) (plane 1 0 a e) (plane 1 (Fin.last 1) t e) := by have hr : MeasurePreserving (plane 1 0 a) (M.parameterLaw 2) (M.parameterLaw 1) := ⟨measurable_plane _ _ _,M.parameterLaw_consistent _ _ _⟩ filter_upwards [raw_row_membership_transfer M hM hk a j t hjt, rawSlotIndicator_on_square M (by omega) a j (fun p => f p j) (hf j), rawSlotIndicator_on_square M (by omega) a t (fun p => f p t) (hf t),hr.quasiMeasurePreserving.ae he] with e htrans hj ht hex obtain ⟨c,hc⟩ := hex apply Bool.eq_iff_iff.mpr rw [hj,ht] exact htrans (f (plane 1 0 a e)) (fun i => (hf i).comp (measurable_const.prodMk measurable_id)) c hc lemma raw_row_membership_forced (hM : M.IsSaturated) (hk : 3 ≤ Fintype.card I) (a j : I) (f : Arr I M.U 1 → I → Arr I M.Y 0 → Circle) (hf : ∀ i, Measurable (fun py : Arr I M.U 1 × Arr I M.Y 0 => f py.1 i py.2)) (he : ∀ᵐ p ∂M.parameterLaw 1, ∃ c : Circle, ∀ᵐ y ∂M.ownKernel 1 p, ∏ i, f p i (plane 0 0 i y) = c) : ∀ᵐ e ∂M.parameterLaw 2, circleLp (M.ownKernel 0 (plane 0 0 j (plane 1 0 a e))) (f (plane 1 0 a e) j) ((hf j).comp (measurable_const.prodMk measurable_id)) ∈ rawSlotActive M a (M.ownKernel 0 (plane 0 0 j (plane 1 0 a e))) (plane 1 (Fin.last 1) j e) := by have hforce (t : I) (hat : a ≠ t) : ∀ᵐ e ∂M.parameterLaw 2, rawSlotIndicator M a (fun p => f p a) (hf a) (plane 1 0 a e) (plane 1 (Fin.last 1) a e) = true ∧ rawSlotIndicator M a (fun p => f p t) (hf t) (plane 1 0 a e) (plane 1 (Fin.last 1) t e) = true := by apply conditional_equal_positive_indicators (measurable_plane _ _ _) (measurable_plane _ _ _) (measurable_plane _ _ _) (parameter_pair_geometry M hM hk a a t hat) (rawSlotIndicator M a (fun p => f p a) (hf a)) (rawSlotIndicator M a (fun p => f p t) (hf t)) (measurable_rawSlotIndicator M a _ _) (measurable_rawSlotIndicator M a _ _) (raw_row_indicators_equal M hM hk a a t hat f hf he) rw [M.parameterLaw_consistent 1 0 a] exact raw_diagonal_positive M hM hk a f hf he have hind : ∀ᵐ e ∂M.parameterLaw 2, rawSlotIndicator M a (fun p => f p j) (hf j) (plane 1 0 a e) (plane 1 (Fin.last 1) j e) = true := by by_cases haj : a = j · subst j have hex : ∃ t : I, a ≠ t := by by_contra! h have hc : Fintype.card I ≤ 1 := Fintype.card_le_one_iff.mpr (fun x y => (h x).symm.trans (h y)) omega obtain ⟨t,hat⟩ := hex exact (hforce t hat).mono fun _ h => h.1 · exact (hforce j haj).mono fun _ h => h.2 filter_upwards [hind,rawSlotIndicator_on_square M (by omega) a j (fun p => f p j) (hf j)] with e he hh exact hh.mp he omit [DecidableEq I] in lemma parameter_cell_commute (a j : I) (e : Arr I M.U 2) : tupleParameter M (plane 1 0 a e) j = tupleParameter M (plane 1 (Fin.last 1) j e) a := by funext x simp only [tupleParameter,plane] congr 1 funext t fin_cases t <;> rfl omit [DecidableEq I] in lemma rawExactCone_parameter_congr (i : I) (u v : Arr I M.U 0) (h : u = v) (p : Arr I M.U 1) (f : Arr I M.Y 0 → Circle) (hf : Measurable f) : (circleLp (M.ownKernel 0 u) f hf ∈ rawExactCone M i (M.ownKernel 0 u) p) ↔ (circleLp (M.ownKernel 0 v) f hf ∈ rawExactCone M i (M.ownKernel 0 v) p) := by subst v rfl lemma rawLineGraph_row_inclusion (hM : M.IsSaturated) (hk : 3 ≤ Fintype.card I) (Λ : Kernel (Arr I M.U 1) (I → Arr I M.Y 0)) [IsMarkovKernel Λ] (hL : Λ =ᵐ[M.parameterLaw 1] rawTupleKernel M) (hm : ∀ p j, MeasurePreserving (fun y : I → Arr I M.Y 0 => y j) (Λ p) (M.ownKernel 0 (tupleParameter M p j))) (hind : ∀ p j, iIndepFun (fun t : (Finset.univ.erase j : Finset I) => fun y : I → Arr I M.Y 0 => y t) (Λ p)) (a j : I) : ∀ᵐ e ∂M.parameterLaw 2, ∀ q : HilbertCode (M.ownKernel 0), (plane 1 0 a e,q) ∈ rawLineGraph M Λ j → (plane 1 (Fin.last 1) j e,q) ∈ rawLineGraph M Λ a := by classical obtain ⟨D,s,hD,hs,hbase,hmem,_,hcover⟩ := exactCode_sections (M.ownKernel 0) Λ (tupleParameter M) (measurable_tupleParameter M) hk hm hind let f : ℕ → Arr I M.U 1 → I → Arr I M.Y 0 → Circle := fun n p i y => if p ∈ D n then HilbertCode.circleRep (s n p i) y else 1 have hf (n i) : Measurable (fun py : Arr I M.U 1 × Arr I M.Y 0 => f n py.1 i py.2) := by exact (HilbertCode.measurable_circleRep.comp ((((measurable_pi_apply i).comp (hs n)).comp measurable_fst).prodMk measurable_snd)).ite ((hD n).preimage measurable_fst) measurable_const have hex (n) : ∀ᵐ p ∂M.parameterLaw 1, ∃ c : Circle, ∀ᵐ y ∂M.ownKernel 1 p, ∏ i, f n p i (plane 0 0 i y) = c := by filter_upwards [hL] with p hp by_cases hpd : p ∈ D n · obtain ⟨c,hc⟩ := exactCode_circle_tuple (M.ownKernel 0) Λ (tupleParameter M) (hm p) (hmem n p hpd) rw [hp,rawTupleKernel,Kernel.map_apply _ (measurable_rawTuple M)] at hc refine ⟨c,?_⟩ have he := ae_of_ae_map (measurable_rawTuple M).aemeasurable hc simpa only [f,ite_eq_left hpd,rawTuple] using he · exact ⟨1,Filter.Eventually.of_forall (fun _ => by simp only [f,ite_eq_right hpd,Finset.prod_const_one])⟩ have hrow : MeasurePreserving (plane 1 0 a) (M.parameterLaw 2) (M.parameterLaw 1) := ⟨measurable_plane _ _ _,M.parameterLaw_consistent _ _ _⟩ have hcol : MeasurePreserving (plane 1 (Fin.last 1) j) (M.parameterLaw 2) (M.parameterLaw 1) := ⟨measurable_plane _ _ _,M.parameterLaw_consistent _ _ _⟩ filter_upwards [ae_all_iff.mpr (fun n => raw_row_membership_forced M hM hk a j (f n) (hf n) (hex n)), raw_row_active_to_column_exact M hM hk a j, hrow.quasiMeasurePreserving.ae (ae_all_iff.mpr hex),hcol.quasiMeasurePreserving.ae hL] with e hforce hcone hexes hLe intro q hq obtain ⟨b,hb,hbi⟩ := hq dsimp only [Prod.fst,Prod.snd] at hb hbi obtain ⟨n,hnd,hns⟩ := hcover (_,b) hb dsimp only [Prod.fst,Prod.snd] at hnd hns have hfq : f n (plane 1 0 a e) j = HilbertCode.circleRep q := by funext y dsimp only [f] rw [ite_eq_left hnd,hns,hbi] obtain ⟨c,hc⟩ := hexes n have hce := hcone (f n (plane 1 0 a e)) (fun i => (hf n i).comp (measurable_const.prodMk measurable_id)) c hc (hforce n) have hcc : q.IsCanonical ∧ q.IsUnimodular := by rw [←hbi] exact hb.2.1 j have hqb : q.base = tupleParameter M (plane 1 (Fin.last 1) j e) a := by rw [←hbi] exact (hb.1 j).trans (parameter_cell_commute M a j e) apply rawCode_of_cone M Λ _ a hLe (hm _) q hqb hcc.1 hcc.2 change circleLp (M.ownKernel 0 (tupleParameter M (plane 1 0 a e) j)) _ _ ∈ rawExactCone M a (M.ownKernel 0 (tupleParameter M (plane 1 0 a e) j)) _ at hce apply (rawExactCone_parameter_congr M a _ _ (parameter_cell_commute M a j e) _ q.circleRep (HilbertCode.measurable_circleRep_fixed q)).mp simpa only [hfq] using hce end CircleSlotIndicators universe u variable {I : Type u} [Fintype I] [DecidableEq I] {X : StandardSpace.{u}} {T : X ≃ᵐ X} {base : InitialLaws I X T} (M : Object I base) omit [DecidableEq I] in lemma rawLineGraph_base {Λ : Kernel (Arr I M.U 1) (I → Arr I M.Y 0)} {p : Arr I M.U 1} {i : I} {q : HilbertCode (M.ownKernel 0)} (h : (p,q) ∈ rawLineGraph M Λ i) : q.base = tupleParameter M p i := by obtain ⟨a,ha,hq⟩ := h dsimp only [Prod.fst,Prod.snd] at ha hq rw [←hq] exact ha.1 i omit [DecidableEq I] in lemma rawLineGraph_canonical {Λ : Kernel (Arr I M.U 1) (I → Arr I M.Y 0)} {p : Arr I M.U 1} {i : I} {q : HilbertCode (M.ownKernel 0)} (h : (p,q) ∈ rawLineGraph M Λ i) : q.IsCanonical ∧ q.IsUnimodular := by obtain ⟨a,ha,hq⟩ := h dsimp only [Prod.fst,Prod.snd] at ha hq rw [←hq] exact ha.2.1 i lemma rawLineGraph_separated (hk : 3 ≤ Fintype.card I) (Λ : Kernel (Arr I M.U 1) (I → Arr I M.Y 0)) [IsMarkovKernel Λ] (hm : ∀ p j, MeasurePreserving (fun y : I → Arr I M.Y 0 => y j) (Λ p) (M.ownKernel 0 (tupleParameter M p j))) (hind : ∀ p j, iIndepFun (fun t : (Finset.univ.erase j : Finset I) => fun y : I → Arr I M.Y 0 => y t) (Λ p)) (p : Arr I M.U 1) (i : I) (q r : HilbertCode (M.ownKernel 0)) (hq : (p,q) ∈ rawLineGraph M Λ i) (hr : (p,r) ∈ rawLineGraph M Λ i) (hne : q ≠ r) : 1 ≤ HilbertCode.distance q r := by obtain ⟨a,ha,hai⟩ := hq obtain ⟨b,hb,hbi⟩ := hr dsimp only [Prod.fst,Prod.snd] at ha hb hai hbi have h := HilbertCode.exact_codes_dichotomy (κ := M.ownKernel 0) hk (Λ p) a b (fun j => (ha.1 j).trans (hb.1 j).symm) ha.2.1 hb.2.1 (fun j => by simpa only [ha.1 j] using hm p j) (hind p) ha.2.2 hb.2.2 rcases h with h | h · exact (hne (hai.symm.trans ((congrFun h i).trans hbi))).elim · simpa only [hai,hbi] using h i end ArrayObjects.Object.Rolled section open MeasureTheory ProbabilityTheory Set variable {P Z U : Type*} [MeasurableSpace P] [MeasurableSpace Z] [MeasurableSpace U] omit [MeasurableSpace Z] in lemma iid_random_set_descent (μ : Measure P) [IsProbabilityMeasure μ] (S : P → Set Z) (he : ∀ᵐ pq ∂μ.prod μ, S pq.1 = S pq.2) : ∀ᵐ p ∂μ, S p = {z | ∀ᵐ q ∂μ, z ∈ S q} := by filter_upwards [Measure.ae_ae_of_ae_prod he] with p hp ext z constructor · intro hz filter_upwards [hp] with q hq rwa [←hq] · intro hz obtain ⟨q,hq,hzq⟩ := (hp.and hz).exists rwa [hq] def essentialMembership (κ : Kernel U P) (S : Set (P × Z)) : Set (U × Z) := {uz | κ uz.1 {p | (p,uz.2) ∈ S} = 1} lemma measurableSet_essentialMembership (κ : Kernel U P) [IsSFiniteKernel κ] {S : Set (P × Z)} (hS : MeasurableSet S) : MeasurableSet (essentialMembership κ S) := by have h := Kernel.measurable_kernel_prodMk_left (κ := κ.comap Prod.fst measurable_fst) (hS.preimage (measurable_snd.prodMk measurable_fst.snd)) exact measurableSet_eq_fun h measurable_const lemma mem_essentialMembership_iff (κ : Kernel U P) [IsMarkovKernel κ] {S : Set (P × Z)} (hS : MeasurableSet S) (u : U) (z : Z) : (u,z) ∈ essentialMembership κ S ↔ ∀ᵐ p ∂κ u, (p,z) ∈ S := by exact (mem_ae_iff_prob_eq_one (hS.preimage (measurable_id.prodMk measurable_const))).symm lemma conditional_random_set_descent (κ : Kernel U P) [IsMarkovKernel κ] {S : Set (P × Z)} (hS : MeasurableSet S) (u : U) (he : ∀ᵐ pq ∂(κ u).prod (κ u), {z | (pq.1,z) ∈ S} = {z | (pq.2,z) ∈ S}) : ∀ᵐ p ∂κ u, {z | (p,z) ∈ S} = {z | (u,z) ∈ essentialMembership κ S} := by filter_upwards [iid_random_set_descent (κ u) (fun p => {z | (p,z) ∈ S}) he] with p hp rw [hp] ext z exact (mem_essentialMembership_iff κ hS u z).symm end section open MeasureTheory ProbabilityTheory Set variable {P Z : Type*} [MeasurableSpace P] lemma iid_random_set_equality (μ : Measure P) [IsProbabilityMeasure μ] (S : P → Set Z) (he : ∀ᵐ pq ∂μ.prod μ, S pq.1 ⊆ S pq.2) : ∀ᵐ pq ∂μ.prod μ, S pq.1 = S pq.2 := by have hs : MeasurePreserving (Prod.swap : P × P → P × P) (μ.prod μ) (μ.prod μ) := ⟨measurable_swap,Measure.prod_swap⟩ filter_upwards [he,hs.quasiMeasurePreserving.ae he] with pq hp hq exact Set.Subset.antisymm hp hq end section open MeasureTheory ProbabilityTheory Set variable {U Y : Type*} [MeasurableSpace U] [StandardBorelSpace U] [MeasurableSpace Y] [MeasurableSpace.CountablyGenerated Y] (κ : Kernel U Y) [IsMarkovKernel κ] lemma separated_family_sections (S : Set (U × HilbertCode κ)) (hS : MeasurableSet S) (hb : ∀ u q, (u,q) ∈ S → q.base = u) (hsep : ∀ u q r, (u,q) ∈ S → (u,r) ∈ S → q ≠ r → 1 ≤ HilbertCode.distance q r) : ∃ (D : ℕ → Set U) (s : ℕ → U → HilbertCode κ), (∀ n, MeasurableSet (D n)) ∧ (∀ n, Measurable (s n)) ∧ (∀ n u, (s n u).base = u) ∧ (∀ n u, u ∈ D n → (u,s n u) ∈ S) ∧ (∀ u q, (u,q) ∈ S → ∃ n, u ∈ D n ∧ s n u = q) := by let : StandardBorelSpace S := hS.standardBorel obtain ⟨C,_,hcover,_,hemb⟩ := HilbertCode.separated_branches (fun x : S => x.1.1) measurable_subtype_coe.fst (fun x : S => x.1.2) measurable_subtype_coe.snd (fun x y he => (hb _ _ x.property).trans (he.trans (hb _ _ y.property).symm)) 1 (by norm_num) (by intro x y he hne apply hsep x.1.1 x.1.2 y.1.2 x.property · rw [he] exact y.property · intro h exact hne (Subtype.ext (Prod.ext he h))) obtain ⟨D,s,hD,hs,hzero,hmem,hcov⟩ := measurable_branch_sections (fun x : S => x.1.1) (fun x : S => x.1.2) measurable_subtype_coe.snd (fun u => HilbertCode.encode u 0) (MeasurableSection.zero measurable_id) C hcover hemb refine ⟨D,s,hD,hs,?_,?_,?_⟩ · intro n u by_cases hu : u ∈ D n · obtain ⟨x,hx,he⟩ := hmem n u hu rw [he] exact (hb _ _ x.property).trans hx · rw [hzero n u hu] rfl · intro n u hu obtain ⟨x,hx,he⟩ := hmem n u hu rw [he,←hx] exact x.property · intro u q hq exact hcov ⟨(u,q),hq⟩ end section open MeasureTheory ProbabilityTheory Set variable {P U Z : Type*} [MeasurableSpace P] [MeasurableSpace U] [MeasurableSpace Z] lemma measurableSet_enumerated_fibre_eq (S : Set (P × Z)) (T : Set (U × Z)) (hS : MeasurableSet S) (hT : MeasurableSet T) (f : P → U) (hf : Measurable f) (D : ℕ → Set P) (s : ℕ → P → Z) (hD : ∀ n, MeasurableSet (D n)) (hs : ∀ n, Measurable (s n)) (hsm : ∀ n p, p ∈ D n → (p,s n p) ∈ S) (hsc : ∀ p z, (p,z) ∈ S → ∃ n, p ∈ D n ∧ s n p = z) (E : ℕ → Set U) (t : ℕ → U → Z) (hE : ∀ n, MeasurableSet (E n)) (ht : ∀ n, Measurable (t n)) (htm : ∀ n u, u ∈ E n → (u,t n u) ∈ T) (htc : ∀ u z, (u,z) ∈ T → ∃ n, u ∈ E n ∧ t n u = z) : MeasurableSet {p | {z | (p,z) ∈ S} = {z | (f p,z) ∈ T}} := by have he : {p | {z | (p,z) ∈ S} = {z | (f p,z) ∈ T}} = {p | (∀ n, p ∈ D n → (f p,s n p) ∈ T) ∧ (∀ n, f p ∈ E n → (p,t n (f p)) ∈ S)} := by ext p constructor · intro hp constructor · intro n hn exact Set.ext_iff.mp hp (s n p) |>.mp (hsm n p hn) · intro n hn exact Set.ext_iff.mp hp (t n (f p)) |>.mpr (htm n (f p) hn) · rintro ⟨ha,hb⟩ ext z constructor · intro hz obtain ⟨n,hn,rfl⟩ := hsc p z hz exact ha n hn · intro hz obtain ⟨n,hn,rfl⟩ := htc (f p) z hz exact hb n hn rw [he] change MeasurableSet ({p | ∀ n, p ∈ D n → (f p,s n p) ∈ T} ∩ {p | ∀ n, f p ∈ E n → (p,t n (f p)) ∈ S}) simp only [Set.ofPred_forall] refine (MeasurableSet.iInter fun n => ?_).inter (MeasurableSet.iInter fun n => ?_) · convert (hD n).compl.union (hT.preimage (hf.prodMk (hs n))) using 1 ext p simp only [mem_ofPred_eq,mem_union,mem_compl_iff,mem_preimage] tauto · convert ((hE n).preimage hf).compl.union (hS.preimage (measurable_id.prodMk ((ht n).comp hf))) using 1 ext p simp only [mem_ofPred_eq,mem_union,mem_compl_iff,mem_preimage,Function.comp_apply,id_eq] tauto end namespace ArrayObjects.Object.Rolled open MeasureTheory ProbabilityTheory Set section universe u variable {I : Type u} [Fintype I] [DecidableEq I] {X : StandardSpace.{u}} {T : X ≃ᵐ X} {base : InitialLaws I X T} (M : Object I base) (hM : M.IsSaturated) (hk : 3 ≤ Fintype.card I) (Λ : Kernel (Arr I M.U 1) (I → Arr I M.Y 0)) [IsMarkovKernel Λ] (hL : Λ =ᵐ[M.parameterLaw 1] rawTupleKernel M) (hm : ∀ p j, MeasurePreserving (fun y : I → Arr I M.Y 0 => y j) (Λ p) (M.ownKernel 0 (tupleParameter M p j))) (hind : ∀ p j, iIndepFun (fun t : (Finset.univ.erase j : Finset I) => fun y : I → Arr I M.Y 0 => y t) (Λ p)) include hk hm hind in lemma measurableSet_rawLineGraph (i : I) : MeasurableSet (rawLineGraph M Λ i) := measurableSet_exactCodeSlot (M.ownKernel 0) Λ (tupleParameter M) (measurable_tupleParameter M) hk hm hind i include hM hk hL hm hind in lemma rawLineGraph_conditional_descent (i : I) : ∀ᵐ u ∂M.parameterLaw 0, ∀ᵐ p ∂M.parameterCoordinateKernel i u, {q | (p,q) ∈ rawLineGraph M Λ i} = {q | (u,q) ∈ essentialMembership (M.parameterCoordinateKernel i) (rawLineGraph M Λ i)} := by have h := conditional_ae_descent (P := fun _ pq => {q | (pq.1,q) ∈ rawLineGraph M Λ i} ⊆ {q | (pq.2,q) ∈ rawLineGraph M Λ i}) ((measurable_plane 0 0 i).comp (measurable_plane 1 0 i)) ((measurable_plane _ _ _).prodMk (measurable_plane _ _ _)) (M.diagonal_parameter_product hM (by omega) i) (rawLineGraph_row_inclusion M hM hk Λ hL hm hind i i) rw [←Measure.map_map (measurable_plane 0 0 i) (measurable_plane 1 0 i), M.parameterLaw_consistent 1 0 i,M.parameterLaw_consistent 0 0 i] at h simp only [Kernel.prod_apply] at h filter_upwards [h] with u hu exact conditional_random_set_descent (M.parameterCoordinateKernel i) (measurableSet_rawLineGraph M hk Λ hm hind i) u (iid_random_set_equality _ (fun p => {q | (p,q) ∈ rawLineGraph M Λ i}) hu) include hM hk hL hm hind in lemma exists_localLineGraph (i : I) : ∃ S : Set (Arr I M.U 0 × HilbertCode (M.ownKernel 0)), MeasurableSet S ∧ (∀ u q, (u,q) ∈ S → q.base = u ∧ q.IsCanonical ∧ q.IsUnimodular) ∧ (∀ u q r, (u,q) ∈ S → (u,r) ∈ S → q ≠ r → 1 ≤ HilbertCode.distance q r) ∧ (∀ᵐ p ∂M.parameterLaw 1, {q | (p,q) ∈ rawLineGraph M Λ i} = {q | (tupleParameter M p i,q) ∈ S}) := by let S₀ := essentialMembership (M.parameterCoordinateKernel i) (rawLineGraph M Λ i) have hS₀ : MeasurableSet S₀ := measurableSet_essentialMembership _ (measurableSet_rawLineGraph M hk Λ hm hind i) have ha := rawLineGraph_conditional_descent M hM hk Λ hL hm hind i have hb := coordinate_conditional_descent M i (P := fun u p => tupleParameter M p i = u) (Filter.Eventually.of_forall fun _ => rfl) let Q : Arr I M.U 0 → Prop := fun u => (∀ q, (u,q) ∈ S₀ → q.base = u ∧ q.IsCanonical ∧ q.IsUnimodular) ∧ (∀ q r, (u,q) ∈ S₀ → (u,r) ∈ S₀ → q ≠ r → 1 ≤ HilbertCode.distance q r) have hQ : ∀ᵐ u ∂M.parameterLaw 0, Q u := by filter_upwards [ha,hb] with u ha hb obtain ⟨p,hp,hpu⟩ := (ha.and hb).exists have heq (q) : (p,q) ∈ rawLineGraph M Λ i ↔ (u,q) ∈ S₀ := Set.ext_iff.mp hp q constructor · intro q hq have hq' := (heq q).mpr hq exact ⟨(rawLineGraph_base M hq').trans hpu,rawLineGraph_canonical M hq'⟩ · intro q r hq hr hne exact rawLineGraph_separated M hk Λ hm hind p i q r ((heq q).mpr hq) ((heq r).mpr hr) hne have hn : NullMeasurableSet {u | Q u} (M.parameterLaw 0) := NullMeasurableSet.congr (nullMeasurableSet_univ (μ := M.parameterLaw 0)) (by filter_upwards [hQ] with u h; exact propext (iff_of_true trivial h)) obtain ⟨A,hA,hAm,hAe⟩ := hn.exists_measurable_subset_ae_eq let S : Set (Arr I M.U 0 × HilbertCode (M.ownKernel 0)) := (Prod.fst ⁻¹' A) ∩ S₀ have hS : MeasurableSet S := (hAm.preimage measurable_fst).inter hS₀ have hSb (u q) (hq : (u,q) ∈ S) : q.base = u ∧ q.IsCanonical ∧ q.IsUnimodular := (hA hq.1).1 q hq.2 have hSs (u q r) (hq : (u,q) ∈ S) (hr : (u,r) ∈ S) (hne : q ≠ r) : 1 ≤ HilbertCode.distance q r := (hA hq.1).2 q r hq.2 hr.2 hne obtain ⟨E,t,hE,ht,_,htm,htc⟩ := separated_family_sections (M.ownKernel 0) S hS (fun u q hq => (hSb u q hq).1) hSs obtain ⟨D,s,hD,hs,_,hsm,_,hsc⟩ := exactCode_sections (M.ownKernel 0) Λ (tupleParameter M) (measurable_tupleParameter M) hk hm hind have hemeas : MeasurableSet {p | {q | (p,q) ∈ rawLineGraph M Λ i} = {q | (tupleParameter M p i,q) ∈ S}} := measurableSet_enumerated_fibre_eq (rawLineGraph M Λ i) S (measurableSet_rawLineGraph M hk Λ hm hind i) hS (fun p => tupleParameter M p i) ((measurable_pi_apply i).comp (measurable_tupleParameter M)) D (fun n p => s n p i) hD (fun n => (measurable_pi_apply i).comp (hs n)) (fun n p hp => ⟨s n p,hsm n p hp,rfl⟩) (by intro p q hq obtain ⟨b,hb,hbi⟩ := hq obtain ⟨n,hn,he⟩ := hsc (p,b) hb exact ⟨n,hn,(congrFun he i).trans hbi⟩) E t hE ht htm htc refine ⟨S,hS,hSb,hSs,?_⟩ apply conditional_ae_lift (κ := M.parameterCoordinateKernel i) (measurable_plane _ _ _) measurable_id (parameterCoordinate_conditional M i) hemeas rw [M.parameterLaw_consistent 0 0 i] filter_upwards [ha,hb,hQ,hAe] with u ha hb hQ hAe filter_upwards [ha,hb] with p hp hpu rw [hpu,hp] ext q exact (and_iff_right (hAe.mpr hQ)).symm end universe u variable {I : Type u} [Fintype I] [DecidableEq I] {X : StandardSpace.{u}} {T : X ≃ᵐ X} {base : InitialLaws I X T} (M : Object I base) lemma localLineGraph_inclusion (hM : M.IsSaturated) (hk : 3 ≤ Fintype.card I) (Λ : Kernel (Arr I M.U 1) (I → Arr I M.Y 0)) [IsMarkovKernel Λ] (hL : Λ =ᵐ[M.parameterLaw 1] rawTupleKernel M) (hm : ∀ p j, MeasurePreserving (fun y : I → Arr I M.Y 0 => y j) (Λ p) (M.ownKernel 0 (tupleParameter M p j))) (hind : ∀ p j, iIndepFun (fun t : (Finset.univ.erase j : Finset I) => fun y : I → Arr I M.Y 0 => y t) (Λ p)) (S : I → Set (Arr I M.U 0 × HilbertCode (M.ownKernel 0))) (hS : ∀ i, ∀ᵐ p ∂M.parameterLaw 1, {q | (p,q) ∈ rawLineGraph M Λ i} = {q | (tupleParameter M p i,q) ∈ S i}) (a j : I) : ∀ᵐ u ∂M.parameterLaw 0, {q | (u,q) ∈ S j} ⊆ {q | (u,q) ∈ S a} := by have hrow : MeasurePreserving (plane 1 0 a) (M.parameterLaw 2) (M.parameterLaw 1) := ⟨measurable_plane _ _ _,M.parameterLaw_consistent _ _ _⟩ have hcol : MeasurePreserving (plane 1 (Fin.last 1) j) (M.parameterLaw 2) (M.parameterLaw 1) := ⟨measurable_plane _ _ _,M.parameterLaw_consistent _ _ _⟩ have h : ∀ᵐ e ∂M.parameterLaw 2, {q | (tupleParameter M (plane 1 0 a e) j,q) ∈ S j} ⊆ {q | (tupleParameter M (plane 1 0 a e) j,q) ∈ S a} := by filter_upwards [rawLineGraph_row_inclusion M hM hk Λ hL hm hind a j, hrow.quasiMeasurePreserving.ae (hS j),hcol.quasiMeasurePreserving.ae (hS a)] with e he hr hc rw [parameter_cell_commute M a j e] at hr ⊢ rw [←hr,←hc] exact he have hd := ae_map_descent (P := fun u => {q | (u,q) ∈ S j} ⊆ {q | (u,q) ∈ S a}) (M.parameterLaw 2) ((measurable_plane 0 0 j).comp (measurable_plane 1 0 a)) h rwa [←Measure.map_map (measurable_plane 0 0 j) (measurable_plane 1 0 a), M.parameterLaw_consistent 1 0 a,M.parameterLaw_consistent 0 0 j] at hd lemma exists_commonLocalLineGraph (hM : M.IsSaturated) (hk : 3 ≤ Fintype.card I) (Λ : Kernel (Arr I M.U 1) (I → Arr I M.Y 0)) [IsMarkovKernel Λ] (hL : Λ =ᵐ[M.parameterLaw 1] rawTupleKernel M) (hm : ∀ p j, MeasurePreserving (fun y : I → Arr I M.Y 0 => y j) (Λ p) (M.ownKernel 0 (tupleParameter M p j))) (hind : ∀ p j, iIndepFun (fun t : (Finset.univ.erase j : Finset I) => fun y : I → Arr I M.Y 0 => y t) (Λ p)) : ∃ S : Set (Arr I M.U 0 × HilbertCode (M.ownKernel 0)), MeasurableSet S ∧ (∀ u q, (u,q) ∈ S → q.base = u ∧ q.IsCanonical ∧ q.IsUnimodular) ∧ (∀ u q r, (u,q) ∈ S → (u,r) ∈ S → q ≠ r → 1 ≤ HilbertCode.distance q r) ∧ (∀ᵐ p ∂M.parameterLaw 1, ∀ i, {q | (p,q) ∈ rawLineGraph M Λ i} = {q | (tupleParameter M p i,q) ∈ S}) := by classical have hI : Nonempty I := Fintype.card_pos_iff.mp (by omega) let i₀ : I := Classical.choice hI choose S hSm hSb hSs hSe using exists_localLineGraph M hM hk Λ hL hm hind have he (i : I) : ∀ᵐ u ∂M.parameterLaw 0, {q | (u,q) ∈ S i} = {q | (u,q) ∈ S i₀} := by filter_upwards [localLineGraph_inclusion M hM hk Λ hL hm hind S hSe i₀ i, localLineGraph_inclusion M hM hk Λ hL hm hind S hSe i i₀] with u ha hb exact Subset.antisymm ha hb have hep (i : I) : ∀ᵐ p ∂M.parameterLaw 1, {q | (tupleParameter M p i,q) ∈ S i} = {q | (tupleParameter M p i,q) ∈ S i₀} := (show MeasurePreserving (plane 0 0 i) (M.parameterLaw 1) (M.parameterLaw 0) from ⟨measurable_plane _ _ _,M.parameterLaw_consistent _ _ _⟩).quasiMeasurePreserving.ae (he i) refine ⟨S i₀,hSm i₀,hSb i₀,hSs i₀,?_⟩ filter_upwards [ae_all_iff.mpr hSe,ae_all_iff.mpr hep] with p h₁ h₂ i exact (h₁ i).trans (h₂ i) end ArrayObjects.Object.Rolled section open MeasureTheory ProbabilityTheory Set open scoped BigOperators attribute [local instance] instMeasurableSpaceCircle_circleLp instBorelSpaceCircle_circleLp variable {P U Y I : Type*} [MeasurableSpace P] [MeasurableSpace U] [MeasurableSpace Y] [MeasurableSpace.CountablyGenerated Y] [Fintype I] (κ : Kernel U Y) [IsMarkovKernel κ] (Λ : Kernel P (I → Y)) [IsMarkovKernel Λ] (u : P → I → U) lemma exactCode_of_circle_tuple {p : P} {a : I → HilbertCode κ} (hm : ∀ i, MeasurePreserving (fun y : I → Y => y i) (Λ p) (κ (u p i))) (hb : ∀ i, (a i).base = u p i) (hcan : ∀ i, (a i).IsCanonical ∧ (a i).IsUnimodular) (c : Circle) (he : ∀ᵐ y ∂Λ p, ∏ i, HilbertCode.circleRep (a i) (y i) = c) : (p,a) ∈ exactCodeSet κ Λ u := by refine ⟨hb,hcan,?_⟩ have hrep (i) : ∀ᵐ y ∂Λ p, (HilbertCode.circleRep (a i) (y i) : ℂ) = HilbertCode.representative (a i,y i) := by have h := HilbertCode.circleRep_ae (a i) (hcan i).2 rw [hb i] at h exact (hm i).quasiMeasurePreserving.ae h have hmean : (fun y => ∏ i, HilbertCode.representative (a i,y i)) =ᵐ[Λ p] fun _ => (c : ℂ) := by filter_upwards [he,ae_all_iff.mpr hrep] with y hy hr calc _ = ∏ i, (HilbertCode.circleRep (a i) (y i) : ℂ) := Finset.prod_congr rfl (fun i _ => (hr i).symm) _ = ((∏ i, HilbertCode.circleRep (a i) (y i) : Circle) : ℂ) := (map_prod Circle.coeHom (fun i => HilbertCode.circleRep (a i) (y i)) Finset.univ).symm _ = _ := congrArg (fun z : Circle => (z : ℂ)) hy change ‖∫ y, ∏ i, HilbertCode.representative (a i,y i) ∂Λ p‖ = 1 rw [integral_congr_ae hmean,integral_const,probReal_univ,one_smul,Circle.norm_coe] end section open MeasureTheory ProbabilityTheory open scoped BigOperators local instance : MeasurableSpace Circle := inferInstanceAs (MeasurableSpace (Submonoid.unitSphere ℂ)) local instance : BorelSpace Circle := inferInstanceAs (BorelSpace (Submonoid.unitSphere ℂ)) variable {Ω I : Type*} [MeasurableSpace Ω] [Fintype I] (μ : Measure Ω) [IsProbabilityMeasure μ] lemma independent_circle_product_constant (f : I → Ω → Circle) (hf : ∀ i, Measurable (f i)) (hind : iIndepFun f μ) (c : Circle) (he : ∀ᵐ x ∂μ, ∏ i, f i x = c) : ∀ i, ∃ d : Circle, f i =ᵐ[μ] fun _ => d := by classical let g : I → Ω → ℂ := fun i x => (f i x : ℂ) have hg (i) : Measurable (g i) := measurable_subtype_coe.comp (hf i) have hgi : iIndepFun g μ := by exact hind.comp (fun (_ : I) (z : Circle) => (z : ℂ)) (fun _ => measurable_subtype_coe) have hprod : (∏ i, ∫ x, g i x ∂μ) = (c : ℂ) := by rw [←hgi.integral_fun_prod_eq_prod_integral (fun i => (hg i).aestronglyMeasurable)] have he' : (fun x => ∏ i, g i x) =ᵐ[μ] fun _ => (c : ℂ) := by filter_upwards [he] with x hx exact (map_prod Circle.coeHom _ _).symm.trans (congrArg (fun z : Circle => (z : ℂ)) hx) rw [integral_congr_ae he',integral_const,probReal_univ,one_smul] have hle (i) : ‖∫ x, g i x ∂μ‖ ≤ 1 := by calc _ ≤ ∫ x, ‖g i x‖ ∂μ := norm_integral_le_integral_norm _ _ = 1 := by simp only [g,Circle.norm_coe,integral_const,probReal_univ,smul_eq_mul,one_mul] have hnorm : (∏ i, ‖∫ x, g i x ∂μ‖) = 1 := by rw [←norm_prod,hprod,Circle.norm_coe] intro i have hone : ‖∫ x, g i x ∂μ‖ = 1 := by apply le_antisymm (hle i) calc 1 = ‖∫ x, g i x ∂μ‖ * ∏ j ∈ Finset.univ.erase i, ‖∫ x, g j x ∂μ‖ := by rw [mul_comm,Finset.prod_erase_mul _ _ (Finset.mem_univ i),hnorm] _ ≤ ‖∫ x, g i x ∂μ‖ * 1 := mul_le_mul_of_nonneg_left (Finset.prod_le_one₀ (fun _ _ => norm_nonneg _) (fun j _ => hle j)) (norm_nonneg _) _ = _ := mul_one _ have heq : g i =ᵐ[μ] fun _ => ∫ x, g i x ∂μ := by rcases ae_eq_const_or_norm_integral_lt_of_norm_le_const (μ := μ) (f := g i) (C := (1 : ℝ)) (Filter.Eventually.of_forall fun x => (Circle.norm_coe (f i x)).le) with h | h · simpa only [average_eq_integral,Function.const_def] using h · simp only [hone,probReal_univ,one_mul,lt_self_iff_false] at h refine ⟨⟨∫ x, g i x ∂μ,mem_sphere_zero_iff_norm.mpr hone⟩,?_⟩ exact heq.mono fun _ h => Circle.coe_injective h end section open MeasureTheory ProbabilityTheory open scoped BigOperators local instance : MeasurableSpace Circle := inferInstanceAs (MeasurableSpace (Submonoid.unitSphere ℂ)) local instance : BorelSpace Circle := inferInstanceAs (BorelSpace (Submonoid.unitSphere ℂ)) variable {Ω I J : Type*} [MeasurableSpace Ω] [Fintype I] [Fintype J] (μ : Measure Ω) [IsProbabilityMeasure μ] lemma circle_square_consistency [DecidableEq I] (f : I → J → Ω → Circle) (hf : ∀ i j, Measurable (f i j)) (a : I) (hind : iIndepFun (fun i : (Finset.univ.erase a : Finset I) => fun x => ∏ j, f i j x) μ) (c : J → Circle) (hc : ∀ j, ∀ᵐ x ∂μ, ∏ i, f i j x = c j) (d : Circle) (hd : ∀ᵐ x ∂μ, ∏ j, f a j x = d) : ∀ i, ∃ e : Circle, ∀ᵐ x ∂μ, ∏ j, f i j x = e := by have ht : ∀ᵐ x ∂μ, ∏ i, ∏ j, f i j x = ∏ j, c j := by filter_upwards [ae_all_iff.mpr hc] with x hx rw [Finset.prod_comm] exact Finset.prod_congr rfl (fun j _ => hx j) have hp : ∀ᵐ x ∂μ, ∏ i : (Finset.univ.erase a : Finset I), ∏ j, f i j x = (∏ j, c j) / d := by filter_upwards [ht,hd] with x htx hdx rw [Finset.prod_coe_sort (Finset.univ.erase a) (fun i => ∏ j, f i j x)] apply (eq_div_iff_mul_eq').mpr rw [←hdx,Finset.prod_erase_mul _ _ (Finset.mem_univ a)] exact htx have hfm (i : (Finset.univ.erase a : Finset I)) : Measurable (fun x => ∏ j, f i j x) := Finset.measurable_prod _ (fun j _ => hf i j) have he := independent_circle_product_constant μ (fun i : (Finset.univ.erase a : Finset I) => fun x => ∏ j, f i j x) hfm hind ((∏ j, c j) / d) hp intro i by_cases hi : i = a · subst i; exact ⟨d,hd⟩ · exact he ⟨i,Finset.mem_erase.mpr ⟨hi,Finset.mem_univ i⟩⟩ end namespace ArrayObjects.Object.Rolled open MeasureTheory ProbabilityTheory Set open scoped BigOperators attribute [local instance] instMeasurableSpaceCircle_circleLp instBorelSpaceCircle_circleLp universe u variable {I : Type u} [Fintype I] [DecidableEq I] {X : StandardSpace.{u}} {T : X ≃ᵐ X} {base : InitialLaws I X T} (M : Object I base) lemma whole_rows_independent_fibre (hM : M.IsSaturated) (a : I) : ∀ᵐ e ∂M.parameterLaw 2, iIndepFun (fun i : (Finset.univ.erase a : Finset I) => plane 1 0 (i : I)) (M.ownKernel 2 e) := by have hp := ConditionalFibres.marginal (measurable_parents M (Finset.univ.erase a) 1) (M.ownKernel_conditional 2) (rows_conditional M hM (Finset.univ.erase a) (by intro he; have := Finset.mem_univ a; rw [←he] at this; exact Finset.notMem_erase a _ this) 0) filter_upwards [hp] with e he change MeasurePreserving _ _ (Measure.pi (fun i : (Finset.univ.erase a : Finset I) => M.ownKernel 1 (plane 1 0 (i : I) e))) at he have h := iIndepFun_pi (μ := fun i : (Finset.univ.erase a : Finset I) => M.ownKernel 1 (plane 1 0 (i : I) e)) (fun _ => measurable_id.aemeasurable) rw [←he.map_eq] at h exact (iIndepFun_map_iff_measurable (M.ownKernel 2 e) (fun (z : ∀ _ : (Finset.univ.erase a : Finset I), Arr I M.Y 1) i => z i) (fun y i => plane 1 0 (i : I) y) (fun i => measurable_pi_apply i) (measurable_parents M _ _)).mp h lemma rawSquare_marginals (hM : M.IsSaturated) (hI : 2 ≤ Fintype.card I) (Λ : Kernel (Arr I M.U 1) (I → Arr I M.Y 0)) [IsMarkovKernel Λ] (hL : Λ =ᵐ[M.parameterLaw 1] rawTupleKernel M) : ∀ᵐ e ∂M.parameterLaw 2, (∀ i, MeasurePreserving (rawTuple M ∘ plane 1 0 i) (M.ownKernel 2 e) (Λ (plane 1 0 i e))) ∧ (∀ j, MeasurePreserving (rawTuple M ∘ plane 1 (Fin.last 1) j) (M.ownKernel 2 e) (Λ (plane 1 (Fin.last 1) j e))) := by have hrow (i : I) : ∀ᵐ e ∂M.parameterLaw 2, Λ (plane 1 0 i e) = rawTupleKernel M (plane 1 0 i e) := (show MeasurePreserving (plane 1 0 i) (M.parameterLaw 2) (M.parameterLaw 1) from ⟨measurable_plane _ _ _,M.parameterLaw_consistent _ _ _⟩).quasiMeasurePreserving.ae hL have hcol (j : I) : ∀ᵐ e ∂M.parameterLaw 2, Λ (plane 1 (Fin.last 1) j e) = rawTupleKernel M (plane 1 (Fin.last 1) j e) := (show MeasurePreserving (plane 1 (Fin.last 1) j) (M.parameterLaw 2) (M.parameterLaw 1) from ⟨measurable_plane _ _ _,M.parameterLaw_consistent _ _ _⟩).quasiMeasurePreserving.ae hL filter_upwards [ae_all_iff.mpr hrow,ae_all_iff.mpr hcol, ae_all_iff.mpr (row_marginal_fibre M hM hI),ae_all_iff.mpr (column_marginal_fibre M hI)] with e hr hc hmr hmc constructor · intro i rw [hr i] exact (MeasurePreserving.mk (measurable_rawTuple M) (Kernel.map_apply _ (measurable_rawTuple M) _).symm).comp (hmr i) · intro j rw [hc j] exact (MeasurePreserving.mk (measurable_rawTuple M) (Kernel.map_apply _ (measurable_rawTuple M) _).symm).comp (hmc j) lemma rawSquare_exact_consistency (hM : M.IsSaturated) (hI : 2 ≤ Fintype.card I) (Λ : Kernel (Arr I M.U 1) (I → Arr I M.Y 0)) [IsMarkovKernel Λ] (hL : Λ =ᵐ[M.parameterLaw 1] rawTupleKernel M) (hm : ∀ p j, MeasurePreserving (fun y : I → Arr I M.Y 0 => y j) (Λ p) (M.ownKernel 0 (tupleParameter M p j))) : ∀ᵐ e ∂M.parameterLaw 2, ∀ (q : I → I → HilbertCode (M.ownKernel 0)) (a : I), (∀ j, (plane 1 (Fin.last 1) j e,fun i => q i j) ∈ exactCodeSet (M.ownKernel 0) Λ (tupleParameter M)) → (plane 1 0 a e,q a) ∈ exactCodeSet (M.ownKernel 0) Λ (tupleParameter M) → ∀ i, (plane 1 0 i e,q i) ∈ exactCodeSet (M.ownKernel 0) Λ (tupleParameter M) := by filter_upwards [rawSquare_marginals M hM hI Λ hL, ae_all_iff.mpr (whole_rows_independent_fibre M hM)] with e hmar hind q a hcodes hr let f : I → I → Arr I M.Y 2 → Circle := fun i j y => HilbertCode.circleRep (q i j) (missingRow M 0 j i y) have hf (i j : I) : Measurable (f i j) := (HilbertCode.measurable_circleRep_fixed _).comp (measurable_missingRow M _ _ _) choose c hconst using fun j => exactCode_circle_tuple (M.ownKernel 0) Λ (tupleParameter M) (hm _) (hcodes j) have hcol (j : I) : ∀ᵐ y ∂M.ownKernel 2 e, ∏ i, f i j y = c j := by have h := (hmar.2 j).quasiMeasurePreserving.ae (hconst j) convert h using 1 congr! 3 with y i exact congrArg (HilbertCode.circleRep (q i j)) (congrFun (plane_first_last M 0 i j) y).symm obtain ⟨d,hd⟩ := exactCode_circle_tuple (M.ownKernel 0) Λ (tupleParameter M) (hm _) hr have hrow : ∀ᵐ y ∂M.ownKernel 2 e, ∏ j, f a j y = d := (hmar.1 a).quasiMeasurePreserving.ae hd have hi : iIndepFun (fun i : (Finset.univ.erase a : Finset I) => fun y => ∏ j, f i j y) (M.ownKernel 2 e) := by exact (hind a).comp (fun (i : (Finset.univ.erase a : Finset I)) (y : Arr I M.Y 1) => ∏ j, HilbertCode.circleRep (q i j) (plane 0 0 j y)) (fun i => Finset.measurable_prod _ (fun j _ => (HilbertCode.measurable_circleRep_fixed _).comp (measurable_plane _ _ _))) have hex := circle_square_consistency (M.ownKernel 2 e) f hf a hi c hcol d hrow intro i obtain ⟨b,hb⟩ := hex i have hbe : ∀ᵐ z ∂Λ (plane 1 0 i e), ∏ j, HilbertCode.circleRep (q i j) (z j) = b := by have hh := ae_map_descent (P := fun z : I → Arr I M.Y 0 => ∏ j, HilbertCode.circleRep (q i j) (z j) = b) (M.ownKernel 2 e) (hmar.1 i).measurable hb rwa [(hmar.1 i).map_eq] at hh apply exactCode_of_circle_tuple (M.ownKernel 0) Λ (tupleParameter M) (hm _) _ _ b hbe · intro j exact ((hcodes j).1 i).trans (parameter_cell_commute M i j e).symm · intro j exact (hcodes j).2.1 i end ArrayObjects.Object.Rolled open MeasureTheory Set variable {U Z : Type*} [MeasurableSpace U] [MeasurableSpace Z] [MeasurableEq Z] lemma enumerate_without_repetition (S : Set (U × Z)) (D : ℕ → Set U) (s : ℕ → U → Z) (hD : ∀ n, MeasurableSet (D n)) (hs : ∀ n, Measurable (s n)) (hm : ∀ n u, u ∈ D n → (u,s n u) ∈ S) (hc : ∀ u z, (u,z) ∈ S → ∃ n, u ∈ D n ∧ s n u = z) : ∃ E : ℕ → Set U, (∀ n, MeasurableSet (E n)) ∧ (∀ n, E n ⊆ D n) ∧ (∀ n u, u ∈ E n → (u,s n u) ∈ S) ∧ (∀ u z, (u,z) ∈ S → ∃ n, u ∈ E n ∧ s n u = z) ∧ (∀ u n m, u ∈ E n → u ∈ E m → s n u = s m u → n = m) := by classical let E : ℕ → Set U := fun n => D n \ ⋃ m < n, {u | u ∈ D m ∧ s m u = s n u} have hED (n) : E n ⊆ D n := fun _ h => h.1 refine ⟨E,?_,hED,(fun n u h => hm n u (hED n h)),?_,?_⟩ · intro n exact (hD n).diff (MeasurableSet.iUnion fun m => MeasurableSet.iUnion fun _ => (hD m).inter (measurableSet_eq_fun (hs m) (hs n))) · intro u z hz have hex := hc u z hz let n := Nat.find hex have hn : u ∈ D n ∧ s n u = z := Nat.find_spec hex refine ⟨n,⟨hn.1,?_⟩,hn.2⟩ intro hu obtain ⟨m,hem⟩ := Set.mem_iUnion.mp hu obtain ⟨hmn,he⟩ := Set.mem_iUnion.mp hem exact Nat.find_min hex hmn ⟨he.1,he.2.trans hn.2⟩ · intro u n m hn hm he have hnot (n m : ℕ) (hn : u ∈ E n) (hm : u ∈ E m) (he : s n u = s m u) : ¬n < m := by intro hnm exact hm.2 (Set.mem_iUnion.mpr ⟨n,Set.mem_iUnion.mpr ⟨hnm,hn.1,he⟩⟩) exact Nat.le_antisymm (not_lt.mp (hnot m n hm hn he.symm)) (not_lt.mp (hnot n m hn hm he)) end Rokhlin end end OAI