| import OAI.Probability.GaussianReplacement.Observation |
|
|
| namespace OAI |
|
|
| open MeasureTheory ProbabilityTheory Set Filter |
| open scoped ENNReal NNReal RealInnerProductSpace Topology |
| noncomputable section |
| namespace CurrentProjection |
| open InnerProductSpace |
| open InformationTheory |
|
|
|
|
| def exchangeMiddle (C A B D : Type*) [MeasurableSpace C] [MeasurableSpace A] |
| [MeasurableSpace B] [MeasurableSpace D] : |
| ((C×(A×B))×D) ≃ᵐ ((C×(A×D))×B) where |
| toFun z := ((z.1.1,(z.1.2.1,z.2)),z.1.2.2) |
| invFun z := ((z.1.1,(z.1.2.1,z.2)),z.1.2.2) |
| left_inv z := by rcases z with ⟨⟨c,a,b⟩,d⟩; rfl |
| right_inv z := by rcases z with ⟨⟨c,a,d⟩,b⟩; rfl |
| measurable_toFun := (measurable_fst.fst.prodMk (measurable_fst.snd.fst.prodMk measurable_snd)).prodMk measurable_fst.snd.snd |
| measurable_invFun := (measurable_fst.fst.prodMk (measurable_fst.snd.fst.prodMk measurable_snd)).prodMk measurable_fst.snd.snd |
|
|
| lemma cauchyObservationLaw_single {d : ℕ} {C : Type*} [MeasurableSpace C] |
| (Γ : Measure (C×Sphere d)) [IsProbabilityMeasure Γ] : |
| cauchyObservationLaw Γ = |
| (scalarObservationLaw (singleSignalLaw (Γ.prod (stdGaussian (Vector d))))).map |
| (Prod.map (exchangeMiddle C (Vector d) ℝ (Vector d)) id) := by |
| rw [scalarObservationLaw,singleSignalLaw, |
| show ((Γ.prod (stdGaussian (Vector d))).map singleResidualObservation).prod |
| (stdGaussian (Vector d)) = |
| ((Γ.prod (stdGaussian (Vector d))).prod (stdGaussian (Vector d))).map |
| (Prod.map singleResidualObservation id) by |
| rw [←Measure.map_prod_map _ _ measurable_singleResidualObservation measurable_id,Measure.map_id], |
| Measure.map_map measurable_scalarObservation (measurable_singleResidualObservation.prodMap measurable_id), |
| Measure.map_map ((exchangeMiddle C (Vector d) ℝ (Vector d)).measurable.prodMap measurable_id) |
| (measurable_scalarObservation.comp (measurable_singleResidualObservation.prodMap measurable_id))] |
| rw [cauchyObservationLaw,show gaussianVectorPair d = (stdGaussian (Vector d)).prod (stdGaussian (Vector d)) from rfl, |
| ←Measure.prodAssoc_prod,Measure.map_map measurable_cauchyObservation MeasurableEquiv.prodAssoc.measurable] |
| rfl |
|
|
| lemma cauchyReference_single {d : ℕ} {C : Type*} [MeasurableSpace C] |
| (Γ : Measure (C×Sphere d)) [IsProbabilityMeasure Γ] : |
| conditionalReferenceKL (cauchyObservationLaw Γ) (gaussianReal 0 1) = |
| conditionalReferenceKL |
| (scalarObservationLaw (singleSignalLaw (Γ.prod (stdGaussian (Vector d))))) (gaussianReal 0 1) := by |
| rw [cauchyObservationLaw_single,conditionalReferenceKL_context_equiv] |
|
|
| lemma cauchyReference_context {d : ℕ} {C D : Type*} [MeasurableSpace C] [MeasurableSpace D] |
| (Γ : Measure (C×Sphere d)) [IsProbabilityMeasure Γ] (e : C ≃ᵐ D) : |
| conditionalReferenceKL (cauchyObservationLaw (Γ.map (Prod.map e id))) (gaussianReal 0 1) = |
| conditionalReferenceKL (cauchyObservationLaw Γ) (gaussianReal 0 1) := by |
| have he : cauchyObservationLaw (Γ.map (Prod.map e id)) = |
| (cauchyObservationLaw Γ).map (Prod.map |
| ((e.prodCongr (MeasurableEquiv.refl (Vector d×Vector d))).prodCongr (MeasurableEquiv.refl ℝ)) id) := by |
| rw [cauchyObservationLaw,show (Γ.map (Prod.map e id)).prod (gaussianVectorPair d) = |
| (Γ.prod (gaussianVectorPair d)).map (Prod.map (Prod.map e id) id) by |
| rw [←Measure.map_prod_map _ _ (e.measurable.prodMap measurable_id) measurable_id,Measure.map_id], |
| Measure.map_map measurable_cauchyObservation ((e.measurable.prodMap measurable_id).prodMap measurable_id), |
| cauchyObservationLaw,Measure.map_map (by fun_prop) measurable_cauchyObservation] |
| rfl |
| rw [he,conditionalReferenceKL_context_equiv] |
|
|
| lemma freshSlope_next_residual {d : ℕ} {C : Type*} [MeasurableSpace C] |
| (Γ : Measure (C×Sphere d)) [IsProbabilityMeasure Γ] (r : ℕ) : |
| freshSlope Γ (r+1) = |
| conditionalReferenceKL (cauchyObservationLaw (residualLaw Γ r)) (gaussianReal 0 1) := by |
| rw [freshSlope_succ,←cauchyReference_single,arrayResidualLaw_eq] |
| exact cauchyReference_context _ ((MeasurableEquiv.refl C).prodCongr (observationEquiv r d)) |
|
|
| def liftActualObservation {d r : ℕ} {C : Type*} (w : ((C×Sphere d)×Vector d)×Rows r d) : |
| (((C×Observations r d)×Sphere d)×Vector d) := |
| (((w.1.1.1,ownObservations w.2 w.1.1.2),w.1.1.2),w.1.2) |
|
|
| lemma measurable_liftActualObservation {d r : ℕ} {C : Type*} [MeasurableSpace C] : |
| Measurable (liftActualObservation (d:=d) (r:=r) (C:=C)) := by |
| unfold liftActualObservation |
| exact ((measurable_fst.fst.fst.prodMk (measurable_ownObservations.comp |
| (measurable_snd.prodMk measurable_fst.fst.snd))).prodMk measurable_fst.fst.snd).prodMk measurable_fst.snd |
|
|
| def liftActualLaw {d : ℕ} {C : Type*} [MeasurableSpace C] |
| (P : Measure ((C×Sphere d)×Vector d)) (r : ℕ) : Measure (((C×Observations r d)×Sphere d)×Vector d) := |
| (P.prod (gaussianRows r d)).map liftActualObservation |
|
|
| instance liftActualLaw_probability {d : ℕ} {C : Type*} [MeasurableSpace C] |
| (P : Measure ((C×Sphere d)×Vector d)) [IsProbabilityMeasure P] (r : ℕ) : |
| IsProbabilityMeasure (liftActualLaw P r) := by |
| exact (Measure.isProbabilityMeasure_map_iff |
| measurable_liftActualObservation.aemeasurable).mpr inferInstance |
|
|
| lemma liftActualLaw_fst {d : ℕ} {C : Type*} [MeasurableSpace C] |
| (P : Measure ((C×Sphere d)×Vector d)) [IsProbabilityMeasure P] (r : ℕ) : |
| (liftActualLaw P r).fst = arrayResidualLaw P.fst r := by |
| rw [liftActualLaw,Measure.fst,Measure.map_map measurable_fst measurable_liftActualObservation, |
| arrayResidualLaw,show P.fst.prod (gaussianRows r d) = |
| (P.prod (gaussianRows r d)).map (Prod.map Prod.fst id) by |
| rw [←Measure.map_prod_map _ _ measurable_fst measurable_id,Measure.map_id]; rfl, |
| Measure.map_map measurable_arrayResidualObservation (measurable_fst.prodMap measurable_id)] |
| rfl |
| |
| def actualFreshArrayLaw {d : ℕ} {C : Type*} [MeasurableSpace C] |
| (P : Measure ((C×Sphere d)×Vector d)) (r : ℕ) : |
| Measure (C×((Vector d×ℝ)×Observations r d)) := |
| (P.prod (gaussianRows r d)).map (fun w => |
| (w.1.1.1,((w.1.2,⟪(w.1.1.2:Vector d),w.1.2⟫),ownObservations w.2 w.1.1.2))) |
|
|
| lemma measurable_actualFreshArray {d r : ℕ} {C : Type*} [MeasurableSpace C] : |
| Measurable (fun w : ((C×Sphere d)×Vector d)×Rows r d => |
| (w.1.1.1,((w.1.2,⟪(w.1.1.2:Vector d),w.1.2⟫),ownObservations w.2 w.1.1.2))) := by |
| apply Measurable.prodMk measurable_fst.fst.fst |
| exact (measurable_fst.snd.prodMk (by fun_prop)).prodMk |
| (measurable_ownObservations.comp (measurable_snd.prodMk measurable_fst.fst.snd)) |
|
|
| instance actualFreshArrayLaw_probability {d : ℕ} {C : Type*} [MeasurableSpace C] |
| (P : Measure ((C×Sphere d)×Vector d)) [IsProbabilityMeasure P] (r : ℕ) : |
| IsProbabilityMeasure (actualFreshArrayLaw P r) := by |
| exact (Measure.isProbabilityMeasure_map_iff |
| measurable_actualFreshArray.aemeasurable).mpr inferInstance |
|
|
| lemma actualFreshArrayLaw_first {d : ℕ} {C : Type*} [MeasurableSpace C] |
| (P : Measure ((C×Sphere d)×Vector d)) [IsProbabilityMeasure P] (r : ℕ) : |
| (actualFreshArrayLaw P r).map (Prod.map id Prod.fst) = singleObservationLaw P := by |
| rw [actualFreshArrayLaw,Measure.map_map (measurable_id.prodMap measurable_fst) measurable_actualFreshArray] |
| have h : (Prod.map id Prod.fst) ∘ (fun w : ((C×Sphere d)×Vector d)×Rows r d => |
| (w.1.1.1,((w.1.2,⟪(w.1.1.2:Vector d),w.1.2⟫),ownObservations w.2 w.1.1.2))) = |
| (fun z : (C×Sphere d)×Vector d => (z.1.1,(z.2,⟪(z.1.2:Vector d),z.2⟫))) ∘ Prod.fst := rfl |
| rw [h,←Measure.map_map (by fun_prop) measurable_fst] |
| change (P.prod (gaussianRows r d)).fst.map _ = _ |
| rw [Measure.fst_prod,singleObservationLaw_eq] |
|
|
| attribute [fun_prop] measurable_ownObservations |
|
|
| lemma actualFreshArrayLaw_second {d : ℕ} {C : Type*} [MeasurableSpace C] |
| (P : Measure ((C×Sphere d)×Vector d)) [IsProbabilityMeasure P] (r : ℕ) : |
| (actualFreshArrayLaw P r).map MeasurableEquiv.prodAssoc.symm = freshArrayLaw (singleSignalLaw P) r := by |
| rw [actualFreshArrayLaw,Measure.map_map MeasurableEquiv.prodAssoc.symm.measurable measurable_actualFreshArray, |
| freshArrayLaw_eq,singleSignalLaw,show (P.map singleResidualObservation).prod (gaussianRows r d) = |
| (P.prod (gaussianRows r d)).map (Prod.map singleResidualObservation id) by |
| rw [←Measure.map_prod_map _ _ measurable_singleResidualObservation measurable_id,Measure.map_id], |
| Measure.map_map (by fun_prop) |
| (measurable_singleResidualObservation.prodMap measurable_id)] |
| rfl |
|
|
| lemma actualFreshArrayLaw_swapped_first {d : ℕ} {C : Type*} [MeasurableSpace C] |
| (P : Measure ((C×Sphere d)×Vector d)) [IsProbabilityMeasure P] (r : ℕ) : |
| ((actualFreshArrayLaw P r).map (Prod.map id Prod.swap)).map (Prod.map id Prod.fst) = |
| freshArrayLaw P.fst r := by |
| rw [actualFreshArrayLaw,Measure.map_map (measurable_id.prodMap measurable_swap) measurable_actualFreshArray, |
| Measure.map_map (measurable_id.prodMap measurable_fst) |
| ((measurable_id.prodMap measurable_swap).comp measurable_actualFreshArray), |
| freshArrayLaw_eq,show P.fst.prod (gaussianRows r d) = |
| (P.prod (gaussianRows r d)).map (Prod.map Prod.fst id) by |
| rw [←Measure.map_prod_map _ _ measurable_fst measurable_id,Measure.map_id]; rfl, |
| Measure.map_map (by fun_prop) |
| (measurable_fst.prodMap measurable_id)] |
| rfl |
| |
| lemma actualFreshArrayLaw_swapped_second {d : ℕ} {C : Type*} [MeasurableSpace C] |
| (P : Measure ((C×Sphere d)×Vector d)) [IsProbabilityMeasure P] (r : ℕ) : |
| ((actualFreshArrayLaw P r).map (Prod.map id Prod.swap)).map MeasurableEquiv.prodAssoc.symm = |
| singleObservationLaw (liftActualLaw P r) := by |
| rw [actualFreshArrayLaw,Measure.map_map (measurable_id.prodMap measurable_swap) measurable_actualFreshArray, |
| Measure.map_map MeasurableEquiv.prodAssoc.symm.measurable |
| ((measurable_id.prodMap measurable_swap).comp measurable_actualFreshArray), |
| singleObservationLaw_eq,liftActualLaw, |
| Measure.map_map (by fun_prop) measurable_liftActualObservation] |
| rfl |
|
|
| lemma actual_fresh_diamond {d : ℕ} {C : Type*} [MeasurableSpace C] |
| (P : Measure ((C×Sphere d)×Vector d)) [IsProbabilityMeasure P] (r : ℕ) : |
| singleReference P + freshReference (singleSignalLaw P) r = |
| freshReference P.fst r + singleReference (liftActualLaw P r) := by |
| let : IsProbabilityMeasure ((actualFreshArrayLaw P r).map (Prod.map id Prod.swap)) := |
| inferInstance |
| have he := conditionalReferenceKL_outcome_equiv (actualFreshArrayLaw P r) |
| ((gaussianObservation d).prod (gaussianObservations r d)) MeasurableEquiv.prodComm |
| change conditionalReferenceKL ((actualFreshArrayLaw P r).map (Prod.map id Prod.swap)) |
| (((gaussianObservation d).prod (gaussianObservations r d)).map Prod.swap) = _ at he |
| rw [Measure.prod_swap] at he |
| rw [conditionalReferenceKL_chain,actualFreshArrayLaw_swapped_first,actualFreshArrayLaw_swapped_second, |
| conditionalReferenceKL_chain,actualFreshArrayLaw_first,actualFreshArrayLaw_second] at he |
| exact he.symm |
|
|
|
|
| lemma residualLabelLaw_to_single {d : ℕ} {C : Type*} [MeasurableSpace C] |
| (P : Measure ((C×Sphere d)×Vector d)) (r : ℕ) : |
| (residualLabelLaw P r).map |
| (MeasurableEquiv.prodAssoc.trans |
| (((MeasurableEquiv.refl C).prodCongr (observationEquiv r d)).prodCongr |
| (MeasurableEquiv.refl (Vector d×ℝ)))) = |
| singleObservationLaw (liftActualLaw P r) := by |
| rw [residualLabelLaw,Measure.map_map (MeasurableEquiv.measurable _) measurable_residualLabelObservation, |
| singleObservationLaw_eq,liftActualLaw,Measure.map_map (by fun_prop) measurable_liftActualObservation] |
| rfl |
|
|
| lemma scalarObservationLaw_fst_direct {d : ℕ} {C : Type*} [MeasurableSpace C] |
| (Γ : Measure (C×Sphere d)) [SFinite Γ] : |
| (scalarObservationLaw Γ).fst = Γ.fst.prod (stdGaussian (Vector d)) := by |
| rw [scalarObservationLaw,Measure.fst,Measure.map_map measurable_fst measurable_scalarObservation] |
| change (Γ.prod (stdGaussian (Vector d))).map (Prod.map Prod.fst id) = _ |
| rw [←Measure.map_prod_map _ _ measurable_fst measurable_id,Measure.map_id] |
| rfl |
|
|
| lemma singleReference_lift_eq {d : ℕ} {C : Type*} [MeasurableSpace C] |
| (P : Measure ((C×Sphere d)×Vector d)) [IsProbabilityMeasure P] (r : ℕ) : |
| singleReference (liftActualLaw P r) = klDiv (residualLabelLaw P r) |
| ((scalarObservationLaw (residualLaw P.fst r)).fst.prod (gaussianReal 0 1)) := by |
| let e := (MeasurableEquiv.refl C).prodCongr (observationEquiv r d) |
| let e' := MeasurableEquiv.prodAssoc.trans (e.prodCongr (MeasurableEquiv.refl (Vector d×ℝ))) |
| have hbase : ((residualLaw P.fst r).fst).map e = freshArrayLaw P.fst r := by |
| rw [freshArrayLaw,arrayResidualLaw_eq] |
| simp only [Measure.fst] |
| rw [Measure.map_map e.measurable measurable_fst, |
| Measure.map_map measurable_fst ((measurable_id.prodMap (observationEquiv r d).measurable).prodMap measurable_id)] |
| rfl |
| have hfst : (singleObservationLaw (liftActualLaw P r)).fst = freshArrayLaw P.fst r := by |
| rw [singleObservationLaw_fst,liftActualLaw_fst]; rfl |
| have href : ((scalarObservationLaw (residualLaw P.fst r)).fst.prod (gaussianReal 0 1)).map e' = |
| (freshArrayLaw P.fst r).prod (gaussianObservation d) := by |
| rw [scalarObservationLaw_fst_direct] |
| change (((residualLaw P.fst r).fst.prod (stdGaussian (Vector d))).prod (gaussianReal 0 1)).map |
| (e.prodCongr (MeasurableEquiv.refl (Vector d×ℝ)) ∘ MeasurableEquiv.prodAssoc) = _ |
| rw [←Measure.map_map (e.prodCongr (MeasurableEquiv.refl (Vector d×ℝ))).measurable |
| MeasurableEquiv.prodAssoc.measurable,Measure.prodAssoc_prod] |
| change (((residualLaw P.fst r).fst).prod (gaussianObservation d)).map (Prod.map e id) = _ |
| rw [←Measure.map_prod_map _ _ e.measurable measurable_id,Measure.map_id,hbase] |
| rw [singleReference,conditionalReferenceKL,hfst, |
| ←residualLabelLaw_to_single P r,←href] |
| exact klDiv_map_equiv _ _ e' |
|
|
| lemma actual_fresh_row_bound {d r q : ℕ} [Nonempty (Sphere d)] {C : Type*} [MeasurableSpace C] |
| (P : Measure ((C×Sphere d)×Vector d)) [IsProbabilityMeasure P] |
| (hKL : klDiv P (P.fst.prod (stdGaussian (Vector d))) ≠ ∞) |
| (hr : r ≤ d) (hd : d ≤ 8*r) (hq : 1 ≤ q) (hqr : 2*q ≤ r) (hmargin : 2 ≤ r-q) |
| (hfresh : freshSlope P.fst r ≠ ∞) (hnext : freshSlope P.fst (r+1) ≠ ∞) |
| (hlabel : (residualLabelLaw P r).snd = gaussianReal 0 1) : |
| singleReference (liftActualLaw P r) ≠ ∞ ∧ |
| (singleReference (liftActualLaw P r)).toReal ≤ |
| (klDiv P (P.fst.prod (stdGaussian (Vector d)))).toReal + |
| (klDiv P (P.fst.prod (stdGaussian (Vector d)))).toReal / q + hybridRowConstant + |
| (freshSlope P.fst (r+1)).toReal := by |
| rw [singleReference_lift_eq,freshSlope_next_residual] at ⊢ |
| rw [freshSlope_eq] at hfresh |
| rw [freshSlope_next_residual] at hnext |
| exact residual_reference_bound P hKL hr hd hq hqr hmargin hfresh hnext hlabel |
|
|
|
|
|
|
|
|
| def initialArray {E : Type*} {i m : ℕ} (hi : i ≤ m) (X : Fin m → E) : Fin i → E := |
| fun j => X (Fin.castLE hi j) |
|
|
| lemma measurable_initialArray {E : Type*} [MeasurableSpace E] {i m : ℕ} (hi : i ≤ m) : |
| Measurable (initialArray (E:=E) hi) := by |
| unfold initialArray; fun_prop |
| |
| lemma initialArray_pi {E : Type*} [MeasurableSpace E] (μ : Measure E) [IsProbabilityMeasure μ] |
| {i m : ℕ} (hi : i ≤ m) : |
| (Measure.pi (fun _ : Fin m => μ)).map (initialArray hi) = Measure.pi (fun _ : Fin i => μ) := by |
| obtain ⟨r,rfl⟩ := Nat.exists_eq_add_of_le hi |
| rw [←map_append_pi μ i r,Measure.map_map (measurable_initialArray hi) (measurable_append i r)] |
| have he : (initialArray hi) ∘ (fun z : (Fin i→E)×(Fin r→E) => Fin.append z.1 z.2) = Prod.fst := by |
| funext z j |
| change Fin.append z.1 z.2 (Fin.castLE hi j) = z.1 j |
| have hj : Fin.castLE hi j = Fin.castAdd r j := rfl |
| rw [hj,Fin.append_left] |
| rw [he] |
| exact Measure.fst_prod |
|
|
| def prefixLaw {d m : ℕ} {W : Type*} [MeasurableSpace W] |
| (P : Measure ((Sphere d×W)×Rows m d)) (i : ℕ) (hi : i ≤ m) : |
| Measure ((Sphere d×W)×Rows i d) := P.map (Prod.map id (initialArray hi)) |
|
|
| instance prefixLaw_probability {d m : ℕ} {W : Type*} [MeasurableSpace W] |
| (P : Measure ((Sphere d×W)×Rows m d)) [IsProbabilityMeasure P] (i : ℕ) (hi : i ≤ m) : |
| IsProbabilityMeasure (prefixLaw P i hi) := by |
| exact (Measure.isProbabilityMeasure_map_iff |
| (measurable_id.prodMap (measurable_initialArray hi)).aemeasurable).mpr inferInstance |
|
|
| lemma prefixLaw_fst {d m : ℕ} {W : Type*} [MeasurableSpace W] |
| (P : Measure ((Sphere d×W)×Rows m d)) (i : ℕ) (hi : i ≤ m) : (prefixLaw P i hi).fst = P.fst := by |
| rw [prefixLaw,Measure.fst,Measure.map_map measurable_fst (measurable_id.prodMap (measurable_initialArray hi))] |
| rfl |
|
|
| lemma prefixLaw_self {d m : ℕ} {W : Type*} [MeasurableSpace W] |
| (P : Measure ((Sphere d×W)×Rows m d)) : prefixLaw P m le_rfl = P := by |
| change P.map id = P |
| rw [Measure.map_id] |
|
|
| lemma prefixLaw_independence {d m : ℕ} {W : Type*} [MeasurableSpace W] |
| (P : Measure ((Sphere d×W)×Rows m d)) [IsProbabilityMeasure P] |
| (ν : Measure (Sphere d)) [IsProbabilityMeasure ν] |
| (hInd : (P.map swapLast).fst = ν.prod (gaussianRows m d)) (i : ℕ) (hi : i ≤ m) : |
| ((prefixLaw P i hi).map swapLast).fst = ν.prod (gaussianRows i d) := by |
| have he := congrArg (fun μ : Measure (Sphere d×Rows m d) => μ.map (Prod.map id (initialArray hi))) hInd |
| rw [←Measure.map_prod_map _ _ measurable_id (measurable_initialArray hi),Measure.map_id] at he |
| change _ = ν.prod ((Measure.pi (fun _ : Fin m => stdGaussian (Vector d))).map (initialArray hi)) at he |
| rw [initialArray_pi] at he |
| rw [prefixLaw,Measure.fst,Measure.map_map measurable_fst swapLast.measurable, |
| Measure.map_map (measurable_fst.comp swapLast.measurable) (measurable_id.prodMap (measurable_initialArray hi))] |
| rw [Measure.fst,Measure.map_map (measurable_id.prodMap (measurable_initialArray hi)) measurable_fst, |
| Measure.map_map ((measurable_id.prodMap (measurable_initialArray hi)).comp measurable_fst) swapLast.measurable] at he |
| exact he |
|
|
| def observationSignalMap {d k : ℕ} {W : Type*} (z : (Sphere d×W)×Rows k d) : |
| (W×Observations k d)×Sphere d := ((z.1.2,ownObservations z.2 z.1.1),z.1.1) |
|
|
| lemma measurable_observationSignalMap {d k : ℕ} {W : Type*} [MeasurableSpace W] : |
| Measurable (observationSignalMap (d:=d) (k:=k) (W:=W)) := by |
| unfold observationSignalMap |
| exact (measurable_fst.snd.prodMk (measurable_ownObservations.comp |
| (measurable_snd.prodMk measurable_fst.fst))).prodMk measurable_fst.fst |
|
|
| def observationSignalLaw {d k : ℕ} {W : Type*} [MeasurableSpace W] |
| (P : Measure ((Sphere d×W)×Rows k d)) : Measure ((W×Observations k d)×Sphere d) := |
| P.map observationSignalMap |
|
|
| instance observationSignalLaw_probability {d k : ℕ} {W : Type*} [MeasurableSpace W] |
| (P : Measure ((Sphere d×W)×Rows k d)) [IsProbabilityMeasure P] : |
| IsProbabilityMeasure (observationSignalLaw P) := by |
| exact (Measure.isProbabilityMeasure_map_iff |
| measurable_observationSignalMap.aemeasurable).mpr inferInstance |
|
|
| lemma observationSignalLaw_context {d k : ℕ} {W : Type*} [MeasurableSpace W] |
| (P : Measure ((Sphere d×W)×Rows k d)) : (observationSignalLaw P).fst.fst = P.fst.snd := by |
| simp only [observationSignalLaw,Measure.fst,Measure.snd] |
| rw [Measure.map_map measurable_fst measurable_observationSignalMap, |
| Measure.map_map measurable_fst (measurable_fst.comp measurable_observationSignalMap), |
| Measure.map_map measurable_snd measurable_fst] |
| rfl |
|
|
| def nextActualRowLaw {d m : ℕ} {W : Type*} [MeasurableSpace W] |
| (P : Measure ((Sphere d×W)×Rows m d)) (i : ℕ) (hi : i < m) : |
| Measure (((W×Observations i d)×Sphere d)×Vector d) := |
| P.map (fun z => (((z.1.2,ownObservations (initialArray (Nat.le_of_lt hi) z.2) z.1.1),z.1.1),z.2 ⟨i,hi⟩)) |
|
|
| lemma measurable_nextActualRow {d m i : ℕ} {W : Type*} [MeasurableSpace W] (hi : i < m) : |
| Measurable (fun z : (Sphere d×W)×Rows m d => |
| (((z.1.2,ownObservations (initialArray (Nat.le_of_lt hi) z.2) z.1.1),z.1.1),z.2 ⟨i,hi⟩)) := by |
| exact ((measurable_fst.snd.prodMk (measurable_ownObservations.comp |
| (((measurable_initialArray _).comp measurable_snd).prodMk measurable_fst.fst))).prodMk |
| measurable_fst.fst).prodMk ((measurable_pi_apply _).comp measurable_snd) |
|
|
| instance nextActualRowLaw_probability {d m : ℕ} {W : Type*} [MeasurableSpace W] |
| (P : Measure ((Sphere d×W)×Rows m d)) [IsProbabilityMeasure P] (i : ℕ) (hi : i < m) : |
| IsProbabilityMeasure (nextActualRowLaw P i hi) := by |
| exact (Measure.isProbabilityMeasure_map_iff |
| (measurable_nextActualRow hi).aemeasurable).mpr inferInstance |
|
|
| lemma nextActualRowLaw_fst {d m : ℕ} {W : Type*} [MeasurableSpace W] |
| (P : Measure ((Sphere d×W)×Rows m d)) (i : ℕ) (hi : i < m) : |
| (nextActualRowLaw P i hi).fst = observationSignalLaw (prefixLaw P i (Nat.le_of_lt hi)) := by |
| rw [nextActualRowLaw,Measure.fst,Measure.map_map measurable_fst (measurable_nextActualRow hi), |
| observationSignalLaw,prefixLaw,Measure.map_map measurable_observationSignalMap |
| (measurable_id.prodMap (measurable_initialArray _))] |
| rfl |
|
|
| lemma initialArray_snoc {E : Type*} {i m : ℕ} (hi : i < m) (X : Fin m → E) : |
| initialArray (Nat.succ_le_of_lt hi) X = Fin.snoc (initialArray (Nat.le_of_lt hi) X) (X ⟨i,hi⟩) := by |
| funext j |
| induction j using Fin.lastCases with |
| | last => simp only [Fin.snoc_last]; rfl |
| | cast j => simp only [Fin.snoc_castSucc]; rfl |
| |
| lemma snoc_ownObservations {d i : ℕ} (X : Rows i d) (x : Vector d) (s : Sphere d) : |
| ownObservations (Fin.snoc X x) s = Fin.snoc (ownObservations X s) (x,⟪(s:Vector d),x⟫) := by |
| funext j |
| induction j using Fin.lastCases <;> simp [ownObservations,pairObservation,label] |
| |
| lemma nextActualRowLaw_single {d m : ℕ} {W : Type*} [MeasurableSpace W] |
| (P : Measure ((Sphere d×W)×Rows m d)) (i : ℕ) (hi : i < m) : |
| (singleSignalLaw (nextActualRowLaw P i hi)).map |
| (Prod.map (MeasurableEquiv.prodAssoc.trans |
| ((MeasurableEquiv.refl W).prodCongr (snocEquiv (Vector d×ℝ) i))) id) = |
| observationSignalLaw (prefixLaw P (i+1) (Nat.succ_le_of_lt hi)) := by |
| rw [singleSignalLaw,nextActualRowLaw, |
| Measure.map_map measurable_singleResidualObservation (measurable_nextActualRow hi), |
| Measure.map_map ((MeasurableEquiv.measurable _).prodMap measurable_id) |
| (measurable_singleResidualObservation.comp (measurable_nextActualRow hi)), |
| observationSignalLaw,prefixLaw,Measure.map_map measurable_observationSignalMap |
| (measurable_id.prodMap (measurable_initialArray _))] |
| congr 1 |
| funext z |
| change ((z.1.2,snocEquiv (Vector d×ℝ) i |
| (ownObservations (initialArray (Nat.le_of_lt hi) z.2) z.1.1, |
| (z.2 ⟨i,hi⟩,⟪(z.1.1:Vector d),z.2 ⟨i,hi⟩⟫))),z.1.1) = |
| ((z.1.2,ownObservations (initialArray (Nat.succ_le_of_lt hi) z.2) z.1.1),z.1.1) |
| rw [snocEquiv_apply,initialArray_snoc,snoc_ownObservations] |
|
|
|
|
|
|
| def rawNextRowLaw {d m : ℕ} {W : Type*} [MeasurableSpace W] |
| (P : Measure ((Sphere d×W)×Rows m d)) (i : ℕ) (hi : i < m) : |
| Measure (((Sphere d×W)×Rows i d)×Vector d) := |
| P.map (fun z => ((z.1,initialArray (Nat.le_of_lt hi) z.2),z.2 ⟨i,hi⟩)) |
|
|
| lemma measurable_rawNextRow {d m i : ℕ} {W : Type*} [MeasurableSpace W] (hi : i < m) : |
| Measurable (fun z : (Sphere d×W)×Rows m d => ((z.1,initialArray (Nat.le_of_lt hi) z.2),z.2 ⟨i,hi⟩)) := by |
| exact (measurable_fst.prodMk ((measurable_initialArray _).comp measurable_snd)).prodMk |
| ((measurable_pi_apply _).comp measurable_snd) |
|
|
| instance rawNextRowLaw_probability {d m : ℕ} {W : Type*} [MeasurableSpace W] |
| (P : Measure ((Sphere d×W)×Rows m d)) [IsProbabilityMeasure P] (i : ℕ) (hi : i < m) : |
| IsProbabilityMeasure (rawNextRowLaw P i hi) := by |
| exact (Measure.isProbabilityMeasure_map_iff |
| (measurable_rawNextRow hi).aemeasurable).mpr inferInstance |
|
|
| lemma rawNextRowLaw_fst {d m : ℕ} {W : Type*} [MeasurableSpace W] |
| (P : Measure ((Sphere d×W)×Rows m d)) (i : ℕ) (hi : i < m) : |
| (rawNextRowLaw P i hi).fst = prefixLaw P i (Nat.le_of_lt hi) := by |
| rw [rawNextRowLaw,Measure.fst,Measure.map_map measurable_fst (measurable_rawNextRow hi)] |
| rfl |
|
|
| lemma nextActualRowLaw_raw {d m : ℕ} {W : Type*} [MeasurableSpace W] |
| (P : Measure ((Sphere d×W)×Rows m d)) (i : ℕ) (hi : i < m) : |
| nextActualRowLaw P i hi = (rawNextRowLaw P i hi).map (Prod.map observationSignalMap id) := by |
| rw [rawNextRowLaw,Measure.map_map (measurable_observationSignalMap.prodMap measurable_id) (measurable_rawNextRow hi)] |
| rfl |
|
|
| lemma rowCharge_eq_raw {d m : ℕ} {W : Type*} [MeasurableSpace W] |
| (P : Measure ((Sphere d×W)×Rows m d)) [IsProbabilityMeasure P] (i : ℕ) (hi : i < m) : |
| klDiv (nextActualRowLaw P i hi) ((nextActualRowLaw P i hi).fst.prod (stdGaussian (Vector d))) = |
| conditionalReferenceKL (rawNextRowLaw P i hi) (stdGaussian (Vector d)) := by |
| change conditionalReferenceKL (nextActualRowLaw P i hi) _ = _ |
| rw [nextActualRowLaw_raw] |
| apply conditionalReferenceKL_map_context _ _ _ |
| (fun z : (W×Observations i d)×Sphere d => ((z.2,z.1.1),fun j => (z.1.2 j).1)) |
| measurable_observationSignalMap (by fun_prop) |
| intro z |
| rfl |
|
|
| lemma prefix_rowInformation_step {d m : ℕ} {W : Type*} [MeasurableSpace W] |
| (P : Measure ((Sphere d×W)×Rows m d)) [IsProbabilityMeasure P] (i : ℕ) (hi : i < m) : |
| rowInformation (prefixLaw P (i+1) (Nat.succ_le_of_lt hi)) (gaussianRows (i+1) d) = |
| rowInformation (prefixLaw P i (Nat.le_of_lt hi)) (gaussianRows i d) + |
| klDiv (nextActualRowLaw P i hi) ((nextActualRowLaw P i hi).fst.prod (stdGaussian (Vector d))) := by |
| let Q := (rawNextRowLaw P i hi).map MeasurableEquiv.prodAssoc |
| let : IsProbabilityMeasure Q := inferInstance |
| have hfirst : Q.map (Prod.map id Prod.fst) = prefixLaw P i (Nat.le_of_lt hi) := by |
| dsimp only [Q] |
| rw [Measure.map_map (measurable_id.prodMap measurable_fst) MeasurableEquiv.prodAssoc.measurable] |
| exact rawNextRowLaw_fst P i hi |
| have htotal : Q.map (Prod.map id (snocEquiv (Vector d) i)) = prefixLaw P (i+1) (Nat.succ_le_of_lt hi) := by |
| dsimp only [Q] |
| rw [rawNextRowLaw,Measure.map_map MeasurableEquiv.prodAssoc.measurable (measurable_rawNextRow hi), |
| Measure.map_map (measurable_id.prodMap (snocEquiv (Vector d) i).measurable) |
| (MeasurableEquiv.prodAssoc.measurable.comp (measurable_rawNextRow hi)),prefixLaw] |
| congr 1 |
| funext z |
| change (z.1,snocEquiv (Vector d) i (initialArray (Nat.le_of_lt hi) z.2,z.2 ⟨i,hi⟩)) = |
| (z.1,initialArray (Nat.succ_le_of_lt hi) z.2) |
| rw [snocEquiv_apply,initialArray_snoc] |
| have he := conditionalReferenceKL_outcome_equiv Q |
| ((gaussianRows i d).prod (stdGaussian (Vector d))) (snocEquiv (Vector d) i) |
| rw [show (((gaussianRows i d).prod (stdGaussian (Vector d))).map (snocEquiv (Vector d) i)) = |
| gaussianRows (i+1) d from snocEquiv_map (stdGaussian (Vector d)) i,htotal, |
| conditionalReferenceKL_chain,hfirst] at he |
| dsimp only [Q] at he |
| rw [MeasurableEquiv.map_symm_map,←rowCharge_eq_raw P i hi] at he |
| exact he |
|
|
|
|
|
|
| end CurrentProjection |
|
|
| end |
|
|
| end OAI |
|
|
