lean/OAI/Dynamics/MultipleMixing/Tensors.lean

import OAI.Dynamics.MultipleMixing.Joinings

namespace OAI

noncomputable section

namespace Rokhlin

section
open MeasureTheory
open scoped InnerProductSpace
variable {X Y : Type*} [MeasurableSpace X] [MeasurableSpace Y]
  {μ : Measure X} {ν : Measure Y} [SFinite μ] [SFinite ν]

omit [SFinite μ] in
lemma memLp_tensor (g : Lp ℂ 2 μ) (h : Lp ℂ 2 ν) :
    MemLp (fun p : X × Y => g p.1 * h p.2) 2 (μ.prod ν) := by
  apply (memLp_two_iff_integrable_sq_norm
    ((g.1.stronglyMeasurable.comp_measurable measurable_fst).mul
      (h.1.stronglyMeasurable.comp_measurable measurable_snd)).aestronglyMeasurable).mpr
  change Integrable (fun p : X × Y => ‖g p.1 * h p.2‖ ^ 2) (μ.prod ν)
  simp only [norm_mul, mul_pow]
  exact ((Lp.memLp g).integrable_norm_pow (by norm_num : (2 : ℕ) ≠ 0)).mul_prod
    ((Lp.memLp h).integrable_norm_pow (by norm_num : (2 : ℕ) ≠ 0))

def tensorLp (g : Lp ℂ 2 μ) (h : Lp ℂ 2 ν) : Lp ℂ 2 (μ.prod ν) :=
  (memLp_tensor g h).toLp _

omit [SFinite μ] in
lemma coe_tensorLp (g : Lp ℂ 2 μ) (h : Lp ℂ 2 ν) :
    (tensorLp g h : X × Y → ℂ) =ᵐ[μ.prod ν] (fun p => g p.1 * h p.2) :=
  MemLp.coeFn_toLp _

