lean/OAI/Dynamics/MultipleMixing/FibreMeasures.lean

import OAI.Dynamics.MultipleMixing.ExactLines

namespace OAI

noncomputable section

namespace Rokhlin

section
open MeasureTheory Set
open scoped ENNReal BigOperators
variable {U Z : Type*} [MeasurableSpace U] [StandardBorelSpace U]
  [MeasurableSpace Z] [StandardBorelSpace Z]

structure BorelFibreEnumeration (S : Set (U × Z)) where
  domain : ℕ → Set U
  section_ : ℕ → U → Z
  measurable_domain : ∀ n, MeasurableSet (domain n)
  measurable_section : ∀ n, Measurable (section_ n)
  mem : ∀ n u, u ∈ domain n → (u,section_ n u) ∈ S
  cover : ∀ u z, (u,z) ∈ S → ∃ n, u ∈ domain n ∧ section_ n u = z
  unique : ∀ u n m, u ∈ domain n → u ∈ domain m → section_ n u = section_ m u → n = m

namespace BorelFibreEnumeration
variable {S : Set (U × Z)} (E : BorelFibreEnumeration S)
def indexDomain : Set (U × ℕ) := {x | x.1 ∈ E.domain x.2}
omit [StandardBorelSpace U] [StandardBorelSpace Z] in
lemma measurable_indexDomain : MeasurableSet E.indexDomain := by
  have he : E.indexDomain = ⋃ n, E.domain n ×ˢ {n} := by
    ext x; simp [indexDomain]
  rw [he]
  exact MeasurableSet.iUnion (fun n => (E.measurable_domain n).prod (measurableSet_singleton n))
instance : StandardBorelSpace E.indexDomain := E.measurable_indexDomain.standardBorel

def point (x : E.indexDomain) : U × Z := (x.val.1,E.section_ x.val.2 x.val.1)
omit [StandardBorelSpace U] [StandardBorelSpace Z] in
lemma measurable_point : Measurable E.point := by
  apply measurable_subtype_coe.fst.prodMk
  have h : Measurable (fun x : U × ℕ => E.section_ x.2 x.1) :=
    measurable_from_prod_countable_left (fun n => E.measurable_section n)
  exact h.comp measurable_subtype_coe
omit [StandardBorelSpace U] [StandardBorelSpace Z] in
lemma injective_point : Function.Injective E.point := by
  intro x y h
  have hu : x.val.1 = y.val.1 := congrArg (fun p : U × Z => p.1) h
  have hn : x.val.2 = y.val.2 := E.unique x.val.1 x.val.2 y.val.2 x.property
    (by rw [hu]; exact y.property) (by
      have hh := congrArg (fun p : U × Z => p.2) h
      change E.section_ x.val.2 x.val.1 = E.section_ y.val.2 y.val.1 at hh
      rwa [←hu] at hh)
  exact Subtype.ext (Prod.ext hu hn)
lemma measurableEmbedding_point : MeasurableEmbedding E.point :=
  E.measurable_point.measurableEmbedding E.injective_point

def indexMeasure (ν : Measure U) : Measure E.indexDomain :=
  (ν.prod Measure.count).comap Subtype.val

instance indexMeasure_sigmaFinite (ν : Measure U) [SigmaFinite ν] : SigmaFinite (E.indexMeasure ν) := by
  apply SigmaFinite.of_map (E.indexMeasure ν) measurable_subtype_coe.aemeasurable
  change SigmaFinite (Measure.map Subtype.val ((ν.prod Measure.count).comap Subtype.val))
  rw [map_comap_subtype_coe E.measurable_indexDomain]
  infer_instance

def measure (ν : Measure U) : Measure (U × Z) := (E.indexMeasure ν).map E.point
instance measure_sigmaFinite (ν : Measure U) [SigmaFinite ν] : SigmaFinite (E.measure ν) :=
  E.measurableEmbedding_point.sigmaFinite_map

lemma ae_mem (ν : Measure U) : ∀ᵐ x ∂E.measure ν, x ∈ S := by
  rw [measure,E.measurableEmbedding_point.ae_map_iff]
  exact Filter.Eventually.of_forall (fun x => E.mem _ _ x.property)

lemma lintegral_measure (ν : Measure U) [SigmaFinite ν]
    (F : U × Z → ℝ≥0∞) (hF : Measurable F) :
    ∫⁻ x, F x ∂E.measure ν = ∫⁻ u, ∑' n, (E.domain n).indicator
      (fun u => F (u,E.section_ n u)) u ∂ν := by
  rw [measure,E.measurableEmbedding_point.lintegral_map]
  change (∫⁻ x : E.indexDomain, F (x.val.1,E.section_ x.val.2 x.val.1)
    ∂(ν.prod Measure.count).comap Subtype.val) = _
  rw [MeasureTheory.lintegral_subtype_comap E.measurable_indexDomain
    (fun x : U × ℕ => F (x.1,E.section_ x.2 x.1))]
  rw [←lintegral_indicator E.measurable_indexDomain]
  have hm : Measurable (fun x : U × ℕ => E.indexDomain.indicator
      (fun x => F (x.1,E.section_ x.2 x.1)) x) := by
    apply Measurable.indicator _ E.measurable_indexDomain
    exact hF.comp (measurable_fst.prodMk
      (measurable_from_prod_countable_left E.measurable_section))
  rw [lintegral_prod _ hm.aemeasurable]
  congr 1
  funext u
  rw [lintegral_count]
  rfl
end BorelFibreEnumeration
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_enumeration (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) :
    Nonempty (BorelFibreEnumeration S) := by
  obtain ⟨D,s,hD,hs,_,hm,hc⟩ := separated_family_sections κ S hS hb hsep
  obtain ⟨E,hE,_,he,hec,heu⟩ := enumerate_without_repetition S D s hD hs hm hc
  exact ⟨⟨E,s,hE,hs,he,hec,heu⟩⟩
end

namespace BorelFibreEnumeration
open MeasureTheory Set
open scoped ENNReal BigOperators
variable {U Z V W : Type*} [MeasurableSpace U] [StandardBorelSpace U]
  [MeasurableSpace Z] [StandardBorelSpace Z]
  [MeasurableSpace V] [StandardBorelSpace V]
  [MeasurableSpace W] [StandardBorelSpace W]
  {S : Set (U × Z)} (E : BorelFibreEnumeration S)

def fibreEquiv (u : U) : {n : ℕ // u ∈ E.domain n} ≃ {z : Z // (u,z) ∈ S} := by
  let f : {n : ℕ // u ∈ E.domain n} → {z : Z // (u,z) ∈ S} :=
    fun n => ⟨E.section_ n u,E.mem n u n.property⟩
  apply Equiv.ofBijective f
  constructor
  · intro n m he
    exact Subtype.ext (E.unique u n m n.property m.property (congrArg Subtype.val he))
  · intro z
    obtain ⟨n,hn,he⟩ := E.cover u z.val z.property
    exact ⟨⟨n,hn⟩,Subtype.ext he⟩

omit [StandardBorelSpace U] [StandardBorelSpace Z] in
lemma sum_sections (u : U) (g : U × Z → ℝ≥0∞) :
    ∑' n, (E.domain n).indicator (fun u => g (u,E.section_ n u)) u =
      ∑' z : {z : Z // (u,z) ∈ S}, g (u,z.val) := by
  classical
  have he := (E.fibreEquiv u).tsum_eq (fun z => g (u,z.val))
  change (∑' n : {n : ℕ // u ∈ E.domain n}, g (u,E.section_ n u)) = _ at he
  have hs := tsum_subtype {n : ℕ | u ∈ E.domain n} (fun n => g (u,E.section_ n u))
  simpa only [Set.indicator_apply,Set.mem_ofPred_eq] using hs.symm.trans he

lemma measurePreserving_fibrewise {R : Set (V × W)} (D : BorelFibreEnumeration R)
    (ν : Measure U) [SigmaFinite ν] (ρ : Measure V) [SigmaFinite ρ]
    (t : U → V) (ht : MeasurePreserving t ν ρ)
    (f : U × Z → W) (hf : Measurable f)
    (he : ∀ᵐ u ∂ν, ∃ e : {z : Z // (u,z) ∈ S} ≃ {w : W // (t u,w) ∈ R},
      ∀ z, (e z).val = f (u,z.val)) :
    MeasurePreserving (fun x : U × Z => (t x.1,f x)) (E.measure ν) (D.measure ρ) := by
  have hm : Measurable (fun x : U × Z => (t x.1,f x)) := (ht.measurable.comp measurable_fst).prodMk hf
  refine ⟨hm,?_⟩
  apply Measure.ext_of_lintegral
  intro F hF
  rw [lintegral_map hF hm]
  have hleft := E.lintegral_measure ν (fun x => F (t x.1,f x)) (hF.comp hm)
  rw [hleft,D.lintegral_measure ρ F hF]
  have hsum : Measurable (fun v => ∑' n, (D.domain n).indicator
      (fun v => F (v,D.section_ n v)) v) := by
    apply Measurable.tsum
    intro n
    exact (hF.comp (measurable_id.prodMk (D.measurable_section n))).indicator (D.measurable_domain n)
  rw [←ht.lintegral_comp hsum]
  apply lintegral_congr_ae
  filter_upwards [he] with u hu
  obtain ⟨e,he⟩ := hu
  rw [E.sum_sections u (fun x => F (t x.1,f x)),D.sum_sections (t u) F]
  have hh := e.tsum_eq (fun w => F (t u,w.val))
  simpa only [he] using hh
end BorelFibreEnumeration

section
open MeasureTheory ProbabilityTheory Set
open scoped ENNReal
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)

lemma exactCode_enumeration (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)) :
    Nonempty (BorelFibreEnumeration (exactCodeSet κ Λ u)) := by
  obtain ⟨D,s,hD,hs,_,hm,_,hc⟩ := exactCode_sections κ Λ u hu hk hm hind
  obtain ⟨E,hE,_,he,hec,heu⟩ := enumerate_without_repetition (exactCodeSet κ Λ u)
    D s hD hs hm (fun p a ha => hc (p,a) ha)
  exact ⟨⟨E,s,hE,hs,he,hec,heu⟩⟩

def exactFibreSlotEquiv (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))
    (S : Set (U × HilbertCode κ)) (p : P) (i : I)
    (hS : {q | ∃ a, (p,a) ∈ exactCodeSet κ Λ u ∧ a i = q} =
      {q | (u p i,q) ∈ S}) :
    {a : I → HilbertCode κ // (p,a) ∈ exactCodeSet κ Λ u} ≃
      {q : HilbertCode κ // (u p i,q) ∈ S} := by
  let f : {a : I → HilbertCode κ // (p,a) ∈ exactCodeSet κ Λ u} →
      {q : HilbertCode κ // (u p i,q) ∈ S} := fun a =>
    ⟨a.val i,by exact (Set.ext_iff.mp hS _).mp ⟨a.val,a.property,rfl⟩⟩
  apply Equiv.ofBijective f
  constructor
  · intro a b he
    exact Subtype.ext (exactCode_unique_slot κ Λ u hk hm hind a.property b.property i
      (congrArg Subtype.val he))
  · intro q
    obtain ⟨a,ha,he⟩ := (Set.ext_iff.mp hS _).mpr q.property
    exact ⟨⟨a,ha⟩,Subtype.ext he⟩

lemma exactCounting_slot_preserving (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))
    (S : Set (U × HilbertCode κ)) (E : BorelFibreEnumeration S)
    (Eπ : BorelFibreEnumeration (exactCodeSet κ Λ u))
    (π : Measure P) [SigmaFinite π] (ν : Measure U) [SigmaFinite ν]
    (i : I) (hui : MeasurePreserving (fun p => u p i) π ν)
    (hS : ∀ᵐ p ∂π, {q | ∃ a, (p,a) ∈ exactCodeSet κ Λ u ∧ a i = q} =
      {q | (u p i,q) ∈ S}) :
    MeasurePreserving (fun x : P × (I → HilbertCode κ) => (u x.1 i,x.2 i))
      (Eπ.measure π) (E.measure ν) := by
  apply Eπ.measurePreserving_fibrewise E π ν (fun p => u p i) hui
    (fun x => x.2 i) ((measurable_pi_apply i).comp measurable_snd)
  filter_upwards [hS] with p hp
  exact ⟨exactFibreSlotEquiv κ Λ u hk hm hind S p i hp,fun _ => rfl⟩
end

section
open MeasureTheory ProbabilityTheory Set
variable {P Q U Y I : Type*} [MeasurableSpace P] [StandardBorelSpace P]
  [MeasurableSpace Q] [StandardBorelSpace Q]
  [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) (row col : Q → I → P)

def exactSquareSet : Set (Q × (I → I → HilbertCode κ)) :=
  {eq | (∀ a, (row eq.1 a,eq.2 a) ∈ exactCodeSet κ Λ u) ∧
    (∀ s, (col eq.1 s,fun a => eq.2 a s) ∈ exactCodeSet κ Λ u)}

omit [StandardBorelSpace P] [StandardBorelSpace Q] [DecidableEq I] in
lemma measurableSet_exactSquareSet (hu : Measurable u) (hr : Measurable row) (hc : Measurable col) :
    MeasurableSet (exactSquareSet κ Λ u row col) := by
  have hrow (a : I) : MeasurableSet {eq : Q × (I → I → HilbertCode κ) |
      (row eq.1 a,eq.2 a) ∈ exactCodeSet κ Λ u} :=
    (measurableSet_exactCodeSet κ Λ u hu).preimage
      ((((measurable_pi_apply a).comp hr).comp measurable_fst).prodMk
        ((measurable_pi_apply a).comp measurable_snd))
  have hcol (s : I) : MeasurableSet {eq : Q × (I → I → HilbertCode κ) |
      (col eq.1 s,fun a => eq.2 a s) ∈ exactCodeSet κ Λ u} := by
    apply (measurableSet_exactCodeSet κ Λ u hu).preimage
    apply (((measurable_pi_apply s).comp hc).comp measurable_fst).prodMk
    exact Measurable.of_eval (fun a => (measurable_pi_apply s).comp
      ((measurable_pi_apply a).comp measurable_snd))
  convert (MeasurableSet.iInter hrow).inter (MeasurableSet.iInter hcol) using 1
  ext eq
  simp [exactSquareSet]

omit [StandardBorelSpace P] [MeasurableSpace Q] [StandardBorelSpace Q] [StandardBorelSpace U] in
lemma exactSquare_unique_cell (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))
    {e : Q} {q r : I → I → HilbertCode κ}
    (hq : (e,q) ∈ exactSquareSet κ Λ u row col)
    (hr : (e,r) ∈ exactSquareSet κ Λ u row col) (a s : I) (he : q a s = r a s) : q = r := by
  have hc : (fun i => q i s) = fun i => r i s :=
    exactCode_unique_slot κ Λ u hk hm hind (hq.2 s) (hr.2 s) a he
  funext i
  exact exactCode_unique_slot κ Λ u hk hm hind (hq.1 i) (hr.1 i) s (congrFun hc i)

omit [StandardBorelSpace P] [MeasurableSpace Q] [StandardBorelSpace Q] [StandardBorelSpace U] in
lemma exactSquare_separated (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))
    {e : Q} {q r : I → I → HilbertCode κ}
    (hq : (e,q) ∈ exactSquareSet κ Λ u row col)
    (hr : (e,r) ∈ exactSquareSet κ Λ u row col) (a s : I) (hne : q ≠ r) :
    1 ≤ HilbertCode.distance (q a s) (r a s) := by
  rcases HilbertCode.exact_codes_dichotomy hk (Λ (row e a)) (q a) (r a)
    (fun j => ((hq.1 a).1 j).trans ((hr.1 a).1 j).symm) (hq.1 a).2.1 (hr.1 a).2.1
    (fun j => by simpa only [(hq.1 a).1 j] using hm (row e a) j)
    (hind (row e a)) (hq.1 a).2.2 (hr.1 a).2.2 with h | h
  · exact (hne (exactSquare_unique_cell κ Λ u row col hk hm hind hq hr a s (congrFun h s))).elim
  · exact h s

omit [StandardBorelSpace P] in
lemma exactSquare_enumeration (hu : Measurable u) (hrow : Measurable row) (hcol : Measurable col)
    (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)) :
    Nonempty (BorelFibreEnumeration (exactSquareSet κ Λ u row col)) := by
  let A := exactSquareSet κ Λ u row col
  let : StandardBorelSpace A := (measurableSet_exactSquareSet κ Λ u row col hu hrow hcol).standardBorel
  obtain ⟨i₀⟩ : Nonempty I := Fintype.card_pos_iff.mp (by omega)
  obtain ⟨C,_,hcover,_,hemb⟩ := HilbertCode.separated_branches
    (fun t : A => t.1.1) measurable_subtype_coe.fst
    (fun t : A => t.1.2 i₀ i₀)
    ((measurable_pi_apply i₀).comp ((measurable_pi_apply i₀).comp measurable_subtype_coe.snd))
    (by
      intro x y he
      exact ((x.property.1 i₀).1 i₀).trans
        ((congrArg (fun e => u (row e i₀) i₀) he).trans ((y.property.1 i₀).1 i₀).symm))
    1 (by norm_num) (by
      intro x y he hne
      have hy : (x.1.1,y.1.2) ∈ A := by rw [he]; exact y.property
      exact exactSquare_separated κ Λ u row col hk hm hind x.property hy i₀ i₀
        (fun h => hne (Subtype.ext (Prod.ext he h))))
  let d : Q → I → I → HilbertCode κ := fun e a s => HilbertCode.encode (u (row e a) s) 0
  have hd : Measurable d := by
    apply Measurable.of_eval
    intro a
    apply Measurable.of_eval
    intro s
    exact MeasurableSection.zero (((measurable_pi_apply s).comp hu).comp
      ((measurable_pi_apply a).comp hrow))
  obtain ⟨D,sec,hD,hs,_,hmem,hcov⟩ := measurable_branch_sections
    (fun t : A => t.1.1) (fun t => t.1.2) measurable_subtype_coe.snd d hd C hcover hemb
  have hm' (n) (e) (he : e ∈ D n) : (e,sec n e) ∈ A := by
    obtain ⟨t,ht,he⟩ := hmem n e he
    rw [he,←ht]
    exact t.property
  have hc' (e) (q) (hq : (e,q) ∈ A) : ∃ n, e ∈ D n ∧ sec n e = q := hcov ⟨(e,q),hq⟩
  obtain ⟨E,hE,_,he,hec,heu⟩ := enumerate_without_repetition A D sec hD hs hm' hc'
  exact ⟨⟨E,sec,hE,hs,he,hec,heu⟩⟩
end

namespace ArrayObjects.Object.Rolled
open MeasureTheory ProbabilityTheory Set
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)
    (Λ : Kernel (Arr I M.U 1) (I → Arr I M.Y 0)) [IsMarkovKernel Λ]

def rawExactSquare : Set (Arr I M.U 2 × (I → I → HilbertCode (M.ownKernel 0))) :=
  exactSquareSet (M.ownKernel 0) Λ (tupleParameter M)
    (fun e i => plane 1 0 i e) (fun e j => plane 1 (Fin.last 1) j e)

