| import OAI.Analysis.FiniteFactor.Coupling.Infinite |
| import OAI.Analysis.FiniteFactor.Coupling.FiniteLaw |
| import OAI.Analysis.FiniteFactor.ProductKernel |
|
|
| namespace OAI |
|
|
| namespace FiniteFactor |
| open MeasureTheory ProbabilityTheory Finset |
| open scoped ENNReal |
| noncomputable section |
| namespace CouplingParameters |
|
|
| / |
| def orientPair (right : Bool) (z : ℝ × ℝ) : ℝ × ℝ := |
| (endpoint right z, endpoint (!right) z) |
|
|
| theorem orientPair_measurable (right : Bool) : Measurable (orientPair right) := |
| (endpoint_measurable right).prodMk (endpoint_measurable (!right)) |
|
|
| theorem posterior_compProd (p : CouplingParameters) (right : Bool) : |
| (p.selectedLaw true right) ⊗ₘ (p.posteriorKernel right) = |
| p.coupling.map (orientPair right) := by |
| apply Measure.ext_prod |
| intro A B hA hB |
| rw [Measure.compProd_apply_prod hA hB, selectedLaw_endpoint, |
| Measure.map_apply (orientPair_measurable right) (hA.prod hB)] |
| cases right |
| · exact p.conditional_given_x hA hB |
| · have he : orientPair true ⁻¹' (A ×ˢ B) = B ×ˢ A := by |
| ext z |
| simp [orientPair, endpoint, and_comm] |
| rw [he] |
| exact p.conditional_given_y hA hB |
|
|
| def vectorCoupling {ι : Type*} (p : ι → CouplingParameters) : |
| Measure (ι → Fin 6 × (ℝ × ℝ)) := Measure.infinitePi (fun i => (p i).labelledCoupling) |
|
|
| instance vectorCoupling_probability {ι : Type*} (p : ι → CouplingParameters) : |
| IsProbabilityMeasure (vectorCoupling p) := by unfold vectorCoupling; infer_instance |
|
|
| def vectorEndpoint {ι : Type*} (right : ι → Bool) (ω : ι → Fin 6 × (ℝ × ℝ)) (i : ι) : ℝ := |
| endpoint (right i) (ω i).2 |
|
|
| theorem vectorEndpoint_measurable {ι : Type*} (right : ι → Bool) : Measurable (vectorEndpoint right) := by |
| exact Measurable.of_eval (fun i => (endpoint_measurable (right i)).comp |
| (measurable_snd.comp (measurable_pi_apply i))) |
|
|
| theorem vectorEndpoint_law {ι : Type*} (p : ι → CouplingParameters) (right : ι → Bool) : |
| (vectorCoupling p).map (vectorEndpoint right) = |
| Measure.infinitePi (fun i => (p i).selectedLaw true (right i)) := by |
| unfold vectorCoupling vectorEndpoint |
| rw [Measure.infinitePi_map_pi _ |
| (f := fun i (z : Fin 6 × (ℝ × ℝ)) => endpoint (right i) z.2) |
| (fun i => (endpoint_measurable (right i)).comp measurable_snd)] |
| simp_rw [labelled_endpoint_density] |
| rfl |
|
|
| def vectorPosterior {ι : Type*} (p : ι → CouplingParameters) (right : ι → Bool) : |
| Kernel (ι → ℝ) (ι → ℝ) := independentKernel (fun i => (p i).posteriorKernel (right i)) |
|
|
| instance vectorPosterior_markov {ι : Type*} (p : ι → CouplingParameters) (right : ι → Bool) : |
| IsMarkovKernel (vectorPosterior p right) := by unfold vectorPosterior; infer_instance |
|
|
| / |
| endpoint vector. This identity holds for the actual augmented product law. -/ |
| theorem vectorPosterior_disintegration {ι : Type*} (p : ι → CouplingParameters) (right : ι → Bool) : |
| ((vectorCoupling p).map (vectorEndpoint right)) ⊗ₘ (vectorPosterior p right) = |
| (vectorCoupling p).map (fun ω => (vectorEndpoint right ω, vectorEndpoint (fun i => !right i) ω)) := by |
| rw [vectorEndpoint_law] |
| have hh := independentKernel_compProd (fun i => (p i).selectedLaw true (right i)) |
| (fun i => (p i).posteriorKernel (right i)) |
| simp_rw [posterior_compProd] at hh |
| let zip : (ι → ℝ) × (ι → ℝ) → (ι → ℝ × ℝ) := fun z i => (z.1 i, z.2 i) |
| let unzip : (ι → ℝ × ℝ) → (ι → ℝ) × (ι → ℝ) := fun z => (fun i => (z i).1, fun i => (z i).2) |
| have hz : Measurable zip := by fun_prop |
| have hu : Measurable unzip := by fun_prop |
| have hleft := congrArg (fun ν : Measure (ι → ℝ × ℝ) => ν.map unzip) hh |
| rw [Measure.map_map hu hz] at hleft |
| have hid : unzip ∘ zip = id := rfl |
| rw [hid, Measure.map_id] at hleft |
| change _ = (Measure.infinitePi (fun i => (p i).coupling.map (orientPair (right i)))).map unzip at hleft |
| unfold vectorPosterior |
| rw [hleft] |
| have hp : (vectorCoupling p).map (fun ω i => orientPair (right i) (ω i).2) = |
| Measure.infinitePi (fun i => (p i).coupling.map (orientPair (right i))) := by |
| unfold vectorCoupling |
| rw [Measure.infinitePi_map_pi _ |
| (f := fun i (z : Fin 6 × (ℝ × ℝ)) => orientPair (right i) z.2) |
| (fun i => (orientPair_measurable (right i)).comp measurable_snd)] |
| congr 1 |
| funext i |
| unfold coupling |
| rw [Measure.map_map (orientPair_measurable (right i)) measurable_snd] |
| rfl |
| have hv : Measurable (fun (ω : ι → Fin 6 × (ℝ × ℝ)) i => orientPair (right i) (ω i).2) := |
| Measurable.of_eval (fun i => (orientPair_measurable (right i)).comp |
| (measurable_snd.comp (measurable_pi_apply i))) |
| rw [← hp, Measure.map_map hu hv] |
| rfl |
|
|
| / |
| Together with vectorPosterior_disintegration this is independence under the |
| actual conditional law, not a statement about a separately chosen product. -/ |
| theorem vectorPosterior_independence {ι : Type*} (p : ι → CouplingParameters) (right : ι → Bool) |
| (x : ι → ℝ) (I : Finset ι) (S : ι → Set ℝ) (hS : ∀ i ∈ I, MeasurableSet (S i)) : |
| vectorPosterior p right x (Set.pi (I : Set ι) S) = |
| ∏ i ∈ I, (p i).posteriorKernel (right i) (x i) (S i) := |
| independentKernel_pi _ x I S hS |
|
|
| / |
| theorem vectorPosterior_rectangle {ι : Type*} (p : ι → CouplingParameters) (right : ι → Bool) |
| {A B : Set (ι → ℝ)} (hA : MeasurableSet A) (hB : MeasurableSet B) : |
| (∫⁻ x in A, vectorPosterior p right x B ∂((vectorCoupling p).map (vectorEndpoint right))) = |
| vectorCoupling p {ω | vectorEndpoint right ω ∈ A ∧ vectorEndpoint (fun i => !right i) ω ∈ B} := by |
| rw [← Measure.compProd_apply_prod hA hB, vectorPosterior_disintegration, |
| Measure.map_apply ((vectorEndpoint_measurable right).prodMk |
| (vectorEndpoint_measurable (fun i => !right i))) (hA.prod hB)] |
| rfl |
|
|
| end CouplingParameters |
| end |
| end FiniteFactor |
|
|
| end OAI |
|
|