lemma tensorLp_inner (g g' : Lp ℂ 2 μ) (h h' : Lp ℂ 2 ν) :
    inner ℂ (tensorLp g h) (tensorLp g' h') = inner ℂ g g' * inner ℂ h h' := by
  rw [L2.inner_def, L2.inner_def g g', L2.inner_def h h', ← integral_prod_mul]
  apply integral_congr_ae
  filter_upwards [coe_tensorLp g h, coe_tensorLp g' h'] with p hp hp'
  rw [hp, hp']
  simp only [RCLike.inner_apply, map_mul]
  ring

lemma tensorLp_norm (g : Lp ℂ 2 μ) (h : Lp ℂ 2 ν) :
    ‖tensorLp g h‖ = ‖g‖ * ‖h‖ := by
  apply (sq_eq_sq₀ (norm_nonneg _) (mul_nonneg (norm_nonneg _) (norm_nonneg _))).mp
  rw [← inner_self_eq_norm_sq (𝕜 := ℂ), tensorLp_inner]
  simp only [inner_self_eq_norm_sq_to_K]
  change ((‖g‖ : ℂ) ^ 2 * (‖h‖ : ℂ) ^ 2).re = _
  simp only [← Complex.ofReal_pow, ← Complex.ofReal_mul, Complex.ofReal_re, mul_pow]

omit [SFinite μ] in
lemma tensorLp_add_left (g g' : Lp ℂ 2 μ) (h : Lp ℂ 2 ν) :
    tensorLp (g + g') h = tensorLp g h + tensorLp g' h := by
  apply Lp.ext
  have hf : Measure.QuasiMeasurePreserving Prod.fst (μ.prod ν) μ :=
    Measure.quasiMeasurePreserving_fst
  filter_upwards [coe_tensorLp (g + g') h, coe_tensorLp g h, coe_tensorLp g' h,
    Lp.coeFn_add (tensorLp g h) (tensorLp g' h), hf.ae (Lp.coeFn_add g g')]
      with p ha hb hc hd he
  simp only [Pi.add_apply] at hd he
  rw [ha, hd, hb, hc, he, add_mul]

omit [SFinite μ] in
lemma tensorLp_smul_left (c : ℂ) (g : Lp ℂ 2 μ) (h : Lp ℂ 2 ν) :
    tensorLp (c • g) h = c • tensorLp g h := by
  apply Lp.ext
  have hf : Measure.QuasiMeasurePreserving Prod.fst (μ.prod ν) μ :=
    Measure.quasiMeasurePreserving_fst
  filter_upwards [coe_tensorLp (c • g) h, coe_tensorLp g h,
    Lp.coeFn_smul c (tensorLp g h), hf.ae (Lp.coeFn_smul c g)] with p ha hb hc hd
  simp only [Pi.smul_apply] at hc hd
  rw [ha, hc, hb, hd]
  simp only [smul_eq_mul, mul_assoc]

omit [SFinite μ] in
lemma tensorLp_add_right (g : Lp ℂ 2 μ) (h h' : Lp ℂ 2 ν) :
    tensorLp g (h + h') = tensorLp g h + tensorLp g h' := by
  apply Lp.ext
  have hf : Measure.QuasiMeasurePreserving Prod.snd (μ.prod ν) ν :=
    Measure.quasiMeasurePreserving_snd
  filter_upwards [coe_tensorLp g (h + h'), coe_tensorLp g h, coe_tensorLp g h',
    Lp.coeFn_add (tensorLp g h) (tensorLp g h'), hf.ae (Lp.coeFn_add h h')]
      with p ha hb hc hd he
  simp only [Pi.add_apply] at hd he
  rw [ha, hd, hb, hc, he, mul_add]

omit [SFinite μ] in
lemma tensorLp_smul_right (c : ℂ) (g : Lp ℂ 2 μ) (h : Lp ℂ 2 ν) :
    tensorLp g (c • h) = c • tensorLp g h := by
  apply Lp.ext
  have hf : Measure.QuasiMeasurePreserving Prod.snd (μ.prod ν) ν :=
    Measure.quasiMeasurePreserving_snd
  filter_upwards [coe_tensorLp g (c • h), coe_tensorLp g h,
    Lp.coeFn_smul c (tensorLp g h), hf.ae (Lp.coeFn_smul c h)] with p ha hb hc hd
  simp only [Pi.smul_apply] at hc hd
  rw [ha, hc, hb, hd]
  simp only [smul_eq_mul]
  ring

end

namespace JoiningOperator
open MeasureTheory ProbabilityTheory ContinuousLinearMap
open scoped InnerProductSpace ENNReal
variable {Ω U X Y : Type*} [MeasurableSpace Ω] [MeasurableSpace U]
  [MeasurableSpace X] [MeasurableSpace Y] {μ : Measure Ω}
  {η : Measure U} {ν : Measure X} {ρ : Measure Y}
  {u : Ω → U} {x : Ω → X} {y : Ω → Y}
  [SFinite η] [SFinite ρ]

def contraction (hx : MeasurePreserving x μ ν)
    (huy : MeasurePreserving (fun ω => (u ω, y ω)) μ (η.prod ρ))
    (g : Lp ℂ 2 η) (h : Lp ℂ 2 ρ) : Lp ℂ 2 ν :=
  operator hx huy (tensorLp g h)

lemma contraction_norm_le (hx : MeasurePreserving x μ ν)
    (huy : MeasurePreserving (fun ω => (u ω, y ω)) μ (η.prod ρ))
    (g : Lp ℂ 2 η) (h : Lp ℂ 2 ρ) : ‖contraction hx huy g h‖ ≤ ‖g‖ * ‖h‖ := by
  calc
    _ ≤ ‖operator hx huy‖ * ‖tensorLp g h‖ := (operator hx huy).le_opNorm _
    _ ≤ ‖tensorLp g h‖ := by grw [operator_norm_le]; simp
    _ = _ := tensorLp_norm g h

omit [SFinite η] in
lemma contraction_inner (hx : MeasurePreserving x μ ν)
    (huy : MeasurePreserving (fun ω => (u ω, y ω)) μ (η.prod ρ))
    (f : Lp ℂ 2 ν) (g : Lp ℂ 2 η) (h : Lp ℂ 2 ρ) :
    inner ℂ f (contraction hx huy g h) =
      ∫ ω, g (u ω) * inner ℂ (f (x ω)) (h (y ω)) ∂μ := by
  rw [contraction, inner_operator]
  apply integral_congr_ae
  filter_upwards [huy.quasiMeasurePreserving.ae (coe_tensorLp g h)] with ω hω
  rw [hω]
  simp only [RCLike.inner_apply]
  ring

omit [SFinite η] in
lemma contraction_integrand (hx : MeasurePreserving x μ ν)
    (huy : MeasurePreserving (fun ω => (u ω, y ω)) μ (η.prod ρ))
    (f : Lp ℂ 2 ν) (g : Lp ℂ 2 η) (h : Lp ℂ 2 ρ) :
    Integrable (fun ω => g (u ω) * inner ℂ (f (x ω)) (h (y ω))) μ := by
  apply (integrable_inner_comp hx huy f (tensorLp g h)).congr
  filter_upwards [huy.quasiMeasurePreserving.ae (coe_tensorLp g h)] with ω hω
  rw [hω]
  simp only [RCLike.inner_apply]
  ring

variable [IsFiniteMeasure η] [SecondCountableTopology (Lp ℂ 2 ν)]
  {κ : Kernel U (X × Y)} [IsMarkovKernel κ]

omit [SFinite η] [SFinite ρ] [IsMarkovKernel κ] in
lemma family_weight_integrable
    (hm : ∀ᵐ a ∂η, MeasurePreserving Prod.fst (κ a) ν ∧ MeasurePreserving Prod.snd (κ a) ρ)
    (g : Lp ℂ 2 η) (h : Lp ℂ 2 ρ) :
    Integrable (fun a => g a • family κ ν ρ a h) η := by
  apply ((Lp.memLp g).integrable (by norm_num : (1 : ℝ≥0∞) ≤ 2)).smul_bdd ‖h‖
    (family_aestronglyMeasurable hm h)
  filter_upwards with a
  calc
    _ ≤ ‖family κ ν ρ a‖ * ‖h‖ := (family κ ν ρ a).le_opNorm h
    _ ≤ _ := by grw [family_norm_le]; simp

omit [SFinite η] in
lemma contraction_integral (hu : MeasurePreserving u μ η)
    (hx : MeasurePreserving x μ ν)
    (huy : MeasurePreserving (fun ω => (u ω, y ω)) μ (η.prod ρ))
    (hκ : HasCondDistrib (fun ω => (x ω, y ω)) u κ μ)
    (hm : ∀ᵐ a ∂η, MeasurePreserving Prod.fst (κ a) ν ∧ MeasurePreserving Prod.snd (κ a) ρ)
    (g : Lp ℂ 2 η) (h : Lp ℂ 2 ρ) :
    contraction hx huy g h = ∫ a, g a • family κ ν ρ a h ∂η := by
  have : IsFiniteMeasure (μ.map u) := hu.map_eq.symm ▸ inferInstance
  apply ext_inner_left ℂ
  intro f
  rw [contraction_inner, ← integral_inner (family_weight_integrable hm g h)]
  let F : U × (X × Y) → ℂ := fun p => g p.1 * inner ℂ (f p.2.1) (h p.2.2)
  have hFm : StronglyMeasurable F :=
    (g.1.stronglyMeasurable.comp_measurable (by fun_prop)).mul
      ((f.1.stronglyMeasurable.comp_measurable (by fun_prop)).inner
        (h.1.stronglyMeasurable.comp_measurable (by fun_prop)))
  have hFi : Integrable F (μ.map u ⊗ₘ κ) := by
    rw [← hκ.map_eq]
    apply (integrable_map_measure hFm.aestronglyMeasurable hκ.aemeasurable).mpr
    exact contraction_integrand hx huy f g h
  calc
    _ = ∫ p, F p ∂μ.map u ⊗ₘ κ := hκ.integral_comp hFm.aestronglyMeasurable
    _ = ∫ a, ∫ p, F (a,p) ∂κ a ∂μ.map u := Measure.integral_compProd hFi
    _ = ∫ a, g a * (∫ p, inner ℂ (f p.1) (h p.2) ∂κ a) ∂η := by
      rw [hu.map_eq]
      simp only [F, integral_const_mul]
    _ = _ := by
      apply integral_congr_ae
      filter_upwards [family_inner hm f h] with a ha
      rw [inner_smul_right, ha]

omit [SFinite η] in
lemma contraction_projection (hu : MeasurePreserving u μ η)
    (hx : MeasurePreserving x μ ν)
    (huy : MeasurePreserving (fun ω => (u ω, y ω)) μ (η.prod ρ))
    (hκ : HasCondDistrib (fun ω => (x ω, y ω)) u κ μ)
    (hm : ∀ᵐ a ∂η, MeasurePreserving Prod.fst (κ a) ν ∧ MeasurePreserving Prod.snd (κ a) ρ)
    (P : Lp ℂ 2 ν →L[ℂ] Lp ℂ 2 ν) (Q : Lp ℂ 2 ρ →L[ℂ] Lp ℂ 2 ρ)
    (hPQ : ∀ᵐ a ∂η, P ∘L family κ ν ρ a = family κ ν ρ a ∘L Q)
    (g : Lp ℂ 2 η) (h : Lp ℂ 2 ρ) :
    P (contraction hx huy g h) = contraction hx huy g (Q h) := by
  rw [contraction_integral hu hx huy hκ hm,
    contraction_integral hu hx huy hκ hm,
    ← P.integral_comp_comm (family_weight_integrable hm g h)]
  apply integral_congr_ae
  filter_upwards [hPQ] with a ha
  rw [map_smul]
  exact congrArg (g a • ·) (congrArg (fun L : Lp ℂ 2 ρ →L[ℂ] Lp ℂ 2 ν => L h) ha)
end JoiningOperator

section
open MeasureTheory
open scoped InnerProductSpace ENNReal
variable {X Y : Type*} [MeasurableSpace X] [MeasurableSpace Y]
  {μ : Measure X} {ν : Measure Y} [IsFiniteMeasure μ] [IsFiniteMeasure ν]

lemma tensorLp_indicator (A : Set X) (hA : MeasurableSet A) (B : Set Y) (hB : MeasurableSet B) :
    tensorLp (indicatorConstLp 2 hA (measure_ne_top μ A) (1 : ℂ))
      (indicatorConstLp 2 hB (measure_ne_top ν B) (1 : ℂ)) =
        indicatorConstLp 2 (hA.prod hB) (measure_ne_top (μ.prod ν) _) (1 : ℂ) := by
  apply Lp.ext
  have hf : Measure.QuasiMeasurePreserving Prod.fst (μ.prod ν) μ :=
    Measure.quasiMeasurePreserving_fst
  have hs : Measure.QuasiMeasurePreserving Prod.snd (μ.prod ν) ν :=
    Measure.quasiMeasurePreserving_snd
  filter_upwards [coe_tensorLp (indicatorConstLp 2 hA (measure_ne_top μ A) (1 : ℂ))
    (indicatorConstLp 2 hB (measure_ne_top ν B) (1 : ℂ)),
    hf.ae (indicatorConstLp_coeFn (p := 2) (hs := hA) (hμs := measure_ne_top μ A) (c := (1 : ℂ))),
    hs.ae (indicatorConstLp_coeFn (p := 2) (hs := hB) (hμs := measure_ne_top ν B) (c := (1 : ℂ))),
    indicatorConstLp_coeFn (p := 2) (hs := hA.prod hB) (hμs := measure_ne_top (μ.prod ν) _) (c := (1 : ℂ))]
    with p ht hp hq hr
  rw [ht, hp, hq, hr]
  by_cases ha : p.1 ∈ A <;> by_cases hb : p.2 ∈ B <;> simp [ha, hb]

lemma dense_tensorLp :
    (Submodule.span ℂ (Set.range (fun p : Lp ℂ 2 μ × Lp ℂ 2 ν => tensorLp p.1 p.2))).topologicalClosure = ⊤ := by
  let S := Submodule.span ℂ (Set.range (fun p : Lp ℂ 2 μ × Lp ℂ 2 ν => tensorLp p.1 p.2))
  have hS : Sᗮ = ⊥ := by
    apply eq_bot_iff.mpr
    intro f hf
    change f = 0
    apply Lp.ext
    apply (JoiningOperator.ae_eq_zero_of_rectangles
      ((Lp.memLp f).integrable (by norm_num : (1 : ℝ≥0∞) ≤ 2)) ?_).trans
      (Lp.coeFn_zero _ _ _).symm
    intro A B hA hB
    rw [← L2.inner_indicatorConstLp_one (hA.prod hB) (measure_ne_top _ _), ← tensorLp_indicator A hA B hB]
    exact S.inner_right_of_mem_orthogonal
      (Submodule.subset_span ⟨(_, _), rfl⟩) hf
  rw [← Submodule.orthogonal_orthogonal_eq_closure, hS, Submodule.bot_orthogonal_eq_top]

end

section
open MeasureTheory ContinuousLinearMap
open scoped InnerProductSpace
variable {X Y H : Type*} [MeasurableSpace X] [MeasurableSpace Y]
  {μ : Measure X} {ν : Measure Y} [IsFiniteMeasure μ] [IsFiniteMeasure ν]
  [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]

omit [CompleteSpace H] in
lemma closure_tensor_image (A : Lp ℂ 2 (μ.prod ν) →L[ℂ] H) :
    (Submodule.span ℂ (Set.range (fun p : Lp ℂ 2 μ × Lp ℂ 2 ν => A (tensorLp p.1 p.2)))).topologicalClosure =
      (LinearMap.range A.toLinearMap).topologicalClosure := by
  let S := (Submodule.span ℂ (Set.range (fun p : Lp ℂ 2 μ × Lp ℂ 2 ν => A (tensorLp p.1 p.2)))).topologicalClosure
  apply le_antisymm
  · apply Submodule.topologicalClosure_minimal
    · apply Submodule.span_le.mpr
      rintro z ⟨⟨g,h⟩, rfl⟩
      exact (Submodule.le_topologicalClosure _) ⟨tensorLp g h, rfl⟩
    · exact Submodule.isClosed_topologicalClosure _
  · apply Submodule.topologicalClosure_minimal
    · rintro z ⟨v,rfl⟩
      have hclosed : IsClosed (S.comap A.toLinearMap : Set (Lp ℂ 2 (μ.prod ν))) :=
        (Submodule.isClosed_topologicalClosure _).preimage A.continuous
      have ht : (⊤ : Submodule ℂ (Lp ℂ 2 (μ.prod ν))) ≤ S.comap A.toLinearMap := by
        rw [← dense_tensorLp]
        apply Submodule.topologicalClosure_minimal _ (Submodule.span_le.mpr ?_) hclosed
        rintro z ⟨⟨g,h⟩,rfl⟩
        exact (Submodule.le_topologicalClosure _) (Submodule.subset_span ⟨(g,h),rfl⟩)
      exact ht (Submodule.mem_top : v ∈ (⊤ : Submodule ℂ (Lp ℂ 2 (μ.prod ν))))
    · exact Submodule.isClosed_topologicalClosure _

omit [CompleteSpace H] in

lemma restricted_contractions_span (A : Lp ℂ 2 (μ.prod ν) →L[ℂ] H)
    (D : Submodule ℂ H) [D.HasOrthogonalProjection]
    (P : Lp ℂ 2 μ →L[ℂ] Lp ℂ 2 μ) (Q : Lp ℂ 2 ν →L[ℂ] Lp ℂ 2 ν)
    (hA : D ≤ (LinearMap.range A.toLinearMap).topologicalClosure)
    (hPQ : ∀ g h, D.starProjection (A (tensorLp g h)) = A (tensorLp (P g) (Q h))) :
    (Submodule.span ℂ (Set.range (fun p : Lp ℂ 2 μ × Lp ℂ 2 ν => A (tensorLp (P p.1) (Q p.2))))).topologicalClosure = D := by
  let S := (Submodule.span ℂ (Set.range (fun p : Lp ℂ 2 μ × Lp ℂ 2 ν => A (tensorLp (P p.1) (Q p.2))))).topologicalClosure
  have hDS : ∀ v ∈ (LinearMap.range A.toLinearMap).topologicalClosure,
      D.starProjection v ∈ S := by
    intro v hv
    have hclosed : IsClosed (S.comap D.starProjection.toLinearMap : Set H) :=
      (Submodule.isClosed_topologicalClosure _).preimage D.starProjection.continuous
    have hh : (LinearMap.range A.toLinearMap).topologicalClosure ≤ S.comap D.starProjection.toLinearMap := by
      rw [← closure_tensor_image A]
      apply Submodule.topologicalClosure_minimal _ (Submodule.span_le.mpr ?_) hclosed
      rintro z ⟨⟨g,h⟩,rfl⟩
      change D.starProjection (A (tensorLp g h)) ∈ S
      rw [hPQ]
      exact (Submodule.le_topologicalClosure _) (Submodule.subset_span ⟨(g,h),rfl⟩)
    exact hh hv
  apply le_antisymm
  · apply Submodule.topologicalClosure_minimal
    · apply Submodule.span_le.mpr
      rintro z ⟨⟨g,h⟩,rfl⟩
      change A (tensorLp (P g) (Q h)) ∈ D
      rw [← hPQ]
      exact D.starProjection_apply_mem _
    · exact D.isTopCompl_orthogonal.isClosed
  · intro v hv
    have hh := hDS v (hA hv)
    rwa [D.starProjection_eq_self_iff.mpr hv] at hh

end

namespace JoiningOperator
open MeasureTheory ProbabilityTheory ContinuousLinearMap
open scoped InnerProductSpace ENNReal
variable {Ω U X Y : Type*} [MeasurableSpace Ω] [MeasurableSpace U]
  [MeasurableSpace X] [MeasurableSpace Y] {μ : Measure Ω}
  {η : Measure U} {ν : Measure X} {ρ : Measure Y}
  {u : Ω → U} {x : Ω → X} {y : Ω → Y}

lemma contraction_swap [SFinite η] [SFinite ρ] (hx : MeasurePreserving x μ ν)
    (huy : MeasurePreserving (fun ω => (u ω,y ω)) μ (η.prod ρ))
    (hyu : MeasurePreserving (fun ω => (y ω,u ω)) μ (ρ.prod η))
    (g : Lp ℂ 2 η) (h : Lp ℂ 2 ρ) :
    contraction hx huy g h = contraction hx hyu h g := by
  apply ext_inner_left ℂ
  intro f
  rw [contraction_inner,contraction_inner]
  apply integral_congr_ae
  filter_upwards with ω
  simp only [RCLike.inner_apply]
  ring

lemma contraction_projection_both
    [IsFiniteMeasure η] [IsFiniteMeasure ρ]
    (hx : MeasurePreserving x μ ν)
    (huy : MeasurePreserving (fun ω => (u ω,y ω)) μ (η.prod ρ))
    (hyu : MeasurePreserving (fun ω => (y ω,u ω)) μ (ρ.prod η))
    (D : Submodule ℂ (Lp ℂ 2 ν)) [D.HasOrthogonalProjection]
    (P : Submodule ℂ (Lp ℂ 2 η)) [P.HasOrthogonalProjection]
    (Q : Submodule ℂ (Lp ℂ 2 ρ)) [Q.HasOrthogonalProjection]
    (hr : ∀ g h, D.starProjection (contraction hx huy g h) = contraction hx huy g (Q.starProjection h))
    (hl : ∀ h g, D.starProjection (contraction hx hyu h g) = contraction hx hyu h (P.starProjection g))
    (g : Lp ℂ 2 η) (h : Lp ℂ 2 ρ) :
    D.starProjection (contraction hx huy g h) =
      contraction hx huy (P.starProjection g) (Q.starProjection h) := by
  calc
    _ = D.starProjection (D.starProjection (contraction hx huy g h)) := by
      rw [D.starProjection_eq_self_iff.mpr (D.starProjection_apply_mem _)]
    _ = D.starProjection (contraction hx huy g (Q.starProjection h)) := by rw [hr]
    _ = D.starProjection (contraction hx hyu (Q.starProjection h) g) := by rw [contraction_swap hx huy hyu]
    _ = contraction hx hyu (Q.starProjection h) (P.starProjection g) := hl _ _
    _ = _ := contraction_swap hx hyu huy _ _

lemma active_eq_essentialRange_product [IsProbabilityMeasure μ]
    [SecondCountableTopology (Lp ℂ 2 ρ)]
    {κ : Kernel U (X × Y)} [IsMarkovKernel κ]
    (hu : MeasurePreserving u μ η) (hx : MeasurePreserving x μ ν)
    (hy : MeasurePreserving y μ ρ)
    (huy : MeasurePreserving (fun ω => (u ω,y ω)) μ (η.prod ρ))
    (hκ : HasCondDistrib (fun ω => (x ω,y ω)) u κ μ)
    (hm : ∀ᵐ a ∂η, MeasurePreserving Prod.fst (κ a) ν ∧ MeasurePreserving Prod.snd (κ a) ρ) :
    (LinearMap.range (operator hx huy).toLinearMap).topologicalClosure =
      essentialRange η (family κ ν ρ) := by
  have h := active_eq_essentialRange hu.measurable hx hy hκ (by simpa only [hu.map_eq] using hm)
  calc
    _ = (LinearMap.range (operator hx ⟨hu.measurable.prodMk hy.measurable,rfl⟩).toLinearMap).topologicalClosure :=
      active_observation_eq hx huy ⟨hu.measurable.prodMk hy.measurable,rfl⟩ rfl
    _ = _ := by simpa only [hu.map_eq] using h
end JoiningOperator

namespace ArrayObjects.Object.Rolled
open MeasureTheory ProbabilityTheory ContinuousLinearMap
open scoped ENNReal

section
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)

lemma commonActive_swapColumns (hM : M.IsSaturated) (rows cols : TriplePartition I) (n : ℕ) :
    ∀ᵐ e ∂(M.law (n+2)).map (amap M.par (n+2)),
      commonActive M rows.P rows.A rows.B cols.P cols.A cols.B n e =
        commonActive M rows.P rows.A rows.B cols.P cols.B cols.A n e := by
  filter_upwards [rowActive_swap M hM rows.P rows.properP cols n] with e he
  simp only [commonActive,he]

lemma commonActive_swapRows (hM : M.IsSaturated) (rows cols : TriplePartition I) (n : ℕ) :
    ∀ᵐ e ∂(M.law (n+2)).map (amap M.par (n+2)),
      commonActive M rows.P rows.A rows.B cols.P cols.A cols.B n e =
        commonActive M rows.P rows.B rows.A cols.P cols.A cols.B n e := by
  filter_upwards [columnActive_swap M hM rows cols.P cols.properP n] with e he
  simp only [commonActive,he]

lemma grouped_first_row_edge (hM : M.IsSaturated) (rows cols : TriplePartition I) (n : ℕ) :
    ∀ᵐ e ∂(M.law (n+2)).map (amap M.par (n+2)),
      ∀ᵐ s ∂cellLaw M rows.P cols.A n e,
        (commonActive M rows.P rows.A rows.B cols.P cols.A cols.B n e).starProjection ∘L
          fibreRowEdge M rows.P cols.A cols.P cols.B n e s =
        fibreRowEdge M rows.P cols.A cols.P cols.B n e s ∘L
          (commonActive M rows.P rows.A rows.B cols.B cols.P cols.A n e).starProjection := by
  filter_upwards [grouped_active_intersections M hM rows.swapPA cols.swapPA n,
    commonActive_swapColumns M hM rows cols.swapPB n] with e he hs
  dsimp only [TriplePartition.swapPA,TriplePartition.swapPB] at he hs
  have hp : (commonActive M rows.P rows.A rows.B cols.B cols.A cols.P n e).starProjection =
      (commonActive M rows.P rows.A rows.B cols.B cols.P cols.A n e).starProjection := by congr 1
  filter_upwards [he.1] with s h
  rw [hp] at h
  exact h

lemma grouped_second_row_edge (hM : M.IsSaturated) (rows cols : TriplePartition I) (n : ℕ) :
    ∀ᵐ e ∂(M.law (n+2)).map (amap M.par (n+2)),
      ∀ᵐ t ∂cellLaw M rows.P cols.B n e,
        (commonActive M rows.P rows.A rows.B cols.P cols.A cols.B n e).starProjection ∘L
          fibreRowEdge M rows.P cols.B cols.P cols.A n e t =
        fibreRowEdge M rows.P cols.B cols.P cols.A n e t ∘L
          (commonActive M rows.P rows.A rows.B cols.A cols.P cols.B n e).starProjection := by
  filter_upwards [grouped_first_row_edge M hM rows cols.swapAB n,
    commonActive_swapColumns M hM rows cols n] with e he hs
  have hp : (commonActive M rows.P rows.A rows.B cols.P cols.A cols.B n e).starProjection =
      (commonActive M rows.P rows.A rows.B cols.P cols.B cols.A n e).starProjection := by congr 1
  filter_upwards [he] with t h
  rw [hp]
  exact h

theorem grouped_row_contraction_projection (hM : M.IsSaturated)
    (rows cols : TriplePartition I) (n : ℕ) :
    ∀ᵐ e ∂(M.law (n+2)).map (amap M.par (n+2)),
      ∀ (hr : MeasurePreserving (cells M rows.P cols.P n) (M.ownKernel (n+2) e) (cellLaw M rows.P cols.P n e))
      (hst : 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)))
      (g : Lp ℂ 2 (cellLaw M rows.P cols.A n e)) (h : Lp ℂ 2 (cellLaw M rows.P cols.B n e)),
      (commonActive M rows.P rows.A rows.B cols.P cols.A cols.B n e).starProjection
        (JoiningOperator.contraction hr hst g h) =
      JoiningOperator.contraction hr hst
        ((commonActive M rows.P rows.A rows.B cols.A cols.P cols.B n e).starProjection g)
        ((commonActive M rows.P rows.A rows.B cols.B cols.P cols.A n e).starProjection h) := by
  filter_upwards [grouped_first_row_edge M hM rows cols n,grouped_second_row_edge M hM rows cols 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,
    rowPair_fixed_conditional M rows.P cols.A cols.P cols.B n,
    rowPair_fixed_conditional M rows.P cols.B cols.P cols.A n,
    rowPair_fixed_marginals M hM rows.P cols.A cols.P cols.B rows.properP
      cols.disjointPA.symm cols.disjointAB (by simpa [Finset.union_comm] using cols.properPA) cols.properAB n,
    rowPair_fixed_marginals M hM rows.P cols.B cols.P cols.A rows.properP
      cols.disjointPB.symm cols.disjointAB.symm (by simpa [Finset.union_comm] using cols.properPB)
      (by simpa [Finset.union_comm] using cols.properAB) n] with e hq hp hs ht hκ hξ hmκ hmξ
  intro hr hst g h
  rw [hs.map_eq] at hmκ
  rw [ht.map_eq] at hmξ
  simp only [fibreRowEdge_eq] at hq hp
  let hts : MeasurePreserving (fun y => (cells M rows.P cols.B n y,cells M rows.P cols.A n y))
      (M.ownKernel (n+2) e) ((cellLaw M rows.P cols.B n e).prod (cellLaw M rows.P cols.A n e)) :=
    Measure.measurePreserving_swap.comp hst
  apply JoiningOperator.contraction_projection_both hr hst hts _ _ _
  · intro g h
    exact JoiningOperator.contraction_projection hs hr hst hκ hmκ _ _ hq g h
  · intro h g
    exact JoiningOperator.contraction_projection ht hr hts hξ hmξ _ _ hp h g

lemma grouped_first_column_edge (hM : M.IsSaturated) (rows cols : TriplePartition I) (n : ℕ) :
    ∀ᵐ e ∂(M.law (n+2)).map (amap M.par (n+2)),
      ∀ᵐ s ∂cellLaw M rows.A cols.P n e,
        (commonActive M rows.P rows.A rows.B cols.P cols.A cols.B n e).starProjection ∘L
          fibreColumnEdge M rows.A rows.P rows.B cols.P n e s =
        fibreColumnEdge M rows.A rows.P rows.B cols.P n e s ∘L
          (commonActive M rows.B rows.P rows.A cols.P cols.A cols.B n e).starProjection := by
  filter_upwards [grouped_active_intersections M hM rows.swapPA cols.swapPA n,
    commonActive_swapRows M hM rows.swapPB cols n] with e he hs
  dsimp only [TriplePartition.swapPA,TriplePartition.swapPB] at he hs
  have hp : (commonActive M rows.B rows.A rows.P 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 := by congr 1
  filter_upwards [he.2.2.1] with s h
  rw [hp] at h
  exact h

lemma grouped_second_column_edge (hM : M.IsSaturated) (rows cols : TriplePartition I) (n : ℕ) :
    ∀ᵐ e ∂(M.law (n+2)).map (amap M.par (n+2)),
      ∀ᵐ t ∂cellLaw M rows.B cols.P n e,
        (commonActive M rows.P rows.A rows.B cols.P cols.A cols.B n e).starProjection ∘L
          fibreColumnEdge M rows.B rows.P rows.A cols.P n e t =
        fibreColumnEdge M rows.B rows.P rows.A cols.P n e t ∘L
          (commonActive M rows.A rows.P rows.B cols.P cols.A cols.B n e).starProjection := by
  filter_upwards [grouped_first_column_edge M hM rows.swapAB cols n,
    commonActive_swapRows M hM rows cols n] with e he hs
  have hp : (commonActive M rows.P rows.A rows.B cols.P cols.A cols.B n e).starProjection =
      (commonActive M rows.P rows.B rows.A cols.P cols.A cols.B n e).starProjection := by congr 1
  filter_upwards [he] with t h
  rw [hp]
  exact h

theorem grouped_column_contraction_projection (hM : M.IsSaturated)
    (rows cols : TriplePartition I) (n : ℕ) :
    ∀ᵐ e ∂(M.law (n+2)).map (amap M.par (n+2)),
      ∀ (hr : MeasurePreserving (cells M rows.P cols.P n) (M.ownKernel (n+2) e) (cellLaw M rows.P cols.P n e))
      (hst : 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)))
      (g : Lp ℂ 2 (cellLaw M rows.A cols.P n e)) (h : Lp ℂ 2 (cellLaw M rows.B cols.P n e)),
      (commonActive M rows.P rows.A rows.B cols.P cols.A cols.B n e).starProjection
        (JoiningOperator.contraction hr hst g h) =
      JoiningOperator.contraction hr hst
        ((commonActive M rows.A rows.P rows.B cols.P cols.A cols.B n e).starProjection g)
        ((commonActive M rows.B rows.P rows.A cols.P cols.A cols.B n e).starProjection h) := by
  let rr := rows.swapPA
  let rt := rows.swapPB
  filter_upwards [grouped_first_column_edge M hM rows cols n,grouped_second_column_edge M hM rows cols 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,
    columnPair_fixed_conditional M hM rows.A rows.P rows.B cols.P rr.cardP cols.properP n,
    columnPair_fixed_conditional M hM rows.B rows.P rows.A cols.P rt.cardP cols.properP n,
    columnPair_fixed_marginals M hM rows.A rows.P rows.B cols.P rr.cardP cols.properP
      rows.properP rows.properB rows.disjointPA.symm rows.disjointAB
      (by simpa [Finset.union_comm] using rows.properPA) rows.properAB n,
    columnPair_fixed_marginals M hM rows.B rows.P rows.A cols.P rt.cardP cols.properP
      rows.properP rows.properA rows.disjointPB.symm rows.disjointAB.symm
      (by simpa [Finset.union_comm] using rows.properPB)
      (by simpa [Finset.union_comm] using rows.properAB) n] with e hq hp hs ht hκ hξ hmκ hmξ
  intro hr hst g h
  rw [hs.map_eq] at hmκ
  rw [ht.map_eq] at hmξ
  simp only [fibreColumnEdge_eq] at hq hp
  let hts : MeasurePreserving (fun y => (cells M rows.B cols.P n y,cells M rows.A cols.P n y))
      (M.ownKernel (n+2) e) ((cellLaw M rows.B cols.P n e).prod (cellLaw M rows.A cols.P n e)) :=
    Measure.measurePreserving_swap.comp hst
  apply JoiningOperator.contraction_projection_both hr hst hts _ _ _
  · intro g h
    exact JoiningOperator.contraction_projection hs hr hst hκ hmκ _ _ hq g h
  · intro h g
    exact JoiningOperator.contraction_projection ht hr hts hξ hmξ _ _ hp h g

end

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)

lemma rowActive_eq_range (hM : M.IsSaturated) (A : Finset I) (hA : A ≠ Finset.univ)
    (cols : TriplePartition I) (n : ℕ) :
    ∀ᵐ e ∂(M.law (n+2)).map (amap M.par (n+2)),
      ∀ (hr : MeasurePreserving (cells M A cols.P n) (M.ownKernel (n+2) e) (cellLaw M A cols.P n e))
      (hst : MeasurePreserving (fun y => (cells M A cols.A n y,cells M A cols.B n y))
        (M.ownKernel (n+2) e) ((cellLaw M A cols.A n e).prod (cellLaw M A cols.B n e))),
      rowActive M A cols.P cols.A cols.B n e =
        (LinearMap.range (JoiningOperator.operator hr hst).toLinearMap).topologicalClosure := by
  filter_upwards [cells_fibre_marginal M hM A cols.A hA n,
    cells_fibre_marginal M hM A cols.B hA n,
    rowPair_fixed_conditional M A cols.A cols.P cols.B n,
    rowPair_fixed_marginals M hM A cols.A cols.P cols.B hA
      cols.disjointPA.symm cols.disjointAB (by simpa [Finset.union_comm] using cols.properPA)
      cols.properAB n] with e hs ht hκ hm
  intro hr hst
  rw [hs.map_eq] at hm
  unfold rowActive
  rw [fibreRowEdge_eq]
  exact (JoiningOperator.active_eq_essentialRange_product hs hr ht hst hκ hm).symm

lemma columnActive_eq_range (hM : M.IsSaturated) (rows : TriplePartition I)
    (R : Finset I) (hR : R ≠ Finset.univ) (n : ℕ) :
    ∀ᵐ e ∂(M.law (n+2)).map (amap M.par (n+2)),
      ∀ (hr : MeasurePreserving (cells M rows.P R n) (M.ownKernel (n+2) e) (cellLaw M rows.P R n e))
      (hst : MeasurePreserving (fun y => (cells M rows.A R n y,cells M rows.B R n y))
        (M.ownKernel (n+2) e) ((cellLaw M rows.A R n e).prod (cellLaw M rows.B R n e))),
      columnActive M rows.P rows.A rows.B R n e =
        (LinearMap.range (JoiningOperator.operator hr hst).toLinearMap).topologicalClosure := by
  filter_upwards [cells_fibre_marginal M hM rows.A R rows.properA n,
    cells_fibre_marginal M hM rows.B R rows.properB n,
    columnPair_fixed_conditional M hM rows.A rows.P rows.B R rows.swapPA.cardP hR n,
    columnPair_fixed_marginals M hM rows.A rows.P rows.B R rows.swapPA.cardP hR
      rows.properP rows.properB rows.disjointPA.symm rows.disjointAB
      (by simpa [Finset.union_comm] using rows.properPA) rows.properAB n] with e hs ht hκ hm
  intro hr hst
  rw [hs.map_eq] at hm
  unfold columnActive
  rw [fibreColumnEdge_eq]
  exact (JoiningOperator.active_eq_essentialRange_product hs hr ht hst hκ hm).symm

theorem grouped_row_contractions_span (hM : M.IsSaturated)
    (rows cols : TriplePartition I) (n : ℕ) :
    ∀ᵐ e ∂(M.law (n+2)).map (amap M.par (n+2)),
      ∀ (hr : MeasurePreserving (cells M rows.P cols.P n) (M.ownKernel (n+2) e) (cellLaw M rows.P cols.P n e))
      (hst : 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))),
      (Submodule.span ℂ (Set.range (fun p : Lp ℂ 2 (cellLaw M rows.P cols.A n e) ×
          Lp ℂ 2 (cellLaw M rows.P cols.B n e) => JoiningOperator.contraction hr hst
          ((commonActive M rows.P rows.A rows.B cols.A cols.P cols.B n e).starProjection p.1)
          ((commonActive M rows.P rows.A rows.B cols.B cols.P cols.A n e).starProjection p.2)))).topologicalClosure =
        commonActive M rows.P rows.A rows.B cols.P cols.A cols.B n e := by
  filter_upwards [rowActive_eq_range M hM rows.P rows.properP cols n,
    grouped_row_contraction_projection M hM rows cols n] with e he hp
  intro hr hst
  apply restricted_contractions_span (JoiningOperator.operator hr hst)
  · rw [←he hr hst]
    exact inf_le_left
  · exact hp hr hst