lemma rawSquare_row_completion (hM : M.IsSaturated) (hk : 3 ≤ Fintype.card I)
    (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)))
    (S : Set (Arr I M.U 0 × HilbertCode (M.ownKernel 0)))
    (hS : ∀ᵐ p ∂M.parameterLaw 1, ∀ i, {q | (p,q) ∈ rawLineGraph M Λ i} =
      {q | (tupleParameter M p i,q) ∈ S}) :
    ∀ᵐ e ∂M.parameterLaw 2, ∀ (a : I) (r : I → HilbertCode (M.ownKernel 0)),
      (plane 1 0 a e,r) ∈ exactCodeSet (M.ownKernel 0) Λ (tupleParameter M) →
      ∃ q : I → I → HilbertCode (M.ownKernel 0), (e,q) ∈ rawExactSquare M Λ ∧ q a = r := by
  have hr (a : I) := (show MeasurePreserving (plane 1 0 a)
    (M.parameterLaw 2) (M.parameterLaw 1) from
    ⟨measurable_plane _ _ _,M.parameterLaw_consistent _ _ _⟩).quasiMeasurePreserving.ae hS
  have hc (s : I) := (show MeasurePreserving (plane 1 (Fin.last 1) s)
    (M.parameterLaw 2) (M.parameterLaw 1) from
    ⟨measurable_plane _ _ _,M.parameterLaw_consistent _ _ _⟩).quasiMeasurePreserving.ae hS
  filter_upwards [ae_all_iff.mpr hr,ae_all_iff.mpr hc,
    rawSquare_exact_consistency M hM (by omega) Λ hL hm] with e hrow hcol hcons a r hr
  have hex (s : I) : ∃ b : I → HilbertCode (M.ownKernel 0),
      (plane 1 (Fin.last 1) s e,b) ∈ exactCodeSet (M.ownKernel 0) Λ (tupleParameter M) ∧ b a = r s := by
    have hs : (tupleParameter M (plane 1 0 a e) s,r s) ∈ S :=
      (Set.ext_iff.mp (hrow a s) _).mp ⟨r,hr,rfl⟩
    rw [parameter_cell_commute M a s e] at hs
    exact (Set.ext_iff.mp (hcol s a) _).mpr hs
  choose b hb hba using hex
  let q : I → I → HilbertCode (M.ownKernel 0) := fun i s => b s i
  have hqa : q a = r := funext hba
  have hqc (s : I) : (plane 1 (Fin.last 1) s e,fun i => q i s) ∈
      exactCodeSet (M.ownKernel 0) Λ (tupleParameter M) := hb s
  refine ⟨q,⟨hcons q a hqc ?_,hqc⟩,hqa⟩
  rwa [hqa]

lemma rawSquare_column_completion (hM : M.IsSaturated) (hk : 3 ≤ Fintype.card I)
    (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)))
    (hS : ∀ᵐ p ∂M.parameterLaw 1, ∀ i, {q | (p,q) ∈ rawLineGraph M Λ i} =
      {q | (tupleParameter M p i,q) ∈ S}) :
    ∀ᵐ e ∂M.parameterLaw 2, ∀ (s : I) (c : I → HilbertCode (M.ownKernel 0)),
      (plane 1 (Fin.last 1) s e,c) ∈ exactCodeSet (M.ownKernel 0) Λ (tupleParameter M) →
      ∃ q : I → I → HilbertCode (M.ownKernel 0), (e,q) ∈ rawExactSquare M Λ ∧
        (fun i => q i s) = c := by
  obtain ⟨a⟩ : Nonempty I := Fintype.card_pos_iff.mp (by omega)
  have hr := (show MeasurePreserving (plane 1 0 a) (M.parameterLaw 2) (M.parameterLaw 1) from
    ⟨measurable_plane _ _ _,M.parameterLaw_consistent _ _ _⟩).quasiMeasurePreserving.ae hS
  have hc (s : I) := (show MeasurePreserving (plane 1 (Fin.last 1) s)
    (M.parameterLaw 2) (M.parameterLaw 1) from
    ⟨measurable_plane _ _ _,M.parameterLaw_consistent _ _ _⟩).quasiMeasurePreserving.ae hS
  filter_upwards [hr,ae_all_iff.mpr hc,rawSquare_row_completion M Λ hM hk hL hm S hS]
    with e hrow hcol hcompl s c hc
  have hs : (tupleParameter M (plane 1 (Fin.last 1) s e) a,c a) ∈ S :=
    (Set.ext_iff.mp (hcol s a) _).mp ⟨c,hc,rfl⟩
  rw [←parameter_cell_commute M a s e] at hs
  obtain ⟨r,hr,hrs⟩ := (Set.ext_iff.mp (hrow s) _).mpr hs
  obtain ⟨q,hq,hqa⟩ := hcompl a r hr
  refine ⟨q,hq,?_⟩
  exact exactCode_unique_slot (M.ownKernel 0) Λ (tupleParameter M) hk hm hind
    (hq.2 s) hc a ((congrFun hqa s).trans hrs)

lemma rawSquare_row_bijective (hk : 3 ≤ Fintype.card I)
    (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))
    (e : Arr I M.U 2) (a : I)
    (hc : ∀ r, (plane 1 0 a e,r) ∈ exactCodeSet (M.ownKernel 0) Λ (tupleParameter M) →
      ∃ q : I → I → HilbertCode (M.ownKernel 0), (e,q) ∈ rawExactSquare M Λ ∧ q a = r) :
    ∃ f : {q : I → I → HilbertCode (M.ownKernel 0) // (e,q) ∈ rawExactSquare M Λ} ≃
        {r : I → HilbertCode (M.ownKernel 0) //
          (plane 1 0 a e,r) ∈ exactCodeSet (M.ownKernel 0) Λ (tupleParameter M)},
      ∀ q, (f q).val = q.val a := by
  let f : {q : I → I → HilbertCode (M.ownKernel 0) // (e,q) ∈ rawExactSquare M Λ} →
      {r : I → HilbertCode (M.ownKernel 0) //
          (plane 1 0 a e,r) ∈ exactCodeSet (M.ownKernel 0) Λ (tupleParameter M)} :=
    fun q => ⟨q.val a,q.property.1 a⟩
  have hf : Function.Bijective f := by
    constructor
    · intro q r he
      apply Subtype.ext
      exact exactSquare_unique_cell (M.ownKernel 0) Λ (tupleParameter M)
        (fun e i => plane 1 0 i e) (fun e j => plane 1 (Fin.last 1) j e) hk hm hind
        q.property r.property a a (congrFun (congrArg Subtype.val he) a)
    · intro r
      obtain ⟨q,hq,he⟩ := hc r.val r.property
      exact ⟨⟨q,hq⟩,Subtype.ext he⟩
  exact ⟨Equiv.ofBijective f hf,fun _ => rfl⟩

lemma rawSquare_col_bijective (hk : 3 ≤ Fintype.card I)
    (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))
    (e : Arr I M.U 2) (s : I)
    (hc : ∀ r, (plane 1 (Fin.last 1) s e,r) ∈ exactCodeSet (M.ownKernel 0) Λ (tupleParameter M) →
      ∃ q : I → I → HilbertCode (M.ownKernel 0), (e,q) ∈ rawExactSquare M Λ ∧ (fun i => q i s) = r) :
    ∃ f : {q : I → I → HilbertCode (M.ownKernel 0) // (e,q) ∈ rawExactSquare M Λ} ≃
        {r : I → HilbertCode (M.ownKernel 0) //
          (plane 1 (Fin.last 1) s e,r) ∈ exactCodeSet (M.ownKernel 0) Λ (tupleParameter M)},
      ∀ q, (f q).val = fun i => q.val i s := by
  let f : {q : I → I → HilbertCode (M.ownKernel 0) // (e,q) ∈ rawExactSquare M Λ} →
      {r : I → HilbertCode (M.ownKernel 0) //
          (plane 1 (Fin.last 1) s e,r) ∈ exactCodeSet (M.ownKernel 0) Λ (tupleParameter M)} :=
    fun q => ⟨fun i => q.val i s,q.property.2 s⟩
  have hf : Function.Bijective f := by
    constructor
    · intro q r he
      apply Subtype.ext
      exact exactSquare_unique_cell (M.ownKernel 0) Λ (tupleParameter M)
        (fun e i => plane 1 0 i e) (fun e j => plane 1 (Fin.last 1) j e) hk hm hind
        q.property r.property s s (congrFun (congrArg Subtype.val he) s)
    · intro r
      obtain ⟨q,hq,he⟩ := hc r.val r.property
      exact ⟨⟨q,hq⟩,Subtype.ext he⟩
  exact ⟨Equiv.ofBijective f hf,fun _ => rfl⟩

lemma rawCounting_rows_preserving (hM : M.IsSaturated) (hk : 3 ≤ Fintype.card I)
    (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)))
    (hS : ∀ᵐ p ∂M.parameterLaw 1, ∀ i, {q | (p,q) ∈ rawLineGraph M Λ i} =
      {q | (tupleParameter M p i,q) ∈ S})
    (Eπ : BorelFibreEnumeration (exactCodeSet (M.ownKernel 0) Λ (tupleParameter M)))
    (Eσ : BorelFibreEnumeration (rawExactSquare M Λ)) (a : I) :
    MeasurePreserving (fun x : Arr I M.U 2 × (I → I → HilbertCode (M.ownKernel 0)) =>
      (plane 1 0 a x.1,x.2 a)) (Eσ.measure (M.parameterLaw 2)) (Eπ.measure (M.parameterLaw 1)) := by
  apply Eσ.measurePreserving_fibrewise Eπ _ _ (plane 1 0 a)
    ⟨measurable_plane _ _ _,M.parameterLaw_consistent _ _ _⟩
    (fun x => x.2 a) ((measurable_pi_apply a).comp measurable_snd)
  filter_upwards [rawSquare_row_completion M Λ hM hk hL hm S hS] with e he
  exact rawSquare_row_bijective M Λ hk hm hind e a (he a)

lemma rawCounting_columns_preserving (hM : M.IsSaturated) (hk : 3 ≤ Fintype.card I)
    (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)))
    (hS : ∀ᵐ p ∂M.parameterLaw 1, ∀ i, {q | (p,q) ∈ rawLineGraph M Λ i} =
      {q | (tupleParameter M p i,q) ∈ S})
    (Eπ : BorelFibreEnumeration (exactCodeSet (M.ownKernel 0) Λ (tupleParameter M)))
    (Eσ : BorelFibreEnumeration (rawExactSquare M Λ)) (s : I) :
    MeasurePreserving (fun x : Arr I M.U 2 × (I → I → HilbertCode (M.ownKernel 0)) =>
      (plane 1 (Fin.last 1) s x.1,fun i => x.2 i s))
      (Eσ.measure (M.parameterLaw 2)) (Eπ.measure (M.parameterLaw 1)) := by
  apply Eσ.measurePreserving_fibrewise Eπ _ _ (plane 1 (Fin.last 1) s)
    ⟨measurable_plane _ _ _,M.parameterLaw_consistent _ _ _⟩
    (fun x i => x.2 i s) (Measurable.of_eval fun i =>
      (measurable_pi_apply s).comp ((measurable_pi_apply i).comp measurable_snd))
  filter_upwards [rawSquare_column_completion M Λ hM hk hL hm hind S hS] with e he
  exact rawSquare_col_bijective M Λ hk hm hind e s (he s)

lemma rawCounting_coordinate_preserving (hk : 3 ≤ Fintype.card I)
    (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)))
    (hS : ∀ᵐ p ∂M.parameterLaw 1, ∀ i, {q | (p,q) ∈ rawLineGraph M Λ i} =
      {q | (tupleParameter M p i,q) ∈ S})
    (E : BorelFibreEnumeration S)
    (Eπ : BorelFibreEnumeration (exactCodeSet (M.ownKernel 0) Λ (tupleParameter M))) (i : I) :
    MeasurePreserving (fun x : Arr I M.U 1 × (I → HilbertCode (M.ownKernel 0)) =>
      (tupleParameter M x.1 i,x.2 i)) (Eπ.measure (M.parameterLaw 1)) (E.measure (M.parameterLaw 0)) := by
  apply exactCounting_slot_preserving (M.ownKernel 0) Λ (tupleParameter M) hk hm hind S E Eπ _ _ i
    ⟨measurable_plane _ _ _,M.parameterLaw_consistent _ _ _⟩
  exact hS.mono (fun _ hp => hp i)

lemma exists_raw_counting_data (hM : M.IsSaturated) (hk : 3 ≤ Fintype.card I)
    (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)))
      (E : BorelFibreEnumeration S)
      (Eπ : BorelFibreEnumeration (exactCodeSet (M.ownKernel 0) Λ (tupleParameter M)))
      (Eσ : BorelFibreEnumeration (rawExactSquare M Λ)),
      MeasurableSet S ∧
      (∀ u q, (u,q) ∈ S → q.base = u ∧ q.IsCanonical ∧ q.IsUnimodular) ∧
      (∀ᵐ p ∂M.parameterLaw 1, ∀ i, {q | (p,q) ∈ rawLineGraph M Λ i} =
        {q | (tupleParameter M p i,q) ∈ S}) ∧
      (∀ i, MeasurePreserving (fun x : Arr I M.U 1 × (I → HilbertCode (M.ownKernel 0)) =>
        (tupleParameter M x.1 i,x.2 i)) (Eπ.measure (M.parameterLaw 1)) (E.measure (M.parameterLaw 0))) ∧
      (∀ a, MeasurePreserving (fun x : Arr I M.U 2 × (I → I → HilbertCode (M.ownKernel 0)) =>
        (plane 1 0 a x.1,x.2 a)) (Eσ.measure (M.parameterLaw 2)) (Eπ.measure (M.parameterLaw 1))) ∧
      (∀ s, MeasurePreserving (fun x : Arr I M.U 2 × (I → I → HilbertCode (M.ownKernel 0)) =>
        (plane 1 (Fin.last 1) s x.1,fun i => x.2 i s))
        (Eσ.measure (M.parameterLaw 2)) (Eπ.measure (M.parameterLaw 1))) := by
  obtain ⟨S,hSm,hSb,hSs,hSe⟩ := exists_commonLocalLineGraph M hM hk Λ hL hm hind
  obtain ⟨E⟩ := separated_family_enumeration (M.ownKernel 0) S hSm (fun u q hq => (hSb u q hq).1) hSs
  obtain ⟨Eπ⟩ := exactCode_enumeration (M.ownKernel 0) Λ (tupleParameter M)
    (measurable_tupleParameter M) hk hm hind
  obtain ⟨Eσ⟩ := exactSquare_enumeration (M.ownKernel 0) Λ (tupleParameter M)
    (fun e i => plane 1 0 i e) (fun e j => plane 1 (Fin.last 1) j e)
    (measurable_tupleParameter M) (Measurable.of_eval fun i => measurable_plane _ _ _)
    (Measurable.of_eval fun j => measurable_plane _ _ _) hk hm hind
  exact ⟨S,E,Eπ,Eσ,hSm,hSb,hSe,
    rawCounting_coordinate_preserving M Λ hk hm hind S hSe E Eπ,
    rawCounting_rows_preserving M Λ hM hk hL hm hind S hSe Eπ Eσ,
    rawCounting_columns_preserving M Λ hM hk hL hm hind S hSe Eπ Eσ⟩
end ArrayObjects.Object.Rolled

namespace BorelFibreEnumeration

open MeasureTheory ProbabilityTheory Set
open scoped ENNReal
variable {P U Z : Type*} [MeasurableSpace P] [StandardBorelSpace P]
  [MeasurableSpace U] [StandardBorelSpace U] [MeasurableSpace Z] [StandardBorelSpace Z]
  {S : Set (U × Z)} (E : BorelFibreEnumeration S)

def comapBase (t : P → U) (ht : Measurable t) :
    BorelFibreEnumeration {x : P × Z | (t x.1,x.2) ∈ S} where
  domain n := t ⁻¹' E.domain n
  section_ n := E.section_ n ∘ t
  measurable_domain n := ht (E.measurable_domain n)
  measurable_section n := (E.measurable_section n).comp ht
  mem n p hp := E.mem n (t p) hp
  cover p z hz := E.cover (t p) z hz
  unique p n m hn hm he := E.unique (t p) n m hn hm he

lemma ae_base (ν : Measure U) [SigmaFinite ν] {P : U → Prop} (h : ∀ᵐ u ∂ν, P u) :
    ∀ᵐ x ∂E.measure ν, P x.1 := by
  rw [measure,E.measurableEmbedding_point.ae_map_iff]
  have h' : ∀ᵐ x ∂ν.prod Measure.count, P x.1 := (Measure.quasiMeasurePreserving_fst (μ := ν) (ν := (Measure.count : Measure ℕ))).ae h
  have hs : ∀ᵐ x ∂(ν.prod Measure.count).restrict E.indexDomain, P x.1 :=
    ae_restrict_of_ae h'
  rw [←map_comap_subtype_coe E.measurable_indexDomain] at hs
  exact (MeasurableEmbedding.subtype_coe E.measurable_indexDomain).ae_map_iff.mp hs

lemma comapBase_preserving (π : Measure P) [SigmaFinite π] (ν : Measure U) [SigmaFinite ν]
    (t : P → U) (ht : MeasurePreserving t π ν) :
    MeasurePreserving (fun x : P × Z => (t x.1,x.2)) ((E.comapBase t ht.measurable).measure π)
      (E.measure ν) := by
  apply (E.comapBase t ht.measurable).measurePreserving_fibrewise E π ν t ht
    Prod.snd measurable_snd
  exact Filter.Eventually.of_forall (fun _ => ⟨Equiv.refl _,fun _ => rfl⟩)

omit [StandardBorelSpace P] [MeasurableSpace U] [StandardBorelSpace U] in
lemma lintegral_indicator_kernel (η : Measure P) (D : Set U) (u : U)
    (g : P → ℝ≥0∞) :
    D.indicator (fun _ => ∫⁻ p, g p ∂η) u = ∫⁻ p, D.indicator (fun _ => g p) u ∂η := by
  classical
  by_cases hu : u ∈ D <;> simp [hu]

lemma parameter_conditional (μ : Measure P) [SigmaFinite μ] (ν : Measure U) [SigmaFinite ν]
    (t : P → U) (ht : MeasurePreserving t μ ν)
    (η : Kernel U P) [IsMarkovKernel η] (hη : HasCondDistrib id t η μ) :
    HasCondDistrib Prod.fst (fun x : P × Z => (t x.1,x.2))
      (η.comap (Prod.fst : U × Z → U) (@measurable_fst U Z _ ‹MeasurableSpace Z›)) ((E.comapBase t ht.measurable).measure μ) := by
  have hobs := E.comapBase_preserving μ ν t ht
  refine ⟨(hobs.measurable.prodMk measurable_fst).aemeasurable,?_⟩
  rw [hobs.map_eq]
  apply Measure.ext_of_lintegral
  intro F hF
  rw [lintegral_map hF (hobs.measurable.prodMk measurable_fst)]
  have hleft := (E.comapBase t ht.measurable).lintegral_measure μ
    (fun x : P × Z => F ((t x.1,x.2),x.1)) (hF.comp (hobs.measurable.prodMk measurable_fst))
  rw [hleft]
  rw [Measure.lintegral_compProd hF]
  have hg : Measurable (fun x : U × Z => ∫⁻ p, F (x,p) ∂η x.1) :=
    Measurable.lintegral_kernel_prod_right (f := fun x p => F (x,p)) hF (κ := η.comap (Prod.fst : U × Z → U) measurable_fst)
  simp only [Kernel.comap_apply]
  rw [E.lintegral_measure ν _ hg]
  let H : U × P → ℝ≥0∞ := fun up => ∑' n, (E.domain n).indicator
    (fun u => F ((u,E.section_ n u),up.2)) up.1
  have hH : Measurable H := by
    apply Measurable.tsum
    intro n
    exact ((hF.comp ((measurable_fst.prodMk ((E.measurable_section n).comp measurable_fst)).prodMk
      measurable_snd)).indicator ((E.measurable_domain n).preimage measurable_fst))
  have hpair : MeasurePreserving (fun p => (t p,p)) μ (ν ⊗ₘ η) :=
    ⟨ht.measurable.prodMk measurable_id,by simpa only [ht.map_eq,id_eq] using hη.map_eq⟩
  have he := hpair.lintegral_comp hH
  rw [Measure.lintegral_compProd hH] at he
  change (∫⁻ p, H (t p,p) ∂μ) = _
  rw [he]
  apply lintegral_congr
  intro u
  dsimp only [H]
  rw [lintegral_tsum]
  · apply tsum_congr
    intro n
    symm
    exact lintegral_indicator_kernel (η u) (E.domain n) u (fun p => F ((u,E.section_ n u),p))
  · intro n
    by_cases hu : u ∈ E.domain n
    · have hf : Measurable (fun p : P => F ((u,E.section_ n u),p)) :=
        hF.comp (measurable_const.prodMk measurable_id)
      convert hf.aemeasurable using 1
      ext p
      exact Set.indicator_of_mem hu _
    · simp only [Set.indicator_of_notMem hu]
      exact measurable_const.aemeasurable
