| import OAI.Dynamics.MultipleMixing.HilbertCodes |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| namespace Rokhlin |
|
|
| section |
|
|
| open MeasureTheory ProbabilityTheory |
| universe u |
| namespace ArrayObjects |
|
|
| section |
|
|
| structure StandardSpace where |
| α : Type u |
| measurableSpace : MeasurableSpace α |
| standardBorel : @StandardBorelSpace α measurableSpace |
| nonempty : Nonempty α |
| |
| instance : CoeSort StandardSpace (Type u) := ⟨StandardSpace.α⟩ |
| instance (S : StandardSpace) : MeasurableSpace S := S.measurableSpace |
| instance (S : StandardSpace) : StandardBorelSpace S := S.standardBorel |
| instance (S : StandardSpace) : Nonempty S := S.nonempty |
| |
| abbrev Index (I : Type u) (n : ℕ) := Fin n → I |
| abbrev Arr (I Y : Type u) (n : ℕ) := Index I n → Y |
| |
| def amap {I Y Z : Type u} (f : Y → Z) (n : ℕ) : Arr I Y n → Arr I Z n := |
| fun y v => f (y v) |
| |
| def plane {I Y : Type u} (n : ℕ) (a : Fin (n + 1)) (i : I) : |
| Arr I Y (n + 1) → Arr I Y n := fun y v => y (a.insertNth i v) |
| |
| def planes {I Y : Type u} (n : ℕ) (J : Finset I) : |
| Arr I Y (n + 1) → (j : J) → Arr I Y n := |
| fun y j => plane n (Fin.last n) j y |
| |
| def zeroEquiv (I Y : Type u) [MeasurableSpace Y] : Arr I Y 0 ≃ᵐ Y where |
| toFun y := y Fin.elim0 |
| invFun y := fun _ => y |
| left_inv y := by funext v; exact congrArg y (Subsingleton.elim _ _) |
| right_inv _ := rfl |
| measurable_toFun := measurable_pi_apply _ |
| measurable_invFun := Measurable.of_eval (fun _ => measurable_id) |
|
|
| @[fun_prop] lemma measurable_amap {I Y Z : Type u} |
| [MeasurableSpace Y] [MeasurableSpace Z] {f : Y → Z} (hf : Measurable f) (n : ℕ) : |
| Measurable (amap (I := I) f n) := |
| Measurable.of_eval (fun _ => hf.comp (measurable_pi_apply _)) |
|
|
| @[fun_prop] lemma measurable_plane {I Y : Type u} [MeasurableSpace Y] |
| (n : ℕ) (a : Fin (n + 1)) (i : I) : Measurable (plane (Y := Y) n a i) := |
| Measurable.of_eval (fun _ => measurable_pi_apply _) |
|
|
| @[fun_prop] lemma measurable_planes {I Y : Type u} [MeasurableSpace Y] |
| (n : ℕ) (J : Finset I) : Measurable (planes (Y := Y) n J) := |
| Measurable.of_eval (fun _ => measurable_plane _ _ _) |
|
|
| @[simp] lemma amap_id {I Y : Type u} (n : ℕ) : amap (I := I) (id : Y → Y) n = id := rfl |
| @[simp] lemma amap_comp {I X Y Z : Type u} (g : Y → Z) (f : X → Y) (n : ℕ) : |
| amap (I := I) (g ∘ f) n = amap g n ∘ amap f n := rfl |
| @[simp] lemma plane_amap {I Y Z : Type u} (f : Y → Z) (n : ℕ) |
| (a : Fin (n + 1)) (i : I) : |
| plane n a i ∘ amap f (n + 1) = amap f n ∘ plane n a i := rfl |
|
|
| variable (I : Type u) [Fintype I] |
|
|
| structure InitialLaws (X : StandardSpace.{u}) (T : X ≃ᵐ X) where |
| law : (n : ℕ) → Measure (Arr I X n) |
| probability : ∀ n, IsProbabilityMeasure (law n) |
| invariant : ∀ n, MeasurePreserving (amap T n) (law n) (law n) |
| consistent : ∀ n (a : Fin (n + 1)) i, |
| (law (n + 1)).map (plane n a i) = law n |
| proper : ∀ n (J : Finset I), J ≠ Finset.univ → |
| (law (n + 1)).map (planes n J) = Measure.pi (fun _ : J => law n) |
|
|
| attribute [instance] InitialLaws.probability |
|
|
| structure Object {X : StandardSpace.{u}} {T : X ≃ᵐ X} (base : InitialLaws I X T) where |
| Y : StandardSpace.{u} |
| U : StandardSpace.{u} |
| timeY : Y ≃ᵐ Y |
| timeU : U ≃ᵐ U |
| x : Y → X |
| par : Y → U |
| measurable_x : Measurable x |
| measurable_par : Measurable par |
| time_x : x ∘ timeY = T ∘ x |
| time_par : par ∘ timeY = timeU ∘ par |
| law : (n : ℕ) → Measure (Arr I Y n) |
| probability : ∀ n, IsProbabilityMeasure (law n) |
| invariant : ∀ n, MeasurePreserving (amap timeY n) (law n) (law n) |
| over_base : ∀ n, (law n).map (amap x n) = base.law n |
| consistent : ∀ n (a : Fin (n + 1)) i, |
| (law (n + 1)).map (plane n a i) = law n |
| proper : ∀ n (J : Finset I), J ≠ Finset.univ → |
| (law (n + 1)).map (planes n J) = Measure.pi (fun _ : J => law n) |
| conditional : ∀ n (J : Finset I), J ≠ Finset.univ → |
| condDistrib (planes n J) (amap par (n + 1)) (law (n + 1)) |
| =ᵐ[(law (n + 1)).map (amap par (n + 1))] |
| fun p => Measure.pi (fun j : J => |
| condDistrib (id : Arr I Y n → Arr I Y n) (amap par n) (law n) |
| (plane n (Fin.last n) j p)) |
| local_independent : IndepFun x par ((law 0).map (zeroEquiv I Y)) |
|
|
| attribute [instance] Object.probability |
|
|
| namespace Object |
| variable {I} {X : StandardSpace.{u}} {T : X ≃ᵐ X} {base : InitialLaws I X T} |
|
|
| noncomputable def localLaw (M : Object I base) : Measure M.Y := |
| (M.law 0).map (zeroEquiv I M.Y) |
| instance (M : Object I base) : IsProbabilityMeasure M.localLaw := by |
| dsimp [localLaw] |
| exact (fun mapMeasurable => (Measure.isProbabilityMeasure_map_iff mapMeasurable).mpr inferInstance) (zeroEquiv I M.Y).measurable.aemeasurable |
| |
| noncomputable def parameter (M : Object I base) : Measure M.U := M.localLaw.map M.par |
| instance (M : Object I base) : IsProbabilityMeasure M.parameter := |
| (fun mapMeasurable => (Measure.isProbabilityMeasure_map_iff mapMeasurable).mpr inferInstance) M.measurable_par.aemeasurable |
| |
| structure Extension (M N : Object I base) where |
| state : N.Y → M.Y |
| parameter : N.U → M.U |
| measurable_state : Measurable state |
| measurable_parameter : Measurable parameter |
| time_state : state ∘ N.timeY = M.timeY ∘ state |
| time_parameter : parameter ∘ N.timeU = M.timeU ∘ parameter |
| state_x : M.x ∘ state = N.x |
| state_par : M.par ∘ state = parameter ∘ N.par |
| laws : ∀ n, (N.law n).map (amap state n) = M.law n |
|
|
| namespace Extension |
|
|
| def refl (M : Object I base) : Extension M M where |
| state := id |
| parameter := id |
| measurable_state := measurable_id |
| measurable_parameter := measurable_id |
| time_state := rfl |
| time_parameter := rfl |
| state_x := rfl |
| state_par := rfl |
| laws n := by simp |
|
|
| def comp {M N P : Object I base} (e : Extension M N) (f : Extension N P) : |
| Extension M P where |
| state := e.state ∘ f.state |
| parameter := e.parameter ∘ f.parameter |
| measurable_state := e.measurable_state.comp f.measurable_state |
| measurable_parameter := e.measurable_parameter.comp f.measurable_parameter |
| time_state := by rw [Function.comp_assoc, f.time_state, ← Function.comp_assoc, |
| e.time_state, Function.comp_assoc] |
| time_parameter := by rw [Function.comp_assoc, f.time_parameter, ← Function.comp_assoc, |
| e.time_parameter, Function.comp_assoc] |
| state_x := by rw [← Function.comp_assoc, e.state_x, f.state_x] |
| state_par := by rw [← Function.comp_assoc, e.state_par, Function.comp_assoc, |
| f.state_par, ← Function.comp_assoc] |
| laws n := by |
| rw [amap_comp, ← Measure.map_map (measurable_amap e.measurable_state n) |
| (measurable_amap f.measurable_state n), f.laws, e.laws] |
|
|
| lemma measurePreserving {M N : Object I base} (e : Extension M N) (n : ℕ) : |
| MeasurePreserving (amap e.state n) (N.law n) (M.law n) := |
| ⟨measurable_amap e.measurable_state n, e.laws n⟩ |
|
|
| lemma localLaw_map {M N : Object I base} (e : Extension M N) : |
| N.localLaw.map e.state = M.localLaw := by |
| rw [localLaw, localLaw, Measure.map_map e.measurable_state (zeroEquiv I N.Y).measurable, |
| ← e.laws 0, Measure.map_map (zeroEquiv I M.Y).measurable |
| (measurable_amap e.measurable_state 0)] |
| rfl |
|
|
| lemma parameter_map {M N : Object I base} (e : Extension M N) : |
| N.parameter.map e.parameter = M.parameter := by |
| rw [Object.parameter, Object.parameter, Measure.map_map e.measurable_parameter N.measurable_par, |
| ← e.state_par, ← Measure.map_map M.measurable_par e.measurable_state, e.localLaw_map] |
|
|
| end Extension |
| end Object |
| end |
|
|
|
|
| lemma condDistrib_condition_const {Ω E P : Type*} [MeasurableSpace Ω] |
| [MeasurableSpace E] [StandardBorelSpace E] [Nonempty E] |
| [MeasurableSpace P] (μ : Measure Ω) [IsProbabilityMeasure μ] |
| (f : Ω → E) (hf : Measurable f) (c : P) : |
| condDistrib f (fun _ : Ω => c) μ c = μ.map f := by |
| have h := condDistrib_comp_map (μ := μ) (X := fun _ : Ω => c) measurable_const.aemeasurable |
| hf.aemeasurable |
| simpa only [Measure.map_const, measure_univ, one_smul, |
| Measure.dirac_bind (condDistrib f (fun _ : Ω => c) μ).measurable] using h |
|
|
| noncomputable def trivialSpace : StandardSpace.{u} where |
| α := PUnit.{u + 1} |
| measurableSpace := inferInstance |
| standardBorel := inferInstance |
| nonempty := inferInstance |
|
|
| variable {I : Type u} [Fintype I] {X : StandardSpace.{u}} {T : X ≃ᵐ X} |
|
|
| noncomputable def initialObject (base : InitialLaws I X T) : Object I base where |
| Y := X |
| U := trivialSpace |
| timeY := T |
| timeU := MeasurableEquiv.refl _ |
| x := id |
| par := fun _ => PUnit.unit |
| measurable_x := measurable_id |
| measurable_par := measurable_const |
| time_x := rfl |
| time_par := rfl |
| law := base.law |
| probability := base.probability |
| invariant := base.invariant |
| over_base n := by simp |
| consistent := base.consistent |
| proper := base.proper |
| conditional n J hJ := by |
| have hleft := condDistrib_condition_const (base.law (n + 1)) |
| (planes n J) (measurable_planes n J) (fun _ : Index I (n + 1) => PUnit.unit) |
| have hright := condDistrib_condition_const (base.law n) |
| (id : Arr I X n → Arr I X n) measurable_id (fun _ : Index I n => PUnit.unit) |
| apply Filter.Eventually.of_forall |
| intro p |
| have hp : p = fun _ => PUnit.unit := by |
| funext v |
| cases p v |
| rfl |
| subst p |
| change condDistrib (planes n J) |
| (fun _ => (fun _ : Index I (n + 1) => PUnit.unit)) (base.law (n + 1)) |
| (fun _ => PUnit.unit) = _ |
| rw [hleft, base.proper n J hJ] |
| congr 1 |
| funext j |
| change base.law n = condDistrib id |
| (fun _ => (fun _ : Index I n => PUnit.unit)) (base.law n) (fun _ => PUnit.unit) |
| simpa using hright.symm |
| local_independent := by |
| let : IsProbabilityMeasure ((base.law 0).map (zeroEquiv I X)) := inferInstance |
| exact indepFun_const_right id PUnit.unit |
|
|
|
|
| end ArrayObjects |
|
|
| open scoped InnerProductSpace |
|
|
| namespace Saturation |
|
|
| variable {𝕜 E H : Type*} [RCLike 𝕜] |
| [NormedAddCommGroup E] [InnerProductSpace 𝕜 E] |
| [NormedAddCommGroup H] [InnerProductSpace 𝕜 H] |
|
|
| theorem projection_difference_inner (J : E →ₗᵢ[𝕜] H) |
| (P : Submodule 𝕜 E) (Q : Submodule 𝕜 H) |
| [P.HasOrthogonalProjection] [Q.HasOrthogonalProjection] |
| (hPQ : ∀ x ∈ P, J x ∈ Q) (v : E) : |
| ⟪Q.starProjection (J v) - J (P.starProjection v), J (P.starProjection v)⟫_𝕜 = 0 := by |
| have h₁ := Q.starProjection_inner_eq_zero (J v) (J (P.starProjection v)) |
| (hPQ _ (P.starProjection_apply_mem v)) |
| have h₂ := P.starProjection_inner_eq_zero v (P.starProjection v) |
| (P.starProjection_apply_mem v) |
| rw [inner_sub_left] at h₁ h₂ ⊢ |
| rw [J.inner_map_map] at h₁ |
| rw [J.inner_map_map, sub_eq_zero] at ⊢ |
| exact (sub_eq_zero.mp h₁).symm.trans (sub_eq_zero.mp h₂) |
|
|
| theorem projection_norm_difference (J : E →ₗᵢ[𝕜] H) |
| (P : Submodule 𝕜 E) (Q : Submodule 𝕜 H) |
| [P.HasOrthogonalProjection] [Q.HasOrthogonalProjection] |
| (hPQ : ∀ x ∈ P, J x ∈ Q) (v : E) : |
| ‖Q.starProjection (J v)‖ ^ 2 - ‖P.starProjection v‖ ^ 2 = |
| ‖Q.starProjection (J v) - J (P.starProjection v)‖ ^ 2 := by |
| have h := norm_add_sq_eq_norm_sq_add_norm_sq_of_inner_eq_zero |
| (Q.starProjection (J v) - J (P.starProjection v)) (J (P.starProjection v)) |
| (projection_difference_inner J P Q hPQ v) |
| simp only [sub_add_cancel, J.norm_map] at h |
| nlinarith |
|
|
| theorem projection_eq_of_norm_eq (J : E →ₗᵢ[𝕜] H) |
| (P : Submodule 𝕜 E) (Q : Submodule 𝕜 H) |
| [P.HasOrthogonalProjection] [Q.HasOrthogonalProjection] |
| (hPQ : ∀ x ∈ P, J x ∈ Q) (v : E) |
| (h : ‖Q.starProjection (J v)‖ = ‖P.starProjection v‖) : |
| Q.starProjection (J v) = J (P.starProjection v) := by |
| have he := projection_norm_difference J P Q hPQ v |
| rw [h, sub_self] at he |
| exact sub_eq_zero.mp (norm_eq_zero.mp (sq_eq_zero_iff.mp he.symm)) |
|
|
| theorem projection_norm_mono (J : E →ₗᵢ[𝕜] H) |
| (P : Submodule 𝕜 E) (Q : Submodule 𝕜 H) |
| [P.HasOrthogonalProjection] [Q.HasOrthogonalProjection] |
| (hPQ : ∀ x ∈ P, J x ∈ Q) (v : E) : |
| ‖P.starProjection v‖ ≤ ‖Q.starProjection (J v)‖ := by |
| have he := projection_norm_difference J P Q hPQ v |
| nlinarith [sq_nonneg ‖Q.starProjection (J v) - J (P.starProjection v)‖, |
| norm_nonneg (P.starProjection v), norm_nonneg (Q.starProjection (J v))] |
|
|
| end Saturation |
|
|
| namespace ArrayObjects |
|
|
| inductive DataKind (I : Type u) |
| | parameter |
| | outside (j : I) |
| | enlarged (j : I) |
| deriving Fintype |
|
|
| namespace Object |
| open scoped ENNReal |
| variable {I : Type u} [Fintype I] {X : StandardSpace.{u}} {T : X ≃ᵐ X} |
| {base : InitialLaws I X T} |
|
|
| noncomputable abbrev data (M : Object I base) (n : ℕ) (d : DataKind I) : |
| MeasurableSpace (Arr I M.Y (n + 1)) := by |
| classical |
| exact match d with |
| | .parameter => MeasurableSpace.comap (amap M.par (n + 1)) inferInstance |
| | .outside j => MeasurableSpace.comap (planes n (Finset.univ.erase j)) inferInstance |
| | .enlarged j => MeasurableSpace.comap (amap M.par (n + 1)) inferInstance ⊔ |
| MeasurableSpace.comap (planes n (Finset.univ.erase j)) inferInstance |
|
|
| lemma data_le (M : Object I base) (n : ℕ) (d : DataKind I) : M.data n d ≤ (inferInstance : MeasurableSpace (Arr I M.Y (n + 1))) := by |
| classical |
| cases d with |
| | parameter => exact (measurable_amap M.measurable_par _).comap_le |
| | outside j => exact (measurable_planes _ _).comap_le |
| | enlarged j => |
| exact sup_le ((measurable_amap M.measurable_par _).comap_le) |
| ((measurable_planes _ _).comap_le) |
|
|
| namespace Extension |
| variable {M N P : Object I base} |
|
|
| lemma data_comap_le (e : Extension M N) (n : ℕ) (d : DataKind I) : |
| MeasurableSpace.comap (amap e.state (n + 1)) (M.data n d) ≤ N.data n d := by |
| classical |
| have hp : MeasurableSpace.comap (amap e.state (n + 1)) (M.data n .parameter) ≤ |
| N.data n .parameter := by |
| change MeasurableSpace.comap (amap e.state (n + 1)) |
| (MeasurableSpace.comap (amap M.par (n + 1)) inferInstance) ≤ _ |
| rw [MeasurableSpace.comap_comp, ← amap_comp, e.state_par, amap_comp] |
| rw [← MeasurableSpace.comap_comp] |
| exact MeasurableSpace.comap_mono (measurable_amap e.measurable_parameter _).comap_le |
| have ho (j : I) : MeasurableSpace.comap (amap e.state (n + 1)) (M.data n (.outside j)) ≤ |
| N.data n (.outside j) := by |
| change MeasurableSpace.comap (amap e.state (n + 1)) |
| (MeasurableSpace.comap (planes n (Finset.univ.erase j)) inferInstance) ≤ _ |
| rw [MeasurableSpace.comap_comp] |
| have he : planes n (Finset.univ.erase j) ∘ amap e.state (n + 1) = |
| (fun (z : (i : Finset.univ.erase j) → Arr I N.Y n) i => amap e.state n (z i)) ∘ |
| planes n (Finset.univ.erase j) := rfl |
| rw [he, ← MeasurableSpace.comap_comp] |
| exact MeasurableSpace.comap_mono (Measurable.of_eval (fun i => |
| (measurable_amap e.measurable_state n).comp (measurable_pi_apply i))).comap_le |
| cases d with |
| | parameter => exact hp |
| | outside j => exact ho j |
| | enlarged j => |
| change MeasurableSpace.comap (amap e.state (n + 1)) |
| (M.data n .parameter ⊔ M.data n (.outside j)) ≤ |
| N.data n .parameter ⊔ N.data n (.outside j) |
| rw [MeasurableSpace.comap_sup] |
| exact sup_le_sup hp (ho j) |
|
|
| noncomputable def pull (e : Extension M N) (n : ℕ) : |
| Lp ℂ 2 (M.law n) →ₗᵢ[ℂ] Lp ℂ 2 (N.law n) := |
| Lp.compMeasurePreservingₗᵢ ℂ (amap e.state n) (e.measurePreserving n) |
|
|
| lemma pull_comp (e : Extension M N) (f : Extension N P) (n : ℕ) (F : Lp ℂ 2 (M.law n)) : |
| (e.comp f).pull n F = f.pull n (e.pull n F) := |
| Lp.compMeasurePreserving_comp_apply F (e.measurePreserving n) (f.measurePreserving n) |
|
|
| lemma pull_data_mem (e : Extension M N) (n : ℕ) (d : DataKind I) |
| (F : Lp ℂ 2 (M.law (n + 1))) (hF : F ∈ lpMeas ℂ ℂ (M.data n d) 2 (M.law (n + 1))) : |
| e.pull (n + 1) F ∈ lpMeas ℂ ℂ (N.data n d) 2 (N.law (n + 1)) := by |
| have hFm := lpMeas.aestronglyMeasurable (⟨F, hF⟩ : lpMeas ℂ ℂ (M.data n d) 2 (M.law (n + 1))) |
| have hm : @Measurable _ _ (N.data n d) (M.data n d) (amap e.state (n + 1)) := |
| measurable_iff_comap_le.mpr (e.data_comap_le n d) |
| have hg := hFm.stronglyMeasurable_mk.comp_measurable hm |
| have he := (e.measurePreserving (n + 1)).quasiMeasurePreserving.ae_eq_comp hFm.ae_eq_mk |
| have hp := Lp.coeFn_compMeasurePreserving F (e.measurePreserving (n + 1)) |
| exact ⟨hFm.mk F ∘ amap e.state (n + 1), hg, hp.trans he⟩ |
|
|
| end Extension |
| end Object |
| end ArrayObjects |
|
|
| namespace ArrayObjects.Object |
| open scoped ENNReal |
| variable {I : Type u} [Fintype I] {X : StandardSpace.{u}} {T : X ≃ᵐ X} |
| {base : InitialLaws I X T} |
|
|
| noncomputable def project (M : Object I base) (n : ℕ) (d : DataKind I) : |
| Lp ℂ 2 (M.law (n + 1)) →L[ℂ] Lp ℂ 2 (M.law (n + 1)) := |
| haveI : Fact (M.data n d ≤ (inferInstance : MeasurableSpace (Arr I M.Y (n + 1)))) := |
| ⟨M.data_le n d⟩ |
| (lpMeas ℂ ℂ (M.data n d) 2 (M.law (n + 1))).starProjection |
|
|
| lemma project_norm_le (M : Object I base) (n : ℕ) (d : DataKind I) |
| (F : Lp ℂ 2 (M.law (n + 1))) : ‖M.project n d F‖ ≤ ‖F‖ := |
| norm_condExpL2_coe_le (M.data_le n d) F |
|
|
| namespace Extension |
| variable {M N : Object I base} |
|
|
| lemma project_norm_mono (e : Extension M N) (n : ℕ) (d : DataKind I) |
| (F : Lp ℂ 2 (M.law (n + 1))) : |
| ‖M.project n d F‖ ≤ ‖N.project n d (e.pull (n + 1) F)‖ := by |
| let : Fact (M.data n d ≤ (inferInstance : MeasurableSpace (Arr I M.Y (n + 1)))) := |
| ⟨M.data_le n d⟩ |
| let : Fact (N.data n d ≤ (inferInstance : MeasurableSpace (Arr I N.Y (n + 1)))) := |
| ⟨N.data_le n d⟩ |
| exact Saturation.projection_norm_mono (e.pull (n + 1)) |
| (lpMeas ℂ ℂ (M.data n d) 2 (M.law (n + 1))) |
| (lpMeas ℂ ℂ (N.data n d) 2 (N.law (n + 1))) (e.pull_data_mem n d) F |
|
|
| lemma project_eq_of_norm_le (e : Extension M N) (n : ℕ) (d : DataKind I) |
| (F : Lp ℂ 2 (M.law (n + 1))) |
| (h : ‖N.project n d (e.pull (n + 1) F)‖ ≤ ‖M.project n d F‖) : |
| N.project n d (e.pull (n + 1) F) = e.pull (n + 1) (M.project n d F) := by |
| let : Fact (M.data n d ≤ (inferInstance : MeasurableSpace (Arr I M.Y (n + 1)))) := |
| ⟨M.data_le n d⟩ |
| let : Fact (N.data n d ≤ (inferInstance : MeasurableSpace (Arr I N.Y (n + 1)))) := |
| ⟨N.data_le n d⟩ |
| exact Saturation.projection_eq_of_norm_eq (e.pull (n + 1)) |
| (lpMeas ℂ ℂ (M.data n d) 2 (M.law (n + 1))) |
| (lpMeas ℂ ℂ (N.data n d) 2 (N.law (n + 1))) (e.pull_data_mem n d) F |
| (le_antisymm h (e.project_norm_mono n d F)) |
|
|
| end Extension |
|
|
| def IsSaturated (M : Object I base) : Prop := |
| ∀ (N : Object I base) (e : Extension M N) n d (F : Lp ℂ 2 (M.law (n + 1))), |
| N.project n d (e.pull (n + 1) F) = e.pull (n + 1) (M.project n d F) |
|
|
| end ArrayObjects.Object |
|
|
| namespace KernelTests |
| variable {Ω U B : Type*} [MeasurableSpace Ω] [MeasurableSpace U] |
| [MeasurableSpace B] [StandardBorelSpace B] [Nonempty B] |
|
|
| omit [Nonempty B] in |
| lemma ae_eq_of_evaluations (ν : Measure U) [IsFiniteMeasure ν] |
| (κ η : Kernel U B) [IsFiniteKernel κ] [IsFiniteKernel η] |
| (h : ∀ S : Set B, MeasurableSet S → |
| (fun u => κ u S) =ᵐ[ν] (fun u => η u S)) : κ =ᵐ[ν] η := by |
| apply Kernel.ae_eq_of_compProd_eq |
| apply Measure.ext_prod |
| intro A S hA hS |
| rw [Measure.compProd_apply_prod hA hS, Measure.compProd_apply_prod hA hS] |
| exact lintegral_congr_ae ((h S hS).filter_mono ae_restrict_le) |
|
|
| lemma hasCondDistrib_of_indicators (μ : Measure Ω) [IsProbabilityMeasure μ] |
| (E : Ω → U) (O : Ω → B) (hE : Measurable E) (hO : Measurable O) |
| (κ : Kernel U B) [IsMarkovKernel κ] |
| (h : ∀ S : Set B, MeasurableSet S → |
| μ⟦O ⁻¹' S | MeasurableSpace.comap E inferInstance⟧ =ᵐ[μ] |
| fun ω => (κ (E ω)).real S) : HasCondDistrib O E κ μ := by |
| have he : condDistrib O E μ =ᵐ[μ.map E] κ := by |
| apply ae_eq_of_evaluations |
| intro S hS |
| apply (ae_map_iff hE.aemeasurable |
| (measurableSet_eq_fun ((condDistrib O E μ).measurable_coe hS) (κ.measurable_coe hS))).mpr |
| filter_upwards [condDistrib_ae_eq_condExp hE hO hS, h S hS] with ω h1 h2 |
| exact (ENNReal.toReal_eq_toReal_iff' (measure_ne_top _ _) (measure_ne_top _ _)).mp |
| (h1.trans h2) |
| exact ⟨(hE.prodMk hO).aemeasurable, |
| (compProd_map_condDistrib hE.aemeasurable hO.aemeasurable).symm.trans (Measure.compProd_congr he)⟩ |
|
|
| end KernelTests |
|
|
| namespace ArrayObjects.Object |
|
|
| section |
| open scoped ENNReal |
| variable {I : Type u} [Fintype I] {X : StandardSpace.{u}} {T : X ≃ᵐ X} |
| {base : InitialLaws I X T} {M N : Object I base} |
|
|
| lemma project_ae_eq_condExp (M : Object I base) (n : ℕ) (d : DataKind I) |
| (F : Lp ℂ 2 (M.law (n + 1))) : |
| (M.project n d F : Arr I M.Y (n + 1) → ℂ) =ᵐ[M.law (n + 1)] |
| (M.law (n + 1))[F | M.data n d] := by |
| have h := (Lp.memLp F).condExpL2_ae_eq_condExp (𝕜 := ℂ) (M.data_le n d) |
| rw [Lp.toLp_coeFn] at h |
| exact h |
|
|
| lemma IsSaturated.condExp (hM : M.IsSaturated) (e : Extension M N) |
| (n : ℕ) (d : DataKind I) (f : Arr I M.Y (n + 1) → ℂ) |
| (hf : MemLp f 2 (M.law (n + 1))) : |
| (N.law (n + 1))[f ∘ amap e.state (n + 1) | N.data n d] =ᵐ[N.law (n + 1)] |
| ((M.law (n + 1))[f | M.data n d] ∘ amap e.state (n + 1)) := by |
| let F := hf.toLp f |
| have hp := Lp.coeFn_compMeasurePreserving F (e.measurePreserving (n + 1)) |
| have hp' := (e.measurePreserving (n + 1)).quasiMeasurePreserving.ae_eq_comp hf.coeFn_toLp |
| have hout := (e.measurePreserving (n + 1)).quasiMeasurePreserving.ae_eq_comp |
| ((M.project_ae_eq_condExp n d F).trans (condExp_congr_ae hf.coeFn_toLp)) |
| have hi := N.project_ae_eq_condExp n d (e.pull (n + 1) F) |
| have hh := hM N e n d F |
| have hl := Lp.coeFn_compMeasurePreserving (M.project n d F) (e.measurePreserving (n + 1)) |
| rw [hh] at hi |
| exact (condExp_congr_ae (hp.trans hp')).symm.trans (hi.symm.trans (hl.trans hout)) |
|
|
| lemma IsSaturated.indicator (hM : M.IsSaturated) (e : Extension M N) |
| (n : ℕ) (d : DataKind I) (S : Set (Arr I M.Y (n + 1))) (hS : MeasurableSet S) : |
| (N.law (n + 1))⟦amap e.state (n + 1) ⁻¹' S | N.data n d⟧ =ᵐ[N.law (n + 1)] |
| ((M.law (n + 1))⟦S | M.data n d⟧ ∘ amap e.state (n + 1)) := by |
| let f : Arr I M.Y (n + 1) → ℝ := S.indicator (fun _ => 1) |
| have hf : Integrable f (M.law (n + 1)) := (integrable_const 1).indicator hS |
| have hfeq : (fun y => (f y : ℂ)) = S.indicator (fun _ => (1 : ℂ)) := by |
| funext y; by_cases hy : y ∈ S <;> simp [f, hy] |
| have hg : MemLp (fun y => (f y : ℂ)) 2 (M.law (n + 1)) := by |
| rw [hfeq] |
| exact |
| memLp_indicator_const (μ := M.law (n + 1)) 2 hS (1 : ℂ) (Or.inr (measure_ne_top _ _)) |
| have h := hM.condExp e n d (fun y => (f y : ℂ)) hg |
| have hnew := Complex.ofRealCLM.comp_condExp_comm (m := N.data n d) |
| ((e.measurePreserving (n + 1)).integrable_comp_of_integrable hf) |
| have hold := (e.measurePreserving (n + 1)).quasiMeasurePreserving.ae_eq_comp |
| (Complex.ofRealCLM.comp_condExp_comm (m := M.data n d) hf) |
| have he := hnew.trans (h.trans hold.symm) |
| have hpre : f ∘ amap e.state (n + 1) = |
| (amap e.state (n + 1) ⁻¹' S).indicator (fun _ => (1 : ℝ)) := by |
| funext y |
| exact (Set.indicator_comp_right (s := S) (g := fun _ => (1 : ℝ)) |
| (amap e.state (n + 1))).symm |
| filter_upwards [he] with y hy |
| have hr := Complex.ofReal_injective hy |
| change (N.law (n + 1))[f ∘ amap e.state (n + 1) | N.data n d] y = _ at hr |
| rw [hpre] at hr |
| exact hr |
|
|
| end |
|
|
| variable {I : Type u} [Fintype I] {X : StandardSpace.{u}} {T : X ≃ᵐ X} |
| {base : InitialLaws I X T} {M N : Object I base} |
|
|
| lemma IsSaturated.hasCondDistrib (hM : M.IsSaturated) (e : Extension M N) |
| (n : ℕ) (d : DataKind I) {A B C : Type*} |
| [MeasurableSpace A] [MeasurableSpace B] [MeasurableSpace C] |
| [StandardBorelSpace B] [Nonempty B] |
| (E : Arr I M.Y (n + 1) → A) (E' : Arr I N.Y (n + 1) → C) |
| (F : Arr I M.Y (n + 1) → B) (p : C → A) |
| (hE : Measurable E) (hE' : Measurable E') (hF : Measurable F) (hp : Measurable p) |
| (hdata : M.data n d = MeasurableSpace.comap E inferInstance) |
| (hdata' : N.data n d = MeasurableSpace.comap E' inferInstance) |
| (hobs : E ∘ amap e.state (n + 1) = p ∘ E') : |
| HasCondDistrib (F ∘ amap e.state (n + 1)) E' |
| ((condDistrib F E (M.law (n + 1))).comap p hp) (N.law (n + 1)) := by |
| apply KernelTests.hasCondDistrib_of_indicators _ E' _ hE' |
| (hF.comp (measurable_amap e.measurable_state _)) |
| intro S hS |
| have hi := hM.indicator e n d (F ⁻¹' S) (hF hS) |
| rw [hdata, hdata'] at hi |
| have ho := (e.measurePreserving (n + 1)).quasiMeasurePreserving.ae_eq_comp |
| (condDistrib_ae_eq_condExp (μ := M.law (n + 1)) hE hF hS) |
| filter_upwards [hi, ho] with y h1 h2 |
| exact h1.trans (h2.symm.trans (by |
| change ((condDistrib F E (M.law (n + 1))) (E (amap e.state (n + 1) y))).real S = |
| ((condDistrib F E (M.law (n + 1))) (p (E' y))).real S |
| exact congrArg (fun a => ((condDistrib F E (M.law (n + 1))) a).real S) |
| (congrFun hobs y))) |
|
|
|
|
| end ArrayObjects.Object |
|
|
| namespace ArrayObjects |
| variable {I : Type u} |
|
|
| def roll {Y : Type u} [MeasurableSpace Y] (n : ℕ) : |
| Arr I Y (n + 1) ≃ᵐ Arr I (I → Y) n where |
| toFun y w c := y (Fin.cons c w) |
| invFun y v := y (Fin.tail v) (v 0) |
| left_inv y := by funext v; simp |
| right_inv y := by funext w c; simp |
| measurable_toFun := by exact Measurable.of_eval (fun _ => |
| Measurable.of_eval (fun _ => measurable_pi_apply _)) |
| measurable_invFun := by |
| change Measurable (fun y : Arr I (I → Y) n => fun v : Fin (n + 1) → I => y (Fin.tail v) (v 0)) |
| exact Measurable.of_eval (fun _ => |
| (measurable_pi_apply _).comp (measurable_pi_apply _)) |
|
|
| lemma roll_amap {Y Z : Type u} [MeasurableSpace Y] [MeasurableSpace Z] |
| (f : Y → Z) (n : ℕ) : |
| roll (I := I) n ∘ amap f (n + 1) = amap (fun y c => f (y c)) n ∘ roll n := rfl |
|
|
| lemma select_roll {Y : Type u} [MeasurableSpace Y] (n : ℕ) (a : I) : |
| amap (Function.eval a) n ∘ roll (I := I) (Y := Y) n = plane n 0 a := by |
| funext y w |
| simp [amap, roll, plane, Fin.insertNth_zero'] |
|
|
| lemma plane_roll {Y : Type u} [MeasurableSpace Y] (n : ℕ) |
| (a : Fin (n + 1)) (i : I) : |
| plane n a i ∘ roll (I := I) (Y := Y) (n + 1) = |
| roll n ∘ plane (n + 1) a.succ i := by |
| funext y w c |
| exact congrArg y (Fin.insertNth_succ_cons a i c w).symm |
|
|
| lemma planes_roll {Y : Type u} [MeasurableSpace Y] (n : ℕ) (J : Finset I) : |
| planes n J ∘ roll (I := I) (Y := Y) (n + 1) = |
| (fun z j => roll n (z j)) ∘ planes (n + 1) J := by |
| funext y j |
| exact congrFun (plane_roll n (Fin.last n) (j : I)) y |
|
|
| namespace Object |
| variable [Fintype I] |
| variable {X : StandardSpace.{u}} {T : X ≃ᵐ X} {base : InitialLaws I X T} |
| variable (M : Object I base) |
| namespace Rolled |
|
|
| noncomputable abbrev State : StandardSpace.{u} where |
| α := I → M.Y |
| measurableSpace := inferInstance |
| standardBorel := inferInstance |
| nonempty := inferInstance |
|
|
| noncomputable abbrev Parameter (R : Finset I) : StandardSpace.{u} where |
| α := (I → M.U) × (R → M.Y) |
| measurableSpace := inferInstance |
| standardBorel := inferInstance |
| nonempty := inferInstance |
|
|
| def timeState : State M ≃ᵐ State M := |
| MeasurableEquiv.piCongrRight (fun _ : I => M.timeY) |
|
|
| def timeParameter (R : Finset I) : Parameter M R ≃ᵐ Parameter M R := |
| (MeasurableEquiv.piCongrRight (fun _ : I => M.timeU)).prodCongr |
| (MeasurableEquiv.piCongrRight (fun _ : R => M.timeY)) |
|
|
| def parameter (R : Finset I) (y : State M) : Parameter M R := |
| (fun c => M.par (y c), fun c => y c) |
|
|
| @[fun_prop] lemma measurable_parameter (R : Finset I) : Measurable (parameter M R) := by |
| exact (Measurable.of_eval (fun c => M.measurable_par.comp (measurable_pi_apply c))).prodMk |
| (Measurable.of_eval (fun c => measurable_pi_apply (c : I))) |
|
|
| lemma time_parameter (R : Finset I) : |
| parameter M R ∘ timeState M = timeParameter M R ∘ parameter M R := by |
| funext y |
| apply Prod.ext |
| · funext c; exact congrFun M.time_par (y c) |
| · rfl |
|
|
| noncomputable def law (n : ℕ) : Measure (Arr I (State M) n) := |
| (M.law (n + 1)).map (roll n) |
| instance law_probability (n : ℕ) : IsProbabilityMeasure (law M n) := |
| (fun mapMeasurable => (Measure.isProbabilityMeasure_map_iff mapMeasurable).mpr inferInstance) (roll n).measurable.aemeasurable |
| |
| lemma invariant (n : ℕ) : MeasurePreserving (amap (timeState M) n) (law M n) (law M n) := by |
| refine ⟨measurable_amap (timeState M).measurable n, ?_⟩ |
| dsimp only [law] |
| rw [Measure.map_map (measurable_amap (timeState M).measurable n) (roll n).measurable] |
| change (M.law (n + 1)).map (roll n ∘ amap M.timeY (n + 1)) = _ |
| rw [← Measure.map_map (roll n).measurable (measurable_amap M.timeY.measurable _), |
| (M.invariant (n + 1)).map_eq] |
| |
| lemma select_law (n : ℕ) (a : I) : |
| (law M n).map (amap (Function.eval a) n) = M.law n := by |
| dsimp only [law] |
| rw [Measure.map_map (measurable_amap (measurable_pi_apply a) n) (roll n).measurable, |
| select_roll, M.consistent] |
| |
| lemma over_base (n : ℕ) (a : I) : |
| (law M n).map (amap (M.x ∘ Function.eval a) n) = base.law n := by |
| rw [amap_comp, ← Measure.map_map (measurable_amap M.measurable_x n) |
| (measurable_amap (measurable_pi_apply a) n), select_law, M.over_base] |
| |
| lemma consistent (n : ℕ) (a : Fin (n + 1)) (i : I) : |
| (law M (n + 1)).map (plane n a i) = law M n := by |
| dsimp only [law] |
| rw [Measure.map_map (measurable_plane _ _ _) (roll _).measurable, plane_roll, |
| ← Measure.map_map (roll _).measurable (measurable_plane _ _ _), M.consistent] |
| |
| lemma proper (n : ℕ) (J : Finset I) (hJ : J ≠ Finset.univ) : |
| (law M (n + 1)).map (planes n J) = Measure.pi (fun _ : J => law M n) := by |
| have hm : Measurable (fun z : (j : J) → Arr I M.Y (n + 1) => fun j => roll n (z j)) := |
| Measurable.of_eval (fun j => (roll n).measurable.comp (measurable_pi_apply j)) |
| dsimp only [law] |
| rw [Measure.map_map (measurable_planes _ _) (roll _).measurable, planes_roll, |
| ← Measure.map_map hm (measurable_planes _ _), M.proper _ _ hJ] |
| exact Measure.pi_map_pi (fun _ : J => (roll n).measurable.aemeasurable) |
| |
| end Rolled |
| end Object |
| end ArrayObjects |
| |
| open MeasureTheory ProbabilityTheory |
| open scoped ENNReal |
| |
| namespace FiniteKernel |
| |
| variable {ι X : Type*} {Y : ι → Type*} |
| [Fintype ι] [MeasurableSpace X] [∀ i, MeasurableSpace (Y i)] |
| |
| noncomputable def pi (κ : ∀ i, Kernel X (Y i)) [∀ i, IsMarkovKernel (κ i)] : |
| Kernel X (∀ i, Y i) where |
| toFun x := Measure.pi (fun i => κ i x) |
| measurable' := by |
| apply Measurable.measure_of_isPiSystem_of_isProbabilityMeasure |
| generateFrom_pi.symm isPiSystem_pi |
| rintro _ ⟨s, hs, rfl⟩ |
| simp only [Measure.pi_pi] |
| exact Finset.measurable_prod _ (fun i _ => (κ i).measurable_coe (hs i (Set.mem_univ i))) |
|
|
| @[simp] theorem pi_apply (κ : ∀ i, Kernel X (Y i)) [∀ i, IsMarkovKernel (κ i)] (x : X) : |
| pi κ x = Measure.pi (fun i => κ i x) := rfl |
| |
| instance (κ : ∀ i, Kernel X (Y i)) [∀ i, IsMarkovKernel (κ i)] : IsMarkovKernel (pi κ) := |
| ⟨fun _ => inferInstanceAs (IsProbabilityMeasure (Measure.pi _))⟩ |
| |
| @[simp] theorem pi_box (κ : ∀ i, Kernel X (Y i)) [∀ i, IsMarkovKernel (κ i)] |
| (x : X) (s : ∀ i, Set (Y i)) : |
| pi κ x (Set.pi Set.univ s) = ∏ i, κ i x (s i) := Measure.pi_pi _ _ |
| |
| theorem map_pi {Z : ι → Type*} [∀ i, MeasurableSpace (Z i)] |
| (κ : ∀ i, Kernel X (Y i)) [∀ i, IsMarkovKernel (κ i)] |
| (f : ∀ i, Y i → Z i) (hf : ∀ i, Measurable (f i)) : |
| letI : ∀ i, IsMarkovKernel ((κ i).map (f i)) := |
| fun i => Kernel.IsMarkovKernel.map (κ i) (hf i) |
| (pi κ).map (fun y i => f i (y i)) = pi (fun i => (κ i).map (f i)) := by |
| ext x : 1 |
| rw [Kernel.map_apply _ (by fun_prop)] |
| simp only [pi_apply, Kernel.map_apply _ (hf _)] |
| exact Measure.pi_map_pi (fun i => (hf i).aemeasurable) |
| |
| def zipEquiv (Y Z : ι → Type*) [∀ i, MeasurableSpace (Y i)] |
| [∀ i, MeasurableSpace (Z i)] : |
| ((∀ i, Y i) × (∀ i, Z i)) ≃ᵐ (∀ i, Y i × Z i) where |
| toFun p i := (p.1 i, p.2 i) |
| invFun p := (fun i => (p i).1, fun i => (p i).2) |
| left_inv _ := rfl |
| right_inv _ := rfl |
| measurable_toFun := by |
| change Measurable (fun p : (∀ i, Y i) × (∀ i, Z i) => fun i => (p.1 i, p.2 i)) |
| fun_prop |
| measurable_invFun := by |
| change Measurable (fun p : ∀ i, Y i × Z i => (fun i => (p i).1, fun i => (p i).2)) |
| fun_prop |
|
|
| theorem compProd_pi {Z : ι → Type*} [∀ i, MeasurableSpace (Z i)] |
| (μ : ∀ i, Measure (Y i)) [∀ i, IsProbabilityMeasure (μ i)] |
| (κ : ∀ i, Kernel (Y i) (Z i)) [∀ i, IsMarkovKernel (κ i)] : |
| (Measure.pi μ ⊗ₘ pi (fun i => (κ i).comap (Function.eval i) (measurable_pi_apply i))).map |
| (zipEquiv Y Z) = Measure.pi (fun i => μ i ⊗ₘ κ i) := by |
| apply (Measure.pi_eq _).symm |
| intro s hs |
| rw [Measure.map_apply (zipEquiv Y Z).measurable (.univ_pi hs), |
| Measure.compProd_apply ((zipEquiv Y Z).measurable (.univ_pi hs))] |
| have hbox (y : ∀ i, Y i) : |
| Prod.mk y ⁻¹' ((zipEquiv Y Z) ⁻¹' Set.pi Set.univ s) = |
| Set.pi Set.univ (fun i => Prod.mk (y i) ⁻¹' s i) := rfl |
| simp_rw [hbox, pi_box, Kernel.comap_apply] |
| have hm (i : ι) : Measurable (fun y => κ i y (Prod.mk y ⁻¹' s i)) := |
| (κ i).measurable_kernel_prodMk_left (hs i) |
| rw [lintegral_prod_eq_prod_lintegral_of_indepFun Finset.univ _ |
| (iIndepFun_pi fun i => (hm i).aemeasurable) (fun i => (hm i).comp (measurable_pi_apply i))] |
| congr 1 |
| funext i |
| rw [(measurePreserving_eval μ i).lintegral_comp (hm i)] |
| rw [← Measure.compProd_apply (hs i)] |
|
|
| theorem pi_compProd {Z : ι → Type*} [∀ i, MeasurableSpace (Z i)] |
| (κ : ∀ i, Kernel X (Y i)) [∀ i, IsMarkovKernel (κ i)] |
| (η : ∀ i, Kernel (X × Y i) (Z i)) [∀ i, IsMarkovKernel (η i)] : |
| (pi κ ⊗ₖ pi (fun i => (η i).comap (fun p : X × (∀ i, Y i) => (p.1, p.2 i)) |
| (by fun_prop))).map (zipEquiv Y Z) = pi (fun i => κ i ⊗ₖ η i) := by |
| ext x : 1 |
| rw [Kernel.map_apply _ (zipEquiv Y Z).measurable, |
| Kernel.compProd_apply_eq_compProd_sectR] |
| have heq : Kernel.sectR |
| (pi (fun i => (η i).comap (fun p : X × (∀ i, Y i) => (p.1, p.2 i)) |
| (by fun_prop))) x = |
| pi (fun i => (Kernel.sectR (η i) x).comap (Function.eval i) (measurable_pi_apply i)) := by |
| ext y : 1 |
| rfl |
| rw [heq] |
| simp only [pi_apply] |
| rw [compProd_pi] |
| simp only [Kernel.compProd_apply_eq_compProd_sectR] |
|
|
| end FiniteKernel |
|
|
| open MeasureTheory ProbabilityTheory |
|
|
| namespace ConditionalScreens |
|
|
| variable {Ω X Y Z : Type*} |
| [MeasurableSpace Ω] [MeasurableSpace X] [MeasurableSpace Y] [MeasurableSpace Z] |
| {P : Measure Ω} [SFinite P] |
| {x : Ω → X} {y : Ω → Y} {z : Ω → Z} |
| {κ : Kernel X Y} [IsMarkovKernel κ] |
| {η : Kernel (X × Y) Z} [IsMarkovKernel η] |
|
|
| omit [SFinite P] [IsMarkovKernel κ] [IsMarkovKernel η] in |
|
|
| theorem chain (hy : HasCondDistrib y x κ P) |
| (hz : HasCondDistrib z (fun ω => (x ω, y ω)) η P) : |
| HasCondDistrib (fun ω => (y ω, z ω)) x (κ ⊗ₖ η) P := by |
| refine ⟨hy.aemeasurable_fst.prodMk |
| (hy.aemeasurable_snd.prodMk hz.aemeasurable_snd), ?_⟩ |
| calc |
| P.map (fun ω => (x ω, y ω, z ω)) = |
| (P.map (fun ω => ((x ω, y ω), z ω))).map MeasurableEquiv.prodAssoc := by |
| rw [AEMeasurable.map_map_of_aemeasurable (by fun_prop) hz.aemeasurable] |
| rfl |
| _ = ((P.map x ⊗ₘ κ) ⊗ₘ η).map MeasurableEquiv.prodAssoc := by |
| rw [hz.map_eq, hy.map_eq] |
| _ = P.map x ⊗ₘ (κ ⊗ₖ η) := Measure.compProd_assoc' |
|
|
| theorem compProd_prodMkRight (κ : Kernel X Y) [IsSFiniteKernel κ] |
| (l : Kernel X Z) [IsSFiniteKernel l] : |
| κ ⊗ₖ l.prodMkRight Y = κ ×ₖ l := by |
| ext a s hs |
| rw [Kernel.compProd_apply hs, Kernel.prod_apply' _ _ _ hs] |
| rfl |
|
|
| theorem screening (hy : HasCondDistrib y x κ P) |
| (l : Kernel X Z) [IsMarkovKernel l] |
| (hz : HasCondDistrib z (fun ω => (x ω, y ω)) (l.prodMkRight Y) P) : |
| HasCondDistrib y (fun ω => (x ω, z ω)) (κ.prodMkRight Z) P := by |
| have h := chain hy hz |
| rw [compProd_prodMkRight] at h |
| have h' := h.comp_left measurable_swap |
| simp only [Function.comp_def, Prod.swap_prod_mk, Kernel.map_prod_swap] at h' |
| rw [← compProd_prodMkRight] at h' |
| exact h'.of_compProd |
|
|
| end ConditionalScreens |
|
|
| namespace ConditionalReveal |
|
|
| open MeasureTheory ProbabilityTheory |
| open scoped ENNReal |
|
|
| variable {ι Y : Type*} [DecidableEq ι] [MeasurableSpace Y] |
|
|
| def insertTuple (S : Finset ι) (i : ι) (p : (S → Y) × Y) : ↥(insert i S) → Y := |
| fun j => if h : j.val = i then p.2 else |
| p.1 ⟨j.val, Finset.mem_of_mem_insert_of_ne j.property h⟩ |
|
|
| theorem measurable_insertTuple (S : Finset ι) (i : ι) : |
| Measurable (insertTuple (Y := Y) S i) := by |
| apply Measurable.of_eval |
| intro j |
| unfold insertTuple |
| split_ifs |
| · exact measurable_snd |
| · exact (measurable_pi_apply _).comp measurable_fst |
|
|
| theorem map_insertTuple (S : Finset ι) (i : ι) (hi : i ∉ S) |
| (μ : ι → Measure Y) [∀ i, IsProbabilityMeasure (μ i)] : |
| ((Measure.pi (fun j : S => μ j)).prod (μ i)).map (insertTuple S i) = |
| Measure.pi (fun j : ↥(insert i S) => μ j) := by |
| apply (Measure.pi_eq _).symm |
| intro s hs |
| rw [Measure.map_apply (measurable_insertTuple S i) (.univ_pi hs)] |
| have hpre : insertTuple S i ⁻¹' Set.pi Set.univ s = |
| (Set.pi Set.univ (fun j : S => s ⟨j, Finset.mem_insert_of_mem j.property⟩)) ×ˢ |
| s ⟨i, Finset.mem_insert_self i S⟩ := by |
| ext p |
| simp only [Set.mem_preimage, Set.mem_pi, Set.mem_univ, forall_const, |
| Set.mem_prod] |
| constructor |
| · intro h |
| constructor |
| · intro j |
| have hji : (j : ι) ≠ i := fun e => hi (e ▸ j.property) |
| simpa only [insertTuple, dite_eq_right hji] using |
| h ⟨j, Finset.mem_insert_of_mem j.property⟩ |
| · simpa [insertTuple] using h ⟨i, Finset.mem_insert_self i S⟩ |
| · rintro ⟨hp, hq⟩ j |
| by_cases hji : (j : ι) = i |
| · have ej : j = ⟨i, Finset.mem_insert_self i S⟩ := Subtype.ext hji |
| rw [ej] |
| simpa [insertTuple] using hq |
| · simpa only [insertTuple, dite_eq_right hji] using |
| hp ⟨j, Finset.mem_of_mem_insert_of_ne j.property hji⟩ |
| rw [hpre, Measure.prod_prod, Measure.pi_pi] |
| classical |
| let g : ι → ℝ≥0∞ := fun j => if h : j ∈ insert i S then μ j (s ⟨j, h⟩) else 1 |
| have hg (j : ↥(insert i S)) : g j = μ j (s j) := by simp only [g, dite_eq_left j.property] |
| have hgS (j : S) : g j = μ j (s ⟨j, Finset.mem_insert_of_mem j.property⟩) := by |
| exact dite_eq_left (Finset.mem_insert_of_mem j.property) |
| simp_rw [← hg, ← hgS] |
| rw [Finset.prod_coe_sort, Finset.prod_coe_sort, Finset.prod_insert hi] |
| have hgi : g i = μ i (s ⟨i, Finset.mem_insert_self i S⟩) := |
| dite_eq_left (Finset.mem_insert_self i S) |
| rw [hgi] |
| exact mul_comm _ _ |
|
|
| def splitTuple (S : Finset ι) (i : ι) (z : ↥(insert i S) → Y) : (S → Y) × Y := |
| (fun j => z ⟨j, Finset.mem_insert_of_mem j.property⟩, |
| z ⟨i, Finset.mem_insert_self i S⟩) |
|
|
| theorem measurable_splitTuple (S : Finset ι) (i : ι) : |
| Measurable (splitTuple (Y := Y) S i) := by |
| exact (Measurable.of_eval (fun _ => measurable_pi_apply _)).prodMk |
| (measurable_pi_apply _) |
|
|
| omit [MeasurableSpace Y] in |
| theorem split_insertTuple (S : Finset ι) (i : ι) (hi : i ∉ S) : |
| splitTuple (Y := Y) S i ∘ insertTuple S i = id := by |
| funext p |
| apply Prod.ext |
| · funext j |
| have hji : (j : ι) ≠ i := fun h => hi (h ▸ j.property) |
| exact dite_eq_right hji |
| · simp [splitTuple, insertTuple] |
|
|
| theorem map_splitTuple (S : Finset ι) (i : ι) (hi : i ∉ S) |
| (μ : ι → Measure Y) [∀ i, IsProbabilityMeasure (μ i)] : |
| (Measure.pi (fun j : ↥(insert i S) => μ j)).map (splitTuple S i) = |
| (Measure.pi (fun j : S => μ j)).prod (μ i) := by |
| rw [← map_insertTuple S i hi μ, |
| Measure.map_map (measurable_splitTuple S i) (measurable_insertTuple S i), |
| split_insertTuple S i hi, Measure.map_id] |
|
|
| theorem probability_eq_of_subsingleton {Z : Type*} [MeasurableSpace Z] [Subsingleton Z] |
| (μ ν : Measure Z) [IsProbabilityMeasure μ] [IsProbabilityMeasure ν] : μ = ν := by |
| ext s |
| by_cases h : s.Nonempty |
| · obtain ⟨z, hz⟩ := h |
| have hs : s = Set.univ := Set.eq_univ_of_forall (fun w => |
| (Subsingleton.elim z w) ▸ hz) |
| simp [hs] |
| · simp [Set.not_nonempty_iff_eq_empty.mp h] |
|
|
| variable {Ω X : Type*} [MeasurableSpace Ω] [MeasurableSpace X] |
|
|
| theorem finite_reveal (P : Measure Ω) [IsProbabilityMeasure P] |
| (E : Ω → X) (hE : Measurable E) (y : ι → Ω → Y) |
| (κ : ι → Kernel X Y) [∀ i, IsMarkovKernel (κ i)] (R : Finset ι) |
| (h : ∀ (S : Finset ι), S ⊆ R → ∀ i ∈ R, i ∉ S → |
| HasCondDistrib (y i) (fun ω => (E ω, fun j : S => y j ω)) |
| ((κ i).prodMkRight (S → Y)) P) : |
| HasCondDistrib (fun ω => fun j : R => y j ω) E |
| (FiniteKernel.pi (fun j : R => κ j)) P := by |
| classical |
| revert h |
| induction R using Finset.induction_on with |
| | empty => |
| intro _ |
| let z : (∅ : Finset ι) → Y := fun i => False.elim (Finset.notMem_empty _ i.property) |
| have hk : FiniteKernel.pi (fun j : (∅ : Finset ι) => κ j) = |
| Kernel.deterministic (fun _ : X => z) measurable_const := by |
| ext x : 1 |
| exact probability_eq_of_subsingleton _ _ |
| have hy : (fun ω => fun j : (∅ : Finset ι) => y j ω) = fun _ => z := by |
| funext ω j |
| exact False.elim (Finset.notMem_empty _ j.property) |
| rw [hy, hk] |
| refine ⟨(hE.prodMk measurable_const).aemeasurable, ?_⟩ |
| rw [Measure.compProd_deterministic, Measure.map_map (by fun_prop) hE] |
| rfl |
| | @insert i S hi ih => |
| intro h |
| have hS := ih (fun A hA j hj hnot => h A |
| (hA.trans (Finset.subset_insert i S)) j (Finset.mem_insert_of_mem hj) hnot) |
| have hi' := h S (Finset.subset_insert i S) i (Finset.mem_insert_self i S) hi |
| have hh := ConditionalScreens.chain hS hi' |
| rw [ConditionalScreens.compProd_prodMkRight] at hh |
| have hout := hh.comp_left (measurable_insertTuple S i) |
| have hk : ((FiniteKernel.pi (fun j : S => κ j)) ×ₖ κ i).map |
| (insertTuple S i) = FiniteKernel.pi (fun j : ↥(insert i S) => κ j) := by |
| ext x : 1 |
| rw [Kernel.map_apply _ (measurable_insertTuple S i), Kernel.prod_apply] |
| exact map_insertTuple S i hi (fun j => κ j x) |
| rw [hk] at hout |
| have hy : insertTuple S i ∘ (fun ω => ((fun j : S => y j ω), y i ω)) = |
| (fun ω => fun j : ↥(insert i S) => y j ω) := by |
| funext ω j |
| simp only [Function.comp_def, insertTuple] |
| split_ifs with hji |
| · rw [hji] |
| · rfl |
| rwa [hy] at hout |
|
|
| end ConditionalReveal |
| open MeasureTheory ProbabilityTheory |
|
|
| namespace ConditionalTransport |
| variable {Ω Ω' A B C : Type*} [MeasurableSpace Ω] [MeasurableSpace Ω'] |
| [MeasurableSpace A] [MeasurableSpace B] [MeasurableSpace C] |
|
|
| theorem pullback {P : Measure Ω} {Q : Measure Ω'} {f : Ω → Ω'} |
| {E : Ω' → A} {O : Ω' → B} {κ : Kernel A B} |
| (hf : MeasurePreserving f P Q) (hE : Measurable E) |
| (h : HasCondDistrib O E κ Q) : HasCondDistrib (O ∘ f) (E ∘ f) κ P := by |
| have hh := h.comp hf.hasLaw |
| have he : P.map (E ∘ f) = Q.map E := by |
| rw [← Measure.map_map hE hf.measurable, hf.map_eq] |
| change HasLaw (fun ω => (E (f ω), O (f ω))) (P.map (E ∘ f) ⊗ₘ κ) P |
| rw [he] |
| exact hh |
|
|
| theorem recondition [StandardBorelSpace B] [Nonempty B] |
| {P : Measure Ω} [IsProbabilityMeasure P] |
| {E : Ω → A} {D : Ω → C} {O : Ω → B} |
| {κ : Kernel A B} [IsMarkovKernel κ] {η : Kernel C B} [IsMarkovKernel η] |
| (hE : Measurable E) (hD : Measurable D) (hO : Measurable O) |
| (h : HasCondDistrib O E κ P) |
| (hfield : MeasurableSpace.comap E inferInstance = MeasurableSpace.comap D inferInstance) |
| (hk : (fun ω => κ (E ω)) =ᵐ[P] fun ω => η (D ω)) : HasCondDistrib O D η P := by |
| apply KernelTests.hasCondDistrib_of_indicators _ D O hD hO |
| intro S hS |
| have hc := ae_of_ae_map hE.aemeasurable |
| (condDistrib_ae_eq_of_measure_eq_compProd hE.aemeasurable hO.aemeasurable h.map_eq) |
| have hi := condDistrib_ae_eq_condExp (μ := P) hE hO hS |
| rw [hfield] at hi |
| filter_upwards [hc, hi, hk] with ω h1 h2 h3 |
| exact h2.symm.trans (by rw [h1, h3]) |
|
|
| omit [MeasurableSpace Ω] in |
|
|
| theorem comap_le_of_factor {f : Ω → A} {g : Ω → C} {p : C → A} |
| (hp : Measurable p) (h : f = p ∘ g) : |
| MeasurableSpace.comap f inferInstance ≤ MeasurableSpace.comap g inferInstance := by |
| rw [h, ← MeasurableSpace.comap_comp] |
| exact MeasurableSpace.comap_mono hp.comap_le |
|
|
| theorem of_indep {P : Measure Ω} [IsProbabilityMeasure P] |
| {E : Ω → A} {O : Ω → B} (hE : Measurable E) (hO : Measurable O) |
| (h : IndepFun E O P) : HasCondDistrib O E (Kernel.const A (P.map O)) P := by |
| refine ⟨(hE.prodMk hO).aemeasurable, ?_⟩ |
| rw [Measure.compProd_const] |
| exact h.map_prod_eq_prod_map_map hE.aemeasurable hO.aemeasurable |
|
|
| theorem indep_of_const {P : Measure Ω} [IsProbabilityMeasure P] |
| {E : Ω → A} {O : Ω → B} (hE : Measurable E) (hO : Measurable O) |
| (Q : Measure B) [IsProbabilityMeasure Q] |
| (h : HasCondDistrib O E (Kernel.const A Q) P) : IndepFun E O P := by |
| apply (indepFun_iff_map_prod_eq_prod_map_map hE.aemeasurable hO.aemeasurable).mpr |
| rw [h.map_eq, h.hasLaw_of_const.map_eq, Measure.compProd_const] |
|
|
| end ConditionalTransport |
|
|
| namespace ConditionalReveal |
| variable {ι Ω X Y Z : Type*} [DecidableEq ι] [MeasurableSpace Ω] |
| [MeasurableSpace X] [MeasurableSpace Y] [MeasurableSpace Z] |
|
|
| theorem independent_image (P : Measure Ω) [IsProbabilityMeasure P] |
| (E : Ω → X) (hE : Measurable E) (y : ι → Ω → Y) (hy : ∀ i, Measurable (y i)) |
| (κ : ι → Kernel X Y) [∀ i, IsMarkovKernel (κ i)] |
| (R : Finset ι) (i : ι) (hi : i ∉ R) (f : Y → Z) (hf : Measurable f) |
| (Q : Measure Z) [IsProbabilityMeasure Q] |
| (h : HasCondDistrib (fun ω => fun j : ↥(insert i R) => y j ω) E |
| (FiniteKernel.pi (fun j : ↥(insert i R) => κ j)) P) |
| (hk : (fun x => (κ i x).map f) =ᵐ[P.map E] fun _ => Q) : |
| IndepFun (fun ω => (E ω, fun j : R => y j ω)) (f ∘ y i) P := by |
| have hs := h.comp_left (measurable_splitTuple R i) |
| have hsk : (FiniteKernel.pi (fun j : ↥(insert i R) => κ j)).map (splitTuple R i) = |
| (FiniteKernel.pi (fun j : R => κ j)) ×ₖ κ i := by |
| ext x : 1 |
| rw [Kernel.map_apply _ (measurable_splitTuple R i), Kernel.prod_apply] |
| exact map_splitTuple R i hi (fun j => κ j x) |
| rw [hsk] at hs |
| change HasCondDistrib (fun ω => ((fun j : R => y j ω), y i ω)) E |
| ((FiniteKernel.pi (fun j : R => κ j)) ×ₖ κ i) P at hs |
| have hx := hs.comp_left (measurable_id.prodMap hf) |
| rw [← Kernel.map_prod_map _ _ measurable_id hf, Kernel.map_id] at hx |
| have hprod : ((FiniteKernel.pi (fun j : R => κ j)) ×ₖ (κ i).map f) =ᵐ[P.map E] |
| ((FiniteKernel.pi (fun j : R => κ j)) ×ₖ Kernel.const X Q) := by |
| filter_upwards [hk] with x hx |
| rw [Kernel.prod_apply, Kernel.prod_apply, Kernel.map_apply _ hf, hx] |
| rfl |
| have hout : HasCondDistrib (fun ω => ((fun j : R => y j ω), f (y i ω))) E |
| ((FiniteKernel.pi (fun j : R => κ j)) ×ₖ Kernel.const X Q) P := |
| ⟨hx.aemeasurable, hx.map_eq.trans (Measure.compProd_congr hprod)⟩ |
| rw [← ConditionalScreens.compProd_prodMkRight] at hout |
| have hout' := hout.of_compProd |
| have hc : (Kernel.const X Q).prodMkRight (R → Y) = Kernel.const (X × (R → Y)) Q := rfl |
| rw [hc] at hout' |
| exact ConditionalTransport.indep_of_const |
| (hE.prodMk (Measurable.of_eval (fun j => hy j))) (hf.comp (hy i)) Q hout' |
|
|
| end ConditionalReveal |
|
|
| namespace ConditionalTransport |
| variable {Ω Ω' A B : Type*} [MeasurableSpace Ω] [MeasurableSpace Ω'] |
| [MeasurableSpace A] [MeasurableSpace B] |
| lemma map_indep {P : Measure Ω} [IsProbabilityMeasure P] |
| {f : Ω → Ω'} {E : Ω' → A} {O : Ω' → B} |
| (hf : Measurable f) (hE : Measurable E) (hO : Measurable O) |
| (h : IndepFun (E ∘ f) (O ∘ f) P) : IndepFun E O (P.map f) := by |
| apply (indepFun_iff_map_prod_eq_prod_map_map hE.aemeasurable hO.aemeasurable).mpr |
| rw [Measure.map_map (hE.prodMk hO) hf, Measure.map_map hE hf, Measure.map_map hO hf] |
| exact h.map_prod_eq_prod_map_map (hE.comp hf).aemeasurable (hO.comp hf).aemeasurable |
| end ConditionalTransport |
|
|
| namespace ArrayObjects.Object |
| variable {I : Type u} [Fintype I] {X : StandardSpace.{u}} {T : X ≃ᵐ X} |
| {base : InitialLaws I X T} (M : Object I base) |
|
|
| noncomputable def ownKernel (n : ℕ) : Kernel (Arr I M.U n) (Arr I M.Y n) := |
| condDistrib id (amap M.par n) (M.law n) |
| instance ownKernel_markov (n : ℕ) : IsMarkovKernel (ownKernel M n) := by |
| unfold ownKernel |
| infer_instance |
| |
| lemma ownKernel_conditional (n : ℕ) : |
| HasCondDistrib id (amap M.par n) (M.ownKernel n) (M.law n) := |
| ⟨((measurable_amap M.measurable_par n).prodMk measurable_id).aemeasurable, |
| (compProd_map_condDistrib (measurable_amap M.measurable_par n).aemeasurable measurable_id.aemeasurable).symm⟩ |
| |
| lemma planes_conditional (n : ℕ) (J : Finset I) (hJ : J ≠ Finset.univ) : |
| HasCondDistrib (planes n J) (amap M.par (n + 1)) |
| (FiniteKernel.pi (fun j : J => (M.ownKernel n).comap |
| (plane n (Fin.last n) j) (measurable_plane _ _ _))) (M.law (n + 1)) := by |
| refine ⟨((measurable_amap M.measurable_par _).prodMk (measurable_planes _ _)).aemeasurable, ?_⟩ |
| exact (compProd_map_condDistrib (measurable_amap M.measurable_par _).aemeasurable (measurable_planes n J).aemeasurable).symm.trans |
| (Measure.compProd_congr (M.conditional n J hJ)) |
| |
| lemma ownKernel_zero_image : |
| (fun p => (M.ownKernel 0 p).map (M.x ∘ zeroEquiv I M.Y)) =ᵐ[ |
| (M.law 0).map (amap M.par 0)] fun _ => M.localLaw.map M.x := by |
| have h := ConditionalTransport.of_indep (P := M.localLaw) M.measurable_par M.measurable_x M.local_independent.symm |
| have h0 := ConditionalTransport.pullback |
| (show MeasurePreserving (zeroEquiv I M.Y) (M.law 0) M.localLaw from |
| ⟨(zeroEquiv I M.Y).measurable, rfl⟩) M.measurable_par h |
| have h1 := h0.measurableEquiv_comp_right (zeroEquiv I M.U).symm |
| have hpar : (zeroEquiv I M.U).symm ∘ M.par ∘ zeroEquiv I M.Y = amap M.par 0 := by |
| funext y w |
| exact congrArg (fun v => M.par (y v)) (Subsingleton.elim _ _) |
| rw [hpar] at h1 |
| have h2 := (M.ownKernel_conditional 0).comp_left |
| (M.measurable_x.comp (zeroEquiv I M.Y).measurable) |
| have hk := Kernel.ae_eq_of_compProd_eq (h2.map_eq.symm.trans h1.map_eq) |
| filter_upwards [hk] with p hp |
| rw [← Kernel.map_apply _ (M.measurable_x.comp (zeroEquiv I M.Y).measurable)] |
| exact hp |
| |
| namespace Rolled |
| lemma local_independent [DecidableEq I] (R : Finset I) (a : I) |
| (ha : a ∉ R) (hR : insert a R ≠ Finset.univ) : |
| IndepFun (M.x ∘ Function.eval a) (parameter M R) |
| ((law M 0).map (zeroEquiv I (State M))) := by |
| let E := amap (I := I) M.par 1 |
| let y := fun c : I => plane 0 (Fin.last 0) c (Y := M.Y) |
| let κ := fun c : I => (M.ownKernel 0).comap |
| (plane 0 (Fin.last 0) c) (measurable_plane _ _ _) |
| have hE : Measurable E := measurable_amap M.measurable_par 1 |
| have hfield : MeasurePreserving (plane 0 (Fin.last 0) a) |
| ((M.law 1).map E) ((M.law 0).map (amap M.par 0)) := by |
| refine ⟨measurable_plane _ _ _, ?_⟩ |
| rw [Measure.map_map (measurable_plane _ _ _) hE, plane_amap, |
| ← Measure.map_map (measurable_amap M.measurable_par 0) (measurable_plane _ _ _), |
| M.consistent] |
| let Q := M.localLaw.map M.x |
| have : IsProbabilityMeasure Q := (fun mapMeasurable => (Measure.isProbabilityMeasure_map_iff mapMeasurable).mpr inferInstance) M.measurable_x.aemeasurable |
| have hk := hfield.quasiMeasurePreserving.ae_eq_comp M.ownKernel_zero_image |
| have h := ConditionalReveal.independent_image (M.law 1) E hE y |
| (fun c => measurable_plane 0 (Fin.last 0) c) κ R a ha |
| (M.x ∘ zeroEquiv I M.Y) (M.measurable_x.comp (zeroEquiv I M.Y).measurable) Q |
| (M.planes_conditional 0 (insert a R) hR) hk |
| let e : Arr I M.U 1 × (R → Arr I M.Y 0) → Parameter M R := fun p => |
| (fun c => p.1 (Fin.cons c Fin.elim0), fun c => zeroEquiv I M.Y (p.2 c)) |
| have he : Measurable e := by |
| exact (Measurable.of_eval (fun _ => (measurable_pi_apply _).comp measurable_fst)).prodMk |
| (Measurable.of_eval (fun _ => (zeroEquiv I M.Y).measurable.comp |
| ((measurable_pi_apply _).comp measurable_snd))) |
| have hh := (h.comp he measurable_id).symm |
| rw [law, Measure.map_map (zeroEquiv I (State M)).measurable (roll 0).measurable] |
| apply ConditionalTransport.map_indep ((zeroEquiv I (State M)).measurable.comp (roll 0).measurable) |
| (M.measurable_x.comp (measurable_pi_apply a)) (measurable_parameter M R) |
| convert hh using 1 <;> funext z <;> simp [E, e, y, parameter, roll, zeroEquiv, plane, |
| amap, Function.comp_def, Fin.insertNth_zero'] |
| |
| end Rolled |
| end ArrayObjects.Object |
| |
| namespace ArrayObjects |
| variable {I : Type u} |
| |
| lemma cons_snoc {n : ℕ} (c j : I) (v : Fin n → I) : |
| (Fin.cons c (Fin.snoc (α := fun _ => I) v j) : Fin (n + 2) → I) = |
| Fin.snoc (α := fun _ => I) (Fin.cons c v) j := by |
| simpa only [show (Fin.last n).succ = Fin.last (n + 1) from rfl, |
| Fin.insertNth_last'] using (Fin.insertNth_succ_cons (Fin.last n) j c v).symm |
| |
| namespace Object.Rolled |
| variable [Fintype I] {X : StandardSpace.{u}} {T : X ≃ᵐ X} |
| {base : InitialLaws I X T} (M : Object I base) |
| |
| noncomputable abbrev Outside (j : I) : Finset I := by |
| classical |
| exact Finset.univ.erase j |
| |
| variable [DecidableEq I] |
| |
| abbrev RawData (n : ℕ) (j : I) := |
| Arr I M.U (n + 2) × (Outside j → Arr I M.Y (n + 1)) |
| |
| abbrev RevealData (R : Finset I) (n : ℕ) (j : I) := |
| RawData M n j × (R → Arr I M.Y n) |
| |
| abbrev RollData (R : Finset I) (n : ℕ) (j : I) := |
| Arr I (Parameter M R) (n + 1) × (Outside j → Arr I (State M) n) |
| |
| def rawData (n : ℕ) (j : I) (y : Arr I M.Y (n + 2)) : RawData M n j := |
| (amap M.par (n + 2) y, planes (n + 1) (Outside j) y) |
| |
| def missingRow (n : ℕ) (j c : I) (y : Arr I M.Y (n + 2)) : Arr I M.Y n := |
| plane n (Fin.last n) j (plane (n + 1) 0 c y) |
| |
| def revealData (R : Finset I) (n : ℕ) (j : I) (y : Arr I M.Y (n + 2)) : |
| RevealData M R n j := (rawData M n j y, fun c => missingRow M n j c y) |
| |
| def rollData (R : Finset I) (n : ℕ) (j : I) (y : Arr I (State M) (n + 1)) : |
| RollData M R n j := (amap (parameter M R) (n + 1) y, planes n (Outside j) y) |
| |
| omit [DecidableEq I] in |
| @[fun_prop] lemma measurable_rawData (n : ℕ) (j : I) : Measurable (rawData M n j) := |
| (measurable_amap M.measurable_par _).prodMk (measurable_planes _ _) |
| omit [DecidableEq I] in |
| @[fun_prop] lemma measurable_missingRow (n : ℕ) (j c : I) : |
| Measurable (missingRow M n j c) := |
| (measurable_plane _ _ _).comp (measurable_plane _ _ _) |
| omit [DecidableEq I] in |
| @[fun_prop] lemma measurable_revealData (R : Finset I) (n : ℕ) (j : I) : |
| Measurable (revealData M R n j) := |
| (measurable_rawData M n j).prodMk |
| (Measurable.of_eval (fun c => measurable_missingRow M n j c)) |
| omit [DecidableEq I] in |
| @[fun_prop] lemma measurable_rollData (R : Finset I) (n : ℕ) (j : I) : |
| Measurable (rollData M R n j) := |
| (measurable_amap (measurable_parameter M R) _).prodMk (measurable_planes _ _) |
| |
| def rollToReveal (R : Finset I) (n : ℕ) (j : I) (p : RollData M R n j) : |
| RevealData M R n j := |
| ((fun v => (p.1 (Fin.tail v)).1 (v 0), fun k => (roll n).symm (p.2 k)), |
| fun c v => (p.1 (Fin.snoc v j)).2 c) |
| |
| omit [DecidableEq I] in |
| @[fun_prop] lemma measurable_rollToReveal (R : Finset I) (n : ℕ) (j : I) : |
| Measurable (rollToReveal M R n j) := by |
| unfold rollToReveal |
| fun_prop |
| |
| def revealToRoll (R : Finset I) (n : ℕ) (j : I) (p : RevealData M R n j) : |
| RollData M R n j := |
| (fun w => (fun c => p.1.1 (Fin.cons c w), fun c => |
| if h : w (Fin.last n) = j then p.2 c (Fin.init w) else |
| p.1.2 ⟨w (Fin.last n), by simp [Outside, h]⟩ (Fin.cons c (Fin.init w))), |
| fun k => roll n (p.1.2 k)) |
| |
| @[fun_prop] lemma measurable_revealToRoll (R : Finset I) (n : ℕ) (j : I) : |
| Measurable (revealToRoll M R n j) := by |
| apply Measurable.prodMk |
| · apply Measurable.of_eval |
| intro w |
| apply Measurable.prodMk |
| · fun_prop |
| · apply Measurable.of_eval |
| intro c |
| split_ifs <;> fun_prop |
| · exact Measurable.of_eval (fun k => (roll n).measurable.comp |
| ((measurable_pi_apply k).comp (measurable_snd.comp measurable_fst))) |
| |
| omit [DecidableEq I] in |
| lemma rollToReveal_observation (R : Finset I) (n : ℕ) (j : I) : |
| rollToReveal M R n j ∘ rollData M R n j ∘ roll (n + 1) = revealData M R n j := by |
| funext y |
| apply Prod.ext |
| · apply Prod.ext |
| · funext v |
| simp [rollToReveal, rollData, revealData, rawData, amap, parameter, roll] |
| · funext k |
| change (roll n).symm ((planes n (Outside j) ∘ roll (n + 1)) y k) = _ |
| rw [planes_roll] |
| exact (roll n).symm_apply_apply _ |
| · funext c v |
| simp [rollToReveal, rollData, revealData, missingRow, amap, parameter, roll, |
| plane, Fin.insertNth_zero', Fin.insertNth_last'] |
| |
| lemma revealToRoll_observation (R : Finset I) (n : ℕ) (j : I) : |
| revealToRoll M R n j ∘ revealData M R n j = rollData M R n j ∘ roll (n + 1) := by |
| funext y |
| apply Prod.ext |
| · funext w |
| apply Prod.ext |
| · rfl |
| · funext c |
| change (if h : w (Fin.last n) = j then missingRow M n j c y (Fin.init w) else |
| planes (n + 1) (Outside j) y |
| ⟨w (Fin.last n), by simp [Outside, h]⟩ (Fin.cons c (Fin.init w))) = _ |
| split_ifs with h |
| · simp only [missingRow, plane, Fin.insertNth_zero', Fin.insertNth_last'] |
| rw [← h, Fin.snoc_init_self] |
| rfl |
| · simp only [planes, plane, Fin.insertNth_last'] |
| rw [← cons_snoc, Fin.snoc_init_self] |
| rfl |
| · funext k |
| exact congrFun (congrFun (planes_roll n (Outside j)) y) k |>.symm |
| |
| lemma comap_reveal_eq_rollData (R : Finset I) (n : ℕ) (j : I) : |
| MeasurableSpace.comap (revealData M R n j) inferInstance = |
| MeasurableSpace.comap (rollData M R n j ∘ roll (n + 1)) inferInstance := by |
| apply le_antisymm |
| · rw [← rollToReveal_observation M R n j, ← MeasurableSpace.comap_comp] |
| exact MeasurableSpace.comap_mono (measurable_rollToReveal M R n j).comap_le |
| · rw [← revealToRoll_observation M R n j, ← MeasurableSpace.comap_comp] |
| exact MeasurableSpace.comap_mono (measurable_revealToRoll M R n j).comap_le |
| |
| abbrev OldData (n : ℕ) (j : I) := |
| Arr I M.U (n + 1) × (Outside j → Arr I M.Y n) |
| |
| def oldData (n : ℕ) (j : I) (y : Arr I M.Y (n + 1)) : OldData M n j := |
| (amap M.par (n + 1) y, planes n (Outside j) y) |
| omit [DecidableEq I] in |
| @[fun_prop] lemma measurable_oldData (n : ℕ) (j : I) : Measurable (oldData M n j) := |
| (measurable_amap M.measurable_par _).prodMk (measurable_planes _ _) |
| |
| def rowData (n : ℕ) (j c : I) (p : RawData M n j) : OldData M n j := |
| (plane (n + 1) 0 c p.1, fun k => plane n 0 c (p.2 k)) |
| omit [DecidableEq I] in |
| @[fun_prop] lemma measurable_rowData (n : ℕ) (j c : I) : Measurable (rowData M n j c) := |
| ((measurable_plane _ _ _).comp measurable_fst).prodMk |
| (Measurable.of_eval (fun _ => (measurable_plane _ _ _).comp |
| ((measurable_pi_apply _).comp measurable_snd))) |
| |
| def selectData (R : Finset I) (n : ℕ) (j c : I) (p : RollData M R n j) : OldData M n j := |
| (amap (fun q => q.1 c) (n + 1) p.1, fun k => amap (Function.eval c) n (p.2 k)) |
| omit [DecidableEq I] in |
| @[fun_prop] lemma measurable_selectData (R : Finset I) (n : ℕ) (j c : I) : |
| Measurable (selectData M R n j c) := by |
| unfold selectData |
| fun_prop |
| |
| omit [DecidableEq I] in |
| lemma selectData_observation (R : Finset I) (n : ℕ) (j c : I) : |
| selectData M R n j c ∘ rollData M R n j ∘ roll (n + 1) = |
| rowData M n j c ∘ rawData M n j := by |
| funext y |
| apply Prod.ext |
| · funext v |
| simp [selectData, rollData, rowData, rawData, amap, parameter, roll, plane, |
| Fin.insertNth_zero'] |
| · funext k v |
| simp [selectData, rollData, rowData, rawData, amap, roll, plane, planes, |
| Fin.insertNth_zero', Fin.insertNth_last', cons_snoc] |
| |
| end Object.Rolled |
| end ArrayObjects |
| namespace ArrayObjects.Object.Rolled |
| variable {I : Type u} [Fintype I] [DecidableEq I] {X : StandardSpace.{u}} {T : X ≃ᵐ X} |
| {base : InitialLaws I X T} (M : Object I base) |
| |
| def IsConditional (R : Finset I) : Prop := |
| ∀ n (J : Finset I), J ≠ Finset.univ → |
| condDistrib (planes n J) (amap (parameter M R) (n + 1)) (law M (n + 1)) |
| =ᵐ[(law M (n + 1)).map (amap (parameter M R) (n + 1))] |
| fun p => Measure.pi (fun j : J => |
| condDistrib (id : Arr I (State M) n → Arr I (State M) n) |
| (amap (parameter M R) n) (law M n) (plane n (Fin.last n) j p)) |
| |
| noncomputable def makeObject (R : Finset I) (hc : IsConditional M R) |
| (a : I) (ha : a ∉ R) (hR : insert a R ≠ Finset.univ) : Object I base where |
| Y := State M |
| U := Parameter M R |
| timeY := timeState M |
| timeU := timeParameter M R |
| x := M.x ∘ Function.eval a |
| par := parameter M R |
| measurable_x := M.measurable_x.comp (measurable_pi_apply a) |
| measurable_par := measurable_parameter M R |
| time_x := by funext y; exact congrFun M.time_x (y a) |
| time_par := time_parameter M R |
| law := law M |
| probability := law_probability M |
| invariant := invariant M |
| over_base := fun n => over_base M n a |
| consistent := consistent M |
| proper := proper M |
| conditional := hc |
| local_independent := local_independent M R a ha hR |
|
|
| noncomputable def extension (R : Finset I) (hc : IsConditional M R) |
| (a : I) (ha : a ∉ R) (hR : insert a R ≠ Finset.univ) : |
| Extension M (makeObject M R hc a ha hR) where |
| state := Function.eval a |
| parameter := fun p => p.1 a |
| measurable_state := measurable_pi_apply a |
| measurable_parameter := (measurable_pi_apply a).comp measurable_fst |
| time_state := rfl |
| time_parameter := rfl |
| state_x := rfl |
| state_par := rfl |
| laws n := select_law M n a |
|
|
| noncomputable def rowKernel (n : ℕ) (j c : I) : Kernel (RawData M n j) (Arr I M.Y n) := |
| (condDistrib (plane n (Fin.last n) j) (oldData M n j) (M.law (n + 1))).comap |
| (rowData M n j c) (measurable_rowData M n j c) |
| instance rowKernel_markov (n : ℕ) (j c : I) : IsMarkovKernel (rowKernel M n j c) := by |
| unfold rowKernel |
| infer_instance |
| |
| lemma parent_reveal (hM : M.IsSaturated) (R : Finset I) (hc : IsConditional M R) |
| (c : I) (hcR : c ∉ R) (hR : insert c R ≠ Finset.univ) (n : ℕ) (j : I) : |
| HasCondDistrib (missingRow M n j c) (revealData M R n j) |
| ((rowKernel M n j c).prodMkRight (R → Arr I M.Y n)) (M.law (n + 2)) := by |
| let N := makeObject M R hc c hcR hR |
| let ext := extension M R hc c hcR hR |
| have hs := hM.hasCondDistrib ext n (.enlarged j) |
| (oldData M n j) (rollData M R n j) (plane n (Fin.last n) j) |
| (selectData M R n j c) (measurable_oldData M n j) (measurable_rollData M R n j) |
| (measurable_plane _ _ _) (measurable_selectData M R n j c) |
| (by |
| unfold Object.data oldData Outside |
| exact (MeasurableSpace.comap_prodMk (mβ := inferInstance) (mγ := inferInstance) |
| (amap M.par (n + 1)) (planes n (Outside j))).symm) |
| (by |
| unfold Object.data rollData Outside makeObject |
| exact (MeasurableSpace.comap_prodMk (mβ := inferInstance) (mγ := inferInstance) |
| (amap (parameter M R) (n + 1)) (planes n (Outside j))).symm) rfl |
| have hp := ConditionalTransport.pullback |
| (show MeasurePreserving (roll (Y := M.Y) (n + 1)) (M.law (n + 2)) (N.law (n + 1)) from |
| ⟨(roll (n + 1)).measurable, rfl⟩) (measurable_rollData M R n j) hs |
| have hobs : (plane n (Fin.last n) j ∘ amap (Function.eval c) (n + 1)) ∘ roll (n + 1) = |
| missingRow M n j c := by |
| rw [Function.comp_assoc, select_roll] |
| rfl |
| change HasCondDistrib ((plane n (Fin.last n) j ∘ amap (Function.eval c) (n + 1)) ∘ |
| roll (n + 1)) (rollData M R n j ∘ roll (n + 1)) _ (M.law _) at hp |
| rw [hobs] at hp |
| apply ConditionalTransport.recondition |
| ((measurable_rollData M R n j).comp (roll (n + 1)).measurable) |
| (measurable_revealData M R n j) (measurable_missingRow M n j c) hp |
| (comap_reveal_eq_rollData M R n j).symm |
| apply Filter.Eventually.of_forall |
| intro y |
| change (condDistrib (plane n (Fin.last n) j) (oldData M n j) (M.law (n + 1))) |
| ((selectData M R n j c ∘ rollData M R n j ∘ roll (n + 1)) y) = |
| (condDistrib (plane n (Fin.last n) j) (oldData M n j) (M.law (n + 1))) |
| ((rowData M n j c ∘ rawData M n j) y) |
| rw [selectData_observation] |
| |
| |
| lemma parent_joint (hM : M.IsSaturated) (R : Finset I) |
| (hR : R.card + 2 ≤ Fintype.card I) |
| (ih : ∀ S : Finset I, S ⊂ R → IsConditional M S) (n : ℕ) (j : I) : |
| HasCondDistrib (fun y => fun c : R => missingRow M n j c y) (rawData M n j) |
| (FiniteKernel.pi (fun c : R => rowKernel M n j c)) (M.law (n + 2)) := by |
| apply ConditionalReveal.finite_reveal _ _ (measurable_rawData M n j) |
| intro S hS c hc hcS |
| have hstrict : S ⊂ R := (Finset.ssubset_iff_subset_ne).mpr ⟨hS, by |
| intro he; subst S; exact hcS hc⟩ |
| have hproper : insert c S ≠ Finset.univ := by |
| intro he |
| have hle : (insert c S).card ≤ R.card := Finset.card_le_card |
| (Finset.insert_subset hc hS) |
| rw [he, Finset.card_univ] at hle |
| omega |
| exact parent_reveal M hM S (ih S hstrict) c hcS hproper n j |
| |
| end ArrayObjects.Object.Rolled |
| |
| namespace LocalConditioning |
| open FiniteKernel ConditionalScreens |
| |
| variable {Ω X Y A : Type*} [MeasurableSpace Ω] [MeasurableSpace X] |
| [MeasurableSpace Y] [MeasurableSpace A] |
| |
| noncomputable def observe (κ : Kernel X Y) (a : X × Y → A) (ha : Measurable a) : |
| Kernel X (A × Y) := |
| (κ ⊗ₖ Kernel.deterministic a ha).map Prod.swap |
| |
| instance (κ : Kernel X Y) [IsMarkovKernel κ] (a : X × Y → A) (ha : Measurable a) : |
| IsMarkovKernel (observe κ a ha) := |
| Kernel.IsMarkovKernel.map _ measurable_swap |
| |
| theorem observe_apply (κ : Kernel X Y) [IsMarkovKernel κ] |
| (a : X × Y → A) (ha : Measurable a) (x : X) : |
| observe κ a ha x = (κ x).map (fun y => (a (x, y), y)) := by |
| rw [observe, Kernel.map_apply _ measurable_swap, |
| Kernel.compProd_apply_eq_compProd_sectR] |
| have heq : Kernel.sectR (Kernel.deterministic a ha) x = |
| Kernel.deterministic (fun y => a (x, y)) (ha.comp measurable_prodMk_left) := by |
| ext y : 1 |
| rfl |
| rw [heq, Measure.compProd_deterministic] |
| rw [Measure.map_map measurable_swap (by fun_prop)] |
| rfl |
| |
| theorem deterministic {P : Measure Ω} [SFinite P] {x : Ω → X} |
| (hx : AEMeasurable x P) (a : X → A) (ha : Measurable a) : |
| HasCondDistrib (a ∘ x) x (Kernel.deterministic a ha) P := by |
| refine ⟨hx.prodMk (ha.comp_aemeasurable hx), ?_⟩ |
| rw [Measure.compProd_deterministic, |
| AEMeasurable.map_map_of_aemeasurable (by fun_prop) hx] |
| rfl |
| |
| theorem hasCondDistrib_observe {P : Measure Ω} [SFinite P] {x : Ω → X} {y : Ω → Y} |
| {κ : Kernel X Y} [IsMarkovKernel κ] (h : HasCondDistrib y x κ P) |
| (a : X × Y → A) (ha : Measurable a) : |
| HasCondDistrib (fun ω => (a (x ω, y ω), y ω)) x (observe κ a ha) P := by |
| have h' := chain h (deterministic h.aemeasurable a ha) |
| exact h'.comp_left measurable_swap |
| |
| variable {ι : Type*} [Fintype ι] |
| {O C : ι → Type*} [∀ i, MeasurableSpace (O i)] [∀ i, MeasurableSpace (C i)] |
| |
| theorem observe_pi (κ : ∀ i, Kernel X (O i)) [∀ i, IsMarkovKernel (κ i)] |
| (a : ∀ i, X × O i → C i) (ha : ∀ i, Measurable (a i)) : |
| observe (pi κ) (fun p : X × (∀ i, O i) => fun i => a i (p.1, p.2 i)) (by fun_prop) = |
| (pi (fun i => observe (κ i) (a i) (ha i))).map (zipEquiv C O).symm := by |
| ext x : 1 |
| rw [observe_apply, Kernel.map_apply _ (zipEquiv C O).symm.measurable] |
| simp only [pi_apply, observe_apply] |
| rw [← Measure.pi_map_pi (fun i => (show Measurable (fun o => (a i (x, o), o)) by |
| fun_prop).aemeasurable), Measure.map_map (zipEquiv C O).symm.measurable (by fun_prop)] |
| rfl |
| |
| theorem compProd_comap {E : Type*} [MeasurableSpace E] |
| (κ : Kernel E A) [IsMarkovKernel κ] (η : Kernel (E × A) Y) [IsMarkovKernel η] |
| (e : X → E) (he : Measurable e) : |
| (κ ⊗ₖ η).comap e he = κ.comap e he ⊗ₖ |
| η.comap (fun p : X × A => (e p.1, p.2)) (by fun_prop) := by |
| ext x s hs |
| simp only [Kernel.comap_apply, Kernel.compProd_apply hs] |
| |
| theorem observe_comap {E : Type*} [MeasurableSpace E] |
| (κ : Kernel E Y) [IsMarkovKernel κ] (a : E × Y → A) (ha : Measurable a) |
| (e : X → E) (he : Measurable e) : |
| observe (κ.comap e he) (fun p : X × Y => a (e p.1, p.2)) (by fun_prop) = |
| (observe κ a ha).comap e he := by |
| ext x : 1 |
| simp only [observe_apply, Kernel.comap_apply] |
| |
| theorem disintegrate_pi (κ : ∀ i, Kernel X (C i)) [∀ i, IsMarkovKernel (κ i)] |
| (η : ∀ i, Kernel (X × C i) (O i)) [∀ i, IsMarkovKernel (η i)] : |
| (pi (fun i => κ i ⊗ₖ η i)).map (zipEquiv C O).symm = |
| pi κ ⊗ₖ pi (fun i => (η i).comap |
| (fun p : X × (∀ i, C i) => (p.1, p.2 i)) (by fun_prop)) := by |
| rw [← pi_compProd, ← Kernel.map_comp_right _ (zipEquiv C O).measurable |
| (zipEquiv C O).symm.measurable] |
| convert Kernel.map_id _ using 1 |
| ext x i |
| rfl |
| |
| theorem hasCondDistrib_update {P : Measure Ω} [SFinite P] |
| {x : Ω → X} {o : Ω → ∀ i, O i} |
| (κ : ∀ i, Kernel X (O i)) [∀ i, IsMarkovKernel (κ i)] |
| (a : ∀ i, X × O i → C i) (ha : ∀ i, Measurable (a i)) |
| (M : ∀ i, Kernel X (C i)) [∀ i, IsMarkovKernel (M i)] |
| (Q : ∀ i, Kernel (X × C i) (O i)) [∀ i, IsMarkovKernel (Q i)] |
| (hd : ∀ i, observe (κ i) (a i) (ha i) = M i ⊗ₖ Q i) |
| (ho : HasCondDistrib o x (pi κ) P) : |
| HasCondDistrib o (fun ω => (x ω, fun i => a i (x ω, o ω i))) |
| (pi (fun i => (Q i).comap |
| (fun p : X × (∀ i, C i) => (p.1, p.2 i)) (by fun_prop))) P := by |
| have h := hasCondDistrib_observe ho |
| (fun p : X × (∀ i, O i) => fun i => a i (p.1, p.2 i)) (by fun_prop) |
| have hpi : pi (fun i => observe (κ i) (a i) (ha i)) = pi (fun i => M i ⊗ₖ Q i) := by |
| ext x : 1 |
| simp only [pi_apply, hd] |
| rw [observe_pi κ a ha, hpi, disintegrate_pi] at h |
| exact h.of_compProd |
| |
| theorem hasCondDistrib_local_update {P : Measure Ω} [SFinite P] |
| {E : ι → Type*} [∀ i, MeasurableSpace (E i)] |
| [∀ i, MeasurableSpace.CountablyGenerated (C i)] |
| [∀ i, StandardBorelSpace (O i)] [∀ i, Nonempty (O i)] |
| {x : Ω → X} {o : Ω → ∀ i, O i} |
| (e : ∀ i, X → E i) (he : ∀ i, Measurable (e i)) |
| (κ : ∀ i, Kernel (E i) (O i)) [∀ i, IsMarkovKernel (κ i)] |
| (a : ∀ i, E i × O i → C i) (ha : ∀ i, Measurable (a i)) |
| (ho : HasCondDistrib o x (pi (fun i => (κ i).comap (e i) (he i))) P) : |
| HasCondDistrib o (fun ω => (x ω, fun i => a i (e i (x ω), o ω i))) |
| (pi (fun i => (observe (κ i) (a i) (ha i)).condKernel.comap |
| (fun p : X × (∀ i, C i) => (e i p.1, p.2 i)) (by fun_prop))) P := by |
| let M (i : ι) : Kernel X (C i) := |
| (observe (κ i) (a i) (ha i)).fst.comap (e i) (he i) |
| let Q (i : ι) : Kernel (X × C i) (O i) := |
| (observe (κ i) (a i) (ha i)).condKernel.comap |
| (fun p : X × C i => (e i p.1, p.2)) (by fun_prop) |
| have hd (i : ι) : observe ((κ i).comap (e i) (he i)) |
| (fun p : X × O i => a i (e i p.1, p.2)) (by fun_prop) = M i ⊗ₖ Q i := by |
| rw [observe_comap] |
| dsimp only [M, Q] |
| rw [← compProd_comap, Kernel.disintegrate] |
| have h := hasCondDistrib_update (fun i => (κ i).comap (e i) (he i)) |
| (fun i => fun p : X × O i => a i (e i p.1, p.2)) (by intro i; fun_prop) |
| M Q hd ho |
| convert h using 1 |
| ext x : 1 |
| rfl |
| |
| theorem hasCondDistrib_posterior [MeasurableSpace.CountablyGenerated A] |
| [StandardBorelSpace Y] [Nonempty Y] |
| {P : Measure Ω} [SFinite P] {x : Ω → X} {y : Ω → Y} |
| {κ : Kernel X Y} [IsMarkovKernel κ] (ho : HasCondDistrib y x κ P) |
| (a : X × Y → A) (ha : Measurable a) : |
| HasCondDistrib y (fun ω => (x ω, a (x ω, y ω))) |
| (observe κ a ha).condKernel P := by |
| have h := hasCondDistrib_observe ho a ha |
| rw [← Kernel.disintegrate (observe κ a ha) (observe κ a ha).condKernel] at h |
| exact h.of_compProd |
| |
| theorem local_conditioning {P : Measure Ω} [SFinite P] |
| {E : ι → Type*} [∀ i, MeasurableSpace (E i)] |
| [∀ i, MeasurableSpace.CountablyGenerated (C i)] |
| [∀ i, StandardBorelSpace (O i)] [∀ i, Nonempty (O i)] |
| {B : Type*} [MeasurableSpace B] |
| {x : Ω → X} {o : Ω → ∀ i, O i} {b : Ω → B} |
| (e : ∀ i, X → E i) (he : ∀ i, Measurable (e i)) |
| (κ : ∀ i, Kernel (E i) (O i)) [∀ i, IsMarkovKernel (κ i)] |
| (a : ∀ i, E i × O i → C i) (ha : ∀ i, Measurable (a i)) |
| (L : Kernel (X × (∀ i, C i)) B) [IsMarkovKernel L] |
| (ho : HasCondDistrib o x (pi (fun i => (κ i).comap (e i) (he i))) P) |
| (hb : HasCondDistrib b (fun ω => (x ω, o ω)) |
| (L.comap (fun p : X × (∀ i, O i) => (p.1, fun i => a i (e i p.1, p.2 i))) |
| (by fun_prop)) P) : |
| HasCondDistrib o (fun ω => ((x ω, fun i => a i (e i (x ω), o ω i)), b ω)) |
| ((pi (fun i => (observe (κ i) (a i) (ha i)).condKernel.comap |
| (fun p : X × (∀ i, C i) => (e i p.1, p.2 i)) (by fun_prop))).prodMkRight B) P := by |
| have hu := hasCondDistrib_local_update e he κ a ha ho |
| let f : X × (∀ i, O i) → (X × (∀ i, C i)) × (∀ i, O i) := |
| fun p => ((p.1, fun i => a i (e i p.1, p.2 i)), p.2) |
| have hf : Measurable f := by dsimp [f]; fun_prop |
| have heq : (L.prodMkRight (∀ i, O i)).comap f hf = |
| L.comap (fun p : X × (∀ i, O i) => (p.1, fun i => a i (e i p.1, p.2 i))) |
| (by fun_prop) := by |
| ext p : 1 |
| rfl |
| have hb' : HasCondDistrib b (fun ω => (x ω, o ω)) |
| ((L.prodMkRight (∀ i, O i)).comap f hf) P := by rw [heq]; exact hb |
| exact screening hu L hb'.comp_right |
| |
| end LocalConditioning |
| |
| namespace ArrayObjects.Object.Rolled |
| |
| section |
| variable {I : Type u} [Fintype I] {X : StandardSpace.{u}} {T : X ≃ᵐ X} |
| {base : InitialLaws I X T} (M : Object I base) |
| |
| def parameterEquiv (R : Finset I) (n : ℕ) : |
| Arr I (Parameter M R) n ≃ᵐ (Arr I M.U (n + 1) × (R → Arr I M.Y n)) where |
| toFun p := (fun v => (p (Fin.tail v)).1 (v 0), fun c w => (p w).2 c) |
| invFun p w := (fun c => p.1 (Fin.cons c w), fun c => p.2 c w) |
| left_inv p := by funext w; rfl |
| right_inv p := by apply Prod.ext <;> funext v <;> simp |
| measurable_toFun := by |
| exact (Measurable.of_eval (fun _ => (measurable_pi_apply _).comp |
| (measurable_fst.comp (measurable_pi_apply _)))).prodMk |
| (Measurable.of_eval (fun _ => Measurable.of_eval (fun _ => |
| (measurable_pi_apply _).comp (measurable_snd.comp (measurable_pi_apply _))))) |
| measurable_invFun := by |
| exact Measurable.of_eval (fun _ => |
| (Measurable.of_eval (fun _ => (measurable_pi_apply _).comp measurable_fst)).prodMk |
| (Measurable.of_eval (fun _ => (measurable_pi_apply _).comp |
| ((measurable_pi_apply _).comp measurable_snd)))) |
|
|
| def parents (R : Finset I) (n : ℕ) (y : Arr I M.Y (n + 1)) : R → Arr I M.Y n := |
| fun c => plane n 0 c y |
| @[fun_prop] lemma measurable_parents (R : Finset I) (n : ℕ) : Measurable (parents M R n) := |
| Measurable.of_eval (fun _ => measurable_plane _ _ _) |
|
|
| lemma parameterEquiv_observation (R : Finset I) (n : ℕ) : |
| parameterEquiv M R n ∘ amap (parameter M R) n ∘ roll n = |
| fun y => (amap M.par (n + 1) y, parents M R n y) := by |
| funext y |
| apply Prod.ext |
| · funext v; simp [parameterEquiv, amap, parameter, roll] |
| · funext c w; simp [parameterEquiv, amap, parameter, roll, parents, plane, |
| Fin.insertNth_zero'] |
|
|
| def posterior (R : Finset I) (n : ℕ) : |
| Kernel (Arr I M.U (n + 1) × (R → Arr I M.Y n)) (Arr I M.Y (n + 1)) := |
| (LocalConditioning.observe (M.ownKernel (n + 1)) |
| (fun p => parents M R n p.2) ((measurable_parents M R n).comp measurable_snd)).condKernel |
| instance posterior_markov (R : Finset I) (n : ℕ) : IsMarkovKernel (posterior M R n) := by |
| unfold posterior |
| infer_instance |
| |
| def ownPosterior (R : Finset I) (n : ℕ) : |
| Kernel (Arr I (Parameter M R) n) (Arr I (State M) n) := |
| ((posterior M R n).map (roll n)).comap (parameterEquiv M R n) |
| (parameterEquiv M R n).measurable |
| instance ownPosterior_markov (R : Finset I) (n : ℕ) : IsMarkovKernel (ownPosterior M R n) := by |
| unfold ownPosterior |
| let := Kernel.IsMarkovKernel.map (posterior M R n) (roll n).measurable |
| infer_instance |
| |
| lemma roll_symm_preserving (n : ℕ) : |
| MeasurePreserving (roll (I := I) (Y := M.Y) n).symm (law M n) (M.law (n + 1)) := by |
| refine ⟨(roll n).symm.measurable, ?_⟩ |
| rw [law, Measure.map_map (roll n).symm.measurable (roll n).measurable] |
| simp |
| |
| lemma ownPosterior_conditional (R : Finset I) (n : ℕ) : |
| HasCondDistrib id (amap (parameter M R) n) (ownPosterior M R n) (law M n) := by |
| have h := LocalConditioning.hasCondDistrib_posterior (M.ownKernel_conditional (n + 1)) |
| (fun p => parents M R n p.2) ((measurable_parents M R n).comp measurable_snd) |
| change HasCondDistrib id |
| (fun y => (amap M.par (n + 1) y, parents M R n y)) (posterior M R n) (M.law _) at h |
| have h' := (h.comp_left (roll n).measurable).measurableEquiv_comp_right |
| (parameterEquiv M R n).symm |
| have hobs : (parameterEquiv M R n).symm ∘ |
| (fun y => (amap M.par (n + 1) y, parents M R n y)) = |
| amap (parameter M R) n ∘ roll n := by |
| rw [← parameterEquiv_observation] |
| funext y |
| exact (parameterEquiv M R n).symm_apply_apply _ |
| rw [hobs] at h' |
| have hout := ConditionalTransport.pullback (roll_symm_preserving M n) |
| ((measurable_amap (measurable_parameter M R) n).comp (roll n).measurable) h' |
| simpa only [ownPosterior, MeasurableEquiv.symm_symm, Function.comp_assoc, MeasurableEquiv.self_comp_symm, |
| Function.comp_id, Function.id_comp] using hout |
| |
| end |
| |
| variable {I : Type u} [Fintype I] [DecidableEq I] {X : StandardSpace.{u}} {T : X ≃ᵐ X} |
| {base : InitialLaws I X T} (M : Object I base) |
| |
| abbrev ParentOutside (R : Finset I) (n : ℕ) (j : I) := |
| Arr I M.U (n + 2) × (Outside j → R → Arr I M.Y n) |
| abbrev ScreenData (R : Finset I) (n : ℕ) (j : I) := |
| ParentOutside M R n j × (R → Arr I M.Y n) |
| |
| def parentOutside (R : Finset I) (n : ℕ) (j : I) (p : RawData M n j) : |
| ParentOutside M R n j := (p.1, fun k => parents M R n (p.2 k)) |
| omit [DecidableEq I] in |
| @[fun_prop] lemma measurable_parentOutside (R : Finset I) (n : ℕ) (j : I) : |
| Measurable (parentOutside M R n j) := by |
| unfold parentOutside |
| fun_prop |
| |
| def parentRow (R : Finset I) (n : ℕ) (j : I) (c : R) (p : ParentOutside M R n j) : |
| OldData M n j := (plane (n + 1) 0 c p.1, fun k => p.2 k c) |
| omit [DecidableEq I] in |
| @[fun_prop] lemma measurable_parentRow (R : Finset I) (n : ℕ) (j : I) (c : R) : |
| Measurable (parentRow M R n j c) := by |
| unfold parentRow |
| fun_prop |
| |
| def parentsKernel (R : Finset I) (n : ℕ) (j : I) : |
| Kernel (ParentOutside M R n j) (R → Arr I M.Y n) := |
| FiniteKernel.pi (fun c : R => |
| (condDistrib (plane n (Fin.last n) j) (oldData M n j) (M.law (n + 1))).comap |
| (parentRow M R n j c) (measurable_parentRow M R n j c)) |
| instance parentsKernel_markov (R : Finset I) (n : ℕ) (j : I) : |
| IsMarkovKernel (parentsKernel M R n j) := by |
| unfold parentsKernel |
| infer_instance |
| |
| omit [DecidableEq I] in |
| lemma parentsKernel_comap (R : Finset I) (n : ℕ) (j : I) : |
| (parentsKernel M R n j).comap (parentOutside M R n j) |
| (measurable_parentOutside M R n j) = |
| FiniteKernel.pi (fun c : R => rowKernel M n j c) := by |
| ext p : 1 |
| rfl |
| |
| def screenData (R : Finset I) (n : ℕ) (j : I) (y : Arr I M.Y (n + 2)) : |
| ScreenData M R n j := |
| (parentOutside M R n j (rawData M n j y), fun c => missingRow M n j c y) |
| omit [DecidableEq I] in |
| @[fun_prop] lemma measurable_screenData (R : Finset I) (n : ℕ) (j : I) : |
| Measurable (screenData M R n j) := by |
| unfold screenData |
| exact ((measurable_parentOutside M R n j).comp (measurable_rawData M n j)).prodMk |
| (Measurable.of_eval (fun c => measurable_missingRow M n j c)) |
| |
| def screenKernel (R : Finset I) (n : ℕ) (j : I) : |
| Kernel (ScreenData M R n j) (Outside j → Arr I M.Y (n + 1)) := |
| (FiniteKernel.pi (fun k : Outside j => (posterior M R n).comap |
| (fun p : ParentOutside M R n j => (plane (n + 1) (Fin.last (n + 1)) k p.1, p.2 k)) |
| (by fun_prop))).prodMkRight (R → Arr I M.Y n) |
| instance screenKernel_markov (R : Finset I) (n : ℕ) (j : I) : |
| IsMarkovKernel (screenKernel M R n j) := by |
| unfold screenKernel |
| infer_instance |
| |
| lemma screen_conditional (hM : M.IsSaturated) (R : Finset I) |
| (hR : R.card + 2 ≤ Fintype.card I) |
| (ih : ∀ S : Finset I, S ⊂ R → IsConditional M S) (n : ℕ) (j : I) : |
| HasCondDistrib (planes (n + 1) (Outside j)) (screenData M R n j) |
| (screenKernel M R n j) (M.law (n + 2)) := by |
| have hproper : Outside j ≠ Finset.univ := by |
| intro he |
| have hj : j ∈ Outside j := he.symm ▸ Finset.mem_univ j |
| simp [Outside] at hj |
| have hb := parent_joint M hM R hR ih n j |
| rw [← parentsKernel_comap] at hb |
| exact LocalConditioning.local_conditioning |
| (fun k : Outside j => plane (n + 1) (Fin.last (n + 1)) (k : I)) |
| (fun _ => measurable_plane _ _ _) (fun _ => M.ownKernel (n + 1)) |
| (fun _ => fun p => parents M R n p.2) |
| (fun _ => (measurable_parents M R n).comp measurable_snd) |
| (parentsKernel M R n j) (M.planes_conditional (n + 1) (Outside j) hproper) hb |
| |
| def screenEquiv (R : Finset I) (n : ℕ) (j : I) : |
| Arr I (Parameter M R) (n + 1) ≃ᵐ ScreenData M R n j where |
| toFun p := ((fun v => (p (Fin.tail v)).1 (v 0), |
| fun k c v => (p (Fin.snoc v (k : I))).2 c), fun c v => (p (Fin.snoc v j)).2 c) |
| invFun p w := (fun c => p.1.1 (Fin.cons c w), fun c => |
| if h : w (Fin.last n) = j then p.2 c (Fin.init w) else |
| p.1.2 ⟨w (Fin.last n), by simp [Outside, h]⟩ c (Fin.init w)) |
| left_inv p := by |
| funext w |
| apply Prod.ext |
| · rfl |
| · funext c |
| dsimp only |
| split_ifs with h |
| · rw [← h, Fin.snoc_init_self] |
| · rw [Fin.snoc_init_self] |
| right_inv p := by |
| apply Prod.ext |
| · apply Prod.ext |
| · funext v; simp |
| · funext k c v |
| have hk : (k : I) ≠ j := |
| @Finset.ne_of_mem_erase I (fun a b => Classical.propDecidable (a = b)) |
| _ _ _ k.property |
| simp [hk] |
| · funext c v |
| simp |
| measurable_toFun := by |
| exact ((Measurable.of_eval (fun _ => (measurable_pi_apply _).comp |
| (measurable_fst.comp (measurable_pi_apply _)))).prodMk |
| (Measurable.of_eval (fun _ => Measurable.of_eval (fun _ => |
| Measurable.of_eval (fun _ => (measurable_pi_apply _).comp |
| (measurable_snd.comp (measurable_pi_apply _))))))).prodMk |
| (Measurable.of_eval (fun _ => Measurable.of_eval (fun _ => |
| (measurable_pi_apply _).comp (measurable_snd.comp (measurable_pi_apply _))))) |
| measurable_invFun := by |
| apply Measurable.of_eval |
| intro w |
| apply Measurable.prodMk |
| · fun_prop |
| · apply Measurable.of_eval |
| intro c |
| split_ifs <;> fun_prop |
|
|
| lemma screenEquiv_observation (R : Finset I) (n : ℕ) (j : I) : |
| screenEquiv M R n j ∘ amap (parameter M R) (n + 1) ∘ roll (n + 1) = |
| screenData M R n j := by |
| funext y |
| apply Prod.ext |
| · apply Prod.ext |
| · funext v; simp [screenEquiv, screenData, parentOutside, rawData, amap, parameter, roll] |
| · funext k c v |
| simp [screenEquiv, screenData, parentOutside, rawData, parents, planes, plane, |
| amap, parameter, roll, Fin.insertNth_zero', Fin.insertNth_last', cons_snoc] |
| · funext c v |
| simp [screenEquiv, screenData, amap, parameter, roll, missingRow, plane, |
| Fin.insertNth_zero', Fin.insertNth_last'] |
|
|
|
|
| lemma screen_plane_parameters (R : Finset I) (n : ℕ) (j : I) |
| (p : Arr I (Parameter M R) (n + 1)) (k : Outside j) : |
| (plane (n + 1) (Fin.last (n + 1)) (k : I) (screenEquiv M R n j p).1.1, |
| (screenEquiv M R n j p).1.2 k) = |
| parameterEquiv M R n (plane n (Fin.last n) (k : I) p) := by |
| apply Prod.ext |
| · funext v |
| obtain ⟨c, w, rfl⟩ := Fin.exists_cons v |
| simp [screenEquiv, parameterEquiv, plane, Fin.insertNth_last', ← cons_snoc] |
| · funext c w |
| simp [screenEquiv, parameterEquiv, plane, Fin.insertNth_last'] |
|
|
| lemma screenKernel_roll (R : Finset I) (n : ℕ) (j : I) : |
| ((screenKernel M R n j).map (fun z k => roll n (z k))).comap |
| (screenEquiv M R n j) (screenEquiv M R n j).measurable = |
| FiniteKernel.pi (fun k : Outside j => (ownPosterior M R n).comap |
| (plane n (Fin.last n) k) (measurable_plane _ _ _)) := by |
| ext p : 1 |
| rw [Kernel.comap_apply] |
| have hm : Measurable (fun z : Outside j → Arr I M.Y (n + 1) => |
| fun k => roll n (z k)) := by fun_prop |
| rw [Kernel.map_apply _ hm] |
| change (Measure.pi (fun k : Outside j => posterior M R n |
| (plane (n + 1) (Fin.last (n + 1)) (k : I) (screenEquiv M R n j p).1.1, |
| (screenEquiv M R n j p).1.2 k))).map (fun z k => roll n (z k)) = _ |
| rw [Measure.pi_map_pi (fun _ => (roll n).measurable.aemeasurable)] |
| congr 1 |
| funext k |
| rw [screen_plane_parameters] |
| change _ = ((posterior M R n).map (roll n)) _ |
| rw [Kernel.map_apply _ (roll n).measurable] |
|
|
| lemma outside_conditional (hM : M.IsSaturated) (R : Finset I) |
| (hR : R.card + 2 ≤ Fintype.card I) |
| (ih : ∀ S : Finset I, S ⊂ R → IsConditional M S) (n : ℕ) (j : I) : |
| HasCondDistrib (planes n (Outside j)) (amap (parameter M R) (n + 1)) |
| (FiniteKernel.pi (fun k : Outside j => (ownPosterior M R n).comap |
| (plane n (Fin.last n) k) (measurable_plane _ _ _))) (law M (n + 1)) := by |
| have h := screen_conditional M hM R hR ih n j |
| have h' := (h.comp_left (Measurable.of_eval (fun k => |
| (roll n).measurable.comp (measurable_pi_apply k)))).measurableEquiv_comp_right |
| (screenEquiv M R n j).symm |
| change HasCondDistrib ((fun z k => roll n (z k)) ∘ planes (n + 1) (Outside j)) |
| ((screenEquiv M R n j).symm ∘ screenData M R n j) |
| (((screenKernel M R n j).map (fun z k => roll n (z k))).comap |
| (screenEquiv M R n j) (screenEquiv M R n j).measurable) (M.law (n + 2)) at h' |
| rw [screenKernel_roll, ← planes_roll] at h' |
| have hobs : (screenEquiv M R n j).symm ∘ screenData M R n j = |
| amap (parameter M R) (n + 1) ∘ roll (n + 1) := by |
| rw [← screenEquiv_observation] |
| funext y |
| exact (screenEquiv M R n j).symm_apply_apply _ |
| rw [hobs] at h' |
| have hout := ConditionalTransport.pullback (roll_symm_preserving M (n + 1)) |
| ((measurable_amap (measurable_parameter M R) _).comp (roll (n + 1)).measurable) h' |
| simpa only [Function.comp_assoc, MeasurableEquiv.self_comp_symm, Function.comp_id] using hout |
|
|
|
|
| end ArrayObjects.Object.Rolled |
|
|
| namespace FiniteKernel |
| open MeasureTheory ProbabilityTheory |
|
|
| lemma measure_pi_precomp {ι τ : Type*} [Fintype ι] [Fintype τ] |
| {Y : ι → Type*} [∀ i, MeasurableSpace (Y i)] |
| (μ : ∀ i, Measure (Y i)) [∀ i, IsProbabilityMeasure (μ i)] (e : τ ↪ ι) : |
| (Measure.pi μ).map (fun y i => y (e i)) = Measure.pi (fun i => μ (e i)) := by |
| have hi : iIndepFun (fun i : ι => Function.eval i) (Measure.pi μ) := |
| iIndepFun_pi (fun _ => measurable_id.aemeasurable) |
| rw [(hi.precomp e.injective).map_fun_eq_pi_map |
| (fun i => (measurable_pi_apply (e i)).aemeasurable)] |
| congr 1 |
| funext i |
| exact (measurePreserving_eval μ (e i)).map_eq |
|
|
| lemma pi_precomp {ι τ X : Type*} [Fintype ι] [Fintype τ] |
| {Y : ι → Type*} [∀ i, MeasurableSpace (Y i)] [MeasurableSpace X] |
| (κ : ∀ i, Kernel X (Y i)) [∀ i, IsMarkovKernel (κ i)] (e : τ ↪ ι) : |
| (pi κ).map (fun y i => y (e i)) = pi (fun i => κ (e i)) := by |
| ext x : 1 |
| rw [Kernel.map_apply _ (by fun_prop)] |
| exact measure_pi_precomp _ e |
|
|
| end FiniteKernel |
|
|
| namespace ArrayObjects.Object.Rolled |
| variable {I : Type u} [Fintype I] [DecidableEq I] {X : StandardSpace.{u}} {T : X ≃ᵐ X} |
| {base : InitialLaws I X T} (M : Object I base) |
|
|
| lemma proper_conditional (hM : M.IsSaturated) (R : Finset I) |
| (hR : R.card + 2 ≤ Fintype.card I) |
| (ih : ∀ S : Finset I, S ⊂ R → IsConditional M S) (n : ℕ) |
| (J : Finset I) (hJ : J ≠ Finset.univ) : |
| HasCondDistrib (planes n J) (amap (parameter M R) (n + 1)) |
| (FiniteKernel.pi (fun k : J => (ownPosterior M R n).comap |
| (plane n (Fin.last n) k) (measurable_plane _ _ _))) (law M (n + 1)) := by |
| have hj : ∃ j, j ∉ J := by |
| by_contra! h |
| exact hJ (Finset.eq_univ_of_forall h) |
| obtain ⟨j, hj⟩ := hj |
| let e : J ↪ Outside j := ⟨fun k => ⟨k, by |
| have hk : (k : I) ≠ j := by intro he; exact hj (he ▸ k.property) |
| simpa [Outside] using And.intro hk (Finset.mem_univ (k : I))⟩, |
| fun x y h => Subtype.ext (show (x : I) = (y : I) from |
| congrArg (fun v : Outside j => (v : I)) h)⟩ |
| have h := (outside_conditional M hM R hR ih n j).comp_left |
| (show Measurable (fun z : Outside j → Arr I (State M) n => fun k => z (e k)) by fun_prop) |
| rw [FiniteKernel.pi_precomp] at h |
| exact h |
|
|
| omit [DecidableEq I] in |
| lemma parameter_plane_preserving (R : Finset I) (n : ℕ) (j : I) : |
| MeasurePreserving (plane n (Fin.last n) j) |
| ((law M (n + 1)).map (amap (parameter M R) (n + 1))) |
| ((law M n).map (amap (parameter M R) n)) := by |
| refine ⟨measurable_plane _ _ _, ?_⟩ |
| rw [Measure.map_map (measurable_plane _ _ _) |
| (measurable_amap (measurable_parameter M R) _), plane_amap, |
| ← Measure.map_map (measurable_amap (measurable_parameter M R) _) |
| (measurable_plane _ _ _), consistent] |
|
|
| lemma conditional_step (hM : M.IsSaturated) (R : Finset I) |
| (hR : R.card + 2 ≤ Fintype.card I) |
| (ih : ∀ S : Finset I, S ⊂ R → IsConditional M S) : IsConditional M R := by |
| intro n J hJ |
| have ho := condDistrib_ae_eq_of_measure_eq_compProd (ownPosterior_conditional M R n).aemeasurable_fst |
| measurable_id.aemeasurable (ownPosterior_conditional M R n).map_eq |
| have hp := condDistrib_ae_eq_of_measure_eq_compProd (proper_conditional M hM R hR ih n J hJ).aemeasurable_fst |
| (measurable_planes n J).aemeasurable (proper_conditional M hM R hR ih n J hJ).map_eq |
| have hplanes : ∀ᵐ p ∂(law M (n + 1)).map (amap (parameter M R) (n + 1)), |
| ∀ j : J, condDistrib id (amap (parameter M R) n) (law M n) |
| (plane n (Fin.last n) j p) = ownPosterior M R n (plane n (Fin.last n) j p) := by |
| rw [ae_all_iff] |
| intro j |
| exact (parameter_plane_preserving M R n j).quasiMeasurePreserving.ae_eq_comp ho |
| filter_upwards [hp, hplanes] with p hp he |
| exact hp.trans (congrArg Measure.pi (funext fun j => (he j).symm)) |
|
|
| theorem isConditional (hM : M.IsSaturated) (R : Finset I) |
| (hR : R.card + 2 ≤ Fintype.card I) : IsConditional M R := by |
| have hall : ∀ R : Finset I, R.card + 2 ≤ Fintype.card I → IsConditional M R := by |
| intro R |
| refine Finset.strongInductionOn R ?_ |
| intro R ih hc |
| apply conditional_step M hM R hc |
| intro S hS |
| exact ih S hS (le_trans (Nat.add_le_add_right (Finset.card_le_card hS.1) 2) hc) |
| exact hall R hR |
|
|
| lemma insert_proper (R : Finset I) (hR : R.card + 2 ≤ Fintype.card I) |
| (a : I) (ha : a ∉ R) : insert a R ≠ Finset.univ := by |
| intro he |
| have h := congrArg Finset.card he |
| rw [Finset.card_insert_of_notMem ha, Finset.card_univ] at h |
| omega |
|
|
| def object (hM : M.IsSaturated) (R : Finset I) |
| (hR : R.card + 2 ≤ Fintype.card I) (a : I) (ha : a ∉ R) : Object I base := |
| makeObject M R (isConditional M hM R hR) a ha (insert_proper R hR a ha) |
|
|
| def objectExtension (hM : M.IsSaturated) (R : Finset I) |
| (hR : R.card + 2 ≤ Fintype.card I) (a : I) (ha : a ∉ R) : |
| Extension M (object M hM R hR a ha) := |
| extension M R (isConditional M hM R hR) a ha (insert_proper R hR a ha) |
|
|
|
|
| lemma row_reveal (hM : M.IsSaturated) (R : Finset I) |
| (hR : R.card + 2 ≤ Fintype.card I) (a : I) (ha : a ∉ R) (n : ℕ) : |
| HasCondDistrib (plane (n + 1) 0 a) |
| (fun y => (amap M.par (n + 2) y, parents M R (n + 1) y)) |
| (((M.ownKernel (n + 1)).comap (plane (n + 1) 0 a) |
| (measurable_plane _ _ _)).prodMkRight (R → Arr I M.Y (n + 1))) |
| (M.law (n + 2)) := by |
| let N := object M hM R hR a ha |
| let e := objectExtension M hM R hR a ha |
| let p : Arr I (Parameter M R) (n + 1) → Arr I M.U (n + 1) := |
| amap (fun z => z.1 a) (n + 1) |
| have hpm : Measurable p := measurable_amap ((measurable_pi_apply a).comp measurable_fst) _ |
| have hs := hM.hasCondDistrib e n .parameter |
| (amap M.par (n + 1)) (amap (parameter M R) (n + 1)) id p |
| (measurable_amap M.measurable_par _) (measurable_amap (measurable_parameter M R) _) |
| measurable_id hpm rfl rfl rfl |
| have hp := ConditionalTransport.pullback |
| (show MeasurePreserving (roll (Y := M.Y) (n + 1)) (M.law (n + 2)) (N.law (n + 1)) from |
| ⟨(roll (n + 1)).measurable, rfl⟩) |
| (measurable_amap (measurable_parameter M R) _) hs |
| have h := hp.measurableEquiv_comp_right (parameterEquiv M R (n + 1)) |
| change HasCondDistrib ((id ∘ amap (Function.eval a) (n + 1)) ∘ roll (n + 1)) |
| (parameterEquiv M R (n + 1) ∘ amap (parameter M R) (n + 1) ∘ roll (n + 1)) |
| (((M.ownKernel (n + 1)).comap p hpm).comap (parameterEquiv M R (n + 1)).symm |
| (parameterEquiv M R (n + 1)).symm.measurable) (M.law (n + 2)) at h |
| rw [Function.id_comp, select_roll, parameterEquiv_observation] at h |
| have hk : (((M.ownKernel (n + 1)).comap p hpm).comap |
| (parameterEquiv M R (n + 1)).symm (parameterEquiv M R (n + 1)).symm.measurable) = |
| (((M.ownKernel (n + 1)).comap (plane (n + 1) 0 a) |
| (measurable_plane _ _ _)).prodMkRight (R → Arr I M.Y (n + 1))) := by |
| ext z : 1 |
| change M.ownKernel (n + 1) (p ((parameterEquiv M R (n + 1)).symm z)) = |
| M.ownKernel (n + 1) (plane (n + 1) 0 a z.1) |
| congr 1 |
| funext v |
| change z.1 (Fin.cons a v) = z.1 ((0 : Fin (n + 2)).insertNth a v) |
| rw [Fin.insertNth_zero'] |
| rw [hk] at h |
| exact h |
|
|
| theorem rows_conditional (hM : M.IsSaturated) (J : Finset I) |
| (hJ : J ≠ Finset.univ) (n : ℕ) : |
| HasCondDistrib (fun y => fun a : J => plane (n + 1) 0 (a : I) y) |
| (amap M.par (n + 2)) |
| (FiniteKernel.pi (fun a : J => (M.ownKernel (n + 1)).comap |
| (plane (n + 1) 0 (a : I)) (measurable_plane _ _ _))) (M.law (n + 2)) := by |
| apply ConditionalReveal.finite_reveal (M.law (n + 2)) (amap M.par (n + 2)) |
| (measurable_amap M.measurable_par _) |
| (fun a : I => plane (n + 1) 0 a) |
| (fun a : I => (M.ownKernel (n + 1)).comap (plane (n + 1) 0 a) |
| (measurable_plane _ _ _)) J |
| intro R hRJ a ha haR |
| have hstrict : R ⊂ J := (Finset.ssubset_iff_subset_ne).mpr ⟨hRJ, by |
| intro he; subst R; exact haR ha⟩ |
| have hcardR := Finset.card_lt_card hstrict |
| have hcardJ := Finset.card_lt_card |
| ((Finset.ssubset_iff_subset_ne).mpr ⟨Finset.subset_univ J, hJ⟩) |
| rw [Finset.card_univ] at hcardJ |
| exact row_reveal M hM R (by omega) a haR n |
|
|
| theorem single_cell_locality (hM : M.IsSaturated) (R : Finset I) |
| (hR : R.card + 2 ≤ Fintype.card I) (a : I) (ha : a ∉ R) (j : I) : |
| HasCondDistrib (missingRow M 0 j a) (revealData M R 0 j) |
| ((rowKernel M 0 j a).prodMkRight (R → Arr I M.Y 0)) (M.law 2) := |
| parent_reveal M hM R (isConditional M hM R hR) a ha (insert_proper R hR a ha) 0 j |
|
|
| end ArrayObjects.Object.Rolled |
|
|
| namespace ConditionalReveal |
| variable {Ω D B ι : Type*} [MeasurableSpace Ω] [MeasurableSpace D] |
| [MeasurableSpace B] [StandardBorelSpace B] [Nonempty B] [DecidableEq ι] |
|
|
| omit [MeasurableSpace Ω] [StandardBorelSpace B] [Nonempty B] in |
| lemma comap_union_reveal (E : Ω → D) (y : ι → Ω → B) (P S : Finset ι) : |
| MeasurableSpace.comap (fun ω => (E ω, fun i : ↥(P ∪ S) => y i ω)) inferInstance = |
| MeasurableSpace.comap (fun ω => ((E ω, fun i : P => y i ω), fun i : S => y i ω)) |
| inferInstance := by |
| simp only [inferInstance, Prod.instMeasurableSpace, MeasurableSpace.comap_prodMk, |
| MeasurableSpace.comap_process_pi] |
| have hu : (⨆ i : ↥(P ∪ S), MeasurableSpace.comap (y i) inferInstance) = |
| (⨆ i : P, MeasurableSpace.comap (y i) inferInstance) ⊔ |
| (⨆ i : S, MeasurableSpace.comap (y i) inferInstance) := by |
| apply le_antisymm |
| · refine iSup_le (fun i => ?_) |
| rcases Finset.mem_union.mp i.property with hi | hi |
| · apply le_sup_of_le_left |
| exact le_iSup_of_le (⟨i, hi⟩ : P) le_rfl |
| · apply le_sup_of_le_right |
| exact le_iSup_of_le (⟨i, hi⟩ : S) le_rfl |
| · apply sup_le |
| · exact iSup_le (fun i => le_iSup_of_le ⟨i, Finset.mem_union_left S i.property⟩ le_rfl) |
| · exact iSup_le (fun i => le_iSup_of_le ⟨i, Finset.mem_union_right P i.property⟩ le_rfl) |
| rw [hu, sup_assoc] |
|
|
| theorem finite_reveal_with_parents (μ : Measure Ω) [IsProbabilityMeasure μ] |
| (E : Ω → D) (hE : Measurable E) (y : ι → Ω → B) |
| (hy : ∀ i, Measurable (y i)) (κ : ι → Kernel D B) [∀ i, IsMarkovKernel (κ i)] |
| (P A : Finset ι) |
| (h : ∀ S ⊆ A, ∀ i ∈ A, i ∉ S → |
| HasCondDistrib (y i) (fun ω => (E ω, fun j : ↥(P ∪ S) => y j ω)) |
| ((κ i).prodMkRight (↥(P ∪ S) → B)) μ) : |
| HasCondDistrib (fun ω => fun i : A => y i ω) |
| (fun ω => (E ω, fun j : P => y j ω)) |
| (FiniteKernel.pi (fun i : A => (κ i).prodMkRight (P → B))) μ := by |
| apply finite_reveal μ (fun ω => (E ω, fun j : P => y j ω)) |
| (hE.prodMk (Measurable.of_eval (fun j => hy j))) y |
| (fun i => (κ i).prodMkRight (P → B)) A |
| intro S hS i hi hiS |
| apply ConditionalTransport.recondition |
| (hE.prodMk (Measurable.of_eval (fun j : ↥(P ∪ S) => hy j))) |
| ((hE.prodMk (Measurable.of_eval (fun j : P => hy j))).prodMk |
| (Measurable.of_eval (fun j : S => hy j))) (hy i) (h S hS i hi hiS) |
| · exact comap_union_reveal E y P S |
| · exact Filter.Eventually.of_forall (fun _ => rfl) |
|
|
| end ConditionalReveal |
|
|
| namespace ArrayObjects.Object.Rolled |
| variable {I : Type u} [Fintype I] [DecidableEq I] {X : StandardSpace.{u}} {T : X ≃ᵐ X} |
| {base : InitialLaws I X T} (M : Object I base) |
|
|
| theorem grouped_single_missing (hM : M.IsSaturated) (P A : Finset I) |
| (hPA : Disjoint P A) (hcard : P.card + A.card + 1 ≤ Fintype.card I) |
| (n : ℕ) (j : I) : |
| HasCondDistrib (fun y => fun a : A => missingRow M n j a y) |
| (revealData M P n j) |
| (FiniteKernel.pi (fun a : A => (rowKernel M n j a).prodMkRight |
| (P → Arr I M.Y n))) (M.law (n + 2)) := by |
| apply ConditionalReveal.finite_reveal_with_parents (M.law (n + 2)) (rawData M n j) |
| (measurable_rawData M n j) (fun a => missingRow M n j a) |
| (fun a => measurable_missingRow M n j a) (fun a => rowKernel M n j a) P A |
| intro S hSA a ha haS |
| have haP : a ∉ P := fun hp => Finset.disjoint_left.mp hPA hp ha |
| have hcS : S.card < A.card := Finset.card_lt_card |
| ((Finset.ssubset_iff_subset_ne).mpr ⟨hSA, by intro he; subst S; exact haS ha⟩) |
| have hcU := Finset.card_union_le P S |
| have hc : (P ∪ S).card + 2 ≤ Fintype.card I := by omega |
| have haU : a ∉ P ∪ S := by simpa only [Finset.mem_union, not_or] using And.intro haP haS |
| exact parent_reveal M hM (P ∪ S) (isConditional M hM (P ∪ S) hc) a haU |
| (insert_proper _ hc a haU) n j |
|
|
| end ArrayObjects.Object.Rolled |
|
|
| namespace ConditionalScreens |
| variable {Ω S Z O : Type*} [MeasurableSpace Ω] [MeasurableSpace S] |
| [MeasurableSpace Z] [StandardBorelSpace Z] [Nonempty Z] |
| [MeasurableSpace O] [StandardBorelSpace O] [Nonempty O] |
|
|
| theorem reverse_screen {μ : Measure Ω} [IsProbabilityMeasure μ] |
| {s : Ω → S} {z : Ω → Z} {o : Ω → O} |
| (hs : Measurable s) (hz : Measurable z) (ho : Measurable o) |
| (f : Z → S) (hf : Measurable f) (g : O → S) (hg : Measurable g) |
| (hsz : s = f ∘ z) (hso : s = g ∘ o) |
| (κ : Kernel S O) [IsMarkovKernel κ] (l : Kernel S Z) [IsMarkovKernel l] |
| (hκ : HasCondDistrib o s κ μ) |
| (hl : HasCondDistrib z o (l.comap g hg) μ) : |
| HasCondDistrib o z (κ.comap f hf) μ := by |
| have hl' : HasCondDistrib z (fun ω => (s ω, o ω)) (l.prodMkRight O) μ := by |
| apply ConditionalTransport.recondition ho (hs.prodMk ho) hz hl |
| · apply le_antisymm |
| · exact ConditionalTransport.comap_le_of_factor measurable_snd rfl |
| · apply ConditionalTransport.comap_le_of_factor (hg.prodMk measurable_id) |
| simpa only [Function.comp_def, id_eq] using congrArg (fun v => fun ω => (v ω, o ω)) hso |
| · filter_upwards [] with ω |
| change l (g (o ω)) = l (s ω) |
| rw [hso]; rfl |
| have hh := screening hκ l hl' |
| apply ConditionalTransport.recondition (hs.prodMk hz) hz ho hh |
| · apply le_antisymm |
| · apply ConditionalTransport.comap_le_of_factor (hf.prodMk measurable_id) |
| simpa only [Function.comp_def, id_eq] using congrArg (fun v => fun ω => (v ω, z ω)) hsz |
| · exact ConditionalTransport.comap_le_of_factor measurable_snd rfl |
| · filter_upwards [] with ω |
| change κ (s ω) = κ (f (z ω)) |
| rw [hsz]; rfl |
|
|
| end ConditionalScreens |
|
|
| namespace FiniteKernel |
| variable {ι : Type*} [Fintype ι] {Y S : ι → Type*} |
| [∀ i, MeasurableSpace (Y i)] [∀ i, StandardBorelSpace (Y i)] [∀ i, Nonempty (Y i)] |
| [∀ i, MeasurableSpace (S i)] |
|
|
| theorem independent_observation (μ : ∀ i, Measure (Y i)) |
| [∀ i, IsProbabilityMeasure (μ i)] (f : ∀ i, Y i → S i) |
| (hf : ∀ i, Measurable (f i)) : |
| HasCondDistrib (id : (∀ i, Y i) → (∀ i, Y i)) (fun y i => f i (y i)) |
| (pi (fun i => (condDistrib id (f i) (μ i)).comap (Function.eval i) |
| (measurable_pi_apply i))) (Measure.pi μ) := by |
| refine ⟨((Measurable.of_eval (fun i => (hf i).comp (measurable_pi_apply i))).prodMk |
| measurable_id).aemeasurable, ?_⟩ |
| let (i : ι) : IsProbabilityMeasure ((μ i).map (f i)) := |
| (fun mapMeasurable => (Measure.isProbabilityMeasure_map_iff mapMeasurable).mpr inferInstance) (hf i).aemeasurable |
| apply (zipEquiv S Y).measurableEmbedding.map_injective |
| rw [Measure.pi_map_pi (fun i => (hf i).aemeasurable), compProd_pi] |
| rw [Measure.map_map (zipEquiv S Y).measurable (by fun_prop)] |
| change (Measure.pi μ).map (fun y i => (f i (y i), y i)) = |
| Measure.pi (fun i => (μ i).map (f i) ⊗ₘ condDistrib id (f i) (μ i)) |
| calc |
| _ = Measure.pi (fun i => (μ i).map (fun y => (f i y, y))) := |
| Measure.pi_map_pi (fun i => ((hf i).prodMk measurable_id).aemeasurable) |
| _ = _ := ?_ |
| congr 1 |
| funext i |
| exact (compProd_map_condDistrib (μ := μ i) (X := f i) |
| (Y := id) (hf i).aemeasurable measurable_id.aemeasurable).symm |
|
|
| end FiniteKernel |
|
|
| namespace ArrayObjects.Object.Rolled |
| variable {I : Type u} [Fintype I] [DecidableEq I] {X : StandardSpace.{u}} {T : X ≃ᵐ X} |
| {base : InitialLaws I X T} (M : Object I base) |
|
|
| lemma outside_row_screen (hM : M.IsSaturated) (hI : 2 ≤ Fintype.card I) |
| (a j₀ : I) (n : ℕ) : |
| HasCondDistrib (plane (n + 1) 0 a) (planes (n + 1) (Outside j₀)) |
| ((condDistrib id (planes n (Outside j₀)) (M.law (n + 1))).comap |
| (fun o : Outside j₀ → Arr I M.Y (n + 1) => fun j => plane n 0 a (o j)) |
| (Measurable.of_eval (fun j => (measurable_plane _ _ _).comp (measurable_pi_apply j)))) |
| (M.law (n + 2)) := by |
| have hR : (∅ : Finset I).card + 2 ≤ Fintype.card I := by simpa using hI |
| let N := object M hM ∅ hR a (Finset.notMem_empty a) |
| let e := objectExtension M hM ∅ hR a (Finset.notMem_empty a) |
| let p : (Outside j₀ → Arr I (State M) n) → (Outside j₀ → Arr I M.Y n) := |
| fun o j => amap (Function.eval a) n (o j) |
| have hpm : Measurable p := Measurable.of_eval (fun j => |
| (measurable_amap (measurable_pi_apply a) n).comp (measurable_pi_apply j)) |
| have hs := hM.hasCondDistrib e n (.outside j₀) |
| (planes n (Outside j₀)) (planes (Y := State M) n (Outside j₀)) |
| (id : Arr I M.Y (n + 1) → Arr I M.Y (n + 1)) p |
| (measurable_planes _ _) (measurable_planes _ _) measurable_id hpm rfl rfl rfl |
| have hp := ConditionalTransport.pullback |
| (show MeasurePreserving (roll (Y := M.Y) (n + 1)) (M.law (n + 2)) (N.law (n + 1)) from |
| ⟨(roll (n + 1)).measurable, rfl⟩) (measurable_planes _ _) hs |
| let E : (Outside j₀ → Arr I (State M) n) ≃ᵐ (Outside j₀ → Arr I M.Y (n + 1)) := |
| MeasurableEquiv.piCongrRight (fun _ => (roll n).symm) |
| change HasCondDistrib ((id ∘ amap (Function.eval a) (n + 1)) ∘ roll (n + 1)) |
| (planes (Y := State M) n (Outside j₀) ∘ roll (n + 1)) |
| ((condDistrib (id : Arr I M.Y (n + 1) → Arr I M.Y (n + 1)) |
| (planes n (Outside j₀)) (M.law (n + 1))).comap p hpm) (M.law (n + 2)) at hp |
| have h := hp.measurableEquiv_comp_right E |
| change HasCondDistrib ((id ∘ amap (Function.eval a) (n + 1)) ∘ roll (n + 1)) |
| (E ∘ planes n (Outside j₀) ∘ roll (n + 1)) |
| (((condDistrib id (planes n (Outside j₀)) (M.law (n + 1))).comap p hpm).comap |
| E.symm E.symm.measurable) (M.law (n + 2)) at h |
| have he : E ∘ planes n (Outside j₀) ∘ roll (n + 1) = planes (n + 1) (Outside j₀) := by |
| rw [planes_roll] |
| funext y j |
| change (roll n).symm (roll n (planes (n + 1) (Outside j₀) y j)) = _ |
| exact (roll n).symm_apply_apply _ |
| rw [Function.id_comp, select_roll, he] at h |
| convert h using 1 |
| ext o : 1 |
| change condDistrib id (planes n (Outside j₀)) (M.law (n + 1)) |
| (fun j => plane n 0 a (o j)) = |
| condDistrib id (planes n (Outside j₀)) (M.law (n + 1)) (p (E.symm o)) |
| congr 1 |
| funext j |
| exact (congrFun (select_roll n a) (o j)).symm |
|
|
| omit [DecidableEq I] in |
|
|
| lemma plane_first_last (n : ℕ) (a j : I) : |
| plane (Y := M.Y) n 0 a ∘ plane (n + 1) (Fin.last (n + 1)) j = |
| plane n (Fin.last n) j ∘ plane (n + 1) 0 a := by |
| funext y v |
| change y ((Fin.last (n + 1)).insertNth j ((0 : Fin (n + 1)).insertNth a v)) = |
| y ((0 : Fin (n + 2)).insertNth a ((Fin.last n).insertNth j v)) |
| simp only [Fin.insertNth_last', Fin.insertNth_zero'] |
| rw [cons_snoc] |
|
|
| theorem columns_given_row (hM : M.IsSaturated) (hI : 2 ≤ Fintype.card I) |
| (a j₀ : I) (n : ℕ) : |
| HasCondDistrib (planes (n + 1) (Outside j₀)) (plane (n + 1) 0 a) |
| (FiniteKernel.pi (fun j : Outside j₀ => |
| (condDistrib id (plane n 0 a) (M.law (n + 1))).comap |
| (plane n (Fin.last n) j) (measurable_plane _ _ _))) (M.law (n + 2)) := by |
| let f : Arr I M.Y (n + 1) → Outside j₀ → Arr I M.Y n := planes n (Outside j₀) |
| let g : (Outside j₀ → Arr I M.Y (n + 1)) → Outside j₀ → Arr I M.Y n := |
| fun o j => plane n 0 a (o j) |
| have hf : Measurable f := measurable_planes _ _ |
| have hg : Measurable g := Measurable.of_eval (fun j => |
| (measurable_plane _ _ _).comp (measurable_pi_apply j)) |
| let κ := FiniteKernel.pi (fun _j : Outside j₀ => |
| (condDistrib (id : Arr I M.Y (n + 1) → Arr I M.Y (n + 1)) |
| (plane n 0 a) (M.law (n + 1))).comap |
| (Function.eval _j) (measurable_pi_apply _j)) |
| let l := condDistrib (id : Arr I M.Y (n + 1) → Arr I M.Y (n + 1)) f (M.law (n + 1)) |
| have hJ : Outside j₀ ≠ Finset.univ := by |
| intro he |
| have hj : j₀ ∈ Outside j₀ := he ▸ Finset.mem_univ j₀ |
| simp only [Outside, Finset.mem_erase, ne_eq, not_true_eq_false, false_and] at hj |
| have ho : MeasurePreserving (planes (n + 1) (Outside j₀)) (M.law (n + 2)) |
| (Measure.pi (fun _ : Outside j₀ => M.law (n + 1))) := |
| ⟨measurable_planes _ _, M.proper _ _ hJ⟩ |
| have hk := ConditionalTransport.pullback ho hg |
| (FiniteKernel.independent_observation (fun _ : Outside j₀ => M.law (n + 1)) |
| (fun _ => plane n 0 a) (fun _ => measurable_plane _ _ _)) |
| have hs : g ∘ planes (n + 1) (Outside j₀) = f ∘ plane (n + 1) 0 a := by |
| funext y j |
| exact congrFun (plane_first_last M n a j) y |
| have h := ConditionalScreens.reverse_screen |
| (hg.comp (measurable_planes _ _)) (measurable_plane _ _ _) (measurable_planes _ _) |
| f hf g hg hs rfl κ l hk (outside_row_screen M hM hI a j₀ n) |
| convert h using 1 |
| ext z : 1 |
| rfl |
|
|
| end ArrayObjects.Object.Rolled |
|
|
| namespace FiniteKernel |
| lemma map_eval {ι X : Type*} [Fintype ι] [MeasurableSpace X] |
| {Y : ι → Type*} [∀ i, MeasurableSpace (Y i)] |
| (κ : ∀ i, Kernel X (Y i)) [∀ i, IsMarkovKernel (κ i)] (i : ι) : |
| (pi κ).map (Function.eval i) = κ i := by |
| ext x : 1 |
| rw [Kernel.map_apply _ (measurable_pi_apply i)] |
| exact (measurePreserving_eval (fun j => κ j x) i).map_eq |
| end FiniteKernel |
|
|
| namespace ArrayObjects.Object |
| 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 plane_conditional (hI : 2 ≤ Fintype.card I) (n : ℕ) (a : I) : |
| HasCondDistrib (plane n (Fin.last n) a) (amap M.par (n + 1)) |
| ((M.ownKernel n).comap (plane n (Fin.last n) a) (measurable_plane _ _ _)) |
| (M.law (n + 1)) := by |
| have hproper : ({a} : Finset I) ≠ Finset.univ := by |
| intro he |
| have hc := congrArg Finset.card he |
| simp only [Finset.card_singleton, Finset.card_univ] at hc |
| omega |
| have h := (M.planes_conditional n {a} hproper).comp_left |
| (measurable_pi_apply (⟨a, Finset.mem_singleton_self a⟩ : ({a} : Finset I))) |
| rw [FiniteKernel.map_eval] at h |
| exact h |
|
|
| omit [DecidableEq I] in |
| noncomputable def parameterLaw (n : ℕ) : Measure (Arr I M.U n) := |
| (M.law n).map (amap M.par n) |
| omit [DecidableEq I] in |
| instance parameterLaw_probability (n : ℕ) : IsProbabilityMeasure (M.parameterLaw n) := |
| (fun mapMeasurable => (Measure.isProbabilityMeasure_map_iff mapMeasurable).mpr inferInstance) (measurable_amap M.measurable_par n).aemeasurable |
| |
| omit [DecidableEq I] in |
| |
| noncomputable def parameterCoordinateKernel (a : I) : |
| Kernel (Arr I M.U 0) (Arr I M.U 1) := |
| condDistrib id (plane 0 0 a) (M.parameterLaw 1) |
| omit [DecidableEq I] in |
| instance parameterCoordinateKernel_markov (a : I) : |
| IsMarkovKernel (M.parameterCoordinateKernel a) := by |
| unfold parameterCoordinateKernel |
| infer_instance |
| |
| omit [DecidableEq I] in |
| |
| lemma column_parameter_given_cell (hI : 2 ≤ Fintype.card I) (a : I) : |
| HasCondDistrib (amap M.par 1) (plane 0 0 a) |
| ((M.parameterCoordinateKernel a).comap (amap M.par 0) |
| (measurable_amap M.measurable_par 0)) (M.law 1) := by |
| have hc : HasCondDistrib (id : Arr I M.U 1 → Arr I M.U 1) (plane 0 0 a) |
| (M.parameterCoordinateKernel a) (M.parameterLaw 1) := |
| ⟨((measurable_plane _ _ _).prodMk measurable_id).aemeasurable, |
| (compProd_map_condDistrib (by fun_prop) measurable_id.aemeasurable).symm⟩ |
| have hq := ConditionalTransport.pullback |
| (show MeasurePreserving (amap M.par 1) (M.law 1) (M.parameterLaw 1) from |
| ⟨measurable_amap M.measurable_par _, rfl⟩) (measurable_plane _ _ _) hc |
| exact ConditionalScreens.reverse_screen |
| (s := amap M.par 0 ∘ plane 0 0 a) (z := plane 0 0 a) (o := amap M.par 1) |
| ((measurable_amap M.measurable_par 0).comp (measurable_plane _ _ _)) |
| (measurable_plane _ _ _) (measurable_amap M.measurable_par _) |
| (amap M.par 0) (measurable_amap M.measurable_par _) (plane 0 0 a) |
| (measurable_plane _ _ _) rfl rfl (M.parameterCoordinateKernel a) (M.ownKernel 0) |
| hq (M.plane_conditional hI 0 a) |
| |
| omit [DecidableEq I] in |
| |
| lemma shared_parameter_kernel (hI : 2 ≤ Fintype.card I) (a : I) : |
| (fun s => (condDistrib (id : Arr I M.Y 1 → Arr I M.Y 1) (plane 0 0 a) |
| (M.law 1) s).map (amap M.par 1)) =ᵐ[M.law 0] |
| fun s => M.parameterCoordinateKernel a (amap M.par 0 s) := by |
| let κ := condDistrib (id : Arr I M.Y 1 → Arr I M.Y 1) (plane 0 0 a) (M.law 1) |
| have h : HasCondDistrib id (plane 0 0 a) κ (M.law 1) := |
| ⟨((measurable_plane _ _ _).prodMk measurable_id).aemeasurable, |
| (compProd_map_condDistrib (by fun_prop) measurable_id.aemeasurable).symm⟩ |
| have hm := h.comp_left (measurable_amap M.measurable_par 1) |
| have he := Kernel.ae_eq_of_compProd_eq |
| (hm.map_eq.symm.trans (M.column_parameter_given_cell hI a).map_eq) |
| rw [show (M.law 1).map (plane 0 0 a) = M.law 0 from M.consistent 0 0 a] at he |
| exact he.mono (fun s hs => by |
| simpa only [Kernel.map_apply _ (measurable_amap M.measurable_par _), Kernel.comap_apply] using hs) |
| |
| end ArrayObjects.Object |
| |
| namespace ConditionalTransport |
| variable {Ω Ω' A B : Type*} [MeasurableSpace Ω] [MeasurableSpace Ω'] |
| [MeasurableSpace A] [MeasurableSpace B] |
| |
| theorem pushforward {P : Measure Ω} {Q : Measure Ω'} {f : Ω → Ω'} |
| {E : Ω' → A} {O : Ω' → B} {κ : Kernel A B} |
| (hf : MeasurePreserving f P Q) (hE : Measurable E) (hO : Measurable O) |
| (h : HasCondDistrib (O ∘ f) (E ∘ f) κ P) : HasCondDistrib O E κ Q := by |
| refine ⟨(hE.prodMk hO).aemeasurable, ?_⟩ |
| have he : P.map (E ∘ f) = Q.map E := by |
| rw [← Measure.map_map hE hf.measurable, hf.map_eq] |
| have hj : P.map (fun ω => (E (f ω), O (f ω))) = Q.map (fun ω => (E ω, O ω)) := by |
| change P.map ((fun ω => (E ω, O ω)) ∘ f) = _ |
| rw [← Measure.map_map (hE.prodMk hO) hf.measurable, hf.map_eq] |
| rw [← he] |
| exact hj.symm.trans h.map_eq |
| end ConditionalTransport |
| |
| namespace ArrayObjects.Object.Rolled |
| variable {I : Type u} [Fintype I] [DecidableEq I] {X : StandardSpace.{u}} {T : X ≃ᵐ X} |
| {base : InitialLaws I X T} (M : Object I base) |
| |
| theorem columns_parameter_given_row (hM : M.IsSaturated) (hI : 2 ≤ Fintype.card I) |
| (a j₀ : I) : |
| HasCondDistrib (fun y => fun j : Outside j₀ => amap M.par 1 (planes 1 (Outside j₀) y j)) |
| (amap M.par 1 ∘ plane 1 0 a) |
| (FiniteKernel.pi (fun j : Outside j₀ => (M.parameterCoordinateKernel a).comap |
| (plane 0 0 j) (measurable_plane _ _ _))) (M.law 2) := by |
| let κ := condDistrib (id : Arr I M.Y 1 → Arr I M.Y 1) (plane 0 0 a) (M.law 1) |
| let η := FiniteKernel.pi (fun j : Outside j₀ => (M.parameterCoordinateKernel a).comap |
| (plane 0 0 j) (measurable_plane _ _ _)) |
| have h := (columns_given_row M hM hI a j₀ 0).comp_left |
| (Measurable.of_eval (fun j => (measurable_amap M.measurable_par 1).comp |
| (measurable_pi_apply j))) |
| simp only [Function.comp_def] at h |
| rw [FiniteKernel.map_pi _ _ (fun _ => measurable_amap M.measurable_par 1)] at h |
| have he : ∀ᵐ z ∂M.law 1, ∀ j : Outside j₀, |
| (κ (plane 0 0 j z)).map (amap M.par 1) = |
| M.parameterCoordinateKernel a (amap M.par 0 (plane 0 0 j z)) := by |
| rw [ae_all_iff] |
| intro j |
| exact (show MeasurePreserving (plane 0 0 (j : I)) (M.law 1) (M.law 0) from |
| ⟨measurable_plane _ _ _, M.consistent 0 0 j⟩).quasiMeasurePreserving.ae_eq_comp |
| (M.shared_parameter_kernel hI a) |
| have hk : HasCondDistrib |
| (fun y => fun j : Outside j₀ => amap M.par 1 (planes 1 (Outside j₀) y j)) |
| (plane 1 0 a) (η.comap (amap M.par 1) (measurable_amap M.measurable_par 1)) |
| (M.law 2) := by |
| refine ⟨h.aemeasurable, h.map_eq.trans (Measure.compProd_congr ?_)⟩ |
| rw [M.consistent 1 0 a] |
| filter_upwards [he] with z hz |
| change Measure.pi (fun j : Outside j₀ => |
| ((κ.comap (plane 0 (Fin.last 0) j) (measurable_plane _ _ _)).map (amap M.par 1)) z) = |
| Measure.pi (fun j : Outside j₀ => M.parameterCoordinateKernel a |
| (plane 0 0 j (amap M.par 1 z))) |
| congr 1 |
| funext j |
| rw [Kernel.map_apply _ (measurable_amap M.measurable_par _), Kernel.comap_apply, |
| Fin.last_zero] |
| exact hz j |
| exact hk.comp_right |
| |
| theorem parameter_geometry_outside (hM : M.IsSaturated) (hI : 2 ≤ Fintype.card I) |
| (a j₀ : I) : |
| HasCondDistrib (planes 1 (Outside j₀)) (plane 1 0 a) |
| (FiniteKernel.pi (fun j : Outside j₀ => (M.parameterCoordinateKernel a).comap |
| (plane 0 0 j) (measurable_plane _ _ _))) (M.parameterLaw 2) := by |
| apply ConditionalTransport.pushforward |
| (show MeasurePreserving (amap M.par 2) (M.law 2) (M.parameterLaw 2) from |
| ⟨measurable_amap M.measurable_par _, rfl⟩) |
| (measurable_plane _ _ _) (measurable_planes _ _) |
| exact columns_parameter_given_row M hM hI a j₀ |
| |
| theorem parameter_geometry (hM : M.IsSaturated) (hI : 2 ≤ Fintype.card I) |
| (a : I) (J : Finset I) (hJ : J ≠ Finset.univ) : |
| HasCondDistrib (planes 1 J) (plane 1 0 a) |
| (FiniteKernel.pi (fun j : J => (M.parameterCoordinateKernel a).comap |
| (plane 0 0 j) (measurable_plane _ _ _))) (M.parameterLaw 2) := by |
| have hex : ∃ j₀ : I, j₀ ∉ J := by |
| by_contra he |
| push Not at he |
| exact hJ (Finset.eq_univ_iff_forall.mpr he) |
| obtain ⟨j₀, hj₀⟩ := hex |
| let e : J ↪ Outside j₀ := |
| ⟨fun j => ⟨j, by |
| simp only [Outside, Finset.mem_erase, Finset.mem_univ, and_true] |
| exact fun he => hj₀ (he ▸ j.property)⟩, |
| fun _ _ he => Subtype.ext (congrArg (fun z : Outside j₀ => (z : I)) he)⟩ |
| have h := (parameter_geometry_outside M hM hI a j₀).comp_left |
| (Measurable.of_eval (fun i => measurable_pi_apply (e i))) |
| rw [FiniteKernel.pi_precomp] at h |
| exact h |
| |
| end ArrayObjects.Object.Rolled |
| |
| namespace ConditionalScreens |
| variable {Ω S Z O : Type*} [MeasurableSpace Ω] [MeasurableSpace S] |
| [MeasurableSpace Z] [MeasurableSpace O] [StandardBorelSpace O] [Nonempty O] |
| |
| theorem joint_of_screen {μ : Measure Ω} [IsProbabilityMeasure μ] |
| {s : Ω → S} {z : Ω → Z} {o : Ω → O} |
| (hs : Measurable s) (hz : Measurable z) (ho : Measurable o) |
| (f : Z → S) (hf : Measurable f) (hsz : s = f ∘ z) |
| (κ : Kernel S Z) [IsMarkovKernel κ] (l : Kernel S O) [IsMarkovKernel l] |
| (hκ : HasCondDistrib z s κ μ) |
| (hl : HasCondDistrib o z (l.comap f hf) μ) : |
| HasCondDistrib (fun ω => (z ω, o ω)) s (κ ×ₖ l) μ := by |
| have hl' : HasCondDistrib o (fun ω => (s ω, z ω)) (l.prodMkRight Z) μ := by |
| apply ConditionalTransport.recondition hz (hs.prodMk hz) ho hl |
| · apply le_antisymm |
| · exact ConditionalTransport.comap_le_of_factor measurable_snd rfl |
| · apply ConditionalTransport.comap_le_of_factor (hf.prodMk measurable_id) |
| simpa only [Function.comp_def, id_eq] using congrArg (fun v => fun ω => (v ω, z ω)) hsz |
| · filter_upwards [] with ω |
| change l (f (z ω)) = l (s ω) |
| rw [hsz]; rfl |
| have h := chain hκ hl' |
| rwa [compProd_prodMkRight] at h |
| end ConditionalScreens |
| |
| namespace ArrayObjects.Object |
| variable {I : Type u} [Fintype I] {X : StandardSpace.{u}} {T : X ≃ᵐ X} |
| {base : InitialLaws I X T} (M : Object I base) |
| |
| lemma parameterLaw_consistent (n : ℕ) (a : Fin (n + 1)) (i : I) : |
| (M.parameterLaw (n + 1)).map (plane n a i) = M.parameterLaw n := by |
| unfold parameterLaw |
| rw [Measure.map_map (measurable_plane _ _ _) (measurable_amap M.measurable_par _), |
| plane_amap, ← Measure.map_map (measurable_amap M.measurable_par _) |
| (measurable_plane _ _ _), M.consistent] |
| |
| variable [DecidableEq I] |
| |
| theorem diagonal_parameter_product (hM : M.IsSaturated) (hI : 2 ≤ Fintype.card I) (i : I) : |
| HasCondDistrib (fun p => (plane 1 0 i p, plane 1 (Fin.last 1) i p)) |
| (plane 0 0 i ∘ plane 1 0 i) |
| ((M.parameterCoordinateKernel i) ×ₖ (M.parameterCoordinateKernel i)) |
| (M.parameterLaw 2) := by |
| have hproper : ({i} : Finset I) ≠ Finset.univ := by |
| intro he |
| have hc := congrArg Finset.card he |
| simp only [Finset.card_singleton, Finset.card_univ] at hc |
| omega |
| have hcol := (Rolled.parameter_geometry M hM hI i {i} hproper).comp_left |
| (measurable_pi_apply (⟨i, Finset.mem_singleton_self i⟩ : ({i} : Finset I))) |
| rw [FiniteKernel.map_eval] at hcol |
| have hc : HasCondDistrib (id : Arr I M.U 1 → Arr I M.U 1) (plane 0 0 i) |
| (M.parameterCoordinateKernel i) (M.parameterLaw 1) := |
| ⟨((measurable_plane _ _ _).prodMk measurable_id).aemeasurable, |
| (compProd_map_condDistrib (by fun_prop) measurable_id.aemeasurable).symm⟩ |
| have hrow := ConditionalTransport.pullback |
| (show MeasurePreserving (plane 1 0 i) (M.parameterLaw 2) (M.parameterLaw 1) from |
| ⟨measurable_plane _ _ _, M.parameterLaw_consistent 1 0 i⟩) |
| (measurable_plane _ _ _) hc |
| exact ConditionalScreens.joint_of_screen |
| (s := plane 0 0 i ∘ plane 1 0 i) (z := plane 1 0 i) (o := plane 1 (Fin.last 1) i) |
| ((measurable_plane _ _ _).comp (measurable_plane _ _ _)) |
| (measurable_plane _ _ _) (measurable_plane _ _ _) |
| (plane 0 0 i) (measurable_plane _ _ _) rfl |
| (M.parameterCoordinateKernel i) (M.parameterCoordinateKernel i) hrow hcol |
| |
| end ArrayObjects.Object |
| |
| namespace FiniteKernel |
| variable {ι X Y : Type*} [MeasurableSpace X] [MeasurableSpace Y] |
| |
| theorem pi_split {S T W : Finset ι} (hS : S ⊆ W) (hT : T ⊆ W) |
| (hST : Disjoint S T) (κ : ι → Kernel X Y) [∀ i, IsMarkovKernel (κ i)] : |
| (pi (fun i : W => κ i)).map |
| (fun y => ((fun i : S => y ⟨i, hS i.property⟩), (fun i : T => y ⟨i, hT i.property⟩))) = |
| (pi (fun i : S => κ i)) ×ₖ (pi (fun i : T => κ i)) := by |
| let e : S ⊕ T ↪ W := ⟨Sum.elim |
| (fun i : S => (⟨i, hS i.property⟩ : W)) |
| (fun i : T => (⟨i, hT i.property⟩ : W)), by |
| intro a b hab |
| cases a with |
| | inl a => |
| cases b with |
| | inl b => exact congrArg Sum.inl (Subtype.ext (congrArg (fun z : W => (z : ι)) hab)) |
| | inr b => |
| have he : (a : ι) = b := congrArg (fun z : W => (z : ι)) hab |
| exact False.elim (Finset.disjoint_left.mp hST a.property (he ▸ b.property)) |
| | inr a => |
| cases b with |
| | inl b => |
| have he : (a : ι) = b := congrArg (fun z : W => (z : ι)) hab |
| exact False.elim (Finset.disjoint_left.mp hST b.property (he ▸ a.property)) |
| | inr b => exact congrArg Sum.inr (Subtype.ext (congrArg (fun z : W => (z : ι)) hab))⟩ |
| ext x : 1 |
| rw [Kernel.map_apply _ (by fun_prop), Kernel.prod_apply] |
| change (Measure.pi (fun i : W => κ i x)).map _ = |
| (Measure.pi (fun i : S => κ i x)).prod (Measure.pi (fun i : T => κ i x)) |
| have he := measure_pi_precomp (fun i : W => κ i x) e |
| have hh := (measurePreserving_sumPiEquivProdPi (fun i : S ⊕ T => κ (e i) x)).map_eq |
| rw [← he, Measure.map_map (MeasurableEquiv.sumPiEquivProdPi (fun _ : S ⊕ T => Y)).measurable |
| (Measurable.of_eval (fun i => measurable_pi_apply (e i)))] at hh |
| exact hh |
| end FiniteKernel |
| |
| namespace ConditionalReveal |
| variable {ι Ω X Y : Type*} [MeasurableSpace Ω] |
| [MeasurableSpace X] [MeasurableSpace Y] |
| |
| theorem disjoint_families (μ : Measure Ω) [IsProbabilityMeasure μ] |
| (E : Ω → X) (y : ι → Ω → Y) |
| (κ : ι → Kernel X Y) [∀ i, IsMarkovKernel (κ i)] |
| {S T W : Finset ι} (hS : S ⊆ W) (hT : T ⊆ W) (hST : Disjoint S T) |
| (h : HasCondDistrib (fun ω => fun i : W => y i ω) E |
| (FiniteKernel.pi (fun i : W => κ i)) μ) : |
| HasCondDistrib (fun ω => fun i : T => y i ω) |
| (fun ω => (E ω, fun i : S => y i ω)) |
| ((FiniteKernel.pi (fun i : T => κ i)).prodMkRight (S → Y)) μ := by |
| have hh := h.comp_left (show Measurable (fun z : W → Y => |
| ((fun i : S => z ⟨i, hS i.property⟩), (fun i : T => z ⟨i, hT i.property⟩))) from by fun_prop) |
| rw [FiniteKernel.pi_split hS hT hST κ, ← ConditionalScreens.compProd_prodMkRight] at hh |
| exact hh.of_compProd |
| end ConditionalReveal |
| |
| namespace ConditionalScreens |
| variable {Ω X Y Z : Type*} [MeasurableSpace Ω] [MeasurableSpace X] |
| [MeasurableSpace Y] [MeasurableSpace Z] [StandardBorelSpace Z] [Nonempty Z] |
| |
| theorem screened_marginal {μ : Measure Ω} [IsProbabilityMeasure μ] |
| {x : Ω → X} {y : Ω → Y} {z : Ω → Z} |
| (hx : Measurable x) (hy : Measurable y) |
| {κ η : Kernel X Z} [IsMarkovKernel κ] [IsMarkovKernel η] |
| (h : HasCondDistrib z (fun ω => (x ω, y ω)) (κ.prodMkRight Y) μ) |
| (hη : HasCondDistrib z x η μ) : |
| HasCondDistrib z (fun ω => (x ω, y ω)) (η.prodMkRight Y) μ := by |
| have hκ : HasCondDistrib z x κ μ := h.comp_right |
| have hke : κ =ᵐ[μ.map x] η := |
| (condDistrib_ae_eq_of_measure_eq_compProd hκ.aemeasurable_fst hκ.aemeasurable_snd hκ.map_eq).symm.trans |
| (condDistrib_ae_eq_of_measure_eq_compProd hη.aemeasurable_fst hη.aemeasurable_snd hη.map_eq) |
| refine ⟨h.aemeasurable, h.map_eq.trans (Measure.compProd_congr ?_)⟩ |
| have hf : (μ.map (fun ω => (x ω, y ω))).map Prod.fst = μ.map x := by |
| rw [Measure.map_map measurable_fst (hx.prodMk hy)] |
| rfl |
| rw [← hf] at hke |
| exact ae_of_ae_map measurable_fst.aemeasurable hke |
| end ConditionalScreens |
| |
| namespace ArrayObjects.Object.Rolled |
| variable {I : Type u} [Fintype I] [DecidableEq I] {X : StandardSpace.{u}} {T : X ≃ᵐ X} |
| {base : InitialLaws I X T} (M : Object I base) |
| |
| abbrev ParentData (R : Finset I) (n : ℕ) := |
| Arr I M.U (n + 2) × (R → Arr I M.Y (n + 1)) |
| |
| def parentData (R : Finset I) (n : ℕ) (y : Arr I M.Y (n + 2)) : ParentData M R n := |
| (amap M.par (n + 2) y, parents M R (n + 1) y) |
| omit [DecidableEq I] in |
| @[fun_prop] lemma measurable_parentData (R : Finset I) (n : ℕ) : |
| Measurable (parentData M R n) := |
| (measurable_amap M.measurable_par _).prodMk (measurable_parents M R _) |
| |
| def columnKernel (R : Finset I) (n : ℕ) (j : I) : |
| Kernel (ParentData M R n) (Arr I M.Y (n + 1)) := |
| ((ownPosterior M R n).map (roll n).symm).comap |
| (plane n (Fin.last n) j ∘ (parameterEquiv M R (n + 1)).symm) |
| ((measurable_plane _ _ _).comp (parameterEquiv M R (n + 1)).symm.measurable) |
| instance columnKernel_markov (R : Finset I) (n : ℕ) (j : I) : |
| IsMarkovKernel (columnKernel M R n j) := by |
| unfold columnKernel |
| have : IsMarkovKernel ((ownPosterior M R n).map (roll n).symm) := |
| Kernel.IsMarkovKernel.map _ (roll n).symm.measurable |
| infer_instance |
| |
| theorem columns_with_parents (hM : M.IsSaturated) (R : Finset I) |
| (hR : R.card + 2 ≤ Fintype.card I) (n : ℕ) |
| (J : Finset I) (hJ : J ≠ Finset.univ) : |
| HasCondDistrib (planes (n + 1) J) (parentData M R n) |
| (FiniteKernel.pi (fun j : J => columnKernel M R n j)) (M.law (n + 2)) := by |
| have hi : ∀ S : Finset I, S ⊂ R → IsConditional M S := by |
| intro S hS |
| apply isConditional M hM S |
| have hc := Finset.card_lt_card hS |
| omega |
| have hc := proper_conditional M hM R hR hi n J hJ |
| have hp := ConditionalTransport.pullback |
| (show MeasurePreserving (roll (Y := M.Y) (n + 1)) (M.law (n + 2)) (law M (n + 1)) from |
| ⟨(roll (n + 1)).measurable, rfl⟩) |
| (measurable_amap (measurable_parameter M R) _) hc |
| have hd := hp.measurableEquiv_comp_right (parameterEquiv M R (n + 1)) |
| have h := hd.comp_left (Measurable.of_eval (fun j : J => |
| (roll n).symm.measurable.comp (measurable_pi_apply j))) |
| have ho : (fun z : J → Arr I (State M) n => fun j => (roll n).symm (z j)) ∘ |
| planes n J ∘ roll (n + 1) = planes (n + 1) J := by |
| rw [planes_roll] |
| funext y j |
| exact (roll n).symm_apply_apply _ |
| change HasCondDistrib |
| ((fun z : J → Arr I (State M) n => fun j => (roll n).symm (z j)) ∘ |
| planes n J ∘ roll (n + 1)) |
| (parameterEquiv M R (n + 1) ∘ amap (parameter M R) (n + 1) ∘ roll (n + 1)) |
| _ (M.law (n + 2)) at h |
| rw [ho, parameterEquiv_observation] at h |
| change HasCondDistrib (planes (n + 1) J) (parentData M R n) _ (M.law (n + 2)) at h |
| convert h using 1 |
| ext p : 1 |
| rw [Kernel.map_apply _ (Measurable.of_eval (fun j : J => |
| (roll n).symm.measurable.comp (measurable_pi_apply j)))] |
| change Measure.pi (fun j : J => columnKernel M R n j p) = |
| (Measure.pi (fun j : J => ownPosterior M R n |
| (plane n (Fin.last n) j ((parameterEquiv M R (n + 1)).symm p)))).map _ |
| simp only [Function.comp_def] |
| rw [Measure.pi_map_pi (fun _ => (roll n).symm.measurable.aemeasurable)] |
| simp only [columnKernel, Kernel.comap_apply, Function.comp_apply, |
| Kernel.map_apply _ (roll n).symm.measurable] |
| |
| |
| def cells (A J : Finset I) (n : ℕ) (y : Arr I M.Y (n + 2)) : J → A → Arr I M.Y n := |
| fun j a => missingRow M n j a y |
| omit [DecidableEq I] in |
| @[fun_prop] lemma measurable_cells (A J : Finset I) (n : ℕ) : Measurable (cells M A J n) := |
| Measurable.of_eval (fun _ => Measurable.of_eval (fun _ => measurable_missingRow M _ _ _)) |
| |
| def rowRestrict (A J : Finset I) (n : ℕ) (y : A → Arr I M.Y (n + 1)) : J → A → Arr I M.Y n := |
| fun j a => plane n (Fin.last n) j (y a) |
| omit [DecidableEq I] in |
| @[fun_prop] lemma measurable_rowRestrict (A J : Finset I) (n : ℕ) : |
| Measurable (rowRestrict M A J n) := by |
| unfold rowRestrict |
| exact Measurable.of_eval (fun _ => Measurable.of_eval (fun _ => |
| (measurable_plane _ _ _).comp (measurable_pi_apply _))) |
| |
| def columnRestrict (A J : Finset I) (n : ℕ) (y : J → Arr I M.Y (n + 1)) : J → A → Arr I M.Y n := |
| fun j a => plane n 0 a (y j) |
| omit [DecidableEq I] in |
| @[fun_prop] lemma measurable_columnRestrict (A J : Finset I) (n : ℕ) : |
| Measurable (columnRestrict M A J n) := by |
| unfold columnRestrict |
| exact Measurable.of_eval (fun _ => Measurable.of_eval (fun _ => |
| (measurable_plane _ _ _).comp (measurable_pi_apply _))) |
| |
| omit [DecidableEq I] in |
| lemma columnRestrict_planes (A J : Finset I) (n : ℕ) : |
| columnRestrict M A J n ∘ planes (n + 1) J = cells M A J n := by |
| funext y j a |
| exact congrFun (plane_first_last M n a j) y |
| |
| def rowFamilyKernel (A : Finset I) (n : ℕ) : |
| Kernel (Arr I M.U (n + 2)) (A → Arr I M.Y (n + 1)) := |
| FiniteKernel.pi (fun a : A => (M.ownKernel (n + 1)).comap |
| (plane (n + 1) 0 a) (measurable_plane _ _ _)) |
| instance rowFamilyKernel_markov (A : Finset I) (n : ℕ) : |
| IsMarkovKernel (rowFamilyKernel M A n) := by unfold rowFamilyKernel; infer_instance |
| |
| def groupMarginal (A J : Finset I) (n : ℕ) : |
| Kernel (Arr I M.U (n + 2)) (J → A → Arr I M.Y n) := |
| (rowFamilyKernel M A n).map (rowRestrict M A J n) |
| instance groupMarginal_markov (A J : Finset I) (n : ℕ) : |
| IsMarkovKernel (groupMarginal M A J n) := |
| Kernel.IsMarkovKernel.map _ (measurable_rowRestrict M A J n) |
| |
| theorem group_marginal_with_parents (hM : M.IsSaturated) (P A J : Finset I) |
| (hPA : Disjoint P A) (hproper : P ∪ A ≠ Finset.univ) (n : ℕ) : |
| HasCondDistrib (cells M A J n) (parentData M P n) |
| ((groupMarginal M A J n).prodMkRight (P → Arr I M.Y (n + 1))) (M.law (n + 2)) := by |
| have h := ConditionalReveal.disjoint_families (M.law (n + 2)) (amap M.par (n + 2)) |
| (fun a => plane (n + 1) 0 a) |
| (fun a => (M.ownKernel (n + 1)).comap (plane (n + 1) 0 a) (measurable_plane _ _ _)) |
| Finset.subset_union_left Finset.subset_union_right hPA |
| (rows_conditional M hM (P ∪ A) hproper n) |
| have hh := h.comp_left (measurable_rowRestrict M A J n) |
| rw [Kernel.map_prodMkRight] at hh |
| exact hh |
| |
| theorem group_intermediate_marginal (hM : M.IsSaturated) (P A C J : Finset I) |
| (hP : P.card + 2 ≤ Fintype.card I) (hPA : Disjoint P A) |
| (hproper : P ∪ A ≠ Finset.univ) (hCJ : Disjoint C J) (hcols : C ∪ J ≠ Finset.univ) |
| (n : ℕ) : |
| HasCondDistrib (cells M A J n) |
| (fun y => (parentData M P n y, planes (n + 1) C y)) |
| (((groupMarginal M A J n).prodMkRight (P → Arr I M.Y (n + 1))).prodMkRight |
| (C → Arr I M.Y (n + 1))) (M.law (n + 2)) := by |
| have h := ConditionalReveal.disjoint_families (M.law (n + 2)) (parentData M P n) |
| (fun j => plane (n + 1) (Fin.last (n + 1)) j) (columnKernel M P n) |
| Finset.subset_union_left Finset.subset_union_right hCJ |
| (columns_with_parents M hM P hP n (C ∪ J) hcols) |
| have hk := h.comp_left (measurable_columnRestrict M A J n) |
| rw [Kernel.map_prodMkRight] at hk |
| change HasCondDistrib (columnRestrict M A J n ∘ planes (n + 1) J) |
| (fun y => (parentData M P n y, planes (n + 1) C y)) |
| (((FiniteKernel.pi (fun j : J => columnKernel M P n j)).map |
| (columnRestrict M A J n)).prodMkRight (C → Arr I M.Y (n + 1))) (M.law (n + 2)) at hk |
| rw [columnRestrict_planes] at hk |
| have : IsMarkovKernel ((FiniteKernel.pi (fun j : J => columnKernel M P n j)).map |
| (columnRestrict M A J n)) := Kernel.IsMarkovKernel.map _ (measurable_columnRestrict M A J n) |
| exact ConditionalScreens.screened_marginal (measurable_parentData M P n) |
| (measurable_planes _ _) hk (group_marginal_with_parents M hM P A J hPA hproper n) |
| |
| |
| abbrev GroupData (A C : Finset I) (n : ℕ) := |
| Arr I M.U (n + 2) × (C → A → Arr I M.Y n) |
| abbrev WholeGroupData (P C : Finset I) (n : ℕ) := |
| ParentData M P n × (C → Arr I M.Y (n + 1)) |
| |
| def groupData (A C : Finset I) (n : ℕ) (y : Arr I M.Y (n + 2)) : GroupData M A C n := |
| (amap M.par (n + 2) y, cells M A C n y) |
| def wholeGroupData (P C : Finset I) (n : ℕ) (y : Arr I M.Y (n + 2)) : WholeGroupData M P C n := |
| (parentData M P n y, planes (n + 1) C y) |
| omit [DecidableEq I] in |
| @[fun_prop] lemma measurable_groupData (A C : Finset I) (n : ℕ) : |
| Measurable (groupData M A C n) := |
| (measurable_amap M.measurable_par _).prodMk (measurable_cells M A C n) |
| omit [DecidableEq I] in |
| @[fun_prop] lemma measurable_wholeGroupData (P C : Finset I) (n : ℕ) : |
| Measurable (wholeGroupData M P C n) := |
| (measurable_parentData M P n).prodMk (measurable_planes _ _) |
| |
| def groupSelect (P A C : Finset I) (n : ℕ) (p : WholeGroupData M P C n) : GroupData M A C n := |
| (p.1.1, columnRestrict M A C n p.2) |
| omit [DecidableEq I] in |
| @[fun_prop] lemma measurable_groupSelect (P A C : Finset I) (n : ℕ) : |
| Measurable (groupSelect M P A C n) := |
| (measurable_fst.comp measurable_fst).prodMk ((measurable_columnRestrict M A C n).comp measurable_snd) |
| omit [DecidableEq I] in |
| lemma groupSelect_observation (P A C : Finset I) (n : ℕ) : |
| groupSelect M P A C n ∘ wholeGroupData M P C n = groupData M A C n := by |
| funext y |
| apply Prod.ext |
| · rfl |
| · exact congrFun (columnRestrict_planes M A C n) y |
| |
| def revealParent (P : Finset I) (n : ℕ) (j : I) (p : RevealData M P n j) : ParentData M P n := |
| parameterEquiv M P (n + 1) (revealToRoll M P n j p).1 |
| @[fun_prop] lemma measurable_revealParent (P : Finset I) (n : ℕ) (j : I) : |
| Measurable (revealParent M P n j) := |
| (parameterEquiv M P (n + 1)).measurable.comp |
| (measurable_fst.comp (measurable_revealToRoll M P n j)) |
| lemma revealParent_observation (P : Finset I) (n : ℕ) (j : I) : |
| revealParent M P n j ∘ revealData M P n j = parentData M P n := by |
| change (parameterEquiv M P (n + 1) ∘ Prod.fst) ∘ |
| (revealToRoll M P n j ∘ revealData M P n j) = _ |
| rw [revealToRoll_observation] |
| exact parameterEquiv_observation M P (n + 1) |
| |
| def revealSelect (P A C J : Finset I) (n : ℕ) (j : I) |
| (hC : C ⊆ Outside j) (hJ : J ⊆ Outside j) (p : RevealData M P n j) : |
| WholeGroupData M P C n × (J → A → Arr I M.Y n) := |
| ((revealParent M P n j p, fun c => p.1.2 ⟨c, hC c.property⟩), |
| fun k a => plane n 0 a (p.1.2 ⟨k, hJ k.property⟩)) |
| @[fun_prop] lemma measurable_revealSelect (P A C J : Finset I) (n : ℕ) (j : I) |
| (hC : C ⊆ Outside j) (hJ : J ⊆ Outside j) : |
| Measurable (revealSelect M P A C J n j hC hJ) := by |
| unfold revealSelect |
| exact ((measurable_revealParent M P n j).prodMk (by fun_prop)).prodMk (by fun_prop) |
| lemma revealSelect_observation (P A C J : Finset I) (n : ℕ) (j : I) |
| (hC : C ⊆ Outside j) (hJ : J ⊆ Outside j) : |
| revealSelect M P A C J n j hC hJ ∘ revealData M P n j = |
| fun y => (wholeGroupData M P C n y, cells M A J n y) := by |
| funext y |
| apply Prod.ext |
| · apply Prod.ext |
| · exact congrFun (revealParent_observation M P n j) y |
| · rfl |
| · funext k a |
| exact congrFun (plane_first_last M n a k) y |
| |
| def groupLastData (A C J : Finset I) (n : ℕ) (j : I) (hCJ : C ∪ J = Outside j) |
| (a : A) (p : GroupData M A C n × (J → A → Arr I M.Y n)) : OldData M n j := |
| (plane (n + 1) 0 a p.1.1, fun k => |
| if h : (k : I) ∈ C then p.1.2 ⟨k, h⟩ a else |
| p.2 ⟨k, (Finset.mem_union.mp (hCJ.symm ▸ k.property)).resolve_left h⟩ a) |
| @[fun_prop] lemma measurable_groupLastData (A C J : Finset I) (n : ℕ) (j : I) |
| (hCJ : C ∪ J = Outside j) (a : A) : Measurable (groupLastData M A C J n j hCJ a) := by |
| unfold groupLastData |
| apply Measurable.prodMk (by fun_prop) |
| apply Measurable.of_eval |
| intro k |
| split_ifs <;> fun_prop |
| |
| def groupLastKernel (A C J : Finset I) (n : ℕ) (j : I) (hCJ : C ∪ J = Outside j) : |
| Kernel (GroupData M A C n × (J → A → Arr I M.Y n)) (A → Arr I M.Y n) := |
| FiniteKernel.pi (fun a => |
| (condDistrib (plane n (Fin.last n) j) (oldData M n j) (M.law (n + 1))).comap |
| (groupLastData M A C J n j hCJ a) (measurable_groupLastData M A C J n j hCJ a)) |
| instance groupLastKernel_markov (A C J : Finset I) (n : ℕ) (j : I) |
| (hCJ : C ∪ J = Outside j) : IsMarkovKernel (groupLastKernel M A C J n j hCJ) := by |
| unfold groupLastKernel |
| infer_instance |
| |
| def wholeLastSelect (P A C J : Finset I) (n : ℕ) |
| (p : WholeGroupData M P C n × (J → A → Arr I M.Y n)) : |
| GroupData M A C n × (J → A → Arr I M.Y n) := |
| (groupSelect M P A C n p.1, p.2) |
| omit [DecidableEq I] in |
| @[fun_prop] lemma measurable_wholeLastSelect (P A C J : Finset I) (n : ℕ) : |
| Measurable (wholeLastSelect M P A C J n) := |
| ((measurable_groupSelect M P A C n).comp measurable_fst).prodMk measurable_snd |
| |
| theorem grouped_missing_after_retain (hM : M.IsSaturated) (P A C J : Finset I) |
| (hPA : Disjoint P A) (hcard : P.card + A.card + 1 ≤ Fintype.card I) |
| (n : ℕ) (j : I) (hCJ : C ∪ J = Outside j) : |
| HasCondDistrib (fun y => fun a : A => missingRow M n j a y) |
| (fun y => (wholeGroupData M P C n y, cells M A J n y)) |
| ((groupLastKernel M A C J n j hCJ).comap (wholeLastSelect M P A C J n) |
| (measurable_wholeLastSelect M P A C J n)) (M.law (n + 2)) := by |
| have hC : C ⊆ Outside j := hCJ ▸ Finset.subset_union_left |
| have hJ : J ⊆ Outside j := hCJ ▸ Finset.subset_union_right |
| have h := grouped_single_missing M hM P A hPA hcard n j |
| have he : (FiniteKernel.pi (fun a : A => (rowKernel M n j a).prodMkRight (P → Arr I M.Y n))) = |
| (((groupLastKernel M A C J n j hCJ).comap (wholeLastSelect M P A C J n) |
| (measurable_wholeLastSelect M P A C J n)).comap |
| (revealSelect M P A C J n j hC hJ) (measurable_revealSelect M P A C J n j hC hJ)) := by |
| ext p : 1 |
| change Measure.pi _ = Measure.pi _ |
| congr 1 |
| funext a |
| change (condDistrib _ _ _) (rowData M n j a p.1) = |
| (condDistrib _ _ _) (groupLastData M A C J n j hCJ a |
| (wholeLastSelect M P A C J n (revealSelect M P A C J n j hC hJ p))) |
| congr 1 |
| apply Prod.ext |
| · funext v |
| simp [groupLastData, wholeLastSelect, groupSelect, revealSelect, rowData, |
| revealParent, parameterEquiv, revealToRoll, plane, Fin.insertNth_zero'] |
| · funext k |
| simp only [groupLastData, wholeLastSelect, groupSelect, columnRestrict, revealSelect, rowData] |
| split_ifs <;> rfl |
| rw [he] at h |
| have hh := h.comp_right |
| rw [revealSelect_observation] at hh |
| exact hh |
| |
| end ArrayObjects.Object.Rolled |
| |
| namespace ConditionalScreens |
| variable {Ω D E Y Z : Type*} [MeasurableSpace Ω] [MeasurableSpace D] |
| [MeasurableSpace E] [MeasurableSpace Y] [MeasurableSpace Z] |
| |
| lemma compProd_comap (κ : Kernel E Y) (η : Kernel (E × Y) Z) |
| [IsMarkovKernel κ] [IsMarkovKernel η] (f : D → E) (hf : Measurable f) : |
| κ.comap f hf ⊗ₖ η.comap (Prod.map f id) (hf.prodMap measurable_id) = |
| (κ ⊗ₖ η).comap f hf := by |
| ext d s hs |
| rw [Kernel.compProd_apply hs] |
| change (∫⁻ y, η (f d, y) (Prod.mk y ⁻¹' s) ∂κ (f d)) = (κ ⊗ₖ η) (f d) s |
| exact (Kernel.compProd_apply hs κ η (f d)).symm |
| |
| theorem canonical_screen [StandardBorelSpace Y] [Nonempty Y] |
| {μ : Measure Ω} [IsProbabilityMeasure μ] {y : Ω → Y} {d : Ω → D} |
| (hd : Measurable d) (f : D → E) (hf : Measurable f) |
| {κ : Kernel E Y} [IsMarkovKernel κ] |
| (h : HasCondDistrib y d (κ.comap f hf) μ) : |
| HasCondDistrib y d ((condDistrib y (f ∘ d) μ).comap f hf) μ := by |
| have hκ := h.comp_right |
| have he : κ =ᵐ[μ.map (f ∘ d)] condDistrib y (f ∘ d) μ := |
| (condDistrib_ae_eq_of_measure_eq_compProd hκ.aemeasurable_fst hκ.aemeasurable_snd hκ.map_eq).symm |
| rw [← Measure.map_map hf hd] at he |
| refine ⟨h.aemeasurable, h.map_eq.trans (Measure.compProd_congr ?_)⟩ |
| exact ae_of_ae_map hf.aemeasurable he |
| end ConditionalScreens |
| |
| namespace ArrayObjects.Object.Rolled |
| variable {I : Type u} [Fintype I] [DecidableEq I] {X : StandardSpace.{u}} {T : X ≃ᵐ X} |
| {base : InitialLaws I X T} (M : Object I base) |
| |
| def joinOutput (A J : Finset I) (n : ℕ) (j : I) |
| (p : (J → A → Arr I M.Y n) × (A → Arr I M.Y n)) : |
| ↥(insert j J) → A → Arr I M.Y n := fun k => |
| if h : (k : I) = j then p.2 else p.1 ⟨k, (Finset.mem_insert.mp k.property).resolve_left h⟩ |
| @[fun_prop] lemma measurable_joinOutput (A J : Finset I) (n : ℕ) (j : I) : |
| Measurable (joinOutput M A J n j) := by |
| unfold joinOutput |
| apply Measurable.of_eval |
| intro k |
| split_ifs <;> fun_prop |
| lemma joinOutput_observation (A J : Finset I) (n : ℕ) (j : I) : |
| joinOutput M A J n j ∘ (fun y => (cells M A J n y, fun a : A => missingRow M n j a y)) = |
| cells M A (insert j J) n := by |
| funext y k a |
| simp only [Function.comp_apply, joinOutput, cells] |
| split_ifs with h |
| · simp [h] |
| · rfl |
| |
| theorem grouped_cell_locality (hM : M.IsSaturated) (P A C J : Finset I) |
| (hP : P.card + 2 ≤ Fintype.card I) (hPA : Disjoint P A) |
| (hcard : P.card + A.card + 1 ≤ Fintype.card I) |
| (hproper : P ∪ A ≠ Finset.univ) (hdisj : Disjoint C J) |
| (n : ℕ) (j : I) (hCJ : C ∪ J = Outside j) : |
| HasCondDistrib (cells M A (insert j J) n) (wholeGroupData M P C n) |
| ((condDistrib (cells M A (insert j J) n) (groupData M A C n) (M.law (n + 2))).comap |
| (groupSelect M P A C n) (measurable_groupSelect M P A C n)) (M.law (n + 2)) := by |
| have hcols : C ∪ J ≠ Finset.univ := by |
| rw [hCJ] |
| simp [Outside] |
| have hW := group_intermediate_marginal M hM P A C J hP hPA hproper hdisj hcols n |
| have hZ := grouped_missing_after_retain M hM P A C J hPA hcard n j hCJ |
| have h := ConditionalScreens.chain hW hZ |
| have hke : (((groupMarginal M A J n).prodMkRight (P → Arr I M.Y (n + 1))).prodMkRight |
| (C → Arr I M.Y (n + 1))) = |
| ((groupMarginal M A J n).prodMkRight (C → A → Arr I M.Y n)).comap |
| (groupSelect M P A C n) (measurable_groupSelect M P A C n) := by |
| ext p : 1 |
| rfl |
| rw [hke] at h |
| change HasCondDistrib _ (wholeGroupData M P C n) |
| (((groupMarginal M A J n).prodMkRight (C → A → Arr I M.Y n)).comap |
| (groupSelect M P A C n) (measurable_groupSelect M P A C n) ⊗ₖ |
| (groupLastKernel M A C J n j hCJ).comap (Prod.map (groupSelect M P A C n) id) |
| ((measurable_groupSelect M P A C n).prodMap measurable_id)) _ at h |
| rw [ConditionalScreens.compProd_comap] at h |
| have hh := h.comp_left (measurable_joinOutput M A J n j) |
| rw [joinOutput_observation, ← Kernel.comap_map_comm _ _ (measurable_joinOutput M A J n j)] at hh |
| have : IsMarkovKernel |
| (((groupMarginal M A J n).prodMkRight (C → A → Arr I M.Y n) ⊗ₖ |
| groupLastKernel M A C J n j hCJ).map (joinOutput M A J n j)) := |
| Kernel.IsMarkovKernel.map _ (measurable_joinOutput M A J n j) |
| have hv := ConditionalScreens.canonical_screen (measurable_wholeGroupData M P C n) |
| (groupSelect M P A C n) (measurable_groupSelect M P A C n) hh |
| rw [groupSelect_observation] at hv |
| exact hv |
| |
| end ArrayObjects.Object.Rolled |
| end |
| |
| section |
| open MeasureTheory ProbabilityTheory |
| variable {Ω U : Type*} [MeasurableSpace Ω] [MeasurableSpace U] [MeasurableSpace.CountablyGenerated Ω] |
| (μ : Measure Ω) [IsProbabilityMeasure μ] |
| (u : Ω → U) (hu : Measurable u) |
| (κ : Kernel U Ω) [IsMarkovKernel κ] |
| |
| include hu in |
| |
| lemma conditional_kernel_equivariant |
| (hκ : HasCondDistrib id u κ μ) (T : Ω ≃ᵐ Ω) (S : U ≃ᵐ U) |
| (hT : MeasurePreserving T μ μ) (hfactor : u ∘ T = S ∘ u) : |
| κ.map T =ᵐ[μ.map u] κ.comap S S.measurable := by |
| have h₁ : HasCondDistrib T (u ∘ T) κ μ := by |
| refine ⟨(hu.comp T.measurable |>.prodMk T.measurable).aemeasurable,?_⟩ |
| have hp : μ.map (u ∘ T) = μ.map u := by |
| rw [←Measure.map_map hu T.measurable,hT.map_eq] |
| rw [hp] |
| calc |
| μ.map (fun x => (u (T x),T x)) = |
| (μ.map T).map (fun x => (u x,x)) := by |
| exact (Measure.map_map (μ := μ) (hu.prodMk measurable_id) T.measurable).symm |
| _ = μ.map u ⊗ₘ κ := by rw [hT.map_eq]; exact hκ.map_eq |
| have h₂ := h₁.measurableEquiv_comp_right S.symm |
| have hc : S.symm ∘ (u ∘ T) = u := by |
| rw [hfactor] |
| funext x |
| exact S.symm_apply_apply _ |
| rw [hc] at h₂ |
| have h₃ := hκ.comp_left T.measurable |
| exact Kernel.ae_eq_of_compProd_eq (h₃.map_eq.symm.trans h₂.map_eq) |
| end |
| |
| namespace ArrayObjects |
| open MeasureTheory ProbabilityTheory |
| universe u |
| variable {I Y Z : Type u} [MeasurableSpace Y] [MeasurableSpace Z] |
| |
| def amapEquiv (E : Y ≃ᵐ Z) (n : ℕ) : Arr I Y n ≃ᵐ Arr I Z n where |
| toFun := amap E n |
| invFun := amap E.symm n |
| left_inv x := by funext a; exact E.symm_apply_apply _ |
| right_inv x := by funext a; exact E.apply_symm_apply _ |
| measurable_toFun := measurable_amap E.measurable n |
| measurable_invFun := measurable_amap E.symm.measurable n |
|
|
| namespace Object |
| variable [Fintype I] {X : StandardSpace.{u}} {T : X ≃ᵐ X} |
| {base : InitialLaws I X T} (M : Object I base) |
|
|
| lemma parameterLaw_invariant (n : ℕ) : |
| MeasurePreserving (amap M.timeU n) (M.parameterLaw n) (M.parameterLaw n) := by |
| refine ⟨measurable_amap M.timeU.measurable n,?_⟩ |
| change ((M.law n).map (amap M.par n)).map (amap M.timeU n) = _ |
| rw [Measure.map_map (measurable_amap M.timeU.measurable _) (measurable_amap M.measurable_par _)] |
| have he : amap (I := I) M.timeU n ∘ amap M.par n = amap M.par n ∘ amap M.timeY n := by |
| rw [←amap_comp,←amap_comp,M.time_par] |
| rw [he,←Measure.map_map (measurable_amap M.measurable_par _) (measurable_amap M.timeY.measurable _), |
| (M.invariant n).map_eq] |
| rfl |
|
|
| lemma ownKernel_time_equivariant (n : ℕ) : |
| (M.ownKernel n).map (amap M.timeY n) =ᵐ[M.parameterLaw n] |
| (M.ownKernel n).comap (amap M.timeU n) (measurable_amap M.timeU.measurable n) := by |
| apply conditional_kernel_equivariant (M.law n) (amap M.par n) |
| (measurable_amap M.measurable_par _) (M.ownKernel n) (M.ownKernel_conditional n) |
| (amapEquiv M.timeY n) (amapEquiv M.timeU n) (M.invariant n) |
| change amap M.par n ∘ amap M.timeY n = amap M.timeU n ∘ amap M.par n |
| rw [←amap_comp,←amap_comp,M.time_par] |
|
|
| lemma ownKernel_time_preserving (n : ℕ) : |
| ∀ᵐ p ∂M.parameterLaw n, MeasurePreserving (amap M.timeY n) |
| (M.ownKernel n p) (M.ownKernel n (amap M.timeU n p)) := by |
| filter_upwards [M.ownKernel_time_equivariant n] with p hp |
| exact ⟨measurable_amap M.timeY.measurable n, |
| (Kernel.map_apply _ (measurable_amap M.timeY.measurable n) _).symm.trans hp⟩ |
| end Object |
| end ArrayObjects |
|
|
| open MeasureTheory ProbabilityTheory |
|
|
| namespace ConditionalFibres |
| variable {Ω U X Y : Type*} [MeasurableSpace Ω] [MeasurableSpace U] |
| [MeasurableSpace X] [MeasurableSpace Y] [StandardBorelSpace X] [StandardBorelSpace Y] |
| {μ : Measure Ω} [IsProbabilityMeasure μ] {u : Ω → U} {x : Ω → X} {y : Ω → Y} |
| {η : Kernel U Ω} [IsMarkovKernel η] {κ : Kernel (U × X) Y} [IsMarkovKernel κ] |
|
|
| omit [StandardBorelSpace X] [StandardBorelSpace Y] [IsProbabilityMeasure μ] [IsMarkovKernel κ] in |
| lemma chain {α : Kernel U X} [IsMarkovKernel α] |
| (hx : HasCondDistrib x u α μ) |
| (hy : HasCondDistrib y (fun ω => (u ω, x ω)) κ μ) : |
| HasCondDistrib (fun ω => (x ω, y ω)) u (α ⊗ₖ κ) μ := by |
| refine ⟨hx.aemeasurable_fst.prodMk |
| (hx.aemeasurable_snd.prodMk hy.aemeasurable_snd), ?_⟩ |
| calc |
| μ.map (fun ω => (u ω, x ω, y ω)) = |
| (μ.map (fun ω => ((u ω, x ω), y ω))).map MeasurableEquiv.prodAssoc := by |
| rw [AEMeasurable.map_map_of_aemeasurable (by fun_prop) hy.aemeasurable] |
| rfl |
| _ = ((μ.map u ⊗ₘ α) ⊗ₘ κ).map MeasurableEquiv.prodAssoc := by |
| rw [hy.map_eq, hx.map_eq] |
| _ = μ.map u ⊗ₘ (α ⊗ₖ κ) := Measure.compProd_assoc' |
|
|
| theorem disintegrate (hx : Measurable x) (hy : Measurable y) |
| (hη : HasCondDistrib id u η μ) |
| (hκ : HasCondDistrib y (fun ω => (u ω, x ω)) κ μ) : |
| ∀ᵐ a ∂μ.map u, HasCondDistrib y x (κ.sectR a) (η a) := by |
| let : IsMarkovKernel (η.map x) := Kernel.IsMarkovKernel.map η hx |
| let : IsMarkovKernel (η.map (fun ω => (x ω, y ω))) := |
| Kernel.IsMarkovKernel.map η (hx.prodMk hy) |
| have hpair := chain (hη.comp_left hx) hκ |
| have hother := hη.comp_left (hx.prodMk hy) |
| have he : η.map (fun ω => (x ω, y ω)) =ᵐ[μ.map u] (η.map x) ⊗ₖ κ := |
| Kernel.ae_eq_of_compProd_eq (hother.map_eq.symm.trans hpair.map_eq) |
| filter_upwards [he] with a ha |
| refine ⟨(hx.prodMk hy).aemeasurable, ?_⟩ |
| rw [Kernel.map_apply _ (hx.prodMk hy), Kernel.compProd_apply_eq_compProd_sectR, |
| Kernel.map_apply _ hx] at ha |
| exact ha |
|
|
| theorem marginal (hx : Measurable x) (hη : HasCondDistrib id u η μ) |
| {α : Kernel U X} [IsMarkovKernel α] (hα : HasCondDistrib x u α μ) : |
| ∀ᵐ a ∂μ.map u, MeasurePreserving x (η a) (α a) := by |
| let : IsMarkovKernel (η.map x) := Kernel.IsMarkovKernel.map η hx |
| have he : η.map x =ᵐ[μ.map u] α := |
| Kernel.ae_eq_of_compProd_eq ((hη.comp_left hx).map_eq.symm.trans hα.map_eq) |
| filter_upwards [he] with a ha |
| exact ⟨hx, (Kernel.map_apply η hx a).symm.trans ha⟩ |
|
|
| end ConditionalFibres |
|
|
| end Rokhlin |
|
|
| end |
|
|
| end OAI |
|
|