theorem grouped_column_contractions_span (hM : M.IsSaturated)
    (rows cols : TriplePartition I) (n : ℕ) :
    ∀ᵐ e ∂(M.law (n+2)).map (amap M.par (n+2)),
      ∀ (hr : MeasurePreserving (cells M rows.P cols.P n) (M.ownKernel (n+2) e) (cellLaw M rows.P cols.P n e))
      (hst : 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))),
      (Submodule.span ℂ (Set.range (fun p : Lp ℂ 2 (cellLaw M rows.A cols.P n e) ×
          Lp ℂ 2 (cellLaw M rows.B cols.P n e) => JoiningOperator.contraction hr hst
          ((commonActive M rows.A rows.P rows.B cols.P cols.A cols.B n e).starProjection p.1)
          ((commonActive M rows.B rows.P rows.A cols.P cols.A cols.B n e).starProjection p.2)))).topologicalClosure =
        commonActive M rows.P rows.A rows.B cols.P cols.A cols.B n e := by
  filter_upwards [columnActive_eq_range M hM rows cols.P cols.properP n,
    grouped_column_contraction_projection M hM rows cols n] with e he hp
  intro hr hst
  apply restricted_contractions_span (JoiningOperator.operator hr hst)
  · rw [←he hr hst]
    exact inf_le_right
  · exact hp hr hst

end ArrayObjects.Object.Rolled

namespace JoiningOperator

open MeasureTheory ProbabilityTheory ContinuousLinearMap
open scoped InnerProductSpace ENNReal

section ContractionCoefficients
variable {Ω U X Y : Type*} [MeasurableSpace Ω] [MeasurableSpace U]
  [MeasurableSpace X] [MeasurableSpace Y] [StandardBorelSpace X] [StandardBorelSpace Y]
  [Nonempty X] [Nonempty Y] {μ : Measure Ω} [IsProbabilityMeasure μ]
  {η : Measure U} {ν : Measure X} {ρ : Measure Y}
  [IsProbabilityMeasure η] [IsProbabilityMeasure ν] [IsProbabilityMeasure ρ]
  {u : Ω → U} {x : Ω → X} {y : Ω → Y}
  {κ : Kernel U (X × Y)} [IsMarkovKernel κ]

omit [IsProbabilityMeasure η] [IsProbabilityMeasure ν] [IsProbabilityMeasure ρ] in
lemma contraction_coefficient [SFinite ρ] (hu : MeasurePreserving u μ η)
    (hxy : MeasurePreserving (fun ω => (x ω,y ω)) μ (ν.prod ρ))
    (hκ : HasCondDistrib (fun ω => (x ω,y ω)) u κ μ)
    (hm : ∀ᵐ a ∂η, MeasurePreserving Prod.fst (κ a) ν ∧ MeasurePreserving Prod.snd (κ a) ρ)
    (g : Lp ℂ 2 ν) (h : Lp ℂ 2 ρ) :
    contraction hu hxy g h =ᵐ[η] (fun a => inner ℂ (star g) (family κ ν ρ a h)) := by
  let F : X × Y → ℂ := fun p => g p.1 * h p.2
  have hFm : StronglyMeasurable F :=
    (g.1.stronglyMeasurable.comp_measurable measurable_fst).mul
      (h.1.stronglyMeasurable.comp_measurable measurable_snd)
  have hten : (fun ω => tensorLp g h (x ω,y ω)) =ᵐ[μ] (fun ω => F (x ω,y ω)) :=
    hxy.quasiMeasurePreserving.ae (coe_tensorLp g h)
  have hFi : Integrable (fun ω => F (x ω,y ω)) μ := by
    apply (((Lp.memLp (tensorLp g h)).comp_measurePreserving hxy).integrable (by norm_num : (1 : ℝ≥0∞) ≤ 2)).congr
    exact hten
  have hcond := (operator_ae_eq_condExp hu hxy (tensorLp g h)).trans
      ((condExp_congr_ae hten).trans (condExp_of_kernel hu.measurable hκ F hFm hFi))
  have hi : contraction hu hxy g h =ᵐ[η] (fun a => ∫ p, F p ∂κ a) := by
    have ht := (ae_map_iff hu.aemeasurable
      (measurableSet_eq_fun (Lp.stronglyMeasurable (contraction hu hxy g h)).measurable hFm.integral_kernel.measurable)).mpr hcond
    change ∀ᵐ a ∂η, contraction hu hxy g h a = ∫ p, F p ∂κ a
    simpa only [hu.map_eq] using ht
  apply hi.trans
  filter_upwards [hm, family_inner hm (star g) h] with a ha hai
  rw [hai]
  apply integral_congr_ae
  filter_upwards [ha.1.quasiMeasurePreserving.ae (Lp.coeFn_star g)] with p hp
  rw [hp]
  simp [F, RCLike.inner_apply, mul_comm]

end ContractionCoefficients


variable {Ω Z X Y A B C : Type*}
  [MeasurableSpace Ω] [MeasurableSpace Z] [MeasurableSpace X] [MeasurableSpace Y]
  [MeasurableSpace A] [MeasurableSpace B] [MeasurableSpace C]
  {μ : Measure Ω} {ν : Measure X} {ρ : Measure Y} {η : Measure Z}
  {α : Measure A} {β : Measure B} {τ : Measure C}
  {x : Ω → X} {y : Ω → Y} {z : Ω → Z} {a : X → A} {b : Y → B} {c : Z → C}
  [SFinite ν] [SFinite ρ]

