Hugging Face's logo

Datasets:
roseking
/
openAI-math-dataset

Languages:
English
Chinese
Size:
100K<n<1M
Tags:
mathematics
mirror
lean
formal-proofs
License:
Dataset card Files
xet
 Community
openAI-math-dataset / lean /OAI /Dynamics /MultipleMixing /FibreMeasures.lean
roseking's picture
roseking
Add lean source and binary files (part 64)
92416a2 verified
Raw History Blame Contribute Delete
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