| import Mathlib |
| import OAI.Probability.GaussianInformation.Dyadic.ChannelEntropy |
|
|
| namespace OAI |
| open MeasureTheory ProbabilityTheory Set |
| open scoped BigOperators ENNReal |
| open MeasureTheory Metric Set |
| open scoped ENNReal NNReal |
| open MeasureTheory Set Filter |
| open scoped ENNReal Topology |
| open MeasureTheory ProbabilityTheory Set Filter |
| open scoped ENNReal Topology |
| open InnerProductSpace Matrix MeasureTheory Set |
| open scoped RealInnerProductSpace ENNReal |
| open MeasureTheory ProbabilityTheory Set |
| open scoped ENNReal NNReal |
| namespace RepeatedLocalization |
| namespace FiniteChannel |
| variable {α ι : Type*} [MeasurableSpace α] [Fintype ι] |
|
|
| noncomputable def expectation (p : FiniteChannel α ι) (μ : Measure α) (f : ι → ℝ) : ℝ := |
| ∑ i,scoreMass μ (p.prob i)*f i |
|
|
| lemma expectation_const (p : FiniteChannel α ι) (μ : Measure α) [IsProbabilityMeasure μ] (c : ℝ) : |
| p.expectation μ (fun _ => c) = c := by |
| rw [expectation,← Finset.sum_mul,p.mass_total μ,one_mul] |
|
|
| lemma expectation_add (p : FiniteChannel α ι) (μ : Measure α) (f g : ι → ℝ) : |
| p.expectation μ (fun i => f i+g i) = p.expectation μ f+p.expectation μ g := by |
| simp [expectation,mul_add,Finset.sum_add_distrib] |
|
|
| lemma expectation_const_mul (p : FiniteChannel α ι) (μ : Measure α) (c : ℝ) (f : ι → ℝ) : |
| p.expectation μ (fun i => c*f i) = c*p.expectation μ f := by |
| simp only [expectation,Finset.mul_sum]; congr 1; funext i; ring |
|
|
| lemma expectation_mono (p : FiniteChannel α ι) (μ : Measure α) {f g : ι → ℝ} (h : ∀ i,f i ≤ g i) : |
| p.expectation μ f ≤ p.expectation μ g := |
| Finset.sum_le_sum (fun i _ => mul_le_mul_of_nonneg_left (h i) (scoreMass_nonneg μ _ (p.nonneg i))) |
|
|
| lemma sum_mass_dbind {κ : ι → Type*} [∀ i,Fintype (κ i)] |
| (p : FiniteChannel α ι) (q : ∀ i,FiniteChannel α (κ i)) |
| (μ : Measure α) [IsFiniteMeasure μ] (i : ι) : |
| (∑ j,scoreMass μ ((p.dbind q).prob ⟨i,j⟩)) = scoreMass μ (p.prob i) := by |
| unfold scoreMass |
| rw [← integral_finsetSum _ (fun j _ => (p.dbind q).integrable μ ⟨i,j⟩)] |
| simp [dbind,← Finset.mul_sum,FiniteChannel.total] |
|
|
| lemma expectation_dbind {κ : ι → Type*} [∀ i,Fintype (κ i)] |
| (p : FiniteChannel α ι) (q : ∀ i,FiniteChannel α (κ i)) |
| (μ : Measure α) [IsFiniteMeasure μ] (f : Sigma κ → ℝ) : |
| (p.dbind q).expectation μ f = p.expectation μ (fun i => |
| (q i).expectation (scorePosterior μ (p.prob i)) (fun j => f ⟨i,j⟩)) := by |
| unfold expectation |
| rw [Fintype.sum_sigma] |
| simp_rw [p.mass_dbind q μ,mul_assoc,← Finset.mul_sum] |
|
|
| lemma expectation_dbind_fst {κ : ι → Type*} [∀ i,Fintype (κ i)] |
| (p : FiniteChannel α ι) (q : ∀ i,FiniteChannel α (κ i)) |
| (μ : Measure α) [IsFiniteMeasure μ] (f : ι → ℝ) : |
| (p.dbind q).expectation μ (fun i => f i.1) = p.expectation μ f := by |
| unfold expectation |
| rw [Fintype.sum_sigma] |
| simp_rw [← Finset.sum_mul,p.sum_mass_dbind q μ] |
|
|
| lemma expectation_bind_fst {κ : Type*} [Fintype κ] |
| (p : FiniteChannel α ι) (q : ι → FiniteChannel α κ) |
| (μ : Measure α) [IsFiniteMeasure μ] (f : ι → ℝ) : |
| (p.bind q).expectation μ (fun i => f i.1) = p.expectation μ f := by |
| have hm (i : ι) : (∑ j,scoreMass μ ((p.bind q).prob (i,j))) = scoreMass μ (p.prob i) := by |
| unfold scoreMass |
| rw [← integral_finsetSum _ (fun j _ => (p.bind q).integrable μ (i,j))] |
| simp [bind,← Finset.mul_sum,FiniteChannel.total] |
| unfold expectation |
| rw [Fintype.sum_prod_type] |
| simp_rw [← Finset.sum_mul,hm] |
|
|
| lemma bind_positive_parent {κ : Type*} [Fintype κ] |
| (p : FiniteChannel α ι) (q : ι → FiniteChannel α κ) |
| (μ : Measure α) [IsFiniteMeasure μ] (i : ι × κ) |
| (hi : 0 < scoreMass μ ((p.bind q).prob i)) : 0 < scoreMass μ (p.prob i.1) := |
| hi.trans_le (scoreMass_mul_le μ _ _ (p.measurable i.1) ((q i.1).measurable i.2) |
| (p.nonneg i.1) ((q i.1).nonneg i.2) (p.le_one i.1) ((q i.1).le_one i.2)) |
|
|
| lemma dbind_positive_parent {κ : ι → Type*} [∀ i,Fintype (κ i)] |
| (p : FiniteChannel α ι) (q : ∀ i,FiniteChannel α (κ i)) |
| (μ : Measure α) [IsFiniteMeasure μ] (i : Sigma κ) |
| (hi : 0 < scoreMass μ ((p.dbind q).prob i)) : 0 < scoreMass μ (p.prob i.1) := |
| hi.trans_le (scoreMass_mul_le μ _ _ (p.measurable i.1) ((q i.1).measurable i.2) |
| (p.nonneg i.1) ((q i.1).nonneg i.2) (p.le_one i.1) ((q i.1).le_one i.2)) |
|
|
| lemma dbind_positive_conditional {κ : ι → Type*} [∀ i,Fintype (κ i)] |
| (p : FiniteChannel α ι) (q : ∀ i,FiniteChannel α (κ i)) |
| (μ : Measure α) [IsFiniteMeasure μ] (i : Sigma κ) |
| (hi : 0 < scoreMass μ ((p.dbind q).prob i)) : |
| 0 < scoreMass (scorePosterior μ (p.prob i.1)) ((q i.1).prob i.2) := by |
| rw [p.mass_dbind q μ i] at hi |
| exact (mul_pos_iff_of_pos_left (p.dbind_positive_parent q μ i (by rw [p.mass_dbind q μ i]; exact hi))).mp hi |
|
|
| end FiniteChannel |
|
|
| lemma zero_heavy_refinement (n : ℕ) (Q : Cell n) : Nonempty (HeavyRefinement n 0 Q) := by |
| let q : FiniteChannel (Coordinate n) Unit := { |
| prob := fun _ _ => 1 |
| measurable := fun _ => measurable_const |
| nonneg := fun _ _ => zero_le_one |
| total := fun _ => by simp } |
| refine ⟨{ Index := Unit |
| channel := q |
| cell := fun _ => Q |
| B := fun _ => 1 |
| B_one := fun _ => le_refl _ |
| select := fun _ => () |
| select_fiber := fun i => by simp only [Subsingleton.elim () i, Set.ofPred_true]; exact MeasurableSet.univ |
| chosen := fun i z hz => Subsingleton.elim _ _ |
| cell_subset := fun _ => Subset.rfl |
| select_mem := fun z hz => hz |
| level_ge := fun _ => le_refl _ |
| support := ?_ |
| spread := ?_ |
| entropy_bound := ?_ |
| concentration_bound := ?_ }⟩ |
| · intro i hi; simp [scoreMass] at hi |
| · intro i hi; simp [scoreMass] at hi |
| · simp [finiteInformation,infoContribution,scoreMass,xlog_zero] |
| exact Real.log_nonneg (by norm_num) |
| · simp [scoreMass] |
| positivity |
|
|
| structure AnalysisState (n : ℕ) where |
| Index : Type |
| [finiteIndex : Fintype Index] |
| channel : FiniteChannel (Coordinate n) Index |
| cell : Index → Cell n |
| B : Index → ℝ |
| B_one : ∀ i,1 ≤ B i |
| support : ∀ i,0 < scoreMass (cubePrior n) (channel.prob i) → |
| scorePosterior (cubePrior n) (channel.prob i) (cellSet (cell i)) = 1 |
| spread : ∀ i,0 < scoreMass (cubePrior n) (channel.prob i) → |
| DyadicSpread (scorePosterior (cubePrior n) (channel.prob i)) (cell i) (B i) |
|
|
| attribute [instance] AnalysisState.finiteIndex |
|
|
| namespace AnalysisState |
| variable {n : ℕ} |
| noncomputable def information (s : AnalysisState n) : ℝ := finiteInformation (cubePrior n) s.channel.prob |
| noncomputable def depth (s : AnalysisState n) : ℝ := s.channel.expectation (cubePrior n) (fun i => (s.cell i).1) |
| noncomputable def concentration (s : AnalysisState n) : ℝ := s.channel.expectation (cubePrior n) (fun i => Real.log (s.B i)) |
| noncomputable def potential (s : AnalysisState n) : ℝ := |
| s.information+s.concentration-((n:ℝ)/2+2)*Real.log 2*s.depth |
|
|
| lemma depth_nonneg (s : AnalysisState n) : 0 ≤ s.depth := |
| Finset.sum_nonneg (fun i _ => mul_nonneg (scoreMass_nonneg _ _ (s.channel.nonneg i)) (Nat.cast_nonneg _)) |
|
|
| lemma concentration_nonneg (s : AnalysisState n) : 0 ≤ s.concentration := |
| Finset.sum_nonneg (fun i _ => mul_nonneg (scoreMass_nonneg _ _ (s.channel.nonneg i)) (Real.log_nonneg (s.B_one i))) |
|
|
| lemma information_lower (hn : 0 < n) (s : AnalysisState n) : |
| (n:ℝ)*Real.log 2*s.depth ≤ s.information := by |
| have := cubePrior_isProbabilityMeasure hn |
| change (n:ℝ)*Real.log 2*(∑ i,scoreMass (cubePrior n) (s.channel.prob i)*((s.cell i).1:ℝ)) ≤ |
| ∑ i,infoContribution (cubePrior n) (s.channel.prob i) |
| rw [Finset.mul_sum] |
| apply Finset.sum_le_sum |
| intro i hi |
| by_cases h : scoreMass (cubePrior n) (s.channel.prob i) = 0 |
| · simp only [h,zero_mul,mul_zero] |
| exact infoContribution_nonneg _ _ (s.channel.measurable i) (s.channel.nonneg i) (s.channel.le_one i) |
| have hP : 0 < scoreMass (cubePrior n) (s.channel.prob i) := |
| lt_of_le_of_ne (scoreMass_nonneg _ _ (s.channel.nonneg i)) (Ne.symm h) |
| have := scorePosterior_probability _ _ (s.channel.measurable i) (s.channel.nonneg i) (s.channel.le_one i) hP |
| have hval : (cubePrior n).real (cellSet (s.cell i)) = (1/2:ℝ)^(n*(s.cell i).1) := by |
| rw [measureReal_def,cubePrior_cellSet hn,ENNReal.toReal_ofReal (by positivity)] |
| have hz := (scorePosterior_null_iff (cubePrior n) _ (s.channel.measurable i) (s.channel.nonneg i) hP |
| _ (measurableSet_cellSet (s.cell i)).compl).mp |
| ((prob_compl_eq_zero_iff (measurableSet_cellSet (s.cell i))).mpr (s.support i hP)) |
| have hl := infoContribution_support_lower (cubePrior n) _ (s.channel.measurable i) (s.channel.nonneg i) (s.channel.le_one i) |
| _ (measurableSet_cellSet (s.cell i)) (by rw [hval]; positivity) hz |
| rw [hval,Real.log_pow] at hl |
| have he : Real.log (1/2:ℝ) = -Real.log 2 := by rw [one_div,Real.log_inv] |
| rw [he] at hl |
| push_cast at hl |
| nlinarith |
|
|
| lemma information_of_potential (hn : 8 ≤ n) (s : AnalysisState n) {A : ℝ} |
| (h : s.potential ≤ A) : s.information ≤ 4*A := by |
| have hl := s.information_lower (by omega) |
| have hc := s.concentration_nonneg |
| have hd := s.depth_nonneg |
| have hlog : 0 < Real.log 2 := Real.log_pos (by norm_num) |
| have hn' : (8:ℝ) ≤ n := by exact_mod_cast hn |
| have hb : (((n:ℝ)/2+2)*Real.log 2)*s.depth ≤ (3/4:ℝ)*((n:ℝ)*Real.log 2*s.depth) := by |
| nlinarith [mul_nonneg (show 0 ≤ (n:ℝ)-8 by linarith) (mul_nonneg hlog.le hd)] |
| unfold potential at h |
| linarith |
| |
| end AnalysisState |
| |
| lemma scorePosterior_one {α : Type*} [MeasurableSpace α] (μ : Measure α) [IsProbabilityMeasure μ] : |
| scorePosterior μ (fun _ => 1) = μ := by simp [scorePosterior,scoreMass] |
| |
| lemma cubePrior_spread_root {n : ℕ} (hn : 0 < n) : DyadicSpread (cubePrior n) (rootCell n) 1 := by |
| intro j R hR hsub |
| have hlev : R.1 = j := by simpa [rootCell] using hR |
| rw [cubePrior_cellSet hn,hlev,one_mul] |
| change ENNReal.ofReal ((1/2:ℝ)^(n*j)) ≤ ENNReal.ofReal (heavyThreshold n j) |
| apply ENNReal.ofReal_le_ofReal |
| rw [← heavyThreshold_sq] |
| have hle : heavyThreshold n j ≤ 1 := by |
| apply Real.rpow_le_one_of_one_le_of_nonpos (by norm_num) |
| have hn0 : (0:ℝ) ≤ n := Nat.cast_nonneg _ |
| have hj0 : (0:ℝ) ≤ j := Nat.cast_nonneg _ |
| nlinarith [mul_nonneg hn0 hj0] |
| have hp := (heavyThreshold_pos n j).le |
| nlinarith |
| |
| noncomputable def initialState {n : ℕ} (hn : 0 < n) : AnalysisState n := by |
| letI := cubePrior_isProbabilityMeasure hn |
| let p : FiniteChannel (Coordinate n) Unit := { |
| prob := fun _ _ => 1 |
| measurable := fun _ => measurable_const |
| nonneg := fun _ _ => zero_le_one |
| total := fun _ => by simp } |
| exact { |
| Index := Unit |
| channel := p |
| cell := fun _ => rootCell n |
| B := fun _ => 1 |
| B_one := fun _ => le_refl _ |
| support := fun _ _ => by |
| change scorePosterior (cubePrior n) (fun _ => 1) (cellSet (rootCell n)) = 1 |
| rw [scorePosterior_one,cubePrior_cellSet hn]; simp [rootCell] |
| spread := fun _ _ => by |
| change DyadicSpread (scorePosterior (cubePrior n) (fun _ => 1)) (rootCell n) 1 |
| rw [scorePosterior_one]; exact cubePrior_spread_root hn } |
| |
| lemma initialState_potential {n : ℕ} (hn : 0 < n) : (initialState hn).potential = 0 := by |
| have := cubePrior_isProbabilityMeasure hn |
| simp [initialState,AnalysisState.potential,AnalysisState.information,AnalysisState.concentration, |
| AnalysisState.depth,FiniteChannel.expectation,finiteInformation,infoContribution,scoreMass,xlog_one,rootCell] |
| |
| lemma posterior_cube_domination {n : ℕ} (hn : 0 < n) |
| {ι : Type*} [Fintype ι] (p : FiniteChannel (Coordinate n) ι) (i : ι) |
| (hi : 0 < scoreMass (cubePrior n) (p.prob i)) (R : Cell n) : |
| (scorePosterior (cubePrior n) (p.prob i)).real (cellSet R) ≤ |
| (1/scoreMass (cubePrior n) (p.prob i))*(1/2:ℝ)^(n*R.1) := by |
| have h := scorePosterior_apply_le (cubePrior n) _ (p.le_one i) hi _ (measurableSet_cellSet R) |
| rw [cubePrior_cellSet hn] at h |
| have he := ENNReal.toReal_mono (by finiteness) h |
| simpa only [measureReal_def,ENNReal.toReal_mul,ENNReal.toReal_ofReal (by positivity : 0 ≤ 1/scoreMass (cubePrior n) (p.prob i)), |
| ENNReal.toReal_ofReal (by positivity : 0 ≤ (1/2:ℝ)^(n*R.1))] using he |
| |
| def appendHistoryEquiv (N t : ℕ) : (History N t × Fin N) ≃ History N (t+1) := |
| (Equiv.prodComm _ _).trans (Fin.snocEquiv (fun _ => Fin N)) |
| |
| lemma appendHistoryEquiv_apply {N t : ℕ} (w : History N t) (v : Fin N) : |
| appendHistoryEquiv N t (w,v) = Fin.snoc (α := fun _ : Fin (t+1) => Fin N) w v := rfl |
| |
| def initRules {n N t : ℕ} (rules : Rules n N (t+1)) : Rules n N t := |
| fun i => rules i.castSucc |
| |
| lemma past_snoc_castSucc {N t : ℕ} (w : History N t) (v : Fin N) (i : Fin t) : |
| past (Fin.snoc (α := fun _ : Fin (t+1) => Fin N) w v) i.castSucc = past w i := by |
| funext j |
| change Fin.snoc (α := fun _ : Fin (t+1) => Fin N) w v (Fin.castSucc ⟨j.val,Nat.lt_trans j.isLt i.isLt⟩) = _ |
| exact Fin.snoc_castSucc (α := fun _ : Fin (t+1) => Fin N) v w ⟨j.val,Nat.lt_trans j.isLt i.isLt⟩ |
| |
| lemma past_snoc_last {N t : ℕ} (w : History N t) (v : Fin N) : |
| past (Fin.snoc (α := fun _ : Fin (t+1) => Fin N) w v) (Fin.last t) = w := by |
| funext j |
| change Fin.snoc (α := fun _ : Fin (t+1) => Fin N) w v j.castSucc = _ |
| simp |
| |
| lemma historyLikelihood_snoc {n N t : ℕ} (rules : Rules n N (t+1)) |
| (z : Coordinate n) (w : History N t) (v : Fin N) : |
| historyLikelihood rules z (Fin.snoc (α := fun _ : Fin (t+1) => Fin N) w v) = |
| historyLikelihood (initRules rules) z w * blockProbability (rules (Fin.last t) w) z v := by |
| rw [historyLikelihood,Fin.prod_univ_castSucc] |
| simp only [Fin.snoc_castSucc,Fin.snoc_last,past_snoc_castSucc,past_snoc_last] |
| rfl |
| |
| lemma historyLikelihood_sum {n N t : ℕ} (rules : Rules n N t) (z : Coordinate n) : |
| ∑ w,historyLikelihood rules z w = 1 := by |
| induction t with |
| | zero => simp [historyLikelihood] |
| | succ t ih => |
| rw [← Equiv.sum_comp (appendHistoryEquiv N t),Fintype.sum_prod_type] |
| simp_rw [appendHistoryEquiv_apply,historyLikelihood_snoc,← Finset.mul_sum,blockProbability_sum,mul_one] |
| exact ih (initRules rules) |
| |
| noncomputable def blockChannel {n N : ℕ} (rule : BlockRule n N) : FiniteChannel (Coordinate n) (Fin N) where |
| prob := fun w z => blockProbability rule z w |
| measurable := measurable_blockProbability rule |
| nonneg := fun w z => blockProbability_nonneg rule z w |
| total := blockProbability_sum rule |
| |
| noncomputable def historyChannel {n N t : ℕ} (rules : Rules n N t) : FiniteChannel (Coordinate n) (History N t) where |
| prob := fun w z => historyLikelihood rules z w |
| measurable := measurable_historyLikelihood rules |
| nonneg := fun w z => historyLikelihood_nonneg rules z w |
| total := historyLikelihood_sum rules |
| |
| end RepeatedLocalization |
| |
| end OAI |
| |