lemma tensor_pull [SFinite β] (ha : MeasurePreserving a ν α) (hb : MeasurePreserving b ρ β)
    (g : Lp ℂ 2 α) (h : Lp ℂ 2 β) :
    tensorLp (pull ha g) (pull hb h) = pull (ha.prod hb) (tensorLp g h) := by
  apply Lp.ext
  filter_upwards [coe_tensorLp (pull ha g) (pull hb h),
    (ha.prod hb).quasiMeasurePreserving.ae (coe_tensorLp g h),
    Lp.coeFn_compMeasurePreserving (tensorLp g h) (ha.prod hb),
    Measure.quasiMeasurePreserving_fst.ae (Lp.coeFn_compMeasurePreserving g ha),
    Measure.quasiMeasurePreserving_snd.ae (Lp.coeFn_compMeasurePreserving h hb)] with p hp ht hpull hga hhb
  exact hp.trans ((congrArg₂ (· * ·) hga hhb).trans (ht.symm.trans hpull.symm))

lemma contraction_pull [SFinite β] (hz : MeasurePreserving z μ η)
    (hxy : MeasurePreserving (fun ω => (x ω,y ω)) μ (ν.prod ρ))
    (ha : MeasurePreserving a ν α) (hb : MeasurePreserving b ρ β)
    (g : Lp ℂ 2 α) (h : Lp ℂ 2 β) :
    contraction hz hxy (pull ha g) (pull hb h) =
      operator hz ((ha.prod hb).comp hxy) (tensorLp g h) := by
  unfold contraction operator
  rw [tensor_pull ha hb, pull_comp hxy (ha.prod hb)]
  rfl

lemma contraction_mem_screen
    [IsProbabilityMeasure μ] [StandardBorelSpace A] [Nonempty A]
    [StandardBorelSpace B] [Nonempty B]
    (hz : MeasurePreserving z μ η)
    (hxy : MeasurePreserving (fun ω => (x ω,y ω)) μ (ν.prod ρ))
    (ha : MeasurePreserving a ν α) (hb : MeasurePreserving b ρ β)
    (hc : MeasurePreserving c η τ)
    {κ : Kernel C (A × B)} [IsMarkovKernel κ]
    (hκ : HasCondDistrib (fun ω => (a (x ω),b (y ω))) z (κ.comap c hc.measurable) μ)
    (g : Lp ℂ 2 ν) (h : Lp ℂ 2 ρ)
    (hg : g ∈ lpMeas ℂ ℂ (MeasurableSpace.comap a inferInstance) 2 ν)
    (hh : h ∈ lpMeas ℂ ℂ (MeasurableSpace.comap b inferInstance) 2 ρ) :
    contraction hz hxy g h ∈ lpMeas ℂ ℂ (MeasurableSpace.comap c inferInstance) 2 η := by
  have : SFinite β := hb.map_eq ▸ inferInstanceAs (SFinite (ρ.map b))
  rw [←pull_range ha] at hg
  rw [←pull_range hb] at hh
  obtain ⟨g,rfl⟩ := hg
  obtain ⟨h,rfl⟩ := hh
  change contraction hz hxy (pull ha g) (pull hb h) ∈ _
  rw [contraction_pull hz hxy ha hb g h, screened_operator hz ((ha.prod hb).comp hxy) hc hκ]
  rw [←pull_range hc]
  exact ⟨operator (hc.comp hz) ((ha.prod hb).comp hxy) (tensorLp g h),rfl⟩

end JoiningOperator

section
open MeasureTheory ProbabilityTheory
variable {G : Type*} [Group G] [MeasurableSpace G] [MeasurableMul₂ G]

lemma measure_eq_graph_of_ratio (μ : Measure (G × G)) (ρ : Measure G) (a : G)
    (hρ : μ.map Prod.snd = ρ) (hr : ∀ᵐ p ∂μ, p.1 * p.2⁻¹ = a) :
    μ = ρ.map (fun b => (a*b,b)) := by
  have hg : Measurable (fun b : G => (a*b,b)) :=
    (measurable_const.mul measurable_id).prodMk measurable_id
  rw [←hρ, Measure.map_map hg measurable_snd]
  calc
    μ = μ.map id := (Measure.map_id).symm
    _ = μ.map ((fun b => (a*b,b)) ∘ Prod.snd) := by
      apply Measure.map_congr
      filter_upwards [hr] with p hp
      apply Prod.ext
      · change p.1 = a*p.2
        rw [←hp, mul_assoc, inv_mul_cancel, mul_one]
      · rfl

def ratioKernel (ρ : Measure G) : Kernel G (G × G) :=
  (Kernel.id.prod (Kernel.const G ρ)).map (fun p : G × G => (p.1*p.2,p.2))

lemma ratioKernel_apply (ρ : Measure G) [SFinite ρ] (a : G) :
    ratioKernel ρ a = ρ.map (fun b => (a*b,b)) := by
  have hm : Measurable (fun p : G × G => (p.1*p.2,p.2)) :=
    (measurable_fst.mul measurable_snd).prodMk measurable_snd
  rw [ratioKernel, Kernel.map_apply _ hm]
  simp only [Kernel.prod_apply, Kernel.id_apply, Kernel.const_apply]
  rw [Measure.dirac_prod]
  rw [Measure.map_map hm (measurable_prodMk_left (x := a))]
  rfl

instance ratioKernel_markov (ρ : Measure G) [IsProbabilityMeasure ρ] :
    IsMarkovKernel (ratioKernel ρ) := by
  unfold ratioKernel
  exact Kernel.IsMarkovKernel.map _ (measurable_fst.mul measurable_snd |>.prodMk measurable_snd)

variable {Ω Z : Type*} [MeasurableSpace Ω] [MeasurableSpace Z]
  {μ : Measure Ω} {z : Ω → Z} {v : Ω → G × G}

lemma hasCondDistrib_ratio {κ : Kernel Z (G × G)} [IsMarkovKernel κ]
    (hκ : HasCondDistrib v z κ μ) (ρ : Measure G) [IsProbabilityMeasure ρ]
    (c : Z → G) (hc : Measurable c)
    (hm : ∀ᵐ t ∂μ.map z, (κ t).map Prod.snd = ρ)
    (hr : ∀ᵐ t ∂μ.map z, ∀ᵐ p ∂κ t, p.1*p.2⁻¹ = c t) :
    HasCondDistrib v z ((ratioKernel ρ).comap c hc) μ := by
  refine ⟨hκ.aemeasurable, hκ.map_eq.trans (Measure.compProd_congr ?_)⟩
  filter_upwards [hm,hr] with t ht htr
  change κ t = ratioKernel ρ (c t)
  rw [ratioKernel_apply]
  exact measure_eq_graph_of_ratio (κ t) ρ (c t) ht htr

end

namespace JoiningOperator

open MeasureTheory ProbabilityTheory ContinuousLinearMap
open scoped InnerProductSpace ENNReal

section FactorFields
variable {Ω Z X Y A B C : Type*}
  [MeasurableSpace Ω] [mZ : MeasurableSpace Z] [MeasurableSpace X] [MeasurableSpace Y]
  [MeasurableSpace A] [MeasurableSpace B] [MeasurableSpace C]
  {μ : Measure Ω} {ν : Measure X} {ρ : Measure Y} {η : Measure Z}
  {α : Measure A} {β : Measure B} {τ : Measure C}
  {x : Ω → X} {y : Ω → Y} {z : Ω → Z} {a : X → A} {b : Y → B} {c : Z → C}

lemma mem_field_of_eq_comp (hc : Measurable c) (f : Lp ℂ 2 η)
    (F : C → ℂ) (hF : Measurable F) (he : f =ᵐ[η] (fun v => F (c v))) :
    f ∈ lpMeas ℂ ℂ (MeasurableSpace.comap c inferInstance) 2 η := by
  let : Fact (MeasurableSpace.comap c inferInstance ≤ mZ) := ⟨hc.comap_le⟩
  apply mem_lpMeas_iff_aestronglyMeasurable.mpr
  have hm : @StronglyMeasurable Z ℂ _ (MeasurableSpace.comap c inferInstance)
      (fun v => F (c v)) :=
    (hF.comp (Measurable.of_comap_le le_rfl)).stronglyMeasurable
  exact hm.aestronglyMeasurable.congr he.symm

lemma common_space_le_screen
    [IsProbabilityMeasure μ] [IsFiniteMeasure ν] [IsFiniteMeasure ρ]
    [StandardBorelSpace A] [Nonempty A] [StandardBorelSpace B] [Nonempty B]
    (hz : MeasurePreserving z μ η)
    (hxy : MeasurePreserving (fun ω => (x ω,y ω)) μ (ν.prod ρ))
    (ha : MeasurePreserving a ν α) (hb : MeasurePreserving b ρ β)
    (hc : MeasurePreserving c η τ)
    {κ : Kernel C (A × B)} [IsMarkovKernel κ]
    (hκ : HasCondDistrib (fun ω => (a (x ω),b (y ω))) z (κ.comap c hc.measurable) μ)
    (D : Submodule ℂ (Lp ℂ 2 η)) [D.HasOrthogonalProjection]
    (P : Lp ℂ 2 ν →L[ℂ] Lp ℂ 2 ν) (Q : Lp ℂ 2 ρ →L[ℂ] Lp ℂ 2 ρ)
    (hD : D ≤ (LinearMap.range (operator hz hxy).toLinearMap).topologicalClosure)
    (hPQ : ∀ g h, D.starProjection (contraction hz hxy g h) =
      contraction hz hxy (P g) (Q h))
    (hP : ∀ g, P g ∈ lpMeas ℂ ℂ (MeasurableSpace.comap a inferInstance) 2 ν)
    (hQ : ∀ h, Q h ∈ lpMeas ℂ ℂ (MeasurableSpace.comap b inferInstance) 2 ρ) :
    D ≤ lpMeas ℂ ℂ (MeasurableSpace.comap c inferInstance) 2 η := by
  rw [←restricted_contractions_span (operator hz hxy) D P Q hD hPQ]
  apply Submodule.topologicalClosure_minimal
  · apply Submodule.span_le.mpr
    rintro _ ⟨⟨g,h⟩,rfl⟩
    exact contraction_mem_screen hz hxy ha hb hc hκ (P g) (Q h) (hP g) (hQ h)
  · exact isClosed_aestronglyMeasurable hc.measurable.comap_le

lemma common_space_le_ratio
    {G : Type*} [gG : Group G] [mG : MeasurableSpace G] [hG : MeasurableMul₂ G]
    [StandardBorelSpace G] [Nonempty G]
    [IsProbabilityMeasure μ] [IsFiniteMeasure ν] [IsFiniteMeasure ρ]
    {a : X → G} {b : Y → G} {c : Z → G}
    (hz : MeasurePreserving z μ η)
    (hxy : MeasurePreserving (fun ω => (x ω,y ω)) μ (ν.prod ρ))
    (ha : Measurable a) (hb : Measurable b) (hc : Measurable c)
    {κ : Kernel Z (G × G)} [IsMarkovKernel κ]
    (hκ : HasCondDistrib (fun ω => (a (x ω),b (y ω))) z κ μ)
    (σ : Measure G) [IsProbabilityMeasure σ]
    (hm : ∀ᵐ t ∂η, (κ t).map Prod.snd = σ)
    (hr : ∀ᵐ t ∂η, ∀ᵐ p ∂κ t, p.1*p.2⁻¹ = c t)
    (D : Submodule ℂ (Lp ℂ 2 η)) [D.HasOrthogonalProjection]
    (P : Lp ℂ 2 ν →L[ℂ] Lp ℂ 2 ν) (Q : Lp ℂ 2 ρ →L[ℂ] Lp ℂ 2 ρ)
    (hD : D ≤ (LinearMap.range (operator hz hxy).toLinearMap).topologicalClosure)
    (hPQ : ∀ g h, D.starProjection (contraction hz hxy g h) =
      contraction hz hxy (P g) (Q h))
    (hP : ∀ g, P g ∈ lpMeas ℂ ℂ (MeasurableSpace.comap a inferInstance) 2 ν)
    (hQ : ∀ h, Q h ∈ lpMeas ℂ ℂ (MeasurableSpace.comap b inferInstance) 2 ρ) :
    D ≤ lpMeas ℂ ℂ (MeasurableSpace.comap c inferInstance) 2 η := by
  have hscreen := hasCondDistrib_ratio hκ σ c hc (by simpa only [hz.map_eq] using hm)
    (by simpa only [hz.map_eq] using hr)
  exact common_space_le_screen hz hxy ⟨ha,rfl⟩ ⟨hb,rfl⟩ ⟨hc,rfl⟩
    hscreen D P Q hD hPQ hP hQ

end FactorFields


variable {Ω U X Y C : Type*} [MeasurableSpace Ω] [MeasurableSpace U]
  [MeasurableSpace X] [MeasurableSpace Y] [MeasurableSpace C]
  [StandardBorelSpace X] [StandardBorelSpace Y] [Nonempty X] [Nonempty Y]
  {μ : Measure Ω} [IsProbabilityMeasure μ]
  {η : Measure U} {ν : Measure X} {ρ : Measure Y}
  {u : Ω → U} {x : Ω → X} {y : Ω → Y}
  {κ : Kernel U (X × Y)} [IsMarkovKernel κ]
local instance : MeasurableSpace (Lp ℂ 2 ν) := borel _
local instance : BorelSpace (Lp ℂ 2 ν) := ⟨rfl⟩

lemma contraction_mem_operatorField [SFinite ρ]
    (hu : MeasurePreserving u μ η)
    (hxy : MeasurePreserving (fun ω => (x ω,y ω)) μ (ν.prod ρ))
    (hκ : HasCondDistrib (fun ω => (x ω,y ω)) u κ μ)
    (hm : ∀ᵐ a ∂η, MeasurePreserving Prod.fst (κ a) ν ∧ MeasurePreserving Prod.snd (κ a) ρ)
    (V : Submodule ℂ (Lp ℂ 2 ρ)) (W : Submodule ℂ (Lp ℂ 2 ν))
    [V.HasOrthogonalProjection] [W.HasOrthogonalProjection]
    (hA : ∀ᵐ a ∂η, W.starProjection ∘L family κ ν ρ a = family κ ν ρ a ∘L V.starProjection)
    (c : U → C) (hc : Measurable c)
    (F : C → V → W) (hF : ∀ v, Measurable (fun q => (F q v : Lp ℂ 2 ν)))
    (hf : ∀ᵐ a ∂η, ∀ v, compress (family κ ν ρ a) V W v = F (c a) v)
    (g : Lp ℂ 2 ν) (h : V) :
    contraction hu hxy g h ∈ lpMeas ℂ ℂ (MeasurableSpace.comap c inferInstance) 2 η := by
  apply mem_field_of_eq_comp hc _ (fun q => inner ℂ (star g) (F q h : Lp ℂ 2 ν))
    ((continuous_const.inner (𝕜 := ℂ) continuous_id).measurable.comp (hF h))
  apply (contraction_coefficient hu hxy hκ hm g h).trans
  filter_upwards [hA,hf] with a ha hf
  rw [←compress_apply _ V W ha h, hf]