end BorelFibreEnumeration

namespace ConditionalTransport
open MeasureTheory ProbabilityTheory
open scoped ENNReal
variable {Ω A B C : Type*} [MeasurableSpace Ω] [MeasurableSpace A]
  [MeasurableSpace B] [MeasurableSpace C]
  {μ : Measure Ω} [SFinite μ] {x : Ω → A} {y : Ω → B}
  {κ : Kernel A B} [IsSFiniteKernel κ]

lemma with_observation (h : HasCondDistrib y x κ μ) :
    HasCondDistrib (fun ω => (x ω,y ω)) x (Kernel.id ×ₖ κ) μ := by
  refine ⟨h.aemeasurable_fst.prodMk h.aemeasurable,?_⟩
  have hm : Measurable (fun ab : A × B => (ab.1,ab)) := measurable_fst.prodMk measurable_id
  have hmap : μ.map (fun ω => (x ω,x ω,y ω)) =
      ((μ.map x) ⊗ₘ κ).map (fun ab : A × B => (ab.1,ab)) := by
    rw [←h.map_eq, AEMeasurable.map_map_of_aemeasurable
      hm.aemeasurable h.aemeasurable]
    rfl
  rw [hmap]
  apply Measure.ext_of_lintegral
  intro f hf
  rw [lintegral_map hf hm]
  have hf' : Measurable (fun ab : A × B => f (ab.1,ab)) := hf.comp hm
  rw [Measure.lintegral_compProd hf',
    Measure.lintegral_compProd hf]
  apply lintegral_congr
  intro a
  have hfa : Measurable (fun ab : A × B => f (a,ab)) :=
    hf.comp (measurable_const.prodMk measurable_id)
  rw [Kernel.lintegral_id_prod hfa κ a]

lemma map_observation (h : HasCondDistrib y x κ μ) (f : A × B → C) (hf : Measurable f) :
    HasCondDistrib (fun ω => f (x ω,y ω)) x ((Kernel.id ×ₖ κ).map f) μ :=
  (with_observation h).comp_left hf
end ConditionalTransport

namespace BorelFibreEnumeration
open MeasureTheory ProbabilityTheory Set
variable {P U Z W : Type*} [MeasurableSpace P] [StandardBorelSpace P]
  [MeasurableSpace U] [StandardBorelSpace U] [MeasurableSpace Z] [StandardBorelSpace Z]
  [MeasurableSpace W] [StandardBorelSpace W]
  {S : Set (P × Z)} (E : BorelFibreEnumeration S)
  {R : Set (U × W)} (D : BorelFibreEnumeration R)

include D in
lemma parameter_conditional_of_fibrewise
    (μ : Measure P) [SigmaFinite μ] (ν : Measure U) [SigmaFinite ν]
    (t : P → U) (ht : MeasurePreserving t μ ν)
    (f : P × Z → W) (hf : Measurable f)
    (he : ∀ᵐ p ∂μ, ∃ e : {z : Z // (p,z) ∈ S} ≃ {w : W // (t p,w) ∈ R},
      ∀ z, (e z).val = f (p,z.val))
    (η : Kernel U P) [IsMarkovKernel η] (hη : HasCondDistrib id t η μ) :
    HasCondDistrib Prod.fst (fun x : P × Z => (t x.1,f x))
      (η.comap (Prod.fst : U × W → U) (@measurable_fst U W _ ‹MeasurableSpace W›))
      (E.measure μ) := by
  have hobs : MeasurePreserving (fun x : P × Z => (x.1,f x)) (E.measure μ)
      ((D.comapBase t ht.measurable).measure μ) :=
    E.measurePreserving_fibrewise (D.comapBase t ht.measurable) μ μ id
      (MeasurePreserving.id μ) f hf he
  have hp := D.comapBase_preserving μ ν t ht
  have hc := D.parameter_conditional μ ν t ht η hη
  change HasLaw _ _ _ at hc ⊢
  rw [hp.map_eq] at hc
  have hout : MeasurePreserving (fun x : P × Z => (t x.1,f x)) (E.measure μ) (D.measure ν) :=
    hp.comp hobs
  rw [hout.map_eq]
  exact hc.comp hobs.hasLaw
end BorelFibreEnumeration

namespace Kernel
open MeasureTheory ProbabilityTheory
variable {A B C D E F : Type*} [MeasurableSpace A] [MeasurableSpace B]
  [MeasurableSpace C] [MeasurableSpace D] [MeasurableSpace E] [MeasurableSpace F]

def depMap (κ : ProbabilityTheory.Kernel A B) (f : A × B → C) : ProbabilityTheory.Kernel A C :=
  (ProbabilityTheory.Kernel.id ×ₖ κ).map f

instance depMap_sfinite (κ : ProbabilityTheory.Kernel A B) [IsSFiniteKernel κ]
    (f : A × B → C) : IsSFiniteKernel (depMap κ f) := by
  unfold depMap
  infer_instance

lemma depMap_markov (κ : ProbabilityTheory.Kernel A B) [IsMarkovKernel κ] (f : A × B → C)
    (hf : Measurable f) : IsMarkovKernel (depMap κ f) := by
  unfold depMap
  exact ProbabilityTheory.Kernel.IsMarkovKernel.map _ hf

lemma depMap_apply (κ : ProbabilityTheory.Kernel A B) [IsSFiniteKernel κ]
    {f : A × B → C} (hf : Measurable f) (a : A) :
    depMap κ f a = (κ a).map (fun b => f (a,b)) := by
  rw [depMap,ProbabilityTheory.Kernel.map_apply _ hf,
    ProbabilityTheory.Kernel.prod_apply,ProbabilityTheory.Kernel.id_apply,Measure.dirac_prod,
    Measure.map_map hf measurable_prodMk_left]
  rfl

lemma depMap_comap (κ : ProbabilityTheory.Kernel A B) [IsSFiniteKernel κ]
    {f : A × B → C} (hf : Measurable f) (g : D → A) (hg : Measurable g) :
    (depMap κ f).comap g hg = depMap (κ.comap g hg) (fun db => f (g db.1,db.2)) := by
  have hfg : Measurable (fun db : D × B => f (g db.1,db.2)) :=
    hf.comp ((hg.comp measurable_fst).prodMk measurable_snd)
  ext d : 1
  rw [ProbabilityTheory.Kernel.comap_apply,depMap_apply κ hf,
    depMap_apply _ hfg,
    ProbabilityTheory.Kernel.comap_apply]

lemma depMap_prod (κ : ProbabilityTheory.Kernel A B) (η : ProbabilityTheory.Kernel A C)
    [IsSFiniteKernel κ] [IsSFiniteKernel η]
    {f : A × B → D} {g : A × C → E} (hf : Measurable f) (hg : Measurable g) :
    depMap (κ ×ₖ η) (fun x => (f (x.1,x.2.1),g (x.1,x.2.2))) =
      depMap κ f ×ₖ depMap η g := by
  have hfg : Measurable (fun x : A × (B × C) => (f (x.1,x.2.1),g (x.1,x.2.2))) :=
    (hf.comp (measurable_fst.prodMk measurable_snd.fst)).prodMk
      (hg.comp (measurable_fst.prodMk measurable_snd.snd))
  ext a : 1
  rw [depMap_apply _ hfg,
    ProbabilityTheory.Kernel.prod_apply,ProbabilityTheory.Kernel.prod_apply,
    depMap_apply _ hf,depMap_apply _ hg]
  exact (Measure.map_prod_map (κ a) (η a) (hf.comp measurable_prodMk_left)
    (hg.comp measurable_prodMk_left)).symm
end Kernel

namespace ArrayObjects.Object.Rolled
open MeasureTheory ProbabilityTheory Set
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)
    (Λ : Kernel (Arr I M.U 1) (I → Arr I M.Y 0)) [IsMarkovKernel Λ]

abbrev RawLabel := Arr I M.U 0 × HilbertCode (M.ownKernel 0)
abbrev RawLabelTuple := Arr I M.U 1 × (I → HilbertCode (M.ownKernel 0))

def rawLabelSlot (a : I) (x : RawLabelTuple M) : RawLabel M :=
  (tupleParameter M x.1 a,x.2 a)

omit [DecidableEq I] in
lemma measurable_rawLabelSlot (a : I) : Measurable (rawLabelSlot M a) :=
  ((measurable_plane _ _ _).comp measurable_fst).prodMk
    ((measurable_pi_apply a).comp measurable_snd)

def rawMatchedLabel (a b : I) (x : RawLabel M × Arr I M.U 1) : RawLabel M :=
  (tupleParameter M x.2 b,exactMatching (M.ownKernel 0) Λ (tupleParameter M) a (x.2,x.1.2) b)

lemma measurable_rawMatchedLabel (hk : 3 ≤ Fintype.card I)
    (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 b : I) :
    Measurable (rawMatchedLabel M Λ a b) := by
  exact ((measurable_plane _ _ _).comp measurable_snd).prodMk
    ((measurable_pi_apply b).comp ((measurable_exactMatching (M.ownKernel 0) Λ
      (tupleParameter M) (measurable_tupleParameter M) hk hm hind a).comp
      (measurable_snd.prodMk measurable_fst.snd)))

def rawLabelTransition (a b : I) : Kernel (RawLabel M) (RawLabel M) :=
  Rokhlin.Kernel.depMap ((M.parameterCoordinateKernel a).comap Prod.fst measurable_fst)
    (rawMatchedLabel M Λ a b)

lemma rawLabelTransition_markov (hk : 3 ≤ Fintype.card I)
    (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 b : I) :
    IsMarkovKernel (rawLabelTransition M Λ a b) :=
  Rokhlin.Kernel.depMap_markov _ _ (measurable_rawMatchedLabel M Λ hk hm hind a b)

lemma rawCounting_parameter_given_label (hk : 3 ≤ Fintype.card I)
    (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)))
    (hS : ∀ᵐ p ∂M.parameterLaw 1, ∀ i, {q | (p,q) ∈ rawLineGraph M Λ i} =
      {q | (tupleParameter M p i,q) ∈ S})
    (E : BorelFibreEnumeration S)
    (Eπ : BorelFibreEnumeration (exactCodeSet (M.ownKernel 0) Λ (tupleParameter M))) (a : I) :
    HasCondDistrib Prod.fst (rawLabelSlot M a)
      ((M.parameterCoordinateKernel a).comap (Prod.fst : RawLabel M → Arr I M.U 0)
        (@measurable_fst (Arr I M.U 0) (HilbertCode (M.ownKernel 0)) _ inferInstance))
      (Eπ.measure (M.parameterLaw 1)) := by
  have he : ∀ᵐ p ∂M.parameterLaw 1, ∃ e :
      {q : I → HilbertCode (M.ownKernel 0) //
        (p,q) ∈ exactCodeSet (M.ownKernel 0) Λ (tupleParameter M)} ≃
      {q : HilbertCode (M.ownKernel 0) // (tupleParameter M p a,q) ∈ S},
      ∀ z, (e z).val = z.val a := by
    filter_upwards [hS] with p hp
    exact ⟨exactFibreSlotEquiv (M.ownKernel 0) Λ (tupleParameter M) hk hm hind S p a
      (hp a),fun _ => rfl⟩
  have hη : HasCondDistrib id (fun p => tupleParameter M p a)
      (M.parameterCoordinateKernel a) (M.parameterLaw 1) :=
    ⟨((measurable_plane _ _ _).prodMk measurable_id).aemeasurable,
      (compProd_map_condDistrib (by fun_prop) measurable_id.aemeasurable).symm⟩
  exact Eπ.parameter_conditional_of_fibrewise E (M.parameterLaw 1) (M.parameterLaw 0)
    (fun p => tupleParameter M p a)
    ⟨measurable_plane _ _ _,M.parameterLaw_consistent _ _ _⟩
    (fun x => x.2 a) ((measurable_pi_apply a).comp measurable_snd) he
    (M.parameterCoordinateKernel a) hη

lemma rawCounting_label_transition (hk : 3 ≤ Fintype.card I)
    (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)))
    (hS : ∀ᵐ p ∂M.parameterLaw 1, ∀ i, {q | (p,q) ∈ rawLineGraph M Λ i} =
      {q | (tupleParameter M p i,q) ∈ S})
    (E : BorelFibreEnumeration S)
    (Eπ : BorelFibreEnumeration (exactCodeSet (M.ownKernel 0) Λ (tupleParameter M))) (a b : I) :
    HasCondDistrib (rawLabelSlot M b) (rawLabelSlot M a) (rawLabelTransition M Λ a b)
      (Eπ.measure (M.parameterLaw 1)) := by
  have h := ConditionalTransport.map_observation
    (rawCounting_parameter_given_label M Λ hk hm hind S hS E Eπ a)
    (rawMatchedLabel M Λ a b) (measurable_rawMatchedLabel M Λ hk hm hind a b)
  change HasLaw _ _ _ at h ⊢
  apply h.congr
  filter_upwards [Eπ.ae_mem (M.parameterLaw 1)] with v hv
  refine Prod.ext (by rfl) ?_
  refine Prod.ext (by rfl) ?_
  dsimp only [rawLabelSlot,rawMatchedLabel]
  rw [exactMatching_exact (M.ownKernel 0) Λ (tupleParameter M)
    (measurable_tupleParameter M) hk hm hind a hv]
end ArrayObjects.Object.Rolled

namespace BorelFibreEnumeration
open MeasureTheory ProbabilityTheory Set
open scoped ENNReal
variable {P Q U Z : Type*} [MeasurableSpace Q] [MeasurableSpace P] [StandardBorelSpace P]
  [MeasurableSpace U] [StandardBorelSpace U] [MeasurableSpace Z] [StandardBorelSpace Z]
  {S : Set (U × Z)} (E : BorelFibreEnumeration S)

lemma observation_conditional (μ : Measure P) [SigmaFinite μ] (ν : Measure U) [SigmaFinite ν]
    (t : P → U) (ht : MeasurePreserving t μ ν)
    (o : P → Q) (ho : Measurable o) (η : Kernel U Q) [IsMarkovKernel η] (hη : HasCondDistrib o t η μ) :
    HasCondDistrib (fun x : P × Z => o x.1) (fun x : P × Z => (t x.1,x.2))
      (η.comap (Prod.fst : U × Z → U) (@measurable_fst U Z _ ‹MeasurableSpace Z›)) ((E.comapBase t ht.measurable).measure μ) := by
  have hobs := E.comapBase_preserving μ ν t ht
  refine ⟨(hobs.measurable.prodMk (ho.comp measurable_fst)).aemeasurable,?_⟩
  rw [hobs.map_eq]
  apply Measure.ext_of_lintegral
  intro F hF
  have hjoint : Measurable (fun x : P × Z => ((t x.1,x.2),o x.1)) :=
    hobs.measurable.prodMk (ho.comp measurable_fst)
  rw [lintegral_map hF hjoint]
  have hleft := (E.comapBase t ht.measurable).lintegral_measure μ
    (fun x : P × Z => F ((t x.1,x.2),o x.1)) (hF.comp (hobs.measurable.prodMk (ho.comp measurable_fst)))
  rw [hleft]
  rw [Measure.lintegral_compProd hF]
  have hg : Measurable (fun x : U × Z => ∫⁻ p, F (x,p) ∂η x.1) :=
    Measurable.lintegral_kernel_prod_right (f := fun x p => F (x,p)) hF (κ := η.comap (Prod.fst : U × Z → U) measurable_fst)
  simp only [Kernel.comap_apply]
  rw [E.lintegral_measure ν _ hg]
  let H : U × Q → ℝ≥0∞ := fun up => ∑' n, (E.domain n).indicator
    (fun u => F ((u,E.section_ n u),up.2)) up.1
  have hH : Measurable H := by
    apply Measurable.tsum
    intro n
    exact ((hF.comp ((measurable_fst.prodMk ((E.measurable_section n).comp measurable_fst)).prodMk
      measurable_snd)).indicator ((E.measurable_domain n).preimage measurable_fst))
  have hpair : MeasurePreserving (fun p => (t p,o p)) μ (ν ⊗ₘ η) :=
    ⟨ht.measurable.prodMk ho,by simpa only [ht.map_eq] using hη.map_eq⟩
  have he := hpair.lintegral_comp hH
  rw [Measure.lintegral_compProd hH] at he
  change (∫⁻ p, H (t p,o p) ∂μ) = _
  rw [he]
  apply lintegral_congr
  intro u
  dsimp only [H]
  rw [lintegral_tsum]
  · apply tsum_congr
    intro n
    symm
    exact lintegral_indicator_kernel (η u) (E.domain n) u (fun p => F ((u,E.section_ n u),p))
  · intro n
    by_cases hu : u ∈ E.domain n
    · have hf : Measurable (fun p : Q => F ((u,E.section_ n u),p)) :=
        hF.comp (measurable_const.prodMk measurable_id)
      convert hf.aemeasurable using 1
      ext p
      exact Set.indicator_of_mem hu _
    · simp only [Set.indicator_of_notMem hu]
      exact measurable_const.aemeasurable
end BorelFibreEnumeration

section
open MeasureTheory ProbabilityTheory Set
namespace BorelFibreEnumeration
variable {P Q U Z W : Type*} [MeasurableSpace Q] [MeasurableSpace P] [StandardBorelSpace P]
  [MeasurableSpace U] [StandardBorelSpace U] [MeasurableSpace Z] [StandardBorelSpace Z]
  [MeasurableSpace W] [StandardBorelSpace W]
  {S : Set (P × Z)} (E : BorelFibreEnumeration S)
  {R : Set (U × W)} (D : BorelFibreEnumeration R)

include D in
lemma observation_conditional_of_fibrewise
    (μ : Measure P) [SigmaFinite μ] (ν : Measure U) [SigmaFinite ν]
    (t : P → U) (ht : MeasurePreserving t μ ν)
    (f : P × Z → W) (hf : Measurable f)
    (he : ∀ᵐ p ∂μ, ∃ e : {z : Z // (p,z) ∈ S} ≃ {w : W // (t p,w) ∈ R},
      ∀ z, (e z).val = f (p,z.val))
    (o : P → Q) (ho : Measurable o) (η : Kernel U Q) [IsMarkovKernel η] (hη : HasCondDistrib o t η μ) :
    HasCondDistrib (fun x : P × Z => o x.1) (fun x : P × Z => (t x.1,f x))
      (η.comap (Prod.fst : U × W → U) (@measurable_fst U W _ ‹MeasurableSpace W›))
      (E.measure μ) := by
  have hobs : MeasurePreserving (fun x : P × Z => (x.1,f x)) (E.measure μ)
      ((D.comapBase t ht.measurable).measure μ) :=
    E.measurePreserving_fibrewise (D.comapBase t ht.measurable) μ μ id
      (MeasurePreserving.id μ) f hf he
  have hp := D.comapBase_preserving μ ν t ht
  have hc := D.observation_conditional μ ν t ht o ho η hη
  change HasLaw _ _ _ at hc ⊢
  rw [hp.map_eq] at hc
  have hout : MeasurePreserving (fun x : P × Z => (t x.1,f x)) (E.measure μ) (D.measure ν) :=
    hp.comp hobs
  rw [hout.map_eq]
  exact hc.comp hobs.hasLaw
end BorelFibreEnumeration

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)
    (Λ : Kernel (Arr I M.U 1) (I → Arr I M.Y 0)) [IsMarkovKernel Λ]
