lean/OAI/Dynamics/MultipleMixing/ExactLines.lean

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