lemma common_space_le_operatorField
    [IsFiniteMeasure ν] [IsFiniteMeasure ρ]
    (hu : MeasurePreserving u μ η)
    (hxy : MeasurePreserving (fun ω => (x ω,y ω)) μ (ν.prod ρ))
    (hκ : HasCondDistrib (fun ω => (x ω,y ω)) u κ μ)
    (hm : ∀ᵐ a ∂η, MeasurePreserving Prod.fst (κ a) ν ∧ MeasurePreserving Prod.snd (κ a) ρ)
    (V : Submodule ℂ (Lp ℂ 2 ρ)) (W : Submodule ℂ (Lp ℂ 2 ν))
    [V.HasOrthogonalProjection] [W.HasOrthogonalProjection]
    (hA : ∀ᵐ a ∂η, W.starProjection ∘L family κ ν ρ a = family κ ν ρ a ∘L V.starProjection)
    (c : U → C) (hc : Measurable c)
    (F : C → V → W) (hF : ∀ v, Measurable (fun q => (F q v : Lp ℂ 2 ν)))
    (hf : ∀ᵐ a ∂η, ∀ v, compress (family κ ν ρ a) V W v = F (c a) v)
    (D : Submodule ℂ (Lp ℂ 2 η)) [D.HasOrthogonalProjection]
    (P : Lp ℂ 2 ν →L[ℂ] Lp ℂ 2 ν) (Q : Lp ℂ 2 ρ →L[ℂ] Lp ℂ 2 ρ)
    (hD : D ≤ (LinearMap.range (operator hu hxy).toLinearMap).topologicalClosure)
    (hPQ : ∀ g h, D.starProjection (contraction hu hxy g h) = contraction hu hxy (P g) (Q h))
    (hQ : ∀ h, Q h ∈ V) :
    D ≤ lpMeas ℂ ℂ (MeasurableSpace.comap c inferInstance) 2 η := by
  rw [←restricted_contractions_span (operator hu hxy) D P Q hD hPQ]
  apply Submodule.topologicalClosure_minimal
  · apply Submodule.span_le.mpr
    rintro _ ⟨⟨g,h⟩,rfl⟩
    exact contraction_mem_operatorField hu hxy hκ hm V W hA c hc F hF hf (P g) ⟨Q h,hQ h⟩
  · exact isClosed_aestronglyMeasurable hc.comap_le
end JoiningOperator

section
open MeasureTheory ContinuousLinearMap
variable {X E H : Type*} [MeasurableSpace X]
  [NormedAddCommGroup E] [InnerProductSpace ℂ E] [CompleteSpace E] [SecondCountableTopology E]
  [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] [SecondCountableTopology H]
  {μ : Measure X} [IsProbabilityMeasure μ] {F : X → E →L[ℂ] H}

omit [SecondCountableTopology H] in

lemma MeasurablePolar.fixed_factor (R : MeasurablePolar μ F)
    (hs : HasFixedInjectiveSquares μ F) :
    ∃ B : E →L[ℂ] E, ∀ᵐ x ∂μ, ∀ v, F x v = R.unitary x (B v) := by
  obtain ⟨P,Q,_,_,hP,_⟩ := hs
  obtain ⟨x₀,hx₀⟩ := hP.exists
  refine ⟨operatorAbs (F x₀),?_⟩
  filter_upwards [hP,R.formula] with x hx hf
  intro v
  have he : operatorAbs (F x) = operatorAbs (F x₀) := by
    unfold operatorAbs
    rw [hx,hx₀]
  rw [←hf.2.2]
  change R.unitary x (operatorAbs (F x) v) = _
  rw [he]
end

section
open MeasureTheory ProbabilityTheory ContinuousLinearMap
open scoped ENNReal
namespace JoiningOperator
local instance : Fact ((2 : ℝ≥0∞) ≠ ∞) := ⟨by norm_num⟩
variable {Ω U X Y : Type*} [MeasurableSpace Ω] [MeasurableSpace U]
  [MeasurableSpace X] [MeasurableSpace Y]
  [StandardBorelSpace X] [StandardBorelSpace Y] [Nonempty X] [Nonempty Y]
  {μ : Measure Ω} [IsProbabilityMeasure μ]
  {η : Measure U} [IsProbabilityMeasure η]
  {ν : Measure X} {ρ : Measure Y} [IsFiniteMeasure ν] [IsFiniteMeasure ρ]
  {u : Ω → U} {x : Ω → X} {y : Ω → Y}
  {κ : Kernel U (X × Y)} [IsMarkovKernel κ]

local instance : MeasurableSpace (Lp ℂ 2 ν) := borel _
local instance : BorelSpace (Lp ℂ 2 ν) := ⟨rfl⟩

lemma common_space_le_polarField
    (hu : MeasurePreserving u μ η)
    (hxy : MeasurePreserving (fun ω => (x ω,y ω)) μ (ν.prod ρ))
    (hκ : HasCondDistrib (fun ω => (x ω,y ω)) u κ μ)
    (hm : ∀ᵐ a ∂η, MeasurePreserving Prod.fst (κ a) ν ∧ MeasurePreserving Prod.snd (κ a) ρ)
    (V : Submodule ℂ (Lp ℂ 2 ρ)) (W : Submodule ℂ (Lp ℂ 2 ν))
    [V.HasOrthogonalProjection] [W.HasOrthogonalProjection] [CompleteSpace V] [CompleteSpace W]
    (hA : ∀ᵐ a ∂η, W.starProjection ∘L family κ ν ρ a = family κ ν ρ a ∘L V.starProjection)
    (R : MeasurablePolar η (fun a => compress (family κ ν ρ a) V W))
    (hs : HasFixedInjectiveSquares η (fun a => compress (family κ ν ρ a) V W))
    (D : Submodule ℂ (Lp ℂ 2 η)) [D.HasOrthogonalProjection]
    (P : Lp ℂ 2 ν →L[ℂ] Lp ℂ 2 ν) (Q : Lp ℂ 2 ρ →L[ℂ] Lp ℂ 2 ρ)
    (hD : D ≤ (LinearMap.range (operator hu hxy).toLinearMap).topologicalClosure)
    (hPQ : ∀ g h, D.starProjection (contraction hu hxy g h) = contraction hu hxy (P g) (Q h))
    (hQ : ∀ h, Q h ∈ V) :
    D ≤ lpMeas ℂ ℂ (MeasurableSpace.comap R.unitary inferInstance) 2 η := by
  obtain ⟨B,hB⟩ := R.fixed_factor hs
  apply common_space_le_operatorField hu hxy hκ hm V W hA R.unitary R.measurable
    (fun q v => q (B v)) _ hB D P Q hD hPQ hQ
  intro v
  exact (continuous_subtype_val.comp (StrongUnitary.continuous_apply (B v))).measurable
end JoiningOperator