abbrev RawLabelSquare := Arr I M.U 2 × (I → I → HilbertCode (M.ownKernel 0))
def rawLabelRow (a : I) (x : RawLabelSquare M) : RawLabelTuple M := (plane 1 0 a x.1,x.2 a)
omit [DecidableEq I] in
lemma measurable_rawLabelRow (a : I) : Measurable (rawLabelRow M a) :=
  ((measurable_plane _ _ _).comp measurable_fst).prodMk
    ((measurable_pi_apply a).comp measurable_snd)

def rawLabelColumn (s : I) (x : RawLabelSquare M) : RawLabelTuple M :=
  (plane 1 (Fin.last 1) s x.1,fun a => x.2 a s)
omit [DecidableEq I] in
lemma measurable_rawLabelColumn (s : I) : Measurable (rawLabelColumn M s) :=
  ((measurable_plane _ _ _).comp measurable_fst).prodMk
    (Measurable.of_eval fun a => (measurable_pi_apply s).comp
      ((measurable_pi_apply a).comp measurable_snd))

lemma rawCounting_parameter_pair_given_row (hM : M.IsSaturated) (hk : 3 ≤ Fintype.card I)
    (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)))
    (hS : ∀ᵐ p ∂M.parameterLaw 1, ∀ i, {q | (p,q) ∈ rawLineGraph M Λ i} =
      {q | (tupleParameter M p i,q) ∈ S})
    (Eπ : BorelFibreEnumeration (exactCodeSet (M.ownKernel 0) Λ (tupleParameter M)))
    (Eσ : BorelFibreEnumeration (rawExactSquare M Λ)) (a s t : I) (hst : s ≠ t) :
    HasCondDistrib (fun x : RawLabelSquare M =>
      (plane 1 (Fin.last 1) s x.1,plane 1 (Fin.last 1) t x.1))
      (rawLabelRow M a)
      (((M.parameterCoordinateKernel a).comap (plane 0 0 s) (measurable_plane _ _ _) ×ₖ
        (M.parameterCoordinateKernel a).comap (plane 0 0 t) (measurable_plane _ _ _)).comap
          (Prod.fst : RawLabelTuple M → Arr I M.U 1)
          (@measurable_fst (Arr I M.U 1) (I → HilbertCode (M.ownKernel 0)) _ inferInstance)) (Eσ.measure (M.parameterLaw 2)) := by
  have he := (rawSquare_row_completion M Λ hM hk hL hm S hS).mono
    (fun e he => rawSquare_row_bijective M Λ hk hm hind e a (he a))
  exact Eσ.observation_conditional_of_fibrewise Eπ _ _ (plane 1 0 a)
    ⟨measurable_plane _ _ _,M.parameterLaw_consistent _ _ _⟩
    (fun x => x.2 a) ((measurable_pi_apply a).comp measurable_snd) he
    (fun e => (plane 1 (Fin.last 1) s e,plane 1 (Fin.last 1) t e))
    ((measurable_plane _ _ _).prodMk (measurable_plane _ _ _)) _
    (parameter_pair_geometry M hM hk a s t hst)

lemma rawCounting_target_pair_given_row (hM : M.IsSaturated) (hk : 3 ≤ Fintype.card I)
    (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)))
    (hS : ∀ᵐ p ∂M.parameterLaw 1, ∀ i, {q | (p,q) ∈ rawLineGraph M Λ i} =
      {q | (tupleParameter M p i,q) ∈ S})
    (Eπ : BorelFibreEnumeration (exactCodeSet (M.ownKernel 0) Λ (tupleParameter M)))
    (Eσ : BorelFibreEnumeration (rawExactSquare M Λ)) (a b s t : I) (hst : s ≠ t) :
    HasCondDistrib (fun x : RawLabelSquare M =>
      (rawLabelSlot M s (rawLabelRow M b x),rawLabelSlot M t (rawLabelRow M b x)))
      (rawLabelRow M a)
      ((rawLabelTransition M Λ a b).comap (rawLabelSlot M s) (measurable_rawLabelSlot M s) ×ₖ
       (rawLabelTransition M Λ a b).comap (rawLabelSlot M t) (measurable_rawLabelSlot M t))
      (Eσ.measure (M.parameterLaw 2)) := by
  let κ := (M.parameterCoordinateKernel a).comap (Prod.fst : RawLabel M → Arr I M.U 0)
    (@measurable_fst (Arr I M.U 0) (HilbertCode (M.ownKernel 0)) _ inferInstance)
  let fs : RawLabelTuple M × Arr I M.U 1 → RawLabel M :=
    fun x => rawMatchedLabel M Λ a b (rawLabelSlot M s x.1,x.2)
  let ft : RawLabelTuple M × Arr I M.U 1 → RawLabel M :=
    fun x => rawMatchedLabel M Λ a b (rawLabelSlot M t x.1,x.2)
  have hfs : Measurable fs := (measurable_rawMatchedLabel M Λ hk hm hind a b).comp
    (((measurable_rawLabelSlot M s).comp measurable_fst).prodMk measurable_snd)
  have hft : Measurable ft := (measurable_rawMatchedLabel M Λ hk hm hind a b).comp
    (((measurable_rawLabelSlot M t).comp measurable_fst).prodMk measurable_snd)
  have hpair : Measurable (fun x : RawLabelTuple M × (Arr I M.U 1 × Arr I M.U 1) =>
      (fs (x.1,x.2.1),ft (x.1,x.2.2))) :=
    (hfs.comp (measurable_fst.prodMk measurable_snd.fst)).prodMk
      (hft.comp (measurable_fst.prodMk measurable_snd.snd))
  have hbase := rawCounting_parameter_pair_given_row M Λ hM hk hL hm hind S hS Eπ Eσ a s t hst
  have hker : (((M.parameterCoordinateKernel a).comap (plane 0 0 s) (measurable_plane _ _ _) ×ₖ
        (M.parameterCoordinateKernel a).comap (plane 0 0 t) (measurable_plane _ _ _)).comap
          (Prod.fst : RawLabelTuple M → Arr I M.U 1)
            (@measurable_fst (Arr I M.U 1) (I → HilbertCode (M.ownKernel 0)) _ inferInstance)) =
      κ.comap (rawLabelSlot M s) (measurable_rawLabelSlot M s) ×ₖ
      κ.comap (rawLabelSlot M t) (measurable_rawLabelSlot M t) := by
    ext x : 1
    simp only [Kernel.comap_apply,Kernel.prod_apply,κ,rawLabelSlot,tupleParameter]
  rw [hker] at hbase
  have h := ConditionalTransport.map_observation hbase _ hpair
  change HasCondDistrib _ _ (Rokhlin.Kernel.depMap _ _) _ at h
  rw [Rokhlin.Kernel.depMap_prod _ _ hfs hft] at h
  have hs := Rokhlin.Kernel.depMap_comap κ
    (measurable_rawMatchedLabel M Λ hk hm hind a b) (rawLabelSlot M s) (measurable_rawLabelSlot M s)
  have ht := Rokhlin.Kernel.depMap_comap κ
    (measurable_rawMatchedLabel M Λ hk hm hind a b) (rawLabelSlot M t) (measurable_rawLabelSlot M t)
  change (rawLabelTransition M Λ a b).comap _ _ = Rokhlin.Kernel.depMap _ fs at hs
  change (rawLabelTransition M Λ a b).comap _ _ = Rokhlin.Kernel.depMap _ ft at ht
  rw [←hs,←ht] at h
  change HasLaw _ _ _ at h ⊢
  apply h.congr
  filter_upwards [Eσ.ae_mem (M.parameterLaw 2)] with x hx
  refine Prod.ext (by rfl) ?_
  dsimp only [fs,ft,rawMatchedLabel,rawLabelSlot,rawLabelRow]
  rw [exactMatching_exact (M.ownKernel 0) Λ (tupleParameter M)
      (measurable_tupleParameter M) hk hm hind a (hx.2 s),
    exactMatching_exact (M.ownKernel 0) Λ (tupleParameter M)
      (measurable_tupleParameter M) hk hm hind a (hx.2 t)]
  rw [parameter_cell_commute M b s x.1,parameter_cell_commute M b t x.1]
end ArrayObjects.Object.Rolled
end

namespace SigmaFiniteConditional
open MeasureTheory ProbabilityTheory
variable {Ω A B : Type*} [mΩ : MeasurableSpace Ω] [MeasurableSpace A] [MeasurableSpace B]
  {μ : Measure Ω} [SigmaFinite μ] {x : Ω → A} {y : Ω → B}
  {κ : Kernel A B} [IsMarkovKernel κ]

omit [SigmaFinite μ] in
lemma sigmaFinite_trim (hx : Measurable x) [hσ : SigmaFinite (μ.map x)] :
    SigmaFinite (μ.trim hx.comap_le) := by
  rw [←map_trim_comap hx] at hσ
  exact SigmaFinite.of_map _ (Measurable.of_comap_le (le_refl _)).aemeasurable hσ

lemma condExp_of_kernel (hx : Measurable x) [SigmaFinite (μ.map x)]
    (h : HasCondDistrib y x κ μ) (g : B → ℂ) (hg : StronglyMeasurable g)
    (hgi : Integrable (fun ω => g (y ω)) μ) :
    μ[(fun ω => g (y ω)) | MeasurableSpace.comap x inferInstance] =ᵐ[μ]
      (fun ω => ∫ b, g b ∂κ (x ω)) := by
  let := sigmaFinite_trim (μ := μ) hx
  have hm : StronglyMeasurable (fun a => ∫ b, g b ∂κ a) := hg.integral_kernel
  have hj : Integrable (fun ab : A × B => g ab.2) ((μ.map x) ⊗ₘ κ) := by
    rw [←h.map_eq]
    exact (integrable_map_measure (hg.comp_measurable measurable_snd).aestronglyMeasurable
      h.aemeasurable).mpr hgi
  have hi : Integrable (fun a => ∫ b, g b ∂κ a) (μ.map x) := by
    exact hj.integral_compProd
  have hix : Integrable (fun ω => ∫ b, g b ∂κ (x ω)) μ :=
    (integrable_map_measure hm.aestronglyMeasurable hx.aemeasurable).mp hi
  symm
  apply ae_eq_condExp_of_forall_setIntegral_eq hx.comap_le hgi
    (fun _ _ _ => hix.integrableOn) _
    ((hm.comp_measurable (Measurable.of_comap_le le_rfl)).aestronglyMeasurable)
  rintro _ ⟨s,hs,rfl⟩ _
  rw [←setIntegral_map hs hm.aestronglyMeasurable hx.aemeasurable]
  have he := Measure.setIntegral_compProd hs MeasurableSet.univ hj.integrableOn
  simp only [Measure.restrict_univ] at he
  rw [←he,←h.map_eq]
  have hgm : AEStronglyMeasurable (fun ab : A × B => g ab.2)
      (μ.map (fun ω => (x ω,y ω))) := (hg.comp_measurable measurable_snd).aestronglyMeasurable
  rw [setIntegral_map (hs.prod MeasurableSet.univ) hgm h.aemeasurable]
  have hset : (fun ω => (x ω,y ω)) ⁻¹' (s ×ˢ Set.univ) = x ⁻¹' s := by
    ext ω
    simp
  rw [hset]
end SigmaFiniteConditional

namespace JoiningOperator
open MeasureTheory ProbabilityTheory ContinuousLinearMap
open scoped InnerProductSpace ENNReal


section
variable {Ω X Y Z : Type*} [MeasurableSpace Ω] [MeasurableSpace X]
  [MeasurableSpace Y] [MeasurableSpace Z]
  {μ : Measure Ω} [SigmaFinite μ] {ν : Measure X} [SigmaFinite ν]
  {ρ : Measure Y} {τ : Measure Z} [SigmaFinite τ]
  {x : Ω → X} {y : Ω → Y} {z : X → Z}

omit [SigmaFinite μ] in
lemma operator_ae_eq_condExp_integrable
    (hx : MeasurePreserving x μ ν) (hy : MeasurePreserving y μ ρ)
    (g : Lp ℂ 2 ρ) (hgi : Integrable (g : Y → ℂ) ρ) :
    (fun ω => operator hx hy g (x ω)) =ᵐ[μ]
      μ[(fun ω => g (y ω)) | MeasurableSpace.comap x inferInstance] := by
  have hσ : SigmaFinite (μ.map x) := by rw [hx.map_eq]; infer_instance
  let := SigmaFiniteConditional.sigmaFinite_trim (μ := μ) hx.measurable
  have hp := pull_adjoint_projection hx (pull hy g)
  have hi : Integrable (pull hy g : Ω → ℂ) μ :=
    ((hy.integrable_comp g.1.stronglyMeasurable.aestronglyMeasurable).mpr hgi).congr (Lp.coeFn_compMeasurePreserving g hy).symm
  have hc := (Lp.memLp (pull hy g)).condExpL2_ae_eq_condExp' (𝕜 := ℂ) hx.measurable.comap_le hi
  rw [Lp.toLp_coeFn, ←hp] at hc
  exact (Lp.coeFn_compMeasurePreserving (operator hx hy g) hx).symm.trans
    (hc.trans (condExp_congr_ae (Lp.coeFn_compMeasurePreserving g hy)))

lemma screened_operator_integrable
    (hx : MeasurePreserving x μ ν) (hy : MeasurePreserving y μ ρ)
    (hz : MeasurePreserving z ν τ) {κ : Kernel Z Y} [IsMarkovKernel κ]
    (h : HasCondDistrib y x (κ.comap z hz.measurable) μ)
    (g : Lp ℂ 2 ρ) (hgi : Integrable (g : Y → ℂ) ρ) :
    operator hx hy g = (pull hz ∘L operator (hz.comp hx) hy) g := by
  have hσx : SigmaFinite (μ.map x) := by rw [hx.map_eq]; infer_instance
  have hσz : SigmaFinite (μ.map (z ∘ x)) := by rw [(hz.comp hx).map_eq]; infer_instance
  apply (Lp.compMeasurePreservingₗᵢ ℂ x hx).injective
  change pull hx (operator hx hy g) = (pull hx ∘L pull hz) (operator (hz.comp hx) hy g)
  rw [←pull_comp]
  apply Lp.ext
  have hi : Integrable (fun ω => g (y ω)) μ := (hy.integrable_comp g.1.stronglyMeasurable.aestronglyMeasurable).mpr hgi
  have hce := (SigmaFiniteConditional.condExp_of_kernel hx.measurable h g
    g.1.stronglyMeasurable hi).trans
    (SigmaFiniteConditional.condExp_of_kernel (hz.measurable.comp hx.measurable)
      h.comp_right g g.1.stronglyMeasurable hi).symm
  exact (Lp.coeFn_compMeasurePreserving _ hx).trans
    ((operator_ae_eq_condExp_integrable hx hy g hgi).trans
      (hce.trans ((operator_ae_eq_condExp_integrable (hz.comp hx) hy g hgi).symm.trans
        (Lp.coeFn_compMeasurePreserving _ (hz.comp hx)).symm)))

theorem screened_operator_sigmaFinite
    (hx : MeasurePreserving x μ ν) (hy : MeasurePreserving y μ ρ)
    (hz : MeasurePreserving z ν τ) {κ : Kernel Z Y} [IsMarkovKernel κ]
    (h : HasCondDistrib y x (κ.comap z hz.measurable) μ) :
    operator hx hy = pull hz ∘L operator (hz.comp hx) hy := by
  apply ContinuousLinearMap.ext
  apply Lp.induction (by norm_num : (2 : ℝ≥0∞) ≠ ∞)
    (fun g => operator hx hy g = (pull hz ∘L operator (hz.comp hx) hy) g)
  · intro c s hs hμs
    apply screened_operator_integrable hx hy hz h
    change Integrable (indicatorConstLp 2 hs hμs.ne c : Y → ℂ) ρ
    apply Integrable.congr _ (indicatorConstLp_coeFn (p := 2) (hs := hs) (hμs := hμs.ne) (c := c)).symm
    exact (integrable_indicator_iff hs).mpr (integrableOn_const (C := c) hμs.ne)
  · intro f g hf hg hfg hF hG
    simp only [map_add,hF,hG]
  · exact isClosed_eq (operator hx hy).continuous
      (pull hz ∘L operator (hz.comp hx) hy).continuous
end
section

variable {Ω R X Y : Type*} [MeasurableSpace Ω] [MeasurableSpace R]
  [MeasurableSpace X] [MeasurableSpace Y]
  {μ : Measure Ω} [SigmaFinite μ] {σ : Measure R} [SigmaFinite σ]
  {ν : Measure X} {ρ : Measure Y}
  {r : Ω → R} {x : Ω → X} {y : Ω → Y}
  {κ : Kernel R X} {η : Kernel R Y} [IsMarkovKernel κ] [IsMarkovKernel η]

lemma product_operator_inner_integrable
    (hr : MeasurePreserving r μ σ) (hx : MeasurePreserving x μ ν)
    (hy : MeasurePreserving y μ ρ) (h : HasCondDistrib (fun ω => (x ω,y ω)) r (κ ×ₖ η) μ)
    (f : Lp ℂ 2 ν) (g : Lp ℂ 2 ρ)
    (hfi : Integrable (f : X → ℂ) ν) (hgi : Integrable (g : Y → ℂ) ρ) :
    inner ℂ f (operator hx hy g) =
      inner ℂ (operator hr hx f) (operator hr hy g) := by
  have hσ : SigmaFinite (μ.map r) := by rw [hr.map_eq]; infer_instance
  have hf : HasCondDistrib x r κ μ := by simpa using h.fst
  have hg : HasCondDistrib y r η μ := by simpa using h.snd
  have hfx : Integrable (fun ω => f (x ω)) μ :=
    (hx.integrable_comp f.1.stronglyMeasurable.aestronglyMeasurable).mpr hfi
  have hgy : Integrable (fun ω => g (y ω)) μ :=
    (hy.integrable_comp g.1.stronglyMeasurable.aestronglyMeasurable).mpr hgi
  have hef := (operator_ae_eq_condExp_integrable hr hx f hfi).trans
    (SigmaFiniteConditional.condExp_of_kernel hr.measurable hf f f.1.stronglyMeasurable hfx)
  have heg := (operator_ae_eq_condExp_integrable hr hy g hgi).trans
    (SigmaFiniteConditional.condExp_of_kernel hr.measurable hg g g.1.stronglyMeasurable hgy)
  let F : R × (X × Y) → ℂ := fun u => inner ℂ (f u.2.1) (g u.2.2)
  have hFm : StronglyMeasurable F :=
    (f.1.stronglyMeasurable.comp_measurable measurable_snd.fst).inner
      (g.1.stronglyMeasurable.comp_measurable measurable_snd.snd)
  have hi : Integrable (fun ω => inner ℂ (f (x ω)) (g (y ω))) μ := by
    apply (L2.integrable_inner (pull hx f) (pull hy g)).congr
    filter_upwards [Lp.coeFn_compMeasurePreserving f hx,Lp.coeFn_compMeasurePreserving g hy]
      with ω h1 h2
    change inner ℂ (Lp.compMeasurePreserving x hx f ω)
      (Lp.compMeasurePreserving y hy g ω) = _
    rw [h1,h2]
    rfl
  have hFi : Integrable F ((μ.map r) ⊗ₘ (κ ×ₖ η)) := by
    rw [←h.map_eq]
    exact (integrable_map_measure hFm.aestronglyMeasurable h.aemeasurable).mpr hi
  rw [inner_operator]
  calc
    (∫ ω, inner ℂ (f (x ω)) (g (y ω)) ∂μ) = ∫ u, F u ∂(μ.map r) ⊗ₘ (κ ×ₖ η) :=
      h.integral_comp hFm.aestronglyMeasurable
    _ = ∫ u, inner ℂ (∫ z, f z ∂κ u) (∫ z, g z ∂η u) ∂μ.map r := by
      rw [Measure.integral_compProd hFi]
      apply integral_congr_ae
      filter_upwards [] with u
      simp only [F,Kernel.prod_apply,RCLike.inner_apply]
      simp_rw [mul_comm (g _) _]
      rw [integral_prod_mul (μ := κ u) (ν := η u)
        (fun z => starRingEnd ℂ (f z)) (fun z => g z),integral_conj]
      exact mul_comm _ _
    _ = ∫ ω, inner ℂ (∫ z, f z ∂κ (r ω)) (∫ z, g z ∂η (r ω)) ∂μ := by
      apply integral_map hr.aemeasurable
      exact ((f.1.stronglyMeasurable.integral_kernel).inner
        (g.1.stronglyMeasurable.integral_kernel)).aestronglyMeasurable
    _ = ∫ ω, inner ℂ (operator hr hx f (r ω)) (operator hr hy g (r ω)) ∂μ := by
      apply integral_congr_ae
      filter_upwards [hef,heg] with ω h1 h2
      rw [h1,h2]
    _ = inner ℂ (operator hr hx f) (operator hr hy g) := by
      rw [L2.inner_def]
      exact hr.hasLaw.integral_comp (f := fun u =>
        inner ℂ (operator hr hx f u) (operator hr hy g u))
        (((operator hr hx f).1.stronglyMeasurable).inner (𝕜 := ℂ)
          (operator hr hy g).1.stronglyMeasurable).aestronglyMeasurable

lemma indicator_integrable {A : Type*} [MeasurableSpace A] (ζ : Measure A)
    (s : Set A) (hs : MeasurableSet s) (hζ : ζ s < ∞) (c : ℂ) :
    Integrable (indicatorConstLp 2 hs hζ.ne c : A → ℂ) ζ := by
  apply Integrable.congr _ (indicatorConstLp_coeFn (p := 2) (hs := hs) (hμs := hζ.ne) (c := c)).symm
  exact (integrable_indicator_iff hs).mpr (integrableOn_const (C := c) hζ.ne)

theorem product_operator
    (hr : MeasurePreserving r μ σ) (hx : MeasurePreserving x μ ν)
    (hy : MeasurePreserving y μ ρ) (h : HasCondDistrib (fun ω => (x ω,y ω)) r (κ ×ₖ η) μ) :
    operator hx hy = (operator hr hx).adjoint ∘L operator hr hy := by
  have htest (g : Lp ℂ 2 ρ) (hgi : Integrable (g : Y → ℂ) ρ) (f : Lp ℂ 2 ν) :
      inner ℂ f (operator hx hy g) = inner ℂ (operator hr hx f) (operator hr hy g) := by
    apply Lp.induction (by norm_num : (2 : ℝ≥0∞) ≠ ∞)
      (fun f => inner ℂ f (operator hx hy g) = inner ℂ (operator hr hx f) (operator hr hy g))
    · intro d t ht hν
      exact product_operator_inner_integrable hr hx hy h _ g (indicator_integrable ν t ht hν d) hgi
    · intro f₁ f₂ hf₁ hf₂ hfg h1 h2
      simp only [map_add,inner_add_left,h1,h2]
    · exact isClosed_eq (continuous_id.inner continuous_const)
        ((operator hr hx).continuous.inner continuous_const)
  have hi : ∀ (f : Lp ℂ 2 ν) (g : Lp ℂ 2 ρ),
      inner ℂ f (operator hx hy g) = inner ℂ (operator hr hx f) (operator hr hy g) := by
    intro f
    apply Lp.induction (by norm_num : (2 : ℝ≥0∞) ≠ ∞)
      (fun g => inner ℂ f (operator hx hy g) = inner ℂ (operator hr hx f) (operator hr hy g))
    · intro c s hs hρ
      exact htest _ (indicator_integrable ρ s hs hρ c) f
    · intro g₁ g₂ hg₁ hg₂ hfg h1 h2
      simp only [map_add,inner_add_right,h1,h2]
    · exact isClosed_eq (continuous_const.inner (operator hx hy).continuous)
        (continuous_const.inner (operator hr hy).continuous)
  apply ContinuousLinearMap.ext
  intro g
  apply ext_inner_left ℂ
  intro f
  rw [ContinuousLinearMap.comp_apply,adjoint_inner_right]
  exact hi f g

end

variable {Ω P Z I : Type*} [MeasurableSpace Ω] [MeasurableSpace P] [MeasurableSpace Z]
  {μ : Measure Ω} [SigmaFinite μ] {π : Measure P} [SigmaFinite π]
  {ξ : Measure Z} [SigmaFinite ξ]

lemma operator_congr {A B C : Type*} [MeasurableSpace A] [MeasurableSpace B] [MeasurableSpace C]
    {μ₁ : Measure A} {μ₂ : Measure B} {μ₃ : Measure C}
    {f f' : A → B} {g g' : A → C}
    (hf : MeasurePreserving f μ₁ μ₂) (hg : MeasurePreserving g μ₁ μ₃)
    (hf' : MeasurePreserving f' μ₁ μ₂) (hg' : MeasurePreserving g' μ₁ μ₃)
    (he : f = f') (he' : g = g') : operator hf hg = operator hf' hg' := by
  subst f'; subst g'; rfl

lemma square_operator (row col : I → Ω → P) (slot : I → P → Z)
    (hr : ∀ a, MeasurePreserving (row a) μ π)
    (hc : ∀ s, MeasurePreserving (col s) μ π)
    (hq : ∀ i, MeasurePreserving (slot i) π ξ)
    (hcomm : ∀ a s, slot s ∘ row a = slot a ∘ col s)
    (a b s t : I) (K : Kernel Z Z) [IsMarkovKernel K]
    (h : HasCondDistrib (fun ω => (slot s (row b ω),slot t (row b ω))) (row a)
      (K.comap (slot s) (hq s).measurable ×ₖ K.comap (slot t) (hq t).measurable) μ) :
    operator (hq s) (hq t) = (operator (hq a) (hq b)).adjoint ∘L
      operator (hq s) (hq t) ∘L operator (hq a) (hq b) := by
  have hscreen (j : I)
      (hj : HasCondDistrib (slot j ∘ row b) (row a) (K.comap (slot j) (hq j).measurable) μ) :
      operator (hr a) ((hq j).comp (hr b)) = pull (hq j) ∘L operator (hq a) (hq b) := by
    rw [screened_operator_sigmaFinite (hr a) ((hq j).comp (hr b)) (hq j) hj]
    have hcol := operator_congr ((hq j).comp (hr a)) ((hq j).comp (hr b))
      ((hq a).comp (hc j)) ((hq b).comp (hc j)) (hcomm a j) (hcomm b j)
    rw [hcol,operator_pullback (hc j) (hq a) (hq b)]
  have hfst : HasCondDistrib (slot s ∘ row b) (row a) (K.comap (slot s) (hq s).measurable) μ :=
    by simpa only [Kernel.fst_prod, Function.comp_def] using h.fst
  have hsnd : HasCondDistrib (slot t ∘ row b) (row a) (K.comap (slot t) (hq t).measurable) μ :=
    by simpa only [Kernel.snd_prod, Function.comp_def] using h.snd
  have hp := product_operator (hr a) ((hq s).comp (hr b)) ((hq t).comp (hr b)) h
  rw [operator_pullback (hr b) (hq s) (hq t),hscreen s hfst,hscreen t hsnd] at hp
  apply hp.trans
  simp only [adjoint_comp,comp_assoc]
  rfl

end JoiningOperator

namespace ArrayObjects.Object.Rolled

open ContinuousLinearMap MeasureTheory ProbabilityTheory Set
open scoped InnerProductSpace

section RawLabelCells
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)
    (Λ : Kernel (Arr I M.U 1) (I → Arr I M.Y 0)) [IsMarkovKernel Λ]

omit [DecidableEq I] in
lemma rawLabel_cell_commute (a s : I) :
    rawLabelSlot M s ∘ rawLabelRow M a = rawLabelSlot M a ∘ rawLabelColumn M s := by
  funext x
  exact Prod.ext (parameter_cell_commute M a s x.1) rfl

lemma rawCounting_square_operator (hM : M.IsSaturated) (hk : 3 ≤ Fintype.card I)
    (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 (RawLabel M))
    (hS : ∀ᵐ p ∂M.parameterLaw 1, ∀ i, {q | (p,q) ∈ rawLineGraph M Λ i} =
      {q | (tupleParameter M p i,q) ∈ S})
    (E : BorelFibreEnumeration S)
    (Eπ : BorelFibreEnumeration (exactCodeSet (M.ownKernel 0) Λ (tupleParameter M)))
    (Eσ : BorelFibreEnumeration (rawExactSquare M Λ)) (a b s t : I) (hst : s ≠ t) :
    let hq := rawCounting_coordinate_preserving M Λ hk hm hind S hS E Eπ
    JoiningOperator.operator (hq s) (hq t) =
      (JoiningOperator.operator (hq a) (hq b)).adjoint ∘L
        JoiningOperator.operator (hq s) (hq t) ∘L
          JoiningOperator.operator (hq a) (hq b) := by
  let := rawLabelTransition_markov M Λ hk hm hind a b
  exact JoiningOperator.square_operator (rawLabelRow M) (rawLabelColumn M) (rawLabelSlot M)
    (rawCounting_rows_preserving M Λ hM hk hL hm hind S hS Eπ Eσ)
    (rawCounting_columns_preserving M Λ hM hk hL hm hind S hS Eπ Eσ)
    (rawCounting_coordinate_preserving M Λ hk hm hind S hS E Eπ)
    (rawLabel_cell_commute M) a b s t (rawLabelTransition M Λ a b)
    (rawCounting_target_pair_given_row M Λ hM hk hL hm hind S hS Eπ Eσ a b s t hst)
end RawLabelCells


universe u
variable {I : Type u} [Fintype I] [retained13 : DecidableEq I] {X : StandardSpace.{u}} {T : X ≃ᵐ X}
    {base : InitialLaws I X T} (M : Object I base)
    (Λ : Kernel (Arr I M.U 1) (I → Arr I M.Y 0)) [IsMarkovKernel Λ]

omit [DecidableEq I] in
lemma ownKernel_tuple_time_preserving : ∀ᵐ p ∂M.parameterLaw 1, ∀ i,
    MeasurePreserving (amap M.timeY 0) (M.ownKernel 0 (tupleParameter M p i))
      (M.ownKernel 0 (amap M.timeU 0 (tupleParameter M p i))) := by
  apply ae_all_iff.mpr
  intro i
  exact (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)

def rawLabelTime (z : RawLabel M) : RawLabel M :=
  (amap M.timeU 0 z.1,HilbertCode.transport (amap M.timeU 0) (amapEquiv M.timeY 0) z.2)
def rawLabelTimeInv (z : RawLabel M) : RawLabel M :=
  (amap M.timeU.symm 0 z.1,HilbertCode.transport (amap M.timeU.symm 0) (amapEquiv M.timeY.symm 0) z.2)
def rawLabelTupleTime (z : RawLabelTuple M) : RawLabelTuple M :=
  (amap M.timeU 1 z.1,fun i => HilbertCode.transport (amap M.timeU 0) (amapEquiv M.timeY 0) (z.2 i))

omit [DecidableEq I] in
lemma measurable_rawLabelTime : Measurable (rawLabelTime M) :=
  ((measurable_amap M.timeU.measurable 0).comp measurable_fst).prodMk
    ((HilbertCode.measurable_transport _ (measurable_amap M.timeU.measurable 0) _).comp measurable_snd)

omit [DecidableEq I] in
lemma measurable_rawLabelTimeInv : Measurable (rawLabelTimeInv M) :=
  ((measurable_amap M.timeU.symm.measurable 0).comp measurable_fst).prodMk
    ((HilbertCode.measurable_transport _ (measurable_amap M.timeU.symm.measurable 0) _).comp measurable_snd)

omit [DecidableEq I] in
lemma measurable_rawLabelTupleTime : Measurable (rawLabelTupleTime M) :=
  ((measurable_amap M.timeU.measurable 1).comp measurable_fst).prodMk
    (Measurable.of_eval fun i => (HilbertCode.measurable_transport _
      (measurable_amap M.timeU.measurable 0) _).comp ((measurable_pi_apply i).comp measurable_snd))

omit [DecidableEq I] in
lemma localGraph_time_equiv (i : I)
    (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)))
    (S : Set (RawLabel M))
    (hS : ∀ᵐ p ∂M.parameterLaw 1, ∀ i, {q | (p,q) ∈ rawLineGraph M Λ i} =
      {q | (tupleParameter M p i,q) ∈ S}) :
    ∀ᵐ u ∂M.parameterLaw 0,
      ∃ e : {q // (u,q) ∈ S} ≃ {q // (amap M.timeU 0 u,q) ∈ S},
        ∀ q, (e q).val = HilbertCode.transport (amap M.timeU 0) (amapEquiv M.timeY 0) q.val := by
  have hp : ∀ᵐ p ∂M.parameterLaw 1,
      ∃ e : {q // (tupleParameter M p i,q) ∈ S} ≃
        {q // (amap M.timeU 0 (tupleParameter M p i),q) ∈ S},
        ∀ q, (e q).val = HilbertCode.transport (amap M.timeU 0) (amapEquiv M.timeY 0) q.val := by
    filter_upwards [ownKernel_tuple_time_preserving M,goodTuple_time_preserving M Λ hL,hS,
      (M.parameterLaw_invariant 1).quasiMeasurePreserving.ae hS] with p hk hΛ h1 h2
    refine ⟨localGraphTimeEquiv (M.ownKernel 0) Λ (tupleParameter M) (amapEquiv M.timeU 0)
      (amapEquiv M.timeY 0) p (amap M.timeU 1 p) (tupleParameter_time M p) hk hΛ hm S i ?_ ?_,fun _ => rfl⟩
    · intro q
      exact (Set.ext_iff.mp (h1 i) q).symm
    · intro q
      exact (Set.ext_iff.mp (h2 i) q).symm
  have hd := ae_map_descent (P := fun u =>
    ∃ e : {q // (u,q) ∈ S} ≃ {q // (amap M.timeU 0 u,q) ∈ S},
      ∀ q, (e q).val = HilbertCode.transport (amap M.timeU 0) (amapEquiv M.timeY 0) q.val)
    (M.parameterLaw 1) (measurable_plane 0 0 i) hp
  rwa [M.parameterLaw_consistent 0 0 i] at hd

include retained13 in
lemma rawCounting_time_preserving (i : I)
    (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)))
    (S : Set (RawLabel M))
    (hS : ∀ᵐ p ∂M.parameterLaw 1, ∀ i, {q | (p,q) ∈ rawLineGraph M Λ i} =
      {q | (tupleParameter M p i,q) ∈ S}) (E : BorelFibreEnumeration S) :
    MeasurePreserving (rawLabelTime M) (E.measure (M.parameterLaw 0)) (E.measure (M.parameterLaw 0)) := by
  let _ := retained13
  apply E.measurePreserving_fibrewise E _ _ (amap M.timeU 0) (M.parameterLaw_invariant 0)
    (fun z => HilbertCode.transport (amap M.timeU 0) (amapEquiv M.timeY 0) z.2)
    ((HilbertCode.measurable_transport _ (measurable_amap M.timeU.measurable 0) _).comp measurable_snd)
  exact localGraph_time_equiv M Λ i hL hm S hS

omit [DecidableEq I] in
lemma rawTupleCounting_time_preserving
    (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π : BorelFibreEnumeration (exactCodeSet (M.ownKernel 0) Λ (tupleParameter M))) :
    MeasurePreserving (rawLabelTupleTime M) (Eπ.measure (M.parameterLaw 1)) (Eπ.measure (M.parameterLaw 1)) := by
  apply Eπ.measurePreserving_fibrewise Eπ _ _ (amap M.timeU 1) (M.parameterLaw_invariant 1)
    (fun z i => HilbertCode.transport (amap M.timeU 0) (amapEquiv M.timeY 0) (z.2 i))
    (Measurable.of_eval fun i => (HilbertCode.measurable_transport _
      (measurable_amap M.timeU.measurable 0) _).comp ((measurable_pi_apply i).comp measurable_snd))
  filter_upwards [ownKernel_tuple_time_preserving M,goodTuple_time_preserving M Λ hL] with p hk hΛ
  exact ⟨exactCodeEquivTransport (M.ownKernel 0) Λ (tupleParameter M) (amapEquiv M.timeU 0)
    (amapEquiv M.timeY 0) p (amap M.timeU 1 p) (tupleParameter_time M p) hk hΛ (hm p)
    (hm (amap M.timeU 1 p)),fun _ => rfl⟩
end ArrayObjects.Object.Rolled

section
open MeasureTheory ContinuousLinearMap
variable {Z : Type*} [MeasurableSpace Z] (ξ : Measure Z)
  (τ σ : Z → Z) (hτ : MeasurePreserving τ ξ ξ) (hσ : MeasurePreserving σ ξ ξ)

lemma lp_time_inverse (hστ : ∀ᵐ z ∂ξ, σ (τ z) = z) (v : Lp ℂ 2 ξ) :
    Lp.compMeasurePreservingₗᵢ ℂ τ hτ (Lp.compMeasurePreservingₗᵢ ℂ σ hσ v) = v := by
  apply Lp.ext
  filter_upwards [Lp.coeFn_compMeasurePreserving (Lp.compMeasurePreservingₗᵢ ℂ σ hσ v) hτ,
    hτ.quasiMeasurePreserving.ae (Lp.coeFn_compMeasurePreserving v hσ),hστ] with z h1 h2 h3
  exact h1.trans (h2.trans (congrArg (fun x => v x) h3))

def aeLpTime (hστ : ∀ᵐ z ∂ξ, σ (τ z) = z) : Lp ℂ 2 ξ ≃ₗᵢ[ℂ] Lp ℂ 2 ξ :=
  LinearIsometryEquiv.ofSurjective (Lp.compMeasurePreservingₗᵢ ℂ τ hτ)
    (fun v => ⟨Lp.compMeasurePreservingₗᵢ ℂ σ hσ v,lp_time_inverse ξ τ σ hτ hσ hστ v⟩)

lemma aeLpTime_coe (hστ : ∀ᵐ z ∂ξ, σ (τ z) = z) (v : Lp ℂ 2 ξ) :
    (aeLpTime ξ τ σ hτ hσ hστ v : Z → ℂ) =ᵐ[ξ] (fun z => v (τ z)) :=
  Lp.coeFn_compMeasurePreserving v hτ

include hτ in
omit hσ in
lemma inverse_measurePreserving (hσm : Measurable σ) (hστ : ∀ᵐ z ∂ξ, σ (τ z) = z) :
    MeasurePreserving σ ξ ξ := by
  refine ⟨hσm,?_⟩
  calc
    ξ.map σ = (ξ.map τ).map σ := congrArg (Measure.map σ) hτ.map_eq.symm
    _ = ξ.map (σ ∘ τ) := Measure.map_map hσm hτ.measurable
    _ = ξ.map id := Measure.map_congr hστ
    _ = ξ := Measure.map_id
end

namespace ArrayObjects.Object.Rolled
open MeasureTheory ProbabilityTheory Set
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)
    (Λ : Kernel (Arr I M.U 1) (I → Arr I M.Y 0)) [IsMarkovKernel Λ]

omit [DecidableEq I] [IsMarkovKernel Λ] in
lemma localGraph_code_properties (i : I) (S : Set (RawLabel M))
    (hS : ∀ᵐ p ∂M.parameterLaw 1, ∀ i, {q | (p,q) ∈ rawLineGraph M Λ i} =
      {q | (tupleParameter M p i,q) ∈ S}) :
    ∀ᵐ u ∂M.parameterLaw 0, ∀ q, (u,q) ∈ S →
      q.base = u ∧ q.IsCanonical ∧ q.IsUnimodular := by
  have hp : ∀ᵐ p ∂M.parameterLaw 1, ∀ q, (tupleParameter M p i,q) ∈ S →
      q.base = tupleParameter M p i ∧ q.IsCanonical ∧ q.IsUnimodular := by
    filter_upwards [hS] with p hp
    intro q hq
    have he : (p,q) ∈ rawLineGraph M Λ i := (Set.ext_iff.mp (hp i) q).mpr hq
    obtain ⟨a,ha,hq⟩ := he
    change a i = q at hq
    rw [←hq]
    exact ⟨ha.1 i,ha.2.1 i⟩
  have hd := ae_map_descent (P := fun u => ∀ q, (u,q) ∈ S →
    q.base = u ∧ q.IsCanonical ∧ q.IsUnimodular) (M.parameterLaw 1)
    (measurable_plane 0 0 i) hp
  rwa [M.parameterLaw_consistent 0 0 i] at hd

omit [DecidableEq I] [IsMarkovKernel Λ] in
lemma rawLabelTime_left_inverse (i : I) (S : Set (RawLabel M))
    (hS : ∀ᵐ p ∂M.parameterLaw 1, ∀ i, {q | (p,q) ∈ rawLineGraph M Λ i} =
      {q | (tupleParameter M p i,q) ∈ S}) (E : BorelFibreEnumeration S) :
    ∀ᵐ z ∂E.measure (M.parameterLaw 0), rawLabelTimeInv M (rawLabelTime M z) = z := by
  filter_upwards [E.ae_mem (M.parameterLaw 0),
    E.ae_base (M.parameterLaw 0) (localGraph_code_properties M Λ i S hS),
    E.ae_base (M.parameterLaw 0) (M.ownKernel_time_preserving 0)] with z hz hq htime
  obtain ⟨hb,hc,hu⟩ := hq z.2 hz
  apply Prod.ext
  · exact (amapEquiv M.timeU 0).symm_apply_apply z.1
  · exact HilbertCode.transport_inverse (amapEquiv M.timeU 0)
      (amapEquiv M.timeY 0) z.2 hu hc (by rw [hb]; exact htime)
end ArrayObjects.Object.Rolled

namespace JoiningOperator
open MeasureTheory ContinuousLinearMap
variable {W Z : Type*} [MeasurableSpace W] [MeasurableSpace Z]
  (ρ : Measure W) (ξ : Measure Z) (x y : W → Z)
  (hx : MeasurePreserving x ρ ξ) (hy : MeasurePreserving y ρ ξ)
  (τ : Z → Z) (hτ : MeasurePreserving τ ξ ξ)
  (t : W → W) (ht : MeasurePreserving t ρ ρ)

include ht in
lemma operator_time_conjugate (hxt : x ∘ t = τ ∘ x) (hyt : y ∘ t = τ ∘ y) :
    (pull hτ).adjoint ∘L operator hx hy ∘L pull hτ = operator hx hy := by
  have he : operator (hτ.comp hx) (hτ.comp hy) = operator (hx.comp ht) (hy.comp ht) := by
    exact operator_congr _ _ _ _ hxt.symm hyt.symm
  rw [operator,pull_comp hx hτ,pull_comp hy hτ,adjoint_comp] at he
  simpa only [operator,comp_assoc] using he.trans (operator_pullback ht hx hy)

include ht in
lemma operator_commutes_time (hxt : x ∘ t = τ ∘ x) (hyt : y ∘ t = τ ∘ y)
    (V : Lp ℂ 2 ξ ≃ₗᵢ[ℂ] Lp ℂ 2 ξ) (hV : (V : Lp ℂ 2 ξ →L[ℂ] Lp ℂ 2 ξ) = pull hτ) :
    ∀ v, V (operator hx hy v) = operator hx hy (V v) := by
  have he := operator_time_conjugate ρ ξ x y hx hy τ hτ t ht hxt hyt
  rw [←hV,V.adjoint_eq_symm] at he
  intro v
  have hh := congrArg (fun A : Lp ℂ 2 ξ →L[ℂ] Lp ℂ 2 ξ => V (A v)) he
  change V (V.symm (operator hx hy (V v))) = V (operator hx hy v) at hh
  rw [V.apply_symm_apply] at hh
  exact hh.symm
end JoiningOperator

section

open ContinuousLinearMap
open scoped InnerProductSpace

section

theorem partial_unitary_algebra {A : Type*} [Monoid A] [StarMul A]
    (a : A) (h₁ : a = star a * a * a) (h₂ : a = a * a * star a) :
    star a * a = a * star a ∧ IsStarProjection (star a * a) := by
  have hn : star a * a = a * star a := calc
    star a * a = star a * (a * a * star a) := congrArg (star a * ·) h₂
    _ = (star a * a * a) * star a := by simp only [mul_assoc]
    _ = a * star a := congrArg (· * star a) h₁.symm
  refine ⟨hn, ?_⟩
  apply IsStarProjection.mk
  · change (star a * a) * (star a * a) = star a * a
    calc
      (star a * a) * (star a * a) = (star a * a) * (a * star a) := by rw [hn]
      _ = ((star a * a) * a) * star a := by simp only [mul_assoc]
      _ = a * star a := by rw [← h₁]
      _ = star a * a := hn.symm
  · simp only [IsSelfAdjoint, star_mul, star_star]

variable {H : Type*} [NormedAddCommGroup H]
  [InnerProductSpace ℂ H] [CompleteSpace H]

theorem partial_unitary_range (M : H →L[ℂ] H)
    (h₁ : M = M.adjoint * M * M) (h₂ : M = M * M * M.adjoint) :
    (M.adjoint * M).range = M.range := by
  have hn := (partial_unitary_algebra M h₁ h₂).1
  apply le_antisymm
  · rintro v ⟨w, rfl⟩
    refine ⟨M.adjoint w, ?_⟩
    have hh := congrArg (fun A : H →L[ℂ] H => A w) hn
    exact hh.symm
  · rintro v ⟨w, rfl⟩
    refine ⟨M w, ?_⟩
    exact (congrArg (fun A : H →L[ℂ] H => A w) h₁).symm

theorem partial_unitary_range_adjoint (M : H →L[ℂ] H)
    (h₁ : M = M.adjoint * M * M) (h₂ : M = M * M * M.adjoint) :
    M.range = M.adjoint.range := by
  have ha₁ : M.adjoint = M * M.adjoint * M.adjoint := by
    change star M = M * star M * star M
    have hh := congrArg star h₂
    simpa only [← star_eq_adjoint, star_mul, star_star, mul_assoc] using hh
  have ha₂ : M.adjoint = M.adjoint * M.adjoint * M := by
    change star M = star M * star M * M
    have hh := congrArg star h₁
    simpa only [← star_eq_adjoint, star_mul, star_star, mul_assoc] using hh
  rw [← partial_unitary_range M h₁ h₂,
    ← partial_unitary_range M.adjoint (by simpa using ha₁) (by simpa using ha₂),
    adjoint_adjoint]
  exact congrArg (fun A : H →L[ℂ] H => A.range) (partial_unitary_algebra M h₁ h₂).1

theorem partial_unitary_norm_on_range (M : H →L[ℂ] H)
    (h₁ : M = M.adjoint * M * M) (v : H) (hv : v ∈ M.range) :
    ‖M v‖ = ‖v‖ := by
  have hfix : (M.adjoint * M) v = v := by
    rcases hv with ⟨w, rfl⟩
    exact (congrArg (fun A : H →L[ℂ] H => A w) h₁).symm
  apply sq_eq_sq₀ (norm_nonneg _) (norm_nonneg _) |>.mp
  rw [← inner_self_eq_norm_sq (𝕜 := ℂ), ← inner_self_eq_norm_sq (𝕜 := ℂ)]
  rw [← adjoint_inner_right]
  exact congrArg (fun w => (inner ℂ v w).re) hfix
end

open MeasureTheory Filter

theorem countable_essential_image_of_countable_fibres
    {Z U C : Type*} [MeasurableSpace Z] [MeasurableSpace U]
    [MeasurableSpace C] [MeasurableEq C]
    (ξ : Measure Z) [SigmaFinite ξ] (ν : Measure U) [IsProbabilityMeasure ν]
    (ψ : Z → C) (hψ : Measurable ψ) (D : C ≃ᵐ C)
    (q : U → ℕ → C) (hq : ∀ n, Measurable (fun u => q u n))
    (hocc : ∀ᵐ z ∂ξ, ∀ᵐ u ∂ν, ∃ n, D (ψ z) = q u n) :
    ∃ S : Set C, S.Countable ∧ ∀ᵐ z ∂ξ, ψ z ∈ S := by
  have hm : MeasurableSet {zu : Z × U | ∃ n, D (ψ zu.1) = q zu.2 n} := by
    simp_rw [Set.ofPred_exists]
    apply MeasurableSet.iUnion
    intro n
    exact measurableSet_eq_fun (D.measurable.comp (hψ.comp measurable_fst))
      ((hq n).comp measurable_snd)
  obtain ⟨u, hu⟩ := ((MeasureTheory.Measure.ae_ae_comm hm).mp hocc).exists
  refine ⟨D.symm '' Set.range (q u), (Set.countable_range (q u)).image D.symm, ?_⟩
  filter_upwards [hu] with z hz
  obtain ⟨n, hn⟩ := hz
  exact ⟨q u n, ⟨n, rfl⟩, by rw [← hn, D.symm_apply_apply]⟩

variable {H J K : Type*}
  [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
  [NormedAddCommGroup J] [InnerProductSpace ℂ J]
  [NormedAddCommGroup K] [InnerProductSpace ℂ K] [CompleteSpace K]

theorem deterministic_transition_of_norm_eq
    (U : H →ₗᵢ[ℂ] K) (V : J →ₗᵢ[ℂ] K) (v : J)
    (hn : ‖(U.toContinuousLinearMap.adjoint ∘L V.toContinuousLinearMap) v‖ = ‖v‖) :
    U ((U.toContinuousLinearMap.adjoint ∘L V.toContinuousLinearMap) v) = V v := by
  let M := U.toContinuousLinearMap.adjoint ∘L V.toContinuousLinearMap
  have hi : inner ℂ (U (M v)) (V v) = inner ℂ (M v) (M v) := by
    change inner ℂ (U.toContinuousLinearMap (M v)) (V v) = _
    rw [← adjoint_inner_right]
    rfl
  have hz : ‖U (M v) - V v‖ ^ 2 = 0 := by
    rw [norm_sub_sq (𝕜 := ℂ), U.norm_map, V.norm_map, hi, inner_self_eq_norm_sq, hn]
    ring
  exact sub_eq_zero.mp (norm_eq_zero.mp (sq_eq_zero_iff.mp hz))
end

section
open ContinuousLinearMap
variable {H : Type*} [NormedAddCommGroup H]
  [InnerProductSpace ℂ H] [CompleteSpace H]

lemma partial_unitary_fixed (M : H →L[ℂ] H)
    (h₁ : M = M.adjoint * M * M) {v : H} (hv : v ∈ M.range) :
    M.adjoint (M v) = v := by
  obtain ⟨w,rfl⟩ := hv
  exact (congrArg (fun A : H →L[ℂ] H => A w) h₁).symm

lemma partial_unitary_fixed' (M : H →L[ℂ] H)
    (h₁ : M = M.adjoint * M * M) (h₂ : M = M * M * M.adjoint)
    {v : H} (hv : v ∈ M.range) : M (M.adjoint v) = v := by
  have hn := (partial_unitary_algebra M h₁ h₂).1
  have hh := congrArg (fun A : H →L[ℂ] H => A v) hn
  exact hh.symm.trans (partial_unitary_fixed M h₁ hv)

lemma partial_unitary_closed_range (M : H →L[ℂ] H)
    (h₁ : M = M.adjoint * M * M) (h₂ : M = M * M * M.adjoint) :
    IsClosed (M.range : Set H) := by
  have he : (M.range : Set H) = {v | M (M.adjoint v) = v} := by
    ext v
    exact ⟨fun hv => partial_unitary_fixed' M h₁ h₂ hv,fun hv => ⟨M.adjoint v,hv⟩⟩
  rw [he]
  exact isClosed_eq (M.continuous.comp M.adjoint.continuous) continuous_id

def partialUnitary (M : H →L[ℂ] H)
    (h₁ : M = M.adjoint * M * M) (h₂ : M = M * M * M.adjoint) :
    M.range ≃ₗᵢ[ℂ] M.range where
  toFun v := ⟨M v,⟨v,rfl⟩⟩
  invFun v := ⟨M.adjoint v,by exact (partial_unitary_range_adjoint M h₁ h₂).ge ⟨v,rfl⟩⟩
  map_add' v w := Subtype.ext (M.map_add _ _)
  map_smul' c v := Subtype.ext (M.map_smul _ _)
  left_inv v := Subtype.ext (partial_unitary_fixed M h₁ v.property)
  right_inv v := Subtype.ext (partial_unitary_fixed' M h₁ h₂ v.property)
  norm_map' v := partial_unitary_norm_on_range M h₁ v.val v.property

def commutingRangeUnitary (M : H →L[ℂ] H) (V : H ≃ₗᵢ[ℂ] H)
    (hV : ∀ v, V (M v) = M (V v)) : M.range ≃ₗᵢ[ℂ] M.range where
  toFun v := ⟨V v,by obtain ⟨w,hw⟩ := v.property; exact ⟨V w,by change M (V w) = V v; exact (hV w).symm.trans (congrArg V hw)⟩⟩
  invFun v := ⟨V.symm v,by
    obtain ⟨w,hw⟩ := v.property
    refine ⟨V.symm w,?_⟩
    apply V.injective
    change V (M (V.symm w)) = V (V.symm v)
    rw [hV,V.apply_symm_apply,V.apply_symm_apply]
    exact hw⟩
  map_add' v w := Subtype.ext (V.map_add _ _)
  map_smul' c v := Subtype.ext (V.map_smul _ _)
  left_inv v := Subtype.ext (V.symm_apply_apply v)
  right_inv v := Subtype.ext (V.apply_symm_apply v)
  norm_map' v := V.norm_map v

lemma partialUnitary_commutingRange (M : H →L[ℂ] H)
    (h₁ : M = M.adjoint * M * M) (h₂ : M = M * M * M.adjoint)
    (V : H ≃ₗᵢ[ℂ] H) (hV : ∀ v, V (M v) = M (V v)) :
    Commute (partialUnitary M h₁ h₂) (commutingRangeUnitary M V hV) := by
  apply LinearIsometryEquiv.ext
  intro v
  apply Subtype.ext
  exact (hV v).symm
end

section
open MeasureTheory
abbrev LabelOrbitVector := (ℤ × ℤ) → ℂ

def labelShiftFirst : LabelOrbitVector ≃ᵐ LabelOrbitVector where
  toFun c p := c (p.1+1,p.2)
  invFun c p := c (p.1-1,p.2)
  left_inv c := by funext p; simp
  right_inv c := by funext p; simp
  measurable_toFun := Measurable.of_eval fun p => measurable_pi_apply _
  measurable_invFun := Measurable.of_eval fun p => measurable_pi_apply _

def labelShiftSecond : LabelOrbitVector ≃ᵐ LabelOrbitVector where
  toFun c p := c (p.1,p.2+1)
  invFun c p := c (p.1,p.2-1)
  left_inv c := by funext p; simp
  right_inv c := by funext p; simp
  measurable_toFun := Measurable.of_eval fun p => measurable_pi_apply _
  measurable_invFun := Measurable.of_eval fun p => measurable_pi_apply _

variable {Z H : Type*} [MeasurableSpace Z] (ξ : Measure Z)
  [NormedAddCommGroup H] [InnerProductSpace ℂ H]
  (U : H →ₗᵢ[ℂ] Lp ℂ 2 ξ) (D S : H ≃ₗᵢ[ℂ] H) (v : H)

def labelOrbitLP (p : ℤ × ℤ) : Lp ℂ 2 ξ := U ((D ^ p.1) ((S ^ p.2) v))
def labelOrbit (z : Z) : LabelOrbitVector := fun p => labelOrbitLP ξ U D S v p z
lemma measurable_labelOrbit : Measurable (labelOrbit ξ U D S v) :=
  Measurable.of_eval fun p => (Lp.stronglyMeasurable (labelOrbitLP ξ U D S v p)).measurable

lemma labelOrbitLP_first (p : ℤ × ℤ) :
    labelOrbitLP ξ U D S v (p.1+1,p.2) = U (D ((D ^ p.1) ((S ^ p.2) v))) := by
  unfold labelOrbitLP
  rw [show p.1+1 = 1+p.1 by omega,zpow_add,zpow_one]
  rfl

lemma labelOrbitLP_second (hDS : Commute D S) (p : ℤ × ℤ) :
    labelOrbitLP ξ U D S v (p.1,p.2+1) = U (S ((D ^ p.1) ((S ^ p.2) v))) := by
  unfold labelOrbitLP
  rw [show p.2+1 = 1+p.2 by omega,zpow_add,zpow_one]
  have h := (hDS.zpow_left p.1).eq
  exact congrArg U (congrArg (fun e : H ≃ₗᵢ[ℂ] H => e ((S ^ p.2) v)) h)

variable {W : Type*} [MeasurableSpace W] (ρ : Measure W)
  (source target : W → Z)
lemma labelOrbit_transition
    (hdet : ∀ w : H, ∀ᵐ x ∂ρ, U w (target x) = U (D w) (source x)) :
    ∀ᵐ x ∂ρ, labelOrbit ξ U D S v (target x) =
      labelShiftFirst (labelOrbit ξ U D S v (source x)) := by
  have ha (p : ℤ × ℤ) := hdet ((D ^ p.1) ((S ^ p.2) v))
  filter_upwards [ae_all_iff.mpr ha] with x hx
  funext p
  change labelOrbitLP ξ U D S v p (target x) = labelOrbitLP ξ U D S v (p.1+1,p.2) (source x)
  rw [labelOrbitLP_first]
  exact hx p

lemma labelOrbit_time (hDS : Commute D S) (τ : Z → Z)
    (htime : ∀ w : H, ∀ᵐ z ∂ξ, U w (τ z) = U (S w) z) :
    ∀ᵐ z ∂ξ, labelOrbit ξ U D S v (τ z) =
      labelShiftSecond (labelOrbit ξ U D S v z) := by
  have ha (p : ℤ × ℤ) := htime ((D ^ p.1) ((S ^ p.2) v))
  filter_upwards [ae_all_iff.mpr ha] with z hz
  funext p
  change labelOrbitLP ξ U D S v p (τ z) = labelOrbitLP ξ U D S v (p.1,p.2+1) z
  rw [labelOrbitLP_second ξ U D S v hDS]
  exact hz p

lemma labelOrbit_zero : labelOrbitLP ξ U D S v (0,0) = U v := by
  simp [labelOrbitLP]
end

section
open MeasureTheory
open scoped ENNReal
variable {Z : Type*} [MeasurableSpace Z] (ξ : Measure Z) [SigmaFinite ξ]

lemma exists_positive_memLp_two : ∃ f : Z → ℝ,
    Measurable f ∧ (∀ z, 0 < f z ∧ f z ≤ 1) ∧ Integrable f ξ ∧ MemLp f 2 ξ := by
  obtain ⟨g,hg,hm,hi⟩ := exists_pos_lintegral_lt_of_sigmaFinite ξ (by simp : (1 : ℝ≥0∞) ≠ 0)
  let f : Z → ℝ := fun z => min (g z : ℝ) 1
  have hf : Measurable f := (measurable_coe_nnreal_real.comp hm).min measurable_const
  have hpos (z) : 0 < f z := lt_min (hg z) zero_lt_one
  have hle (z) : f z ≤ 1 := min_le_right _ _
  have hgint : Integrable (fun z => (g z : ℝ)) ξ := by
    have hh := integrable_toReal_of_lintegral_ne_top (hm.coe_nnreal_ennreal.aemeasurable) (ne_top_of_lt hi)
    simpa only [ENNReal.coe_toReal] using hh
  have hfi : Integrable f ξ := hgint.mono' hf.aestronglyMeasurable
    (Filter.Eventually.of_forall (fun z => by rw [Real.norm_eq_abs,abs_of_pos (hpos z)]; exact min_le_left _ _))
  refine ⟨f,hf,fun z => ⟨hpos z,hle z⟩,hfi,?_⟩
  apply (memLp_two_iff_integrable_sq_norm hf.aestronglyMeasurable).mpr
  apply hfi.mono' (hf.norm.pow_const 2).aestronglyMeasurable
  filter_upwards [] with z
  rw [Real.norm_eq_abs,abs_of_nonneg (sq_nonneg _),Real.norm_eq_abs,abs_of_pos (hpos z)]
  nlinarith [hpos z,hle z]
end

namespace JoiningOperator

open Set MeasureTheory ProbabilityTheory ContinuousLinearMap
open scoped ENNReal

section KernelRepresentatives
variable {W Z : Type*} [MeasurableSpace W] [MeasurableSpace Z]
  {ρ : Measure W} [SigmaFinite ρ] {ξ : Measure Z} [SigmaFinite ξ]
  {source target : W → Z}
  (hs : MeasurePreserving source ρ ξ) (ht : MeasurePreserving target ρ ξ)
  (K : Kernel Z Z) [IsMarkovKernel K]
  (hK : HasCondDistrib target source K ρ)

include hK in
lemma operator_integral_representative (g : Lp ℂ 2 ξ) (f : Z → ℂ)
    (hf : StronglyMeasurable f) (hfi : Integrable f ξ) (hg : (g : Z → ℂ) =ᵐ[ξ] f) :
    (operator hs ht g : Z → ℂ) =ᵐ[ξ] (fun z => ∫ y, f y ∂K z) := by
  have hσ : SigmaFinite (ρ.map source) := by rw [hs.map_eq]; infer_instance
  have hgi := hfi.congr hg.symm
  have he := operator_ae_eq_condExp_integrable hs ht g hgi
  have hx : (fun w => g (target w)) =ᵐ[ρ] (fun w => f (target w)) := ht.quasiMeasurePreserving.ae hg
  have hc := SigmaFiniteConditional.condExp_of_kernel hs.measurable hK f hf
    ((ht.integrable_comp hf.aestronglyMeasurable).mpr hfi)
  have he' := he.trans ((condExp_congr_ae hx).trans hc)
  have hd := (ae_map_iff hs.measurable.aemeasurable
    (measurableSet_eq_fun (Lp.stronglyMeasurable (operator hs ht g)).measurable
      hf.integral_kernel.measurable)).mpr he'
  rwa [hs.map_eq] at hd

include hs ht hK in
omit [SigmaFinite ρ] in
lemma kernel_integrable (f : Z → ℝ) (hf : Measurable f) (hfi : Integrable f ξ) :
    ∀ᵐ z ∂ξ, Integrable f (K z) := by
  have hj : Integrable (fun zy : Z × Z => f zy.2) (ξ ⊗ₘ K) := by
    rw [←hs.map_eq,←hK.map_eq]
    exact (integrable_map_measure (hf.comp measurable_snd).aestronglyMeasurable
      hK.aemeasurable).mpr ((ht.integrable_comp hf.aestronglyMeasurable).mpr hfi)
  exact hj.ae_of_compProd

include K hK in

lemma exists_positive_range_vector : ∃ v : Lp ℂ 2 ξ,
    v ∈ (operator hs ht).range ∧ ∀ᵐ z ∂ξ, 0 < (v z).re := by
  obtain ⟨f,hf,hpos,hfi,hflp⟩ := Rokhlin.exists_positive_memLp_two ξ
  have hfc : MemLp (fun z => (f z : ℂ)) 2 ξ := hflp.ofReal
  let g : Lp ℂ 2 ξ := hfc.toLp _
  refine ⟨operator hs ht g,⟨g,rfl⟩,?_⟩
  have he := operator_integral_representative hs ht K hK g (fun z => (f z : ℂ))
    (Complex.measurable_ofReal.comp hf).stronglyMeasurable hfi.ofReal hfc.coeFn_toLp
  filter_upwards [he,kernel_integrable hs ht K hK f hf hfi] with z hz hi
  rw [hz,integral_complex_ofReal]
  change 0 < ∫ y, f y ∂K z
  apply (integral_pos_iff_support_of_nonneg (fun y => (hpos y).1.le) hi).mpr
  have he : Function.support f = univ := by
    ext y
    simp only [Function.mem_support,mem_univ,iff_true]
    exact ne_of_gt (hpos y).1
  rw [he,measure_univ]
  exact zero_lt_one
end KernelRepresentatives


variable {W Z : Type*} [MeasurableSpace W] [MeasurableSpace Z]
  {ρ : Measure W} [SigmaFinite ρ] {ξ : Measure Z} [SigmaFinite ξ]
  {source target : W → Z}
  (hs : MeasurePreserving source ρ ξ) (ht : MeasurePreserving target ρ ξ)

omit [SigmaFinite ρ] [SigmaFinite ξ] in
lemma deterministic_on_range
    (h₁ : operator hs ht = (operator hs ht).adjoint * operator hs ht * operator hs ht)
    (v : (operator hs ht).range) :
    ∀ᵐ x ∂ρ, v.val (target x) = operator hs ht v.val (source x) := by
  let U : Lp ℂ 2 ξ →ₗᵢ[ℂ] Lp ℂ 2 ρ := Lp.compMeasurePreservingₗᵢ ℂ source hs
  let V : Lp ℂ 2 ξ →ₗᵢ[ℂ] Lp ℂ 2 ρ := Lp.compMeasurePreservingₗᵢ ℂ target ht
  have hn : ‖(U.toContinuousLinearMap.adjoint ∘L V.toContinuousLinearMap) v.val‖ = ‖v.val‖ :=
    partial_unitary_norm_on_range (operator hs ht) h₁ v.val v.property
  have he : U (operator hs ht v.val) = V v.val :=
    deterministic_transition_of_norm_eq U V v.val hn
  have h : (U (operator hs ht v.val) : W → ℂ) =ᵐ[ρ] (V v.val : W → ℂ) := Lp.ext_iff.mp he
  filter_upwards [h,Lp.coeFn_compMeasurePreserving (operator hs ht v.val) hs,
    Lp.coeFn_compMeasurePreserving v.val ht] with w hw h1 h2
  exact h2.symm.trans (hw.symm.trans h1)

lemma exists_orbit_vector
    (h₁ : operator hs ht = (operator hs ht).adjoint * operator hs ht * operator hs ht)
    (h₂ : operator hs ht = operator hs ht * operator hs ht * (operator hs ht).adjoint)
    (V : Lp ℂ 2 ξ ≃ₗᵢ[ℂ] Lp ℂ 2 ξ)
    (hV : ∀ v, V (operator hs ht v) = operator hs ht (V v))
    (τ : Z → Z) (htime : ∀ v : Lp ℂ 2 ξ, (V v : Z → ℂ) =ᵐ[ξ] fun z => v (τ z))
    (K : Kernel Z Z) [IsMarkovKernel K] (hK : HasCondDistrib target source K ρ) :
    ∃ (ψ : Z → LabelOrbitVector) (v : Lp ℂ 2 ξ),
      Measurable ψ ∧ (∀ z, ψ z (0,0) = v z) ∧
      (∀ᵐ z ∂ξ, 0 < (v z).re) ∧
      (∀ᵐ w ∂ρ, ψ (target w) = labelShiftFirst (ψ (source w))) ∧
      (∀ᵐ z ∂ξ, ψ (τ z) = labelShiftSecond (ψ z)) := by
  obtain ⟨v,hvr,hvp⟩ := exists_positive_range_vector hs ht K hK
  let vr : (operator hs ht).range := ⟨v,hvr⟩
  let U := (operator hs ht).range.subtypeₗᵢ
  let D := partialUnitary (operator hs ht) h₁ h₂
  let S := commutingRangeUnitary (operator hs ht) V hV
  have hDS : Commute D S := partialUnitary_commutingRange _ h₁ h₂ V hV
  refine ⟨labelOrbit ξ U D S vr,v,measurable_labelOrbit _ _ _ _ _,?_,hvp,?_,?_⟩
  · intro z
    exact congrArg (fun g : Lp ℂ 2 ξ => g z) (labelOrbit_zero ξ U D S vr)
  · exact labelOrbit_transition ξ U D S vr ρ source target (deterministic_on_range hs ht h₁)
  · exact labelOrbit_time ξ U D S vr hDS τ (fun w => (htime w.val).symm)
end JoiningOperator

namespace ArrayObjects.Object.Rolled
open MeasureTheory ProbabilityTheory Set
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 parameterLaw_proper (n : ℕ) (J : Finset I) (hJ : J ≠ Finset.univ) :
    (M.parameterLaw (n+1)).map (planes n J) = Measure.pi (fun _ : J => M.parameterLaw n) := by
  unfold Object.parameterLaw
  rw [Measure.map_map (measurable_planes _ _) (measurable_amap M.measurable_par _)]
  have he : planes n J ∘ amap M.par (n+1) =
      (fun z : J → Arr I M.Y n => fun j => amap M.par n (z j)) ∘ planes n J := rfl
  have hg : Measurable (fun z : J → Arr I M.Y n => fun j => amap M.par n (z j)) :=
    Measurable.of_eval fun j => (measurable_amap M.measurable_par n).comp (measurable_pi_apply j)
  rw [he,←Measure.map_map hg (measurable_planes n J),M.proper n J hJ,
    Measure.pi_map_pi (fun _ => (measurable_amap M.measurable_par n).aemeasurable)]

lemma parameter_pair_preserving (hk : 3 ≤ Fintype.card I) (s t : I) (hst : s ≠ t) :
    MeasurePreserving (fun p => (tupleParameter M p s,tupleParameter M p t))
      (M.parameterLaw 1) ((M.parameterLaw 0).prod (M.parameterLaw 0)) := by
  have hJ : ({s,t} : Finset I) ≠ Finset.univ := by
    intro h
    have hcard : ({s,t} : Finset I).card = 2 := by simp [hst]
    rw [h,Finset.card_univ] at hcard
    omega
  let s' : ({s,t} : Finset I) := ⟨s,by simp⟩
  let t' : ({s,t} : Finset I) := ⟨t,by simp⟩
  have hne : s' ≠ t' := fun h => hst (congrArg Subtype.val h)
  have hi : iIndepFun (fun i : ({s,t} : Finset I) => Function.eval i)
      (Measure.pi (fun _ : ({s,t} : Finset I) => M.parameterLaw 0)) :=
    iIndepFun_pi (fun _ => measurable_id.aemeasurable)
  have hp : MeasurePreserving (fun z : ({s,t} : Finset I) → Arr I M.U 0 => (z s',z t'))
      (Measure.pi (fun _ => M.parameterLaw 0)) ((M.parameterLaw 0).prod (M.parameterLaw 0)) := by
    refine ⟨(measurable_pi_apply _).prodMk (measurable_pi_apply _),?_⟩
    rw [(hi.indepFun hne).map_prod_eq_prod_map_map (measurable_pi_apply s').aemeasurable
      (measurable_pi_apply t').aemeasurable,
      (measurePreserving_eval (fun _ : ({s,t} : Finset I) => M.parameterLaw 0) s').map_eq,
      (measurePreserving_eval (fun _ : ({s,t} : Finset I) => M.parameterLaw 0) t').map_eq]
  exact hp.comp ⟨measurable_planes 0 {s,t},parameterLaw_proper M 0 {s,t} hJ⟩

variable (Λ : Kernel (Arr I M.U 1) (I → Arr I M.Y 0)) [IsMarkovKernel Λ]

lemma rawCounting_target_parameter_independent (hk : 3 ≤ Fintype.card I)
    (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 (RawLabel M))
    (hS : ∀ᵐ p ∂M.parameterLaw 1, ∀ i, {q | (p,q) ∈ rawLineGraph M Λ i} =
      {q | (tupleParameter M p i,q) ∈ S})
    (E : BorelFibreEnumeration S)
    (Eπ : BorelFibreEnumeration (exactCodeSet (M.ownKernel 0) Λ (tupleParameter M)))
    (s t : I) (hst : s ≠ t) :
    MeasurePreserving (fun z : RawLabelTuple M => (rawLabelSlot M s z,(rawLabelSlot M t z).1))
      (Eπ.measure (M.parameterLaw 1)) ((E.measure (M.parameterLaw 0)).prod (M.parameterLaw 0)) := by
  have he : ∀ᵐ p ∂M.parameterLaw 1, ∃ e :
      {q : I → HilbertCode (M.ownKernel 0) //
        (p,q) ∈ exactCodeSet (M.ownKernel 0) Λ (tupleParameter M)} ≃
      {q : HilbertCode (M.ownKernel 0) // (tupleParameter M p s,q) ∈ S},
      ∀ z, (e z).val = z.val s := by
    filter_upwards [hS] with p hp
    exact ⟨exactFibreSlotEquiv (M.ownKernel 0) Λ (tupleParameter M) hk hm hind S p s
      (hp s),fun _ => rfl⟩
  have hη : HasCondDistrib (fun p => tupleParameter M p t) (fun p => tupleParameter M p s)
      (Kernel.const (Arr I M.U 0) (M.parameterLaw 0)) (M.parameterLaw 1) := by
    refine ⟨((measurable_plane _ _ _).prodMk (measurable_plane _ _ _)).aemeasurable,?_⟩
    change (M.parameterLaw 1).map (fun p => (tupleParameter M p s,tupleParameter M p t)) =
      (M.parameterLaw 1).map (plane 0 0 s) ⊗ₘ Kernel.const _ (M.parameterLaw 0)
    rw [M.parameterLaw_consistent,Measure.compProd_const]
    exact (parameter_pair_preserving M hk s t hst).map_eq
  have hc := Eπ.observation_conditional_of_fibrewise E (M.parameterLaw 1) (M.parameterLaw 0)
    (fun p => tupleParameter M p s) ⟨measurable_plane _ _ _,M.parameterLaw_consistent _ _ _⟩
    (fun z => z.2 s) ((measurable_pi_apply s).comp measurable_snd) he
    (fun p => tupleParameter M p t) (measurable_plane _ _ _)
    (Kernel.const _ (M.parameterLaw 0)) hη
  refine ⟨(measurable_rawLabelSlot M s).prodMk (measurable_rawLabelSlot M t).fst,?_⟩
  have hh := hc.map_eq
  rw [(rawCounting_coordinate_preserving M Λ hk hm hind S hS E Eπ s).map_eq] at hh
  change (Eπ.measure (M.parameterLaw 1)).map (fun z => (rawLabelSlot M s z,(rawLabelSlot M t z).1)) =
    E.measure (M.parameterLaw 0) ⊗ₘ Kernel.const _ (M.parameterLaw 0) at hh
  rwa [Measure.compProd_const] at hh
end ArrayObjects.Object.Rolled

namespace BorelFibreEnumeration
open MeasureTheory Set
variable {U Z : Type*} [MeasurableSpace U] [StandardBorelSpace U]
  [MeasurableSpace Z] [StandardBorelSpace Z]
  {S : Set (U × Z)} (E : BorelFibreEnumeration S)

lemma ae_fibre_all (ν : Measure U) [SigmaFinite ν] {P : U × Z → Prop}
    (h : ∀ᵐ x ∂E.measure ν, P x) :
    ∀ᵐ u ∂ν, ∀ z, (u,z) ∈ S → P (u,z) := by
  rw [measure,E.measurableEmbedding_point.ae_map_iff] at h
  have hh : ∀ᵐ x ∂(ν.prod Measure.count).restrict E.indexDomain,
      P (x.1,E.section_ x.2 x.1) := by
    rw [←map_comap_subtype_coe E.measurable_indexDomain]
    exact (MeasurableEmbedding.subtype_coe E.measurable_indexDomain).ae_map_iff.mpr h
  have hprod := (ae_restrict_iff' E.measurable_indexDomain).mp hh
  have ha := Measure.ae_ae_of_ae_prod hprod
  filter_upwards [ha] with u hu
  have hon : ∀ n : ℕ, u ∈ E.domain n → P (u,E.section_ n u) := by
    simpa only [Measure.ae_count_iff,indexDomain,Set.mem_ofPred_eq] using hu
  intro z hz
  obtain ⟨n,hn,rfl⟩ := E.cover u z hz
  exact hon n hn
end BorelFibreEnumeration

section
open MeasureTheory Set
variable {U Z C W : Type*} [MeasurableSpace U] [StandardBorelSpace U]
  [MeasurableSpace Z] [StandardBorelSpace Z] [MeasurableSpace C] [MeasurableEq C]
  [MeasurableSpace W] {S : Set (U × Z)} (E : BorelFibreEnumeration S)
  (ν : Measure U) [IsProbabilityMeasure ν] (ρ : Measure W) [SigmaFinite ρ]
  (source target : W → U × Z)

omit [SigmaFinite ρ] in

lemma countable_orbit_image (ht : MeasurePreserving target ρ (E.measure ν))
    (hpp : MeasurePreserving (fun w => (source w,(target w).1)) ρ ((E.measure ν).prod ν))
    (ψ : U × Z → C) (hψ : Measurable ψ) (D : C ≃ᵐ C)
    (hD : ∀ᵐ w ∂ρ, ψ (target w) = D (ψ (source w))) :
    ∃ R : Set C, R.Countable ∧ ∀ᵐ z ∂E.measure ν, ψ z ∈ R := by
  let q : U → ℕ → C := fun u n => ψ (u,E.section_ n u)
  have hq (n : ℕ) : Measurable (fun u => q u n) :=
    hψ.comp (measurable_id.prodMk (E.measurable_section n))
  have hmeas : MeasurableSet {zu : (U × Z) × U | ∃ n, D (ψ zu.1) = q zu.2 n} := by
    simp_rw [Set.ofPred_exists]
    exact MeasurableSet.iUnion fun n => measurableSet_eq_fun
      (D.measurable.comp (hψ.comp measurable_fst)) ((hq n).comp measurable_snd)
  have hw : ∀ᵐ w ∂ρ, ∃ n, D (ψ (source w)) = q (target w).1 n := by
    filter_upwards [hD,ht.quasiMeasurePreserving.ae (E.ae_mem ν)] with w hw hm
    obtain ⟨n,_,hn⟩ := E.cover (target w).1 (target w).2 hm
    exact ⟨n,hw.symm.trans (congrArg ψ (Prod.ext rfl hn.symm))⟩
  have hp : ∀ᵐ zu ∂(E.measure ν).prod ν, ∃ n, D (ψ zu.1) = q zu.2 n := by
    rw [←hpp.map_eq]
    exact (ae_map_iff hpp.measurable.aemeasurable hmeas).mpr hw
  exact countable_essential_image_of_countable_fibres (E.measure ν) ν ψ hψ D q hq
    (Measure.ae_ae_of_ae_prod hp)
end

section
open MeasureTheory ProbabilityTheory Set ContinuousLinearMap
namespace JoiningOperator
lemma partial_unitary_of_squares_aux {H : Type*} [NormedAddCommGroup H]
    [InnerProductSpace ℂ H] [CompleteSpace H] (A B : H →L[ℂ] H)
    (hb : B = A.adjoint) (hb' : B.adjoint = A)
    (h1 : A = A.adjoint ∘L A ∘L A) (h2 : A = B.adjoint ∘L A ∘L B) :
    A = A.adjoint * A * A ∧ A = A * A * A.adjoint := by
  constructor
  · simpa only [ContinuousLinearMap.mul_def,ContinuousLinearMap.comp_assoc] using h1
  · rw [hb',hb] at h2
    simpa only [ContinuousLinearMap.mul_def,ContinuousLinearMap.comp_assoc] using h2

lemma partial_unitary_of_squares {Z W : Type*} [MeasurableSpace Z] [MeasurableSpace W]
    {μ : Measure W} {ν : Measure Z} {f g : W → Z}
    (hf : MeasurePreserving f μ ν) (hg : MeasurePreserving g μ ν)
    (h1 : operator hf hg = (operator hf hg).adjoint ∘L operator hf hg ∘L operator hf hg)
    (h2 : operator hf hg = (operator hg hf).adjoint ∘L operator hf hg ∘L operator hg hf) :
    operator hf hg = (operator hf hg).adjoint * operator hf hg * operator hf hg ∧
      operator hf hg = operator hf hg * operator hf hg * (operator hf hg).adjoint :=
  partial_unitary_of_squares_aux _ _ (operator_adjoint hf hg).symm
    (operator_adjoint hg hf) h1 h2
end JoiningOperator
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)
    (Λ : Kernel (Arr I M.U 1) (I → Arr I M.Y 0)) [IsMarkovKernel Λ]
    (hM : M.IsSaturated) (hk : 3 ≤ Fintype.card I)
    (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 (RawLabel M))
    (hS : ∀ᵐ p ∂M.parameterLaw 1, ∀ i, {q | (p,q) ∈ rawLineGraph M Λ i} =
      {q | (tupleParameter M p i,q) ∈ S})
    (E : BorelFibreEnumeration S)
    (Eπ : BorelFibreEnumeration (exactCodeSet (M.ownKernel 0) Λ (tupleParameter M)))
    (Eσ : BorelFibreEnumeration (rawExactSquare M Λ)) (s t : I) (hst : s ≠ t)

include hM hL Eσ hst in
lemma rawCounting_partial_unitary :
    let hq := rawCounting_coordinate_preserving M Λ hk hm hind S hS E Eπ
    let A := JoiningOperator.operator (hq s) (hq t)
    A = A.adjoint * A * A ∧ A = A * A * A.adjoint := by
  dsimp only
  exact JoiningOperator.partial_unitary_of_squares _ _
    (rawCounting_square_operator M Λ hM hk hL hm hind S hS E Eπ Eσ s t s t hst)
    (rawCounting_square_operator M Λ hM hk hL hm hind S hS E Eπ Eσ t s s t hst)

include hM hk hL hm hind hS Eσ hst in
lemma rawCounting_exists_orbit :
    ∃ (ψ : RawLabel M → LabelOrbitVector) (v : Lp ℂ 2 (E.measure (M.parameterLaw 0))),
      Measurable ψ ∧ (∀ z, ψ z (0,0) = v z) ∧
      (∀ᵐ z ∂E.measure (M.parameterLaw 0), 0 < (v z).re) ∧
      (∀ᵐ w ∂Eπ.measure (M.parameterLaw 1), ψ (rawLabelSlot M t w) = labelShiftFirst (ψ (rawLabelSlot M s w))) ∧
      (∀ᵐ z ∂E.measure (M.parameterLaw 0), ψ (rawLabelTime M z) = labelShiftSecond (ψ z)) ∧
      (∃ R : Set LabelOrbitVector, R.Countable ∧ ∀ᵐ z ∂E.measure (M.parameterLaw 0), ψ z ∈ R) := by
  let hq := rawCounting_coordinate_preserving M Λ hk hm hind S hS E Eπ
  have hτ := rawCounting_time_preserving M Λ s hL hm S hS E
  have hi := rawLabelTime_left_inverse M Λ s S hS E
  have hσ := inverse_measurePreserving (E.measure (M.parameterLaw 0)) (rawLabelTime M)
    (rawLabelTimeInv M) hτ (measurable_rawLabelTimeInv M) hi
  let V := aeLpTime _ _ _ hτ hσ hi
  have hV : ∀ v, V (JoiningOperator.operator (hq s) (hq t) v) =
      JoiningOperator.operator (hq s) (hq t) (V v) :=
    JoiningOperator.operator_commutes_time _ _ _ _ (hq s) (hq t) _ hτ _
      (rawTupleCounting_time_preserving M Λ hL hm Eπ) rfl rfl V rfl
  have hA := rawCounting_partial_unitary M Λ hM hk hL hm hind S hS E Eπ Eσ s t hst
  let := rawLabelTransition_markov M Λ hk hm hind s t
  obtain ⟨ψ,v,hψ,hzero,hpos,htr,htime⟩ := JoiningOperator.exists_orbit_vector (hq s) (hq t)
    hA.1 hA.2 V hV (rawLabelTime M) (aeLpTime_coe _ _ _ hτ hσ hi)
    (rawLabelTransition M Λ s t) (rawCounting_label_transition M Λ hk hm hind S hS E Eπ s t)
  refine ⟨ψ,v,hψ,hzero,hpos,htr,htime,?_⟩
  exact countable_orbit_image E (M.parameterLaw 0) (Eπ.measure (M.parameterLaw 1))
    (rawLabelSlot M s) (rawLabelSlot M t) (hq t)
    (rawCounting_target_parameter_independent M Λ hk hm hind S hS E Eπ s t hst)
    ψ hψ labelShiftFirst htr
end ArrayObjects.Object.Rolled
end

namespace BorelFibreEnumeration
open MeasureTheory Set
open scoped ENNReal
variable {U Z : Type*} [MeasurableSpace U] [StandardBorelSpace U]
  [MeasurableSpace Z] [StandardBorelSpace Z]
  {S : Set (U × Z)} (E : BorelFibreEnumeration S)

def restrictGraph (Q : Set (U × Z)) (hQ : MeasurableSet Q) : BorelFibreEnumeration (S ∩ Q) where
  domain n := {u | u ∈ E.domain n ∧ (u,E.section_ n u) ∈ Q}
  section_ := E.section_
  measurable_domain n := (E.measurable_domain n).inter ((measurable_id.prodMk (E.measurable_section n)) hQ)
  measurable_section := E.measurable_section
  mem n u hu := ⟨E.mem n u hu.1,hu.2⟩
  cover u z hz := by
    obtain ⟨n,hn,he⟩ := E.cover u z hz.1
    exact ⟨n,⟨hn,by rw [he]; exact hz.2⟩,he⟩
  unique u n m hn hm he := E.unique u n m hn.1 hm.1 he

lemma restrictGraph_mass (ν : Measure U) [SigmaFinite ν]
    (Q : Set (U × Z)) (hQ : MeasurableSet Q) :
    (E.restrictGraph Q hQ).measure ν univ = E.measure ν Q := by
  rw [←lintegral_one,←lintegral_indicator_one hQ]
  change (∫⁻ u, (1 : ℝ≥0∞) ∂(E.restrictGraph Q hQ).measure ν) =
    ∫⁻ a, Q.indicator (fun _ => (1 : ℝ≥0∞)) a ∂E.measure ν
  rw [(E.restrictGraph Q hQ).lintegral_measure ν (fun _ => 1) measurable_const,
    E.lintegral_measure ν (Q.indicator (fun _ => 1)) (measurable_const.indicator hQ)]
  apply lintegral_congr
  intro u
  apply tsum_congr
  intro n
  classical
  simp only [restrictGraph,indicator_apply,mem_ofPred]
  split_ifs <;> simp_all

lemma ae_finite_fibres (ν : Measure U) [SigmaFinite ν]
    (hν : E.measure ν univ < ∞) : ∀ᵐ u ∂ν, {z | (u,z) ∈ S}.Finite := by
  let g : U → ℝ≥0∞ := fun u => ∑' n, (E.domain n).indicator (fun _ => 1) u
  have hg : Measurable g := Measurable.tsum fun n => measurable_const.indicator (E.measurable_domain n)
  have hi : ∫⁻ u, g u ∂ν ≠ ∞ := by
    rw [←E.lintegral_measure ν (fun _ => 1) measurable_const,lintegral_one]
    exact hν.ne
  filter_upwards [ae_lt_top hg hi] with u hu
  have he : g u = Measure.count {n : ℕ | u ∈ E.domain n} := by
    rw [←lintegral_indicator_one (Set.to_countable _).measurableSet,lintegral_count]
    rfl
  rw [he,Measure.count_apply_lt_top] at hu
  have hr : {z | (u,z) ∈ S} = (fun n => E.section_ n u) '' {n | u ∈ E.domain n} := by
    ext z
    constructor
    · intro hz
      obtain ⟨n,hn,he⟩ := E.cover u z hz
      exact ⟨n,hn,he⟩
    · rintro ⟨n,hn,rfl⟩
      exact E.mem n u hn
  rw [hr]
  exact hu.image _

lemma ae_finite_level (ν : Measure U) [SigmaFinite ν]
    (Q : Set (U × Z)) (hQ : MeasurableSet Q) (hν : E.measure ν Q < ∞) :
    ∀ᵐ u ∂ν, {z | (u,z) ∈ S ∧ (u,z) ∈ Q}.Finite := by
  apply (E.restrictGraph Q hQ).ae_finite_fibres ν
  rw [E.restrictGraph_mass ν Q hQ]
  exact hν
end BorelFibreEnumeration

section
open MeasureTheory Set
open scoped ENNReal
variable {Z C W : Type*} [MeasurableSpace Z] [MeasurableSpace C]
  [MeasurableSingletonClass C] [MeasurableSpace W]
  (ξ : Measure Z) (ψ : Z → C)

def positiveLevels : Set C := {b | ξ {z | ψ z = b} ≠ 0}

omit [MeasurableSpace C] [MeasurableSingletonClass C] in
lemma positiveLevels_countable (S : Set C) (hSc : S.Countable)
    (hS : ∀ᵐ z ∂ξ, ψ z ∈ S) : (positiveLevels ξ ψ).Countable := by
  apply hSc.mono
  intro b hb
  by_contra hbS
  have he : ∀ᵐ z ∂ξ, ψ z ≠ b := hS.mono fun z hz he => hbS (he ▸ hz)
  have hz : ξ {z | ψ z = b} = 0 := by simpa only [ae_iff,not_not] using he
  exact hb hz

omit [MeasurableSpace C] [MeasurableSingletonClass C] in
lemma ae_mem_positiveLevels (S : Set C) (hSc : S.Countable)
    (hS : ∀ᵐ z ∂ξ, ψ z ∈ S) : ∀ᵐ z ∂ξ, ψ z ∈ positiveLevels ξ ψ := by
  let : Countable S := hSc.to_subtype
  have h (b : S) : ∀ᵐ z ∂ξ, ψ z = b.val → b.val ∈ positiveLevels ξ ψ := by
    by_cases hb : ξ {z | ψ z = b.val} = 0
    · have he : ∀ᵐ z ∂ξ, ψ z ≠ b.val := by simpa only [ae_iff,not_not] using hb
      exact he.mono fun _ hz he => False.elim (hz he)
    · exact Filter.Eventually.of_forall fun _ _ => hb
  filter_upwards [hS,ae_all_iff.mpr h] with z hz hb
  exact hb ⟨ψ z,hz⟩ rfl

omit [MeasurableSingletonClass C] in
lemma joining_transport_invariant (hψ : Measurable ψ) (ρ : Measure W)
    (source target : W → Z) (hs : MeasurePreserving source ρ ξ)
    (ht : MeasurePreserving target ρ ξ) (D : C ≃ᵐ C)
    (hD : (ψ ∘ target) =ᵐ[ρ] (D ∘ ψ ∘ source)) :
    MeasurePreserving D (ξ.map ψ) (ξ.map ψ) := by
  refine ⟨D.measurable,?_⟩
  rw [←hs.map_eq,Measure.map_map hψ hs.measurable,
    Measure.map_map D.measurable (hψ.comp hs.measurable),←Measure.map_congr hD,
    ←Measure.map_map hψ ht.measurable,ht.map_eq]
  rw [←Measure.map_map hψ hs.measurable,hs.map_eq]

lemma positiveLevel_mass_transport (hψ : Measurable ψ) (D : C ≃ᵐ C)
    (hD : MeasurePreserving D (ξ.map ψ) (ξ.map ψ)) (b : C) :
    ξ {z | ψ z = D b} = ξ {z | ψ z = b} := by
  have h := hD.measure_preimage (measurableSet_singleton (D b)).nullMeasurableSet
  have he : D ⁻¹' ({D b} : Set C) = {b} := by ext c; simp
  rw [he,Measure.map_apply hψ (measurableSet_singleton b),
    Measure.map_apply hψ (measurableSet_singleton (D b))] at h
  exact h.symm

def positiveLevelsEquiv (hψ : Measurable ψ) (D : C ≃ᵐ C)
    (hD : MeasurePreserving D (ξ.map ψ) (ξ.map ψ)) :
    positiveLevels ξ ψ ≃ positiveLevels ξ ψ where
  toFun b := ⟨D b,by
    change ξ {z | ψ z = D b.val} ≠ 0
    rw [positiveLevel_mass_transport ξ ψ hψ D hD]
    exact b.property⟩
  invFun b := ⟨D.symm b,by
    have h := positiveLevel_mass_transport ξ ψ hψ D hD (D.symm b)
    rw [D.apply_symm_apply] at h
    change ξ {z | ψ z = D.symm b.val} ≠ 0
    rw [←h]
    exact b.property⟩
  left_inv b := Subtype.ext (D.symm_apply_apply b)
  right_inv b := Subtype.ext (D.apply_symm_apply b)

omit [MeasurableSpace C] [MeasurableSingletonClass C] in

lemma finite_positive_level_mass (v : Lp ℂ 2 ξ) (c : C → ℂ)
    (hcoord : ∀ᵐ z ∂ξ, c (ψ z) = v z) (hpos : ∀ᵐ z ∂ξ, v z ≠ 0)
    (b : positiveLevels ξ ψ) : ξ {z | ψ z = b.val} < ∞ := by
  have hb : c b.val ≠ 0 := by
    intro hb
    have he : ∀ᵐ z ∂ξ, ψ z ≠ b.val := by
      filter_upwards [hcoord,hpos] with z hz hp he
      exact hp (hz.symm.trans ((congrArg c he).trans hb))
    exact b.property (by simpa only [ae_iff,not_not] using he)
  have hi : Integrable (fun z => ‖v z‖ ^ 2) ξ := (Lp.memLp v).integrable_norm_pow (by decide : 2 ≠ 0)
  have hbound := hi.measure_ge_lt_top (sq_pos_of_ne_zero (norm_ne_zero_iff.mpr hb))
  apply lt_of_le_of_lt _ hbound
  apply measure_mono_ae
  filter_upwards [hcoord] with z hz hzb
  change ‖c b.val‖ ^ 2 ≤ ‖v z‖ ^ 2
  rw [←hz,hzb]
end

open MeasureTheory ProbabilityTheory Set
open scoped ENNReal
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)
    (Λ : Kernel (Arr I M.U 1) (I → Arr I M.Y 0)) [IsMarkovKernel Λ]
    (hM : M.IsSaturated) (hk : 3 ≤ Fintype.card I)
    (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 (RawLabel M))
    (hS : ∀ᵐ p ∂M.parameterLaw 1, ∀ i, {q | (p,q) ∈ rawLineGraph M Λ i} =
      {q | (tupleParameter M p i,q) ∈ S})
    (E : BorelFibreEnumeration S)
    (Eπ : BorelFibreEnumeration (exactCodeSet (M.ownKernel 0) Λ (tupleParameter M)))
    (Eσ : BorelFibreEnumeration (rawExactSquare M Λ)) (s t : I) (hst : s ≠ t)

include hM hk hL hm hind hS Eπ Eσ hst in
lemma exists_raw_finite_levels :
    ∃ ψ : RawLabel M → LabelOrbitVector,
      Measurable ψ ∧
      (positiveLevels (E.measure (M.parameterLaw 0)) ψ).Countable ∧
      (∀ᵐ u ∂M.parameterLaw 0, ∀ q, (u,q) ∈ S →
        ψ (u,q) ∈ positiveLevels (E.measure (M.parameterLaw 0)) ψ) ∧
      (∀ b : positiveLevels (E.measure (M.parameterLaw 0)) ψ,
        E.measure (M.parameterLaw 0) {z | ψ z = b.val} < ∞) ∧
      (∀ᵐ u ∂M.parameterLaw 0, ∀ b : positiveLevels (E.measure (M.parameterLaw 0)) ψ,
        {q | (u,q) ∈ S ∧ ψ (u,q) = b.val}.Finite) ∧
      MeasurePreserving labelShiftFirst ((E.measure (M.parameterLaw 0)).map ψ)
        ((E.measure (M.parameterLaw 0)).map ψ) ∧
      MeasurePreserving labelShiftSecond ((E.measure (M.parameterLaw 0)).map ψ)
        ((E.measure (M.parameterLaw 0)).map ψ) ∧
      (∀ᵐ p ∂M.parameterLaw 1, ∀ a, (p,a) ∈ exactCodeSet (M.ownKernel 0) Λ (tupleParameter M) →
        ψ (tupleParameter M p t,a t) = labelShiftFirst (ψ (tupleParameter M p s,a s))) ∧
      (∀ᵐ u ∂M.parameterLaw 0, ∀ q, (u,q) ∈ S →
        ψ (rawLabelTime M (u,q)) = labelShiftSecond (ψ (u,q))) := by
  obtain ⟨ψ,v,hψ,hzero,hpos,htr,htime,R,hRc,hR⟩ :=
    rawCounting_exists_orbit M Λ hM hk hL hm hind S hS E Eπ Eσ s t hst
  have hBc := positiveLevels_countable (E.measure (M.parameterLaw 0)) ψ R hRc hR
  let : Countable (positiveLevels (E.measure (M.parameterLaw 0)) ψ) := hBc.to_subtype
  have hb (b : positiveLevels (E.measure (M.parameterLaw 0)) ψ) :
      E.measure (M.parameterLaw 0) {z | ψ z = b.val} < ∞ := by
    apply finite_positive_level_mass _ ψ v (fun c => c (0,0))
      (Filter.Eventually.of_forall hzero) _ b
    filter_upwards [hpos] with z hz
    intro he
    rw [he,Complex.zero_re] at hz
    exact lt_irrefl _ hz
  refine ⟨ψ,hψ,hBc,E.ae_fibre_all _ (ae_mem_positiveLevels _ ψ R hRc hR),hb,?_,?_,?_,
    Eπ.ae_fibre_all _ htr,E.ae_fibre_all _ htime⟩
  · apply ae_all_iff.mpr
    intro b
    exact E.ae_finite_level _ {z | ψ z = b.val} (measurableSet_eq_fun hψ measurable_const) (hb b)
  · exact joining_transport_invariant _ ψ hψ _ (rawLabelSlot M s) (rawLabelSlot M t)
      (rawCounting_coordinate_preserving M Λ hk hm hind S hS E Eπ s)
      (rawCounting_coordinate_preserving M Λ hk hm hind S hS E Eπ t) labelShiftFirst htr
  · exact joining_transport_invariant _ ψ hψ _ id (rawLabelTime M) (MeasurePreserving.id _)
      (rawCounting_time_preserving M Λ s hL hm S hS E) labelShiftSecond htime
end ArrayObjects.Object.Rolled

end Rokhlin

end

end OAI