| import Mathlib | |
| import OAI.Analysis.HardSphere.Allocation.PhysicalAssembly | |
| namespace OAI | |
| section | |
| noncomputable section | |
| open MeasureTheory ProbabilityTheory Set | |
| open scoped ENNReal BigOperators | |
| namespace HardSphere.Comparison | |
| variable {E I : Type*} [MeasurableSpace E] [Fintype I] | |
| {X : I → Type*} [∀i,MeasurableSpace (X i)] | |
| def blockExpose (p : I → Prop) (z : E × (∀i,X i)) : | |
| E × (∀i : {i // ¬p i},X i) := (z.1,fun i ↦ z.2 i) | |
| omit [Fintype I] in | |
| lemma blockExpose_measurable (p : I → Prop) : Measurable (blockExpose (E:=E) (X:=X) p) := | |
| measurable_fst.prodMk (Measurable.of_eval fun i ↦ | |
| (measurable_pi_apply i.val).comp measurable_snd) | |
| omit [MeasurableSpace E] [Fintype I] in | |
| lemma blockExpose_glue (p : I → Prop) [DecidablePred p] : | |
| blockExpose (E:=E) (X:=X) p ∘ blockGlue p = Prod.fst := by | |
| funext z | |
| apply Prod.ext | |
| · rfl | |
| funext i | |
| simp [blockExpose,blockGlue,MeasurableEquiv.piEquivPiSubtypeProd,i.property] | |
| lemma exposedLaw_marginal (μ : Measure E) [SFinite μ] | |
| (ν : ∀i,Measure (X i)) [∀i,IsProbabilityMeasure (ν i)] | |
| (p : I → Prop) [DecidablePred p] {B : Set (E × (∀i,X i))} | |
| (hB : MeasurableSet B) : | |
| exposedLaw μ ν p B = ((μ.prod (Measure.pi ν)).restrict B).map (blockExpose p) := by | |
| have : SFinite (exposedLaw μ ν p B) := by unfold exposedLaw; infer_instance | |
| rw [←exposed_block_reconstruct μ ν p hB, | |
| Measure.map_map (blockExpose_measurable p) (blockGlue_measurable p),blockExpose_glue] | |
| symm | |
| exact fiberNormalize_fst (exposedLaw μ ν p B) | |
| (Kernel.const _ (Measure.pi fun i : {i // p i} ↦ ν i)) | |
| (hB.preimage (blockGlue_measurable p)) (exposed_block_positive μ ν p hB) | |
| lemma exposedLaw_mass (μ : Measure E) [SFinite μ] | |
| (ν : ∀i,Measure (X i)) [∀i,IsProbabilityMeasure (ν i)] | |
| (p : I → Prop) [DecidablePred p] {B : Set (E × (∀i,X i))} | |
| (hB : MeasurableSet B) : | |
| exposedLaw μ ν p B univ = ((μ.prod (Measure.pi ν)).restrict B) univ := by | |
| rw [exposedLaw_marginal μ ν p hB,Measure.map_apply (blockExpose_measurable p) | |
| MeasurableSet.univ,preimage_univ] | |
| variable {A : Type*} [Fintype A] [MeasurableSpace A] [MeasurableSingletonClass A] | |
| attribute [local instance] Classical.propDecidable | |
| abbrev AllocatedDatum (E I A : Type*) (X : I → Type*) := | |
| E × (I → Bool) × A × (∀i,X i) | |
| def fillOutside (p : I → Prop) (x₀ : ∀i,X i) (x : ∀i : {i // ¬p i},X i) : ∀i,X i := | |
| fun i ↦ if h : p i then x₀ i else x ⟨i,h⟩ | |
| omit [Fintype I] in | |
| lemma fillOutside_measurable (p : I → Prop) (x₀ : ∀i,X i) : | |
| Measurable (fillOutside p x₀) := by | |
| apply Measurable.of_eval | |
| intro i | |
| by_cases hi : p i | |
| · simpa only [fillOutside,dite_eq_left hi] using | |
| (measurable_const : Measurable (fun _ : ∀i : {i // ¬p i},X i ↦ x₀ i)) | |
| · simpa only [fillOutside,dite_eq_right hi] using (measurable_pi_apply (⟨i,hi⟩ : {i // ¬p i})) | |
| def branchDatum (p : A → I → Prop) (x₀ : ∀i,X i) (a : A) (b : I → Bool) | |
| (w : E × (∀i : {i // ¬p a i},X i)) : AllocatedDatum E I A X := | |
| (w.1,b,a,fillOutside (p a) x₀ w.2) | |
| omit [Fintype I] [Fintype A] [MeasurableSingletonClass A] in | |
| lemma branchDatum_measurable (p : A → I → Prop) (x₀ : ∀i,X i) (a : A) (b : I → Bool) : | |
| Measurable (branchDatum (E:=E) p x₀ a b) := | |
| measurable_fst.prodMk (measurable_const.prodMk (measurable_const.prodMk | |
| ((fillOutside_measurable (p a) x₀).comp measurable_snd))) | |
| def allocationDatum (flag : ∀i,E × X i → Bool) (p : A → I → Prop) (x₀ : ∀i,X i) | |
| (z : (E × (∀i,X i)) × A) : AllocatedDatum E I A X := | |
| (z.1.1,(fun i ↦ flag i (z.1.1,z.1.2 i)),z.2, | |
| fun i ↦ if p z.2 i then x₀ i else z.1.2 i) | |
| omit [Fintype I] in | |
| lemma allocationDatum_measurable (flag : ∀i,E × X i → Bool) | |
| (hflag : ∀i,Measurable (flag i)) (p : A → I → Prop) (x₀ : ∀i,X i) : | |
| Measurable (allocationDatum flag p x₀) := by | |
| apply measurable_fst.fst.prodMk | |
| apply Measurable.prodMk | |
| · exact Measurable.of_eval fun i ↦ (hflag i).comp | |
| (measurable_fst.fst.prodMk ((measurable_pi_apply i).comp measurable_fst.snd)) | |
| apply measurable_snd.prodMk | |
| apply Measurable.of_eval | |
| intro i | |
| exact Measurable.ite (measurable_snd ((Set.to_countable {a : A | p a i}).measurableSet)) | |
| measurable_const ((measurable_pi_apply i).comp measurable_fst.snd) | |
| omit [MeasurableSpace E] [Fintype I] [∀i,MeasurableSpace (X i)] | |
| [Fintype A] [MeasurableSpace A] [MeasurableSingletonClass A] in | |
| lemma allocationDatum_branch (flag : ∀i,E × X i → Bool) (p : A → I → Prop) | |
| (x₀ : ∀i,X i) (a : A) (b : I → Bool) (z : E × (∀i,X i)) | |
| (hz : z ∈ flagEvent flag b) : | |
| allocationDatum flag p x₀ (z,a) = branchDatum p x₀ a b (blockExpose (p a) z) := by | |
| have hb : (fun i ↦ flag i (z.1,z.2 i)) = b := funext hz | |
| simp only [allocationDatum,branchDatum,blockExpose,hb] | |
| congr 3 | |
| def allocatedDatumLaw (μ : Measure E) [SFinite μ] | |
| (ν : ∀i,Measure (X i)) [∀i,IsProbabilityMeasure (ν i)] | |
| (flag : ∀i,E × X i → Bool) (hflag : ∀i,Measurable (flag i)) | |
| (κ : Kernel (E × (I → Bool)) A) [IsMarkovKernel κ] | |
| (p : A → I → Prop) (x₀ : ∀i,X i) (B : Set (E × (∀i,X i))) : | |
| Measure (AllocatedDatum E I A X) := | |
| (((μ.prod (Measure.pi ν)).restrict B).compProd | |
| (κ.comap (fun z ↦ (z.1,fun i ↦ flag i (z.1,z.2 i))) | |
| (measurable_fst.prodMk (Measurable.of_eval fun i ↦ | |
| (hflag i).comp (measurable_fst.prodMk ((measurable_pi_apply i).comp measurable_snd)))))).map | |
| (allocationDatum flag p x₀) | |
| lemma allocatedDatumLaw_branches (μ : Measure E) [SFinite μ] | |
| (ν : ∀i,Measure (X i)) [∀i,IsProbabilityMeasure (ν i)] | |
| (flag : ∀i,E × X i → Bool) (hflag : ∀i,Measurable (flag i)) | |
| (κ : Kernel (E × (I → Bool)) A) [IsMarkovKernel κ] | |
| (p : A → I → Prop) (x₀ : ∀i,X i) | |
| {B : Set (E × (∀i,X i))} (hB : MeasurableSet B) : | |
| allocatedDatumLaw μ ν flag hflag κ p x₀ B = | |
| ∑ b, ∑ a, (exposedLaw (allocationBase μ κ b a) ν (p a) | |
| (B ∩ flagEvent flag b)).map (branchDatum p x₀ a b) := by | |
| have hd := allocationDatum_measurable flag hflag p x₀ | |
| have hf : Measurable (fun z : E × (∀i,X i) ↦ fun i ↦ flag i (z.1,z.2 i)) := | |
| Measurable.of_eval fun i ↦ (hflag i).comp | |
| (measurable_fst.prodMk ((measurable_pi_apply i).comp measurable_snd)) | |
| unfold allocatedDatumLaw | |
| rw [←allocated_flag_joint μ (Measure.pi ν) κ _ hf hB] | |
| simp only [Measure.map_finset_sum' hd.aemeasurable] | |
| apply Finset.sum_congr rfl | |
| intro b _ | |
| apply Finset.sum_congr rfl | |
| intro a _ | |
| rw [exposedLaw_marginal _ _ _ (hB.inter (flagEvent_measurable flag hflag b)), | |
| Measure.map_map (branchDatum_measurable p x₀ a b) (blockExpose_measurable (p a)), | |
| Measure.map_map hd measurable_prodMk_right] | |
| simp only [allocationBase, flagEvent, ←funext_iff] | |
| apply Measure.map_congr | |
| filter_upwards [ae_restrict_mem (hB.inter (measurableSet_eq_fun hf measurable_const))] with z hz | |
| exact allocationDatum_branch flag p x₀ a b z (fun i ↦ congrFun hz.2 i) | |
| omit [Fintype A] [MeasurableSingletonClass A] in | |
| lemma allocatedDatumLaw_probability (μ : Measure E) [SFinite μ] | |
| (ν : ∀i,Measure (X i)) [∀i,IsProbabilityMeasure (ν i)] | |
| (flag : ∀i,E × X i → Bool) (hflag : ∀i,Measurable (flag i)) | |
| (κ : Kernel (E × (I → Bool)) A) [IsMarkovKernel κ] | |
| (p : A → I → Prop) (x₀ : ∀i,X i) (B : Set (E × (∀i,X i))) | |
| [IsProbabilityMeasure ((μ.prod (Measure.pi ν)).restrict B)] : | |
| IsProbabilityMeasure (allocatedDatumLaw μ ν flag hflag κ p x₀ B) := by | |
| unfold allocatedDatumLaw | |
| infer_instance | |
| end HardSphere.Comparison | |
| namespace HardSphere.Groups | |
| open Comparison Wiener Bridge Sampling | |
| attribute [local instance] Classical.propDecidable | |
| abbrev GroupDatum (N K M G : ℕ) (L : Length) := | |
| AllocatedDatum (BridgeEndpoints N L) (Fin N) (GridAllocation N K (G*M)) | |
| (fun _ ↦ Bridge.Noise) | |
| def groundDatumLaw {N K M G : ℕ} {L : Length} (hL : L.val=(K:ℝ)) | |
| (ψ : Jet N L) (m : ℕ) (r R C S s₀ t : ℝ) (u : Time) (g : Fin G) : | |
| Measure (GroupDatum N K M G L) := | |
| allocatedDatumLaw (endpointWeightedBase ψ t) (fun _ : Fin N ↦ Bridge.law) | |
| (eligibilityFlag (K:=K) m r R C S s₀ t u) | |
| (fun i ↦ eligibilityFlag_measurable m r R C S s₀ t u i) | |
| (gridAllocationKernel hL (G*M)) (fun a i ↦ i∈groupUnion g a) | |
| (fun _ ↦ 0) (labelInteraction N L r t) | |
| lemma groundDatumLaw_probability {N K M G : ℕ} {L : Length} (hL : L.val=(K:ℝ)) | |
| {ψ : Jet N L} (r : ℝ) (hψ : IsGroundVector N L r ψ) | |
| (m : ℕ) (R C S s₀ t : ℝ) (ht : 0≤t) (u : Time) (g : Fin G) : | |
| IsProbabilityMeasure (groundDatumLaw (M:=M) hL ψ m r R C S s₀ t u g) := by | |
| have := hψ.groundPathLaw_probability ht | |
| have : IsProbabilityMeasure (((endpointWeightedBase ψ t).prod | |
| (Measure.pi fun _ : Fin N ↦ Bridge.law)).restrict (labelInteraction N L r t)) := by | |
| constructor | |
| have h := congrArg (fun μ : Measure (ConfigurationPath N L) ↦ μ univ) | |
| (genuine_ground_label_bridge ψ r t) | |
| simpa only [Measure.map_apply (labelBridgePath_measurable N L t) | |
| MeasurableSet.univ,preimage_univ,measure_univ] using h | |
| exact allocatedDatumLaw_probability _ _ _ _ _ _ _ _ | |
| end HardSphere.Groups | |
| end | |
| end | |
| end OAI | |