namespace ArrayObjects.Object.Rolled
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_polar_a_field (hM : M.IsSaturated)
    (rows cols : TriplePartition I) (n : ℕ) :
    ∀ᵐ e ∂(M.law (n+2)).map (amap M.par (n+2)),
      ∀ R : GroupedPolarData M rows cols n e,
        commonActive M rows.A rows.P rows.B cols.P cols.A cols.B n e ≤
          lpMeas ℂ ℂ (MeasurableSpace.comap R.a.unitary inferInstance) 2
            (cellLaw M rows.A cols.P n e) := by
  filter_upwards [grouped_rectangle_spaces M hM rows cols n,
    grouped_restricted_fixed_squares M hM rows cols n,
    grouped_active_intersections M hM rows cols n,
    grouped_row_contraction_projection M hM rows.swapPA cols n,
    rowActive_eq_range M hM rows.A rows.properA cols n,
    cells_fibre_marginal M hM rows.A cols.P rows.properA n,
    cells_fibre_marginal M hM rows.A cols.A rows.properA n,
    cells_fibre_marginal M hM rows.A cols.B rows.properA n,
    cells_indep_columns_fibre M rows.A rows.A cols.A cols.B cols.disjointAB cols.properAB 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]
      with e hspaces hs hA hproj hrange hx hc hd hcd hκ hm
  intro R
  rw [hx.map_eq] at hm
  let hpair : MeasurePreserving (fun y => (cells M rows.A cols.A n y,cells M rows.A cols.B n y))
      (M.ownKernel (n+2) e) ((cellLaw M rows.A cols.A n e).prod (cellLaw M rows.A 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 V := rectangleSpace₂ (cellLaw M rows.A cols.P n e) (cellLaw M rows.P cols.B n e)
    (fibreRowEdge M rows.A cols.P cols.A cols.B n e) (fibreColumnEdge M rows.P rows.A rows.B cols.B n e)
  let W := rectangleSpace₁ (cellLaw M rows.A cols.P n e) (cellLaw M rows.P cols.A n e)
    (fibreRowEdge M rows.A cols.P cols.A cols.B n e) (fibreColumnEdge M rows.P rows.A rows.B cols.A n e)
  have hv : V = commonActive M rows.A rows.P rows.B cols.B cols.P cols.A n e := hspaces.2.1
  have hw : W = commonActive M rows.A rows.P rows.B cols.A cols.P cols.B n e := hspaces.1
  have ha : ∀ᵐ a ∂cellLaw M rows.A cols.P n e,
      W.starProjection ∘L JoiningOperator.family ((rowPairKernel M rows.A cols.P cols.A cols.B n).sectR e)
        (cellLaw M rows.A cols.A n e) (cellLaw M rows.A cols.B n e) a =
      JoiningOperator.family ((rowPairKernel M rows.A cols.P cols.A cols.B n).sectR e)
        (cellLaw M rows.A cols.A n e) (cellLaw M rows.A cols.B n e) a ∘L V.starProjection := by
    simpa only [hv,hw,fibreRowEdge_eq] using hA.1
  apply JoiningOperator.common_space_le_polarField hx hpair hκ hm V W ha R.a hs.1 _
    (commonActive M rows.A rows.P rows.B cols.A cols.P cols.B n e).starProjection
    (commonActive M rows.A rows.P rows.B cols.B cols.P cols.A n e).starProjection
  · rw [←hrange hx hpair]
    exact inf_le_left
  · exact hproj hx hpair
  · intro h
    rw [hv]
    exact Submodule.starProjection_apply_mem _ h

theorem grouped_polar_b_field (hM : M.IsSaturated)
    (rows cols : TriplePartition I) (n : ℕ) :
    ∀ᵐ e ∂(M.law (n+2)).map (amap M.par (n+2)),
      ∀ R : GroupedPolarData M rows cols n e,
        commonActive M rows.B rows.P rows.A cols.P cols.A cols.B n e ≤
          lpMeas ℂ ℂ (MeasurableSpace.comap R.b.unitary inferInstance) 2
            (cellLaw M rows.B cols.P n e) := by
  filter_upwards [grouped_rectangle_spaces M hM rows cols n,
    grouped_restricted_fixed_squares M hM rows cols n,
    grouped_active_intersections M hM rows cols n,
    grouped_row_contraction_projection M hM rows.swapAB.swapPA cols n,
    rowActive_eq_range M hM rows.B rows.properB cols n,
    cells_fibre_marginal M hM rows.B cols.P rows.properB n,
    cells_fibre_marginal M hM rows.B cols.A rows.properB n,
    cells_fibre_marginal M hM rows.B cols.B rows.properB n,
    cells_indep_columns_fibre M rows.B rows.B cols.A cols.B cols.disjointAB cols.properAB n,
    rowPair_fixed_conditional M rows.B cols.P cols.A cols.B n,
    rowPair_fixed_marginals M hM rows.B cols.P cols.A cols.B rows.properB
      cols.disjointPA cols.disjointPB cols.properPA cols.properPB n]
      with e hspaces hs hA hproj hrange hx hc hd hcd hκ hm
  intro R
  rw [hx.map_eq] at hm
  let hpair : MeasurePreserving (fun y => (cells M rows.B cols.A n y,cells M rows.B cols.B n y))
      (M.ownKernel (n+2) e) ((cellLaw M rows.B cols.A n e).prod (cellLaw M rows.B 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 V := rectangleSpace₄ (cellLaw M rows.B cols.P n e) (cellLaw M rows.P cols.B n e)
    (fibreRowEdge M rows.B cols.P cols.A cols.B n e) (fibreColumnEdge M rows.P rows.A rows.B cols.B n e)
  let W := rectangleSpace₃ (cellLaw M rows.B cols.P n e) (cellLaw M rows.P cols.A n e)
    (fibreRowEdge M rows.B cols.P cols.A cols.B n e) (fibreColumnEdge M rows.P rows.A rows.B cols.A n e)
  have hv : V = commonActive M rows.B rows.P rows.A cols.B cols.P cols.A n e := hspaces.2.2.2
  have hw : W = commonActive M rows.B rows.P rows.A cols.A cols.P cols.B n e := hspaces.2.2.1
  have ha : ∀ᵐ a ∂cellLaw M rows.B cols.P n e,
      W.starProjection ∘L JoiningOperator.family ((rowPairKernel M rows.B cols.P cols.A cols.B n).sectR e)
        (cellLaw M rows.B cols.A n e) (cellLaw M rows.B cols.B n e) a =
      JoiningOperator.family ((rowPairKernel M rows.B cols.P cols.A cols.B n).sectR e)
        (cellLaw M rows.B cols.A n e) (cellLaw M rows.B cols.B n e) a ∘L V.starProjection := by
    simpa only [hv,hw,fibreRowEdge_eq] using hA.2.1
  apply JoiningOperator.common_space_le_polarField hx hpair hκ hm V W ha R.b hs.2.1 _
    (commonActive M rows.B rows.P rows.A cols.A cols.P cols.B n e).starProjection
    (commonActive M rows.B rows.P rows.A cols.B cols.P cols.A n e).starProjection
  · rw [←hrange hx hpair]
    exact inf_le_left
  · exact hproj hx hpair
  · intro h
    rw [hv]
    exact Submodule.starProjection_apply_mem _ h
end ArrayObjects.Object.Rolled
end

section
open MeasureTheory
open scoped ENNReal
variable {Ω A B : Type*} [MeasurableSpace Ω] [MeasurableSpace A] [MeasurableSpace B]
  {μ : Measure Ω} {a a' : Ω → A} {b : Ω → B}

lemma lpMeas_comap_congr (he : a =ᵐ[μ] a') :
    lpMeas ℂ ℂ (MeasurableSpace.comap a inferInstance) 2 μ =
      lpMeas ℂ ℂ (MeasurableSpace.comap a' inferInstance) 2 μ := by
  suffices h : ∀ (a a' : Ω → A), a =ᵐ[μ] a' →
      lpMeas ℂ ℂ (MeasurableSpace.comap a inferInstance) 2 μ ≤
        lpMeas ℂ ℂ (MeasurableSpace.comap a' inferInstance) 2 μ from
    le_antisymm (h a a' he) (h a' a he.symm)
  intro a a' hae f hf
  have hm := mem_lpMeas_iff_aestronglyMeasurable.mp hf
  obtain ⟨g,hg,hgcomp⟩ := hm.stronglyMeasurable_mk.exists_eq_measurable_comp
  apply mem_lpMeas_iff_aestronglyMeasurable.mpr
  have hstrong : StronglyMeasurable[MeasurableSpace.comap a' inferInstance] (g ∘ a') :=
    hg.comp_measurable (Measurable.of_comap_le le_rfl)
  apply hstrong.aestronglyMeasurable.congr
  filter_upwards [hm.ae_eq_mk,hae] with ω hfω haω
  exact (congrArg g haω).symm.trans ((congrFun hgcomp ω).symm.trans hfω.symm)

lemma lpMeas_comap_mono (hab : MeasurableSpace.comap a inferInstance ≤
    MeasurableSpace.comap b inferInstance) :
    lpMeas ℂ ℂ (MeasurableSpace.comap a inferInstance) 2 μ ≤
      lpMeas ℂ ℂ (MeasurableSpace.comap b inferInstance) 2 μ := by
  intro f hf
  apply mem_lpMeas_iff_aestronglyMeasurable.mpr
  exact (mem_lpMeas_iff_aestronglyMeasurable.mp hf).mono hab

end

section
open MeasureTheory
lemma comap_eq_of_measurable_leftInverse {X Y Z : Type*} [MeasurableSpace X]
    [MeasurableSpace Y] [MeasurableSpace Z] (a : X → Y)
    (f : Y → Z) (g : Z → Y) (hf : Measurable f) (hg : Measurable g)
    (hgf : Function.LeftInverse g f) :
    MeasurableSpace.comap (f ∘ a) inferInstance = MeasurableSpace.comap a inferInstance := by
  apply le_antisymm
  · rw [←MeasurableSpace.comap_comp]
    exact MeasurableSpace.comap_mono hf.comap_le
  · have he : a = g ∘ (f ∘ a) := funext fun x => (hgf (a x)).symm
    conv_lhs => rw [he,←MeasurableSpace.comap_comp]
    exact MeasurableSpace.comap_mono hg.comap_le
namespace StrongUnitary
variable {X H₁ H₂ H₃ H₄ : Type*} [MeasurableSpace X]
  [NormedAddCommGroup H₁] [NormedSpace ℂ H₁] [SecondCountableTopology H₁]
  [NormedAddCommGroup H₂] [NormedSpace ℂ H₂] [SecondCountableTopology H₂]
  [NormedAddCommGroup H₃] [NormedSpace ℂ H₃] [SecondCountableTopology H₃]
  [NormedAddCommGroup H₄] [NormedSpace ℂ H₄] [SecondCountableTopology H₄]

omit [SecondCountableTopology H₁] in
lemma comap_normalizeA (a₀ : H₂ ≃ₗᵢ[ℂ] H₁) (d₀ : H₄ ≃ₗᵢ[ℂ] H₂)
    (a : X → H₂ ≃ₗᵢ[ℂ] H₁) :
    MeasurableSpace.comap (normalizeA a₀ d₀ ∘ a) inferInstance =
      MeasurableSpace.comap a inferInstance := by
  let g (u : H₄ ≃ₗᵢ[ℂ] H₄) := d₀.symm.trans (u.trans (d₀.trans a₀))
  have hg : Continuous g := by
    apply continuous_iff.mpr
    intro v
    exact (d₀.trans a₀).continuous.comp (continuous_apply (d₀.symm v))
  apply comap_eq_of_measurable_leftInverse a _ g (continuous_normalizeA a₀ d₀).measurable hg.measurable
  intro u
  ext v
  simp [g,normalizeA]

omit [SecondCountableTopology H₃] in
lemma comap_normalizeB (b₀ : H₄ ≃ₗᵢ[ℂ] H₃) (b : X → H₄ ≃ₗᵢ[ℂ] H₃) :
    MeasurableSpace.comap (normalizeB b₀ ∘ b) inferInstance =
      MeasurableSpace.comap b inferInstance := by
  let g (u : H₄ ≃ₗᵢ[ℂ] H₄) := u.trans b₀
  have hg : Continuous g := by
    apply continuous_iff.mpr
    intro v
    exact b₀.continuous.comp (continuous_apply v)
  apply comap_eq_of_measurable_leftInverse b _ g (continuous_normalizeB b₀).measurable hg.measurable
  intro u
  ext v
  simp [g,normalizeB]

end StrongUnitary
end

namespace StrongUnitary

open MeasureTheory

section MeasurableEigenvalues
variable {H I X : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H]
  [CompleteSpace H] [SecondCountableTopology H] [MeasurableSpace X]

lemma measurable_of_eigenvalues (b : HilbertBasis I ℂ H) (U : X → H ≃ₗᵢ[ℂ] H)
    (χ : I → X → ℂ) (hχ : ∀ i, Measurable (χ i))
    (he : ∀ i x, U x (b i) = χ i x • b i) : Measurable U := by
  borelize H
  let : Countable I := hilbertBasis_countable b
  apply measurable_iff.mpr
  intro v
  have hes (x : X) : (∑' i, (b.repr v i * χ i x) • b i) = U x v := by
    have hs := (U x : H →L[ℂ] H).hasSum (b.hasSum_repr v)
    change HasSum (fun i => U x (b.repr v i • b i)) (U x v) at hs
    simpa only [map_smul, he, smul_smul] using hs.tsum_eq
  have hm : Measurable (fun x => ∑' i, (b.repr v i * χ i x) • b i) :=
    Measurable.tsum (fun i => (measurable_const.mul (hχ i)).smul measurable_const)
  simpa only [hes] using hm.stronglyMeasurable

end MeasurableEigenvalues


section
variable {H I X : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H]
  [CompleteSpace H] [SecondCountableTopology H]
local instance : MeasurableSpace Circle := inferInstanceAs (MeasurableSpace (Submonoid.unitSphere ℂ))
local instance : BorelSpace Circle := inferInstanceAs (BorelSpace (Submonoid.unitSphere ℂ))

lemma measurable_iff_eigenCoords [MeasurableSpace X]
    (b : HilbertBasis I ℂ H) (U : X → H ≃ₗᵢ[ℂ] H) (γ : X → I → Circle)
    (he : ∀ i x, U x (b i) = (γ x i : ℂ) • b i) :
    Measurable U ↔ Measurable γ := by
  borelize H
  constructor
  · intro hU
    apply Measurable.of_eval
    intro i
    apply Measurable.subtype_mk
    have hm : Measurable (fun x => inner ℂ (b i) (U x (b i))) :=
      (measurable_const (a := b i)).inner (𝕜 := ℂ) ((continuous_apply (b i)).measurable.comp hU)
    have heq (x : X) : (γ x i : ℂ) = inner ℂ (b i) (U x (b i)) := by
      rw [he, inner_smul_right]
      simp [inner_self_eq_norm_sq_to_K, b.orthonormal.1 i]
    convert hm using 1
    ext x
    exact heq x
  · intro hγ
    apply measurable_of_eigenvalues b U (fun i x => (γ x i : ℂ)) _ he
    intro i
    exact measurable_subtype_coe.comp ((measurable_pi_apply i).comp hγ)

lemma comap_eigenCoords (b : HilbertBasis I ℂ H)
    (U : X → H ≃ₗᵢ[ℂ] H) (γ : X → I → Circle)
    (he : ∀ i x, U x (b i) = (γ x i : ℂ) • b i) :
    MeasurableSpace.comap U inferInstance = MeasurableSpace.comap γ inferInstance := by
  apply le_antisymm
  · let : MeasurableSpace X := MeasurableSpace.comap γ inferInstance
    have hm : Measurable γ := Measurable.of_comap_le le_rfl
    exact ((measurable_iff_eigenCoords b U γ he).mpr hm).comap_le
  · let : MeasurableSpace X := MeasurableSpace.comap U inferInstance
    have hm : Measurable U := Measurable.of_comap_le le_rfl
    exact ((measurable_iff_eigenCoords b U γ he).mp hm).comap_le
end

variable {H J X : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H]
  [CompleteSpace H] [SecondCountableTopology H]
local instance : MeasurableSpace Circle := inferInstanceAs (MeasurableSpace (Submonoid.unitSphere ℂ))
local instance : BorelSpace Circle := inferInstanceAs (BorelSpace (Submonoid.unitSphere ℂ))

def subgroupVersion (S : Subgroup (H ≃ₗᵢ[ℂ] H)) (g : H ≃ₗᵢ[ℂ] H) : S := by
  classical
  exact if h : g ∈ S then ⟨g,h⟩ else 1

omit [CompleteSpace H] in
lemma measurable_subgroupVersion (S : Subgroup (H ≃ₗᵢ[ℂ] H))
    (hS : IsClosed (S : Set (H ≃ₗᵢ[ℂ] H))) : Measurable (subgroupVersion S) := by
  classical
  exact Measurable.dite measurable_id measurable_const hS.measurableSet

omit [CompleteSpace H] [SecondCountableTopology H] in
lemma subgroupVersion_coe (S : Subgroup (H ≃ₗᵢ[ℂ] H)) {g : H ≃ₗᵢ[ℂ] H} (hg : g ∈ S) :
    (subgroupVersion S g : H ≃ₗᵢ[ℂ] H) = g := by simp [subgroupVersion,hg]

def spectralCoords (S : Subgroup (H ≃ₗᵢ[ℂ] H)) (γ : J → S →* Circle)
    (g : H ≃ₗᵢ[ℂ] H) : J → Circle := fun j => γ j (subgroupVersion S g)

omit [CompleteSpace H] in
lemma measurable_spectralCoords (S : Subgroup (H ≃ₗᵢ[ℂ] H))
    (hS : IsClosed (S : Set (H ≃ₗᵢ[ℂ] H))) (γ : J → S →* Circle)
    (hγ : ∀ j, Continuous (γ j)) : Measurable (spectralCoords S γ) :=
  Measurable.of_eval fun j => (hγ j).measurable.comp (measurable_subgroupVersion S hS)

omit [CompleteSpace H] [SecondCountableTopology H] in
lemma spectralCoords_mul_inv (S : Subgroup (H ≃ₗᵢ[ℂ] H)) (γ : J → S →* Circle)
    {g h : H ≃ₗᵢ[ℂ] H} (hg : g ∈ S) (hh : h ∈ S) :
    spectralCoords S γ (g*h⁻¹) = spectralCoords S γ g * (spectralCoords S γ h)⁻¹ := by
  have hs : subgroupVersion S (g*h⁻¹) = subgroupVersion S g * (subgroupVersion S h)⁻¹ := by
    apply Subtype.ext
    simp only [Subgroup.coe_mul,Subgroup.coe_inv,subgroupVersion_coe S hg,
      subgroupVersion_coe S hh,subgroupVersion_coe S (S.mul_mem hg (S.inv_mem hh))]
  funext j
  simp only [spectralCoords,hs,map_mul,map_inv,Pi.mul_apply,Pi.inv_apply]

lemma lpMeas_spectralCoords [MeasurableSpace X] (μ : Measure X)
    (S : Subgroup (H ≃ₗᵢ[ℂ] H)) (b : HilbertBasis J ℂ H) (γ : J → S →* Circle)
    (heig : ∀ j (g : S), (g : H ≃ₗᵢ[ℂ] H) (b j) = (γ j g : ℂ) • b j)
    (U : X → H ≃ₗᵢ[ℂ] H) (hU : ∀ᵐ x ∂μ, U x ∈ S) :
    lpMeas ℂ ℂ (MeasurableSpace.comap U inferInstance) 2 μ =
      lpMeas ℂ ℂ (MeasurableSpace.comap (spectralCoords S γ ∘ U) inferInstance) 2 μ := by
  let V (x : X) : H ≃ₗᵢ[ℂ] H := subgroupVersion S (U x)
  have huv : U =ᵐ[μ] V := hU.mono fun x hx => (subgroupVersion_coe S hx).symm
  rw [lpMeas_comap_congr huv]
  rw [comap_eigenCoords b V (spectralCoords S γ ∘ U) (fun j x => heig j (subgroupVersion S (U x)))]
  rfl


end StrongUnitary

section
open MeasureTheory ProbabilityTheory

lemma exists_const_of_ae_prod_eq {X Y V : Type*} [MeasurableSpace X] [MeasurableSpace Y]
    {μ : Measure X} {ν : Measure Y} [IsProbabilityMeasure μ] [IsProbabilityMeasure ν]
    {f : X → V} {g : Y → V}
    (h : ∀ᵐ p ∂μ.prod ν, f p.1 = g p.2) :
    ∃ v, f =ᵐ[μ] (fun _ => v) ∧ g =ᵐ[ν] (fun _ => v) := by
  have hh : ∀ᵐ x ∂μ, ∀ᵐ y ∂ν, f x = g y := Measure.ae_ae_of_ae_prod h
  obtain ⟨x₀,hx₀⟩ := hh.exists
  refine ⟨f x₀, ?_, hx₀.mono (fun _ hy => hy.symm)⟩
  filter_upwards [hh] with x hx
  obtain ⟨y,hy,h0y⟩ := (hx.and hx₀).exists
  exact hy.trans h0y.symm

lemma measurable_conull_subset {Z : Type*} [MeasurableSpace Z] {σ : Measure Z}
    {p : Z → Prop} (h : ∀ᵐ z ∂σ, p z) :
    ∃ s : Set Z, MeasurableSet s ∧ (∀ᵐ z ∂σ, z ∈ s) ∧ ∀ z ∈ s, p z := by
  obtain ⟨t,ht,htm,ht0⟩ := exists_measurable_superset_of_null (ae_iff.mp h)
  refine ⟨tᶜ, htm.compl, ?_, ?_⟩
  · apply mem_ae_iff.mpr
    change σ (tᶜ)ᶜ = 0
    simpa only [compl_compl] using ht0
  · intro z hz
    by_contra hp
    exact hz (ht hp)

lemma exists_measurable_common_unitary {Z X Y H : Type*}
    [MeasurableSpace Z] [MeasurableSpace X] [MeasurableSpace Y]
    [NormedAddCommGroup H] [NormedSpace ℂ H] [SecondCountableTopology H] [CompleteSpace H]
    {σ : Measure Z} (κ : Kernel Z X) (ξ : Kernel Z Y)
    [IsMarkovKernel κ] [IsMarkovKernel ξ]
    (f : X → H ≃ₗᵢ[ℂ] H) (g : Y → H ≃ₗᵢ[ℂ] H)
    (hf : Measurable f)
    (heq : ∀ᵐ z ∂σ, ∀ᵐ p ∂(κ z).prod (ξ z), f p.1 = g p.2) :
    ∃ U : Z → H ≃ₗᵢ[ℂ] H, Measurable U ∧
      ∀ᵐ z ∂σ, f =ᵐ[κ z] (fun _ => U z) ∧ g =ᵐ[ξ z] (fun _ => U z) := by
  classical
  have he : ∀ᵐ z ∂σ, ∃ U, f =ᵐ[κ z] (fun _ => U) ∧ g =ᵐ[ξ z] (fun _ => U) :=
    heq.mono fun _ hz => exists_const_of_ae_prod_eq hz
  obtain ⟨s,hsm,hs,hsprop⟩ := measurable_conull_subset he
  choose U₀ hU₀ using fun z : s => hsprop z z.property
  let U : Z → H ≃ₗᵢ[ℂ] H := fun z => if hz : z ∈ s then U₀ ⟨z,hz⟩ else 1
  refine ⟨U, ?_, ?_⟩
  · apply StrongUnitary.measurable_iff.mpr
    intro v
    have hev : (fun z => U z v) = s.piecewise (fun z => ∫ x, f x v ∂κ z) (fun _ => v) := by
      funext z
      by_cases hz : z ∈ s
      · simp only [U, dite_eq_left hz, Set.piecewise_eq_of_mem s _ _ hz]
        calc
          U₀ ⟨z,hz⟩ v = ∫ _x, U₀ ⟨z,hz⟩ v ∂κ z := by simp
          _ = ∫ x, f x v ∂κ z := integral_congr_ae ((hU₀ ⟨z,hz⟩).1.fun_comp (fun A => A v)).symm
      · simp [U, hz]
    rw [hev]
    exact ((StrongUnitary.measurable_iff.mp hf v).integral_kernel).piecewise hsm stronglyMeasurable_const
  · filter_upwards [hs] with z hz
    simpa only [U,dite_eq_left hz] using hU₀ ⟨z,hz⟩

namespace StrongUnitary

lemma rectangle_ratio_eq {G : Type*} [Group G] {a b c d : G}
    (hbd : Commute b d) (h : a * d = c * b) : a * b⁻¹ = c * d⁻¹ := by
  apply mul_inv_eq_iff_eq_mul.mpr
  calc
    a = c * b * d⁻¹ := by rw [←h, mul_assoc, mul_inv_cancel, mul_one]
    _ = (c * d⁻¹) * b := by rw [mul_assoc, hbd.inv_right.eq, ←mul_assoc]

variable {Z H : Type*} [MeasurableSpace Z]
  [NormedAddCommGroup H] [NormedSpace ℂ H] [CompleteSpace H] [SecondCountableTopology H]

lemma measurable_corner_ratio (σ : Measure Z)
    (κ ξ : Kernel Z ((H ≃ₗᵢ[ℂ] H) × (H ≃ₗᵢ[ℂ] H)))
    [IsMarkovKernel κ] [IsMarkovKernel ξ]
    (ρ τ : ProbabilityMeasure (H ≃ₗᵢ[ℂ] H)) (G : Subgroup (H ≃ₗᵢ[ℂ] H))
    (hρ : (ρ : Measure _).support = (G : Set (H ≃ₗᵢ[ℂ] H))) (hτ : (τ : Measure _).support = (G : Set (H ≃ₗᵢ[ℂ] H)))
    (hcomm : ∀ u ∈ G, ∀ v ∈ G, u * v = v * u)
    (hm : ∀ᵐ z ∂σ, (κ z).map Prod.fst = ρ ∧ (κ z).map Prod.snd = ρ ∧
      (ξ z).map Prod.fst = τ ∧ (ξ z).map Prod.snd = τ)
    (hr : ∀ᵐ z ∂σ, ∀ᵐ p ∂(κ z).prod (ξ z), p.1.1*p.2.2 = p.2.1*p.1.2) :
    ∃ U : Z → H ≃ₗᵢ[ℂ] H, Measurable U ∧ ∀ᵐ z ∂σ, U z ∈ G ∧
      (∀ᵐ p ∂κ z, p.1 * p.2⁻¹ = U z) ∧
      (∀ᵐ p ∂ξ z, p.1 * p.2⁻¹ = U z) := by
  have hρm : ∀ᵐ u ∂(ρ : Measure _), u ∈ G := by
    change (G : Set (H ≃ₗᵢ[ℂ] H)) ∈ ae (ρ : Measure _)
    rw [←hρ]
    exact Measure.support_mem_ae
  have hτm : ∀ᵐ u ∂(τ : Measure _), u ∈ G := by
    change (G : Set (H ≃ₗᵢ[ℂ] H)) ∈ ae (τ : Measure _)
    rw [←hτ]
    exact Measure.support_mem_ae
  have hpairs : ∀ᵐ z ∂σ, (∀ᵐ p ∂κ z, p.1 ∈ G ∧ p.2 ∈ G) ∧
      (∀ᵐ p ∂ξ z, p.1 ∈ G ∧ p.2 ∈ G) := by
    filter_upwards [hm] with z hz
    constructor
    · have ha := ae_of_ae_map measurable_fst.aemeasurable (hz.1 ▸ hρm)
      have hb := ae_of_ae_map measurable_snd.aemeasurable (hz.2.1 ▸ hρm)
      exact ha.and hb
    · have hc := ae_of_ae_map measurable_fst.aemeasurable (hz.2.2.1 ▸ hτm)
      have hd := ae_of_ae_map measurable_snd.aemeasurable (hz.2.2.2 ▸ hτm)
      exact hc.and hd
  have he : ∀ᵐ z ∂σ, ∀ᵐ p ∂(κ z).prod (ξ z), p.1.1 * p.1.2⁻¹ = p.2.1 * p.2.2⁻¹ := by
    filter_upwards [hpairs,hr] with z hz hzr
    filter_upwards [Measure.quasiMeasurePreserving_fst.ae hz.1,
      Measure.quasiMeasurePreserving_snd.ae hz.2,hzr] with p hp hq hrect
    exact rectangle_ratio_eq (hcomm _ hp.2 _ hq.2) hrect
  obtain ⟨U,hU,heU⟩ := exists_measurable_common_unitary κ ξ
    (fun p => p.1 * p.2⁻¹) (fun p => p.1 * p.2⁻¹)
    (measurable_fst.mul measurable_snd.inv) he
  refine ⟨U,hU,?_⟩
  filter_upwards [hpairs,heU] with z hz hzu
  obtain ⟨p,hp,heq⟩ := (hz.1.and hzu.1).exists
  change p.1 * p.2⁻¹ = U z at heq
  exact ⟨heq ▸ G.mul_mem hp.1 (G.inv_mem hp.2), hzu⟩

end StrongUnitary

namespace ConditionalFibres
lemma ae_of_ae_kernel {Ω Z V : Type*} [MeasurableSpace Ω] [MeasurableSpace Z]
    [MeasurableSpace V] {μ : Measure Ω} {z : Ω → Z} {v : Ω → V}
    {κ : Kernel Z V} (h : HasCondDistrib v z κ μ) {p : Z × V → Prop}
    (hp : MeasurableSet {q | p q}) (hv : ∀ᵐ a ∂μ.map z, ∀ᵐ b ∂κ a, p (a,b)) :
    ∀ᵐ ω ∂μ, p (z ω,v ω) := by
  have hh := Measure.ae_compProd_of_ae_ae hp hv
  rw [←h.map_eq] at hh
  exact ae_of_ae_map h.aemeasurable hh
end ConditionalFibres
namespace StrongUnitary
local instance : MeasurableSpace Circle := inferInstanceAs (MeasurableSpace (Submonoid.unitSphere ℂ))
local instance : BorelSpace Circle := inferInstanceAs (BorelSpace (Submonoid.unitSphere ℂ))
universe u
variable {Ω Z X Y C D : Type*} {H : Type u}
  [MeasurableSpace Ω] [MeasurableSpace Z] [MeasurableSpace X] [MeasurableSpace Y]
  [MeasurableSpace C] [MeasurableSpace D]
  [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] [SecondCountableTopology H]
  {μ : Measure Ω} {ν : Measure X} {η : Measure Y} {ξC : Measure C} {ξD : Measure D}
  {z : Ω → Z} {x : Ω → X} {y : Ω → Y} {c : Ω → C} {d : Ω → D}

lemma spectral_corner
    (G : Subgroup (H ≃ₗᵢ[ℂ] H)) (hG : IsClosed (G : Set (H ≃ₗᵢ[ℂ] H)))
    (ρ τ : ProbabilityMeasure (H ≃ₗᵢ[ℂ] H))
    (hρ : (ρ : Measure _).support = (G : Set (H ≃ₗᵢ[ℂ] H)))
    (hτ : (τ : Measure _).support = (G : Set (H ≃ₗᵢ[ℂ] H)))
    (hcomm : ∀ g ∈ G, ∀ h ∈ G, g*h = h*g)
    (hinv : ∀ g ∈ G, (ρ : Measure _).map (g * ·) = ρ)
    (a : X → H ≃ₗᵢ[ℂ] H) (b : Y → H ≃ₗᵢ[ℂ] H)
    (f : C → H ≃ₗᵢ[ℂ] H) (g : D → H ≃ₗᵢ[ℂ] H)
    (ha : MeasurePreserving a ν ρ) (hb : MeasurePreserving b η ρ)
    (hf : MeasurePreserving f ξC τ) (hg : MeasurePreserving g ξD τ)
    (κ ξ : Kernel Z ((H ≃ₗᵢ[ℂ] H) × (H ≃ₗᵢ[ℂ] H)))
    [IsMarkovKernel κ] [IsMarkovKernel ξ]
    (hκ : HasCondDistrib (fun ω => (a (x ω),b (y ω))) z κ μ)
    (hξ : HasCondDistrib (fun ω => (f (c ω),g (d ω))) z ξ μ)
    (hm : ∀ᵐ t ∂μ.map z, (κ t).map Prod.fst = ρ ∧ (κ t).map Prod.snd = ρ ∧
      (ξ t).map Prod.fst = τ ∧ (ξ t).map Prod.snd = τ)
    (hr : ∀ᵐ t ∂μ.map z, ∀ᵐ p ∂(κ t).prod (ξ t), p.1.1*p.2.2 = p.2.1*p.1.2) :
    ∃ (J : Type u) (_ : Countable J)
      (A : X → J → Circle) (B : Y → J → Circle)
      (F : C → J → Circle) (Q : D → J → Circle) (K : Z → J → Circle),
      Measurable A ∧ Measurable B ∧ Measurable F ∧ Measurable Q ∧ Measurable K ∧
      lpMeas ℂ ℂ (MeasurableSpace.comap a inferInstance) 2 ν =
        lpMeas ℂ ℂ (MeasurableSpace.comap A inferInstance) 2 ν ∧
      lpMeas ℂ ℂ (MeasurableSpace.comap b inferInstance) 2 η =
        lpMeas ℂ ℂ (MeasurableSpace.comap B inferInstance) 2 η ∧
      (∀ᵐ ω ∂μ, K (z ω) = A (x ω) * (B (y ω))⁻¹) ∧
      (∀ᵐ ω ∂μ, K (z ω) = F (c ω) * (Q (d ω))⁻¹) := by
  obtain ⟨U,hU,hUr⟩ := measurable_corner_ratio (μ.map z) κ ξ ρ τ G hρ hτ hcomm hm hr
  obtain ⟨J,hJ,e,γ,hγ,he⟩ := polar_spectral G hG ρ hρ hcomm hinv
  let sc := spectralCoords G γ
  have hsc : Measurable sc := measurable_spectralCoords G hG γ hγ
  have hgρ : ∀ᵐ v ∂(ρ : Measure _), v ∈ G := by
    change (G : Set (H ≃ₗᵢ[ℂ] H)) ∈ ae (ρ : Measure _)
    rw [←hρ]
    exact Measure.support_mem_ae
  have hgτ : ∀ᵐ v ∂(τ : Measure _), v ∈ G := by
    change (G : Set (H ≃ₗᵢ[ℂ] H)) ∈ ae (τ : Measure _)
    rw [←hτ]
    exact Measure.support_mem_ae
  have hmκ : ∀ᵐ t ∂μ.map z, ∀ᵐ p ∂κ t, p.1 ∈ G ∧ p.2 ∈ G := by
    filter_upwards [hm] with t ht
    exact (ae_of_ae_map measurable_fst.aemeasurable (ht.1 ▸ hgρ)).and
      (ae_of_ae_map measurable_snd.aemeasurable (ht.2.1 ▸ hgρ))
  have hmξ : ∀ᵐ t ∂μ.map z, ∀ᵐ p ∂ξ t, p.1 ∈ G ∧ p.2 ∈ G := by
    filter_upwards [hm] with t ht
    exact (ae_of_ae_map measurable_fst.aemeasurable (ht.2.2.1 ▸ hgτ)).and
      (ae_of_ae_map measurable_snd.aemeasurable (ht.2.2.2 ▸ hgτ))
  refine ⟨J,hJ,sc ∘ a,sc ∘ b,sc ∘ f,sc ∘ g,sc ∘ U,
    hsc.comp ha.measurable,hsc.comp hb.measurable,hsc.comp hf.measurable,
    hsc.comp hg.measurable,hsc.comp hU,?_,?_,?_,?_⟩
  · exact lpMeas_spectralCoords ν G e γ he a (ha.quasiMeasurePreserving.ae hgρ)
  · exact lpMeas_spectralCoords η G e γ he b (hb.quasiMeasurePreserving.ae hgρ)
  · have hh : ∀ᵐ t ∂μ.map z, ∀ᵐ p ∂κ t, sc (U t) = sc p.1 * (sc p.2)⁻¹ := by
      filter_upwards [hUr,hmκ] with t ht hm
      filter_upwards [ht.2.1,hm] with p hp hmem
      rw [←hp]
      exact spectralCoords_mul_inv G γ hmem.1 hmem.2
    exact ConditionalFibres.ae_of_ae_kernel hκ
      (measurableSet_eq_fun ((hsc.comp hU).comp measurable_fst)
        ((hsc.comp measurable_snd.fst).mul (hsc.comp measurable_snd.snd).inv)) hh
  · have hh : ∀ᵐ t ∂μ.map z, ∀ᵐ p ∂ξ t, sc (U t) = sc p.1 * (sc p.2)⁻¹ := by
      filter_upwards [hUr,hmξ] with t ht hm
      filter_upwards [ht.2.2,hm] with p hp hmem
      rw [←hp]
      exact spectralCoords_mul_inv G γ hmem.1 hmem.2
    exact ConditionalFibres.ae_of_ae_kernel hξ
      (measurableSet_eq_fun ((hsc.comp hU).comp measurable_fst)
        ((hsc.comp measurable_snd.fst).mul (hsc.comp measurable_snd.snd).inv)) hh
end StrongUnitary
end

section
open MeasureTheory ProbabilityTheory ContinuousLinearMap
local instance : MeasurableSpace Circle := inferInstanceAs (MeasurableSpace (Submonoid.unitSphere ℂ))
local instance : BorelSpace Circle := inferInstanceAs (BorelSpace (Submonoid.unitSphere ℂ))
universe u
variable {Ω Z X Y C D H₁ H₂ H₃ : Type*} {H₄ : Type u}
  [MeasurableSpace Ω] [MeasurableSpace Z] [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 Ω} [IsProbabilityMeasure μ]
  {μX : Measure X} {μY : Measure Y} {μC : Measure C} {μD : Measure D}
  [IsProbabilityMeasure μX] [IsProbabilityMeasure μY]
  [IsProbabilityMeasure μC] [IsProbabilityMeasure μ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₂}

omit [SecondCountableTopology H₁] [IsProbabilityMeasure μY] [IsProbabilityMeasure μD] in

lemma MeasurablePolarRectangle.torus_coordinates
    (R : MeasurablePolarRectangle μ μX μY μC μD F G K N x y c d)
    (hR : R.HasHaarNormalization)
    {z : Ω → Z}
    (κ : Kernel Z (X × Y)) (ξ : Kernel Z (C × D)) [IsMarkovKernel κ] [IsMarkovKernel ξ]
    (hκ : HasCondDistrib (fun ω => (x ω,y ω)) z κ μ)
    (hξ : HasCondDistrib (fun ω => (c ω,d ω)) z ξ μ)
    (hpair : HasCondDistrib (fun ω => ((x ω,y ω),(c ω,d ω))) z (κ ×ₖ ξ) μ)
    (hκm : ∀ᵐ v ∂μ.map z, (κ v).map Prod.fst = μX ∧ (κ v).map Prod.snd = μY)
    (hξm : ∀ᵐ v ∂μ.map z, (ξ v).map Prod.fst = μC ∧ (ξ v).map Prod.snd = μD) :
    ∃ (J : Type u) (_ : Countable J)
      (A : X → J → Circle) (B : Y → J → Circle)
      (P : C → J → Circle) (Q : D → J → Circle) (H : Z → J → Circle),
      Measurable A ∧ Measurable B ∧ Measurable P ∧ Measurable Q ∧ Measurable H ∧
      lpMeas ℂ ℂ (MeasurableSpace.comap R.a.unitary inferInstance) 2 μX =
        lpMeas ℂ ℂ (MeasurableSpace.comap A inferInstance) 2 μX ∧
      lpMeas ℂ ℂ (MeasurableSpace.comap R.b.unitary inferInstance) 2 μY =
        lpMeas ℂ ℂ (MeasurableSpace.comap B inferInstance) 2 μY ∧
      (∀ᵐ ω ∂μ, H (z ω) = A (x ω) * (B (y ω))⁻¹) ∧
      (∀ᵐ ω ∂μ, H (z ω) = P (c ω) * (Q (d ω))⁻¹) := by
  obtain ⟨a₀,b₀,d₀,S,hS,hAB,hCD,hρ,hτ,hcomm,hinv⟩ := hR
  let na := StrongUnitary.normalizeA a₀ d₀
  let nb := StrongUnitary.normalizeB b₀
  let nc := StrongUnitary.normalizeC a₀ b₀ d₀
  let nd := StrongUnitary.normalizeD d₀
  have hna : Measurable na := (StrongUnitary.continuous_normalizeA a₀ d₀).measurable
  have hnb : Measurable nb := (StrongUnitary.continuous_normalizeB b₀).measurable
  have hnc : Measurable nc := (StrongUnitary.continuous_normalizeC a₀ b₀ d₀).measurable
  have hnd : Measurable nd := (StrongUnitary.continuous_normalizeD d₀).measurable
  let aa := na ∘ R.a.unitary
  let bb := nb ∘ R.b.unitary
  let cc := nc ∘ R.p.unitary
  let dd := nd ∘ R.q.unitary
  have ha : Measurable aa := hna.comp R.a.measurable
  have hb : Measurable bb := hnb.comp R.b.measurable
  have hc : Measurable cc := hnc.comp R.p.measurable
  have hd : Measurable dd := hnd.comp R.q.measurable
  let ρ : ProbabilityMeasure (H₄ ≃ₗᵢ[ℂ] H₄) :=
    ⟨μX.map aa,(fun mapMeasurable => (Measure.isProbabilityMeasure_map_iff mapMeasurable).mpr inferInstance) ha.aemeasurable⟩
  let τ : ProbabilityMeasure (H₄ ≃ₗᵢ[ℂ] H₄) :=
    ⟨μC.map cc,(fun mapMeasurable => (Measure.isProbabilityMeasure_map_iff mapMeasurable).mpr inferInstance) hc.aemeasurable⟩
  have hρeq : (μX.map R.a.unitary).map na = (ρ : Measure _) :=
    Measure.map_map hna R.a.measurable
  have hτeq : (μC.map R.p.unitary).map nc = (τ : Measure _) :=
    Measure.map_map hnc R.p.measurable
  change (μX.map R.a.unitary).map na = (μY.map R.b.unitary).map nb at hAB
  change (μC.map R.p.unitary).map nc = (μD.map R.q.unitary).map nd at hCD
  have hab : μY.map bb = (ρ : Measure _) :=
    (Measure.map_map hnb R.b.measurable).symm.trans (hAB.symm.trans hρeq)
  have hcd : μD.map dd = (τ : Measure _) :=
    (Measure.map_map hnd R.q.measurable).symm.trans (hCD.symm.trans hτeq)
  let α := κ.map (Prod.map aa bb)
  let β := ξ.map (Prod.map cc dd)
  let : IsMarkovKernel α := Kernel.IsMarkovKernel.map κ (ha.prodMap hb)
  let : IsMarkovKernel β := Kernel.IsMarkovKernel.map ξ (hc.prodMap hd)
  have hα : HasCondDistrib (fun ω => (aa (x ω),bb (y ω))) z α μ := hκ.comp_left (ha.prodMap hb)
  have hβ : HasCondDistrib (fun ω => (cc (c ω),dd (d ω))) z β μ := hξ.comp_left (hc.prodMap hd)
  have hm : ∀ᵐ v ∂μ.map z, (α v).map Prod.fst = ρ ∧ (α v).map Prod.snd = ρ ∧
      (β v).map Prod.fst = τ ∧ (β v).map Prod.snd = τ := by
    filter_upwards [hκm,hξm] with v hv hw
    dsimp only [α,β]
    rw [kernel_map_pair_fst _ _ ha hb,kernel_map_pair_snd _ _ ha hb,
      kernel_map_pair_fst _ _ hc hd,kernel_map_pair_snd _ _ hc hd,hv.1,hv.2,hw.1,hw.2,hab,hcd]
    exact ⟨rfl,rfl,rfl,rfl⟩
  have hr : ∀ᵐ v ∂μ.map z, ∀ᵐ w ∂(α v).prod (β v), w.1.1*w.2.2 = w.2.1*w.1.2 := by
    have hh := hpair.comp_left ((ha.prodMap hb).prodMap (hc.prodMap hd))
    have he : (κ ×ₖ ξ).map (Prod.map (Prod.map aa bb) (Prod.map cc dd)) = α ×ₖ β :=
      (Kernel.map_prod_map κ ξ (ha.prodMap hb) (hc.prodMap hd)).symm
    rw [he] at hh
    have hr := ConditionalFibres.ae_kernel hh
      (isClosed_eq (continuous_fst.fst.mul continuous_snd.snd)
        (continuous_snd.fst.mul continuous_fst.snd)).measurableSet
      (R.rectangle.mono (fun ω hω => StrongUnitary.normalized_rectangle a₀
        (R.a.unitary (x ω)) b₀ (R.b.unitary (y ω)) (R.p.unitary (c ω)) d₀ (R.q.unitary (d ω)) hω))
    simpa only [Kernel.prod_apply, Pi.mul_apply] using hr
  have hρs : (ρ : Measure _).support = (S : Set (H₄ ≃ₗᵢ[ℂ] H₄)) := by rw [←hρeq]; exact hρ
  have hτs : (τ : Measure _).support = (S : Set (H₄ ≃ₗᵢ[ℂ] H₄)) := by rw [←hτeq]; exact hτ
  have hρi : ∀ g ∈ S, (ρ : Measure _).map (g*·) = ρ := by rw [←hρeq]; exact hinv
  obtain ⟨J,hJ,A,B,P,Q,H,hA,hB,hP,hQ,hH,hfa,hfb,hra,hrb⟩ :=
    StrongUnitary.spectral_corner S hS ρ τ hρs hτs hcomm hρi aa bb cc dd
      ⟨ha,rfl⟩ ⟨hb,hab⟩ ⟨hc,rfl⟩ ⟨hd,hcd⟩ α β hα hβ hm hr
  refine ⟨J,hJ,A,B,P,Q,H,hA,hB,hP,hQ,hH,?_,?_,hra,hrb⟩
  · rw [←StrongUnitary.comap_normalizeA a₀ d₀ R.a.unitary]
    exact hfa
  · rw [←StrongUnitary.comap_normalizeB b₀ R.b.unitary]
    exact hfb
end

section
open MeasureTheory
variable {X G : Type*} [TopologicalSpace X] [CompactSpace X] [Group G]

def characterAlgebra (χ : G →* C(X,ℂ)) (hs : ∀ g, star (χ g) = χ g⁻¹) :
    StarSubalgebra ℂ C(X,ℂ) where
  toSubalgebra := Algebra.adjoin ℂ (Set.range χ)
  star_mem' := by
    intro f hf
    induction hf using Algebra.adjoin_induction with
    | mem f hf =>
      obtain ⟨g,rfl⟩ := hf
      rw [hs]
      exact Algebra.subset_adjoin ⟨g⁻¹,rfl⟩
    | algebraMap c =>
      exact (Algebra.adjoin ℂ (Set.range χ)).algebraMap_mem (star c)
    | add f g hf hg hfs hgs =>
      rw [star_add]
      exact (Algebra.adjoin ℂ (Set.range χ)).add_mem hfs hgs
    | mul f g hf hg hfs hgs =>
      rw [star_mul]
      exact (Algebra.adjoin ℂ (Set.range χ)).mul_mem hgs hfs

lemma characterAlgebra_span (χ : G →* C(X,ℂ)) (hs : ∀ g, star (χ g) = χ g⁻¹) :
    (characterAlgebra χ hs).toSubmodule = Submodule.span ℂ (Set.range χ) := by
  change (Algebra.adjoin ℂ (Set.range χ)).toSubmodule = _
  rw [Algebra.adjoin_eq_span]
  rw [←MonoidHom.coe_mrange χ, (MonoidHom.mrange χ).closure_eq]

lemma dense_character_span (χ : G →* C(X,ℂ)) (hs : ∀ g, star (χ g) = χ g⁻¹)
    (hsep : ∀ x y : X, x ≠ y → ∃ g, χ g x ≠ χ g y) :
    (Submodule.span ℂ (Set.range χ)).topologicalClosure = ⊤ := by
  have hA : (characterAlgebra χ hs).SeparatesPoints := by
    intro x y hxy
    obtain ⟨g,hg⟩ := hsep x y hxy
    refine ⟨(χ g : X → ℂ), ⟨χ g, Algebra.subset_adjoin ⟨g,rfl⟩, rfl⟩, hg⟩
  have h := ContinuousMap.starSubalgebra_topologicalClosure_eq_top_of_separatesPoints
    (characterAlgebra χ hs) hA
  have hh := congrArg (fun A : StarSubalgebra ℂ C(X,ℂ) => A.toSubalgebra.toSubmodule) h
  change (characterAlgebra χ hs).toSubmodule.topologicalClosure = ⊤ at hh
  rwa [characterAlgebra_span] at hh

end

section
open MeasureTheory
open scoped ENNReal
variable {I : Type*}

def torusWordCircle : FreeGroup I →* C((I → Circle), Circle) :=
  FreeGroup.lift (fun i => ⟨fun x => x i, continuous_apply i⟩)

def circleMapComplex {X : Type*} [TopologicalSpace X] : C(X,Circle) →* C(X,ℂ) where
  toFun f := ⟨fun x => (f x : ℂ), continuous_subtype_val.comp f.continuous⟩
  map_one' := by ext x; rfl
  map_mul' f g := by ext x; rfl

def torusWord : FreeGroup I →* C((I → Circle),ℂ) :=
  circleMapComplex.comp torusWordCircle

lemma torusWord_star (w : FreeGroup I) : star (torusWord w) = torusWord w⁻¹ := by
  ext x
  change star ((torusWordCircle w x : Circle) : ℂ) = (torusWordCircle w⁻¹ x : ℂ)
  rw [map_inv]
  exact (Circle.coe_inv_eq_conj (torusWordCircle w x)).symm

@[simp] lemma torusWord_of (i : I) (x : I → Circle) :
    torusWord (FreeGroup.of i) x = (x i : ℂ) := by
  change (torusWordCircle (FreeGroup.of i) x : ℂ) = _
  simp only [torusWordCircle, FreeGroup.lift_apply_of]
  rfl

lemma torusWord_dense :
    (Submodule.span ℂ (Set.range (torusWord (I := I)))).topologicalClosure = ⊤ := by
  apply dense_character_span _ torusWord_star
  intro x y hxy
  obtain ⟨i,hi⟩ := Function.ne_iff.mp hxy
  refine ⟨FreeGroup.of i, ?_⟩
  simpa only [torusWord_of] using (fun h => hi (Subtype.ext h))

variable {E F : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E]
  [NormedAddCommGroup F] [NormedSpace ℂ F]
lemma dense_span_image (A : E →L[ℂ] F) (hA : DenseRange A) (s : Set E)
    (hs : (Submodule.span ℂ s).topologicalClosure = ⊤) :
    (Submodule.span ℂ (A '' s)).topologicalClosure = ⊤ := by
  let P := (Submodule.span ℂ (A '' s)).topologicalClosure
  have hspan : Submodule.span ℂ s ≤ P.comap A.toLinearMap := by
    apply Submodule.span_le.mpr
    intro x hx
    exact Submodule.le_topologicalClosure _ (Submodule.subset_span ⟨x,hx,rfl⟩)
  have htop : ⊤ ≤ P.comap A.toLinearMap := by
    rw [←hs]
    exact Submodule.topologicalClosure_minimal _ hspan
      ((Submodule.isClosed_topologicalClosure _).preimage A.continuous)
  apply top_unique
  intro x hx
  exact (Submodule.isClosed_topologicalClosure _).closure_subset_iff.mpr
    (Set.range_subset_iff.mpr (fun v => htop (show v ∈ (⊤ : Submodule ℂ E) from trivial)))
    (by rw [hA.closure_range]; trivial : x ∈ closure (Set.range A))

lemma dense_span_continuous_toLp {X J : Type*} [TopologicalSpace X] [CompactSpace X]
    [NormalSpace X] [MeasurableSpace X] [BorelSpace X]
    (μ : Measure X) [IsFiniteMeasure μ] [μ.WeaklyRegular]
    (f : J → C(X,ℂ)) (hf : (Submodule.span ℂ (Set.range f)).topologicalClosure = ⊤) :
    (Submodule.span ℂ (Set.range (fun j => ContinuousMap.toLp 2 μ ℂ (f j)))).topologicalClosure = ⊤ := by
  have hD : DenseRange (ContinuousMap.toLp 2 μ ℂ : C(X,ℂ) →L[ℂ] Lp ℂ 2 μ) :=
    ContinuousMap.toLp_denseRange ℂ μ ℂ (by norm_num : (2 : ENNReal) ≠ ∞)
  have h := dense_span_image (ContinuousMap.toLp 2 μ ℂ : C(X,ℂ) →L[ℂ] Lp ℂ 2 μ) hD
    (Set.range f) hf
  simpa only [←Set.range_comp, Function.comp_def] using h

local instance : MeasurableSpace Circle := inferInstanceAs (MeasurableSpace (Submonoid.unitSphere ℂ))
local instance : BorelSpace Circle := inferInstanceAs (BorelSpace (Submonoid.unitSphere ℂ))

lemma torusWord_L2_dense [Countable I] (μ : Measure (I → Circle)) [IsFiniteMeasure μ] :
    (Submodule.span ℂ (Set.range (fun w => ContinuousMap.toLp 2 μ ℂ (torusWord (I := I) w)))).topologicalClosure = ⊤ := by
  exact dense_span_continuous_toLp μ (torusWord (I := I)) torusWord_dense

end

variable {I : Type*}

lemma torusWordCircle_of (i : I) (x : I → Circle) :
    torusWordCircle (FreeGroup.of i) x = x i := by
  simp only [torusWordCircle, FreeGroup.lift_apply_of]
  rfl

lemma torusWordCircle_mul (w : FreeGroup I) (x y : I → Circle) :
    torusWordCircle w (x*y) = torusWordCircle w x * torusWordCircle w y := by
  induction w using FreeGroup.induction_on with
  | one => simp only [map_one, ContinuousMap.one_apply, one_mul]
  | of i => simp only [torusWordCircle_of, Pi.mul_apply]
  | inv_of i hi =>
    simp only [map_inv, ContinuousMap.inv_apply, hi, mul_inv_rev]
    exact mul_comm _ _
  | mul a b ha hb =>
    simp only [map_mul, ContinuousMap.mul_apply, ha, hb]
    ac_rfl

lemma torusWordCircle_one (w : FreeGroup I) : torusWordCircle w (1 : I → Circle) = 1 := by
  have h := torusWordCircle_mul w (1 : I → Circle) 1
  simp only [one_mul] at h
  exact mul_left_cancel (by simpa only [mul_one] using h.symm :
    torusWordCircle w 1 * torusWordCircle w 1 = torusWordCircle w 1 * 1)

lemma torusWordCircle_inv (w : FreeGroup I) (x : I → Circle) :
    torusWordCircle w x⁻¹ = (torusWordCircle w x)⁻¹ := by
  symm
  apply inv_eq_of_mul_eq_one_left
  rw [←torusWordCircle_mul, inv_mul_cancel, torusWordCircle_one]

def torusCharacter (w : FreeGroup I) : (I → Circle) →* Circle where
  toFun := torusWordCircle w
  map_one' := torusWordCircle_one w
  map_mul' := torusWordCircle_mul w

lemma torusWord_ratio (w : FreeGroup I) (x y : I → Circle) :
    torusWord w (x*y⁻¹) = torusWord w x * star (torusWord w y) := by
  change (torusCharacter w (x*y⁻¹) : ℂ) =
    (torusCharacter w x : ℂ) * star (torusCharacter w y : ℂ)
  rw [map_mul, map_inv, Circle.coe_mul, Circle.coe_inv_eq_conj]
  rfl

lemma torusWord_norm (w : FreeGroup I) (x : I → Circle) : ‖torusWord w x‖ = 1 := by
  change ‖(torusWordCircle w x : ℂ)‖ = 1
  exact Circle.norm_coe _


end Rokhlin

end

end OAI