| import OAI.Probability.FreeIsing.Brownian.ArrayObservation |
| import OAI.Probability.FreeIsing.Conditioning.Naturality |
| import OAI.Probability.FreeIsing.Factors.CoordinateNaturality |
| import OAI.Probability.FreeIsing.Posterior.PlantedStationarity |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| open MeasureTheory |
| open scoped NNReal |
|
|
| namespace Problem367 |
|
|
| lemma measurable_arrayNaturalFiltration_of_intertwining |
| {ι Ω : Type*} [MeasurableSpace Ω] |
| (X : ι → ℝ≥0 → Ω → ℝ) (hmX : ∀ i t, Measurable (X i t)) |
| (T : Ω → Ω) (r : ι → ι) |
| (hT : ∀ i t ω, X i t (T ω) = X (r i) t ω) (t : ℝ≥0) : |
| Measurable[arrayNaturalFiltration X hmX t, |
| arrayNaturalFiltration X hmX t] T := by |
| rw [arrayNaturalFiltration_eq_comap] |
| apply measurable_comap_iff.mpr |
| have heq : (fun ω i (s : Set.Iic t) => X i s ω) ∘ T = |
| (fun x : ι → Set.Iic t → ℝ => fun i s => x (r i) s) ∘ |
| (fun ω i (s : Set.Iic t) => X i s ω) := by |
| funext ω i s |
| exact hT i s ω |
| rw [heq] |
| exact (Measurable.of_eval fun index => |
| Measurable.of_eval fun time => (measurable_pi_apply time).comp |
| (measurable_pi_apply (r index))).comp (comap_measurable _) |
|
|
| theorem ae_all_nnrealTimePrimitive_eq_of_version |
| {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) [SFinite P] |
| {m n : ℝ≥0 → Ω → ℝ} |
| (hm : Measurable (fun p : ℝ≥0 × Ω => m p.1 p.2)) |
| (hn : Measurable (fun p : ℝ≥0 × Ω => n p.1 p.2)) |
| (heq : ∀ t, m t =ᵐ[P] n t) : |
| ∀ᵐ ω ∂P, ∀ t, nnrealTimePrimitive m t ω = nnrealTimePrimitive n t ω := by |
| have hmR : Measurable (fun p : ℝ × Ω => m p.1.toNNReal p.2) := |
| hm.comp (show Measurable (fun p : ℝ × Ω => (p.1.toNNReal, p.2)) by fun_prop) |
| have hnR : Measurable (fun p : ℝ × Ω => n p.1.toNNReal p.2) := |
| hn.comp (show Measurable (fun p : ℝ × Ω => (p.1.toNNReal, p.2)) by fun_prop) |
| have htime : ∀ᵐ ω ∂P, ∀ᵐ (s : ℝ) ∂volume, m s.toNNReal ω = n s.toNNReal ω := |
| (Measure.ae_ae_comm (μ := (volume : Measure ℝ)) (ν := P) |
| (p := fun s ω => m s.toNNReal ω = n s.toNNReal ω) |
| (measurableSet_eq_fun hmR hnR)).mp |
| (Filter.Eventually.of_forall fun (s : ℝ) => heq s.toNNReal) |
| filter_upwards [htime] with ω hω |
| intro t |
| exact intervalIntegral.integral_congr_ae (hω.mono fun _ hs _ => hs) |
|
|
| namespace ArrayPosteriorStationarity |
|
|
| variable {d : ℕ} {A : Type*} [MeasurableSpace A] |
|
|
| def plantedRelabel (g : TreeAut d) : |
| ((TreeVertex d → IsingSpin) × (TreeVertex d → A)) ≃ᵐ |
| ((TreeVertex d → IsingSpin) × (TreeVertex d → A)) := |
| (coordinateRelabelEquiv g.toEquiv).prodCongr (coordinateRelabelEquiv g.toEquiv) |
|
|
| def spinArray (σ : TreeVertex d → IsingSpin) : TreeVertex d → ℝ := |
| fun v => spinSign (σ v) |
|
|
| lemma measurable_spinArray : Measurable (spinArray (d := d)) := by |
| have hm : Measurable spinSign := by intro s hs; trivial |
| exact Measurable.of_eval fun vertex => hm.comp (measurable_pi_apply vertex) |
|
|
| def filtration (B : ℝ≥0 → A → ℝ) (hmB : ∀ t, Measurable (B t)) : |
| Filtration ℝ≥0 |
| (inferInstance : MeasurableSpace ((TreeVertex d → IsingSpin) × (TreeVertex d → A))) := |
| arrayObservationFiltration (fun _ : TreeVertex d => B) (fun _ => hmB) |
| spinArray measurable_spinArray |
|
|
| lemma measurable_plantedRelabel_filtration |
| (B : ℝ≥0 → A → ℝ) (hmB : ∀ t, Measurable (B t)) |
| (g : TreeAut d) (t : ℝ≥0) : |
| Measurable[filtration B hmB t, filtration B hmB t] (plantedRelabel (A := A) g) := by |
| apply measurable_arrayNaturalFiltration_of_intertwining |
| (plantedArrayObservation (fun _ : TreeVertex d => B) spinArray) |
| (plantedArrayObservation_measurable (fun _ => hmB) measurable_spinArray) |
| (plantedRelabel g) g.toEquiv.symm |
| intro i s q |
| rfl |
|
|
| lemma measurable_plantedRelabel_symm_filtration |
| (B : ℝ≥0 → A → ℝ) (hmB : ∀ t, Measurable (B t)) |
| (g : TreeAut d) (t : ℝ≥0) : |
| Measurable[filtration B hmB t, filtration B hmB t] (plantedRelabel (A := A) g).symm := by |
| apply measurable_arrayNaturalFiltration_of_intertwining |
| (plantedArrayObservation (fun _ : TreeVertex d => B) spinArray) |
| (plantedArrayObservation_measurable (fun _ => hmB) measurable_spinArray) |
| (plantedRelabel g).symm g.toEquiv |
| intro i s q |
| rfl |
|
|
| lemma measurePreserving_plantedRelabel {theta : ℝ} |
| {μ : Measure (TreeVertex d → IsingSpin)} (hμ : HasFreeIsingLaw theta μ) |
| (ν : Measure A) [IsProbabilityMeasure ν] (g : TreeAut d) : |
| MeasurePreserving (plantedRelabel (A := A) g) |
| (μ.prod (Measure.infinitePi (fun _ : TreeVertex d => ν))) |
| (μ.prod (Measure.infinitePi (fun _ : TreeVertex d => ν))) := |
| PlantedStationarity.measurePreserving_planted_relabel hμ ν g |
|
|
| lemma integrable_spin_coordinate |
| (P : Measure ((TreeVertex d → IsingSpin) × (TreeVertex d → A))) |
| [IsFiniteMeasure P] (v : TreeVertex d) : |
| Integrable (fun q => spinSign (q.1 v)) P := by |
| have hm : Measurable spinSign := by intro s hs; trivial |
| apply Integrable.of_bound |
| (hm.comp ((measurable_pi_apply v).comp measurable_fst)).aestronglyMeasurable 1 |
| apply Filter.Eventually.of_forall |
| intro q |
| cases hs : q.1 v <;> norm_num [spinSign, hs] |
|
|
| def posterior |
| (P : Measure ((TreeVertex d → IsingSpin) × (TreeVertex d → A))) |
| (B : ℝ≥0 → A → ℝ) (hmB : ∀ t, Measurable (B t)) |
| (t : ℝ≥0) (v : TreeVertex d) : |
| ((TreeVertex d → IsingSpin) × (TreeVertex d → A)) → ℝ := |
| P[fun q => spinSign (q.1 v) | filtration B hmB t] |
|
|
| lemma measurable_posterior |
| (P : Measure ((TreeVertex d → IsingSpin) × (TreeVertex d → A))) |
| (B : ℝ≥0 → A → ℝ) (hmB : ∀ t, Measurable (B t)) |
| (t : ℝ≥0) (v : TreeVertex d) : Measurable (posterior P B hmB t v) := |
| stronglyMeasurable_condExp.measurable.mono (filtration B hmB |>.le t) le_rfl |
|
|
| theorem posterior_relabel_ae {theta : ℝ} |
| {μ : Measure (TreeVertex d → IsingSpin)} (hμ : HasFreeIsingLaw theta μ) |
| (ν : Measure A) [IsProbabilityMeasure ν] |
| (B : ℝ≥0 → A → ℝ) (hmB : ∀ t, Measurable (B t)) |
| (g : TreeAut d) (t : ℝ≥0) (v : TreeVertex d) : |
| posterior (μ.prod (Measure.infinitePi (fun _ : TreeVertex d => ν))) B hmB t v ∘ |
| plantedRelabel g =ᵐ[μ.prod (Measure.infinitePi (fun _ : TreeVertex d => ν))] |
| posterior (μ.prod (Measure.infinitePi (fun _ : TreeVertex d => ν))) B hmB t |
| (g.toEquiv.symm v) := by |
| let := hμ.isProbabilityMeasure |
| exact condExp_comp_measurePreserving_equiv (filtration B hmB |>.le t) |
| (plantedRelabel g) (measurePreserving_plantedRelabel hμ ν g) |
| (measurable_plantedRelabel_filtration B hmB g t) |
| (measurable_plantedRelabel_symm_filtration B hmB g t) |
| (integrable_spin_coordinate _ v) |
|
|
| theorem posterior_version_relabel_ae {theta : ℝ} |
| {μ : Measure (TreeVertex d → IsingSpin)} (hμ : HasFreeIsingLaw theta μ) |
| (ν : Measure A) [IsProbabilityMeasure ν] |
| (B : ℝ≥0 → A → ℝ) (hmB : ∀ t, Measurable (B t)) |
| {m : ℝ≥0 → TreeVertex d → |
| ((TreeVertex d → IsingSpin) × (TreeVertex d → A)) → ℝ} |
| (hversion : ∀ t v, m t v =ᵐ[μ.prod (Measure.infinitePi (fun _ : TreeVertex d => ν))] |
| posterior (μ.prod (Measure.infinitePi (fun _ : TreeVertex d => ν))) B hmB t v) |
| (g : TreeAut d) (t : ℝ≥0) (v : TreeVertex d) : |
| m t v ∘ plantedRelabel g =ᵐ[μ.prod (Measure.infinitePi (fun _ : TreeVertex d => ν))] |
| m t (g.toEquiv.symm v) := by |
| exact ((measurePreserving_plantedRelabel hμ ν g).quasiMeasurePreserving.ae_eq_comp |
| (hversion t v)).trans ((posterior_relabel_ae hμ ν B hmB g t v).trans |
| (hversion t (g.toEquiv.symm v)).symm) |
|
|
| theorem posterior_version_array_relabel_ae {theta : ℝ} |
| {μ : Measure (TreeVertex d → IsingSpin)} (hμ : HasFreeIsingLaw theta μ) |
| (ν : Measure A) [IsProbabilityMeasure ν] |
| (B : ℝ≥0 → A → ℝ) (hmB : ∀ t, Measurable (B t)) |
| {m : ℝ≥0 → TreeVertex d → |
| ((TreeVertex d → IsingSpin) × (TreeVertex d → A)) → ℝ} |
| (hversion : ∀ t v, m t v =ᵐ[μ.prod (Measure.infinitePi (fun _ : TreeVertex d => ν))] |
| posterior (μ.prod (Measure.infinitePi (fun _ : TreeVertex d => ν))) B hmB t v) |
| (g : TreeAut d) (t : ℝ≥0) : |
| (fun q v => m t v (plantedRelabel g q)) |
| =ᵐ[μ.prod (Measure.infinitePi (fun _ : TreeVertex d => ν))] |
| (fun q => relabel g (fun v => m t v q)) := by |
| filter_upwards [ae_all_iff.mpr |
| (fun v => posterior_version_relabel_ae hμ ν B hmB hversion g t v)] with q hq |
| exact funext hq |
|
|
| theorem posterior_primitive_relabel_ae {theta : ℝ} |
| {μ : Measure (TreeVertex d → IsingSpin)} (hμ : HasFreeIsingLaw theta μ) |
| (ν : Measure A) [IsProbabilityMeasure ν] |
| (B : ℝ≥0 → A → ℝ) (hmB : ∀ t, Measurable (B t)) |
| {m : ℝ≥0 → TreeVertex d → |
| ((TreeVertex d → IsingSpin) × (TreeVertex d → A)) → ℝ} |
| (hm : ∀ v, Measurable (fun p : ℝ≥0 × |
| ((TreeVertex d → IsingSpin) × (TreeVertex d → A)) => m p.1 v p.2)) |
| (hversion : ∀ t v, m t v =ᵐ[μ.prod (Measure.infinitePi (fun _ : TreeVertex d => ν))] |
| posterior (μ.prod (Measure.infinitePi (fun _ : TreeVertex d => ν))) B hmB t v) |
| (g : TreeAut d) : |
| ∀ᵐ q ∂μ.prod (Measure.infinitePi (fun _ : TreeVertex d => ν)), ∀ v t, |
| nnrealTimePrimitive (fun u => m u v) t (plantedRelabel g q) = |
| nnrealTimePrimitive (fun u => m u (g.toEquiv.symm v)) t q := by |
| let := hμ.isProbabilityMeasure |
| apply ae_all_iff.mpr |
| intro v |
| have hleft : Measurable (fun p : ℝ≥0 × |
| ((TreeVertex d → IsingSpin) × (TreeVertex d → A)) => |
| m p.1 v (plantedRelabel g p.2)) := |
| (hm v).comp (measurable_fst.prodMk ((plantedRelabel g).measurable.comp measurable_snd)) |
| exact ae_all_nnrealTimePrimitive_eq_of_version _ hleft (hm (g.toEquiv.symm v)) |
| (fun t => posterior_version_relabel_ae hμ ν B hmB hversion g t v) |
|
|
| theorem innovation_array_relabel_ae {theta : ℝ} |
| {μ : Measure (TreeVertex d → IsingSpin)} (hμ : HasFreeIsingLaw theta μ) |
| (ν : Measure A) [IsProbabilityMeasure ν] |
| (B : ℝ≥0 → A → ℝ) (hmB : ∀ t, Measurable (B t)) |
| {m : ℝ≥0 → TreeVertex d → |
| ((TreeVertex d → IsingSpin) × (TreeVertex d → A)) → ℝ} |
| (hm : ∀ v, Measurable (fun p : ℝ≥0 × |
| ((TreeVertex d → IsingSpin) × (TreeVertex d → A)) => m p.1 v p.2)) |
| (hversion : ∀ t v, m t v =ᵐ[μ.prod (Measure.infinitePi (fun _ : TreeVertex d => ν))] |
| posterior (μ.prod (Measure.infinitePi (fun _ : TreeVertex d => ν))) B hmB t v) |
| (g : TreeAut d) : |
| ∀ᵐ q ∂μ.prod (Measure.infinitePi (fun _ : TreeVertex d => ν)), |
| (fun v t => plantedArrayObservation (fun _ : TreeVertex d => B) spinArray |
| v t (plantedRelabel g q) - |
| nnrealTimePrimitive (fun u => m u v) t (plantedRelabel g q)) = |
| relabel g (fun v t => plantedArrayObservation (fun _ : TreeVertex d => B) spinArray |
| v t q - nnrealTimePrimitive (fun u => m u v) t q) := by |
| filter_upwards [posterior_primitive_relabel_ae hμ ν B hmB hm hversion g] with q hq |
| funext v t |
| rw [hq v t] |
| rfl |
|
|
| end ArrayPosteriorStationarity |
| end Problem367 |
|
|
| end |
|
|
| end OAI |
|
|
