Download data/lean/OAI/Dynamics/MultipleMixing/FibreMeasures.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 125 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Dynamics/MultipleMixing/FibreMeasures.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Dynamics/MultipleMixing/FibreMeasures.lean
-
curl -L -o FibreMeasures.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Dynamics/MultipleMixing/FibreMeasures.lean
125 kB
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
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)