| import OAI.Probability.FreeIsing.Estimates.ComponentFusionRecurrence |
| import OAI.Probability.FreeIsing.Posterior.ProgressiveIsingPosterior |
| import OAI.Probability.FreeIsing.Posterior.SelectedPosteriorField |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| open MeasureTheory ProbabilityTheory |
| open scoped NNReal |
|
|
| namespace Problem367 |
|
|
| theorem component_or_flipped_component {d : ℕ} (c : Fin d) (v : TreeVertex d) : |
| v ∈ Set.range (componentIndexVertex (c := c)) ∨ |
| v ∈ Set.range (fun u : ComponentIndex c => prefixFlip c (componentIndexVertex u)) := by |
| by_cases h : [c] <+: v.1 |
| · left |
| apply mem_range_componentIndexVertex.mpr |
| obtain ⟨w, hw⟩ := h |
| exact ⟨w, by simpa using hw.symm⟩ |
| · right |
| have hf := (RootedBroadcast.prefix_flip_iff_not_prefix c v).mpr h |
| obtain ⟨w, hw⟩ := hf |
| have hmem : prefixFlip c v ∈ Set.range (componentIndexVertex (c := c)) := |
| mem_range_componentIndexVertex.mpr ⟨w, by simpa using hw.symm⟩ |
| obtain ⟨u, hu⟩ := hmem |
| refine ⟨u, ?_⟩ |
| change prefixFlip c (componentIndexVertex u) = v |
| rw [hu, prefixFlip_twice] |
|
|
| theorem selectedObservationField_eq_component_sup_flip |
| {d : ℕ} {A B : Type*} [MeasurableSpace A] [MeasurableSpace B] |
| (F : IsingSpin → A → B) (c : Fin d) : |
| selectedObservationField F id = |
| selectedObservationField F (fun u : ComponentIndex c => prefixFlip c (componentIndexVertex u)) ⊔ |
| selectedObservationField F (componentIndexVertex (c := c)) := by |
| apply le_antisymm |
| · simp only [selectedObservationField, MeasurableSpace.comap_process_pi, id_eq] |
| apply iSup_le |
| intro v |
| rcases component_or_flipped_component c v with ⟨u, rfl⟩ | ⟨u, rfl⟩ |
| · exact le_sup_of_le_right (le_iSup_of_le u le_rfl) |
| · exact le_sup_of_le_left (le_iSup_of_le u le_rfl) |
| · apply sup_le |
| · apply selectedObservationField_le_of_range_subset F |
| intro v hv |
| exact ⟨v, rfl⟩ |
| · apply selectedObservationField_le_of_range_subset F |
| intro v hv |
| exact ⟨v, rfl⟩ |
|
|
| theorem HasFreeIsingLaw.condIndepFun_component_flip_observations |
| {d : ℕ} {theta : ℝ} {A B : Type*} |
| [MeasurableSpace A] [StandardBorelSpace A] [MeasurableSpace B] |
| {μ : Measure (TreeVertex d → IsingSpin)} [IsFiniteMeasure μ] |
| (hμ : HasFreeIsingLaw theta μ) (h0 : -1 ≤ theta) (h1 : theta ≤ 1) |
| (ν : Measure A) [IsProbabilityMeasure ν] |
| {F : IsingSpin → A → B} (hF : Measurable (Function.uncurry F)) (c : Fin d) : |
| CondIndepFun |
| ((inferInstance : MeasurableSpace IsingSpin).comap |
| (fun z : (TreeVertex d → IsingSpin) × (TreeVertex d → A) => z.1 (RootedBroadcast.root d))) |
| ((measurable_pi_apply (RootedBroadcast.root d)).comp measurable_fst).comap_le |
| (fun z => fun u : ComponentIndex c => F |
| (z.1 (prefixFlip c (componentIndexVertex u))) (z.2 (prefixFlip c (componentIndexVertex u)))) |
| (fun z => fun u : ComponentIndex c => F (z.1 (componentIndexVertex u)) (z.2 (componentIndexVertex u))) |
| (μ.prod (Measure.infinitePi (fun _ : TreeVertex d => ν))) := by |
| let v (u : ComponentIndex c) : RootedBroadcast.BranchVertex c := |
| ⟨componentIndexVertex u, by simp [componentIndexVertex, componentVertex]⟩ |
| let G (p : (RootedBroadcast.BranchVertex c → IsingSpin) × |
| (RootedBroadcast.BranchVertex c → A)) := |
| fun u : ComponentIndex c => F (p.1 (v u)) (p.2 (v u)) |
| have hG : Measurable G := by |
| apply Measurable.of_eval |
| intro u |
| exact hF.comp (show Measurable (fun p : |
| (RootedBroadcast.BranchVertex c → IsingSpin) × |
| (RootedBroadcast.BranchVertex c → A) => (p.1 (v u), p.2 (v u))) by fun_prop) |
| have h := (hμ.condIndepFun_noisy_root_others_branch h0 h1 (fun _ => ν) c).comp |
| (hG.comp (measurable_decodeFlippedBranch c)) hG |
| simpa only [Function.comp_def, G, decodeFlippedBranch, noisyRootOtherDecode_array, |
| RootedBroadcast.flipBranchToComplement_val, noisyBranchArray, v] using h |
|
|
| theorem HasFreeIsingLaw.gaussian_root_information_le_component |
| {d : ℕ} {beta : ℝ} {μ : Measure (TreeVertex d → IsingSpin)} |
| (hμ : HasFreeIsingLaw (Real.tanh beta) μ) (hb : 0 ≤ beta) |
| (t : ℝ≥0) (c : Fin d) : |
| (∫ z, (PlantedSymmetry.posteriorMagnetization |
| (μ.prod (PlantedSymmetry.gaussianNoiseLaw (TreeVertex d) t)) t |
| (RootedBroadcast.root d) z) ^ 2 |
| ∂μ.prod (PlantedSymmetry.gaussianNoiseLaw (TreeVertex d) t)) ≤ |
| (1 + (Real.tanh beta) ^ 2) * gaussianComponentInformation μ t c := by |
| let := hμ.isProbabilityMeasure |
| let mΩ : MeasurableSpace ((TreeVertex d → IsingSpin) × (TreeVertex d → ℝ)) := inferInstance |
| let ρ := μ.prod (PlantedSymmetry.gaussianNoiseLaw (TreeVertex d) t) |
| let F : IsingSpin → ℝ → ℝ := fun s x => (t : ℝ) * spinSign s + x |
| let r := RootedBroadcast.root d |
| let w := fun u : ComponentIndex c => prefixFlip c (componentIndexVertex u) |
| let mL := selectedObservationField F w |
| let mR := selectedObservationField F (componentIndexVertex (c := c)) |
| let : MeasurableSpace ((TreeVertex d → IsingSpin) × (TreeVertex d → ℝ)) := mΩ |
| let S (z : (TreeVertex d → IsingSpin) × (TreeVertex d → ℝ)) := z.1 r |
| have hF : Measurable (Function.uncurry F) := |
| ((PlantedInformation.measurable_spinSign.comp measurable_fst).const_mul _).add measurable_snd |
| have hS : Measurable S := (measurable_pi_apply r).comp measurable_fst |
| have hθ0 := tanh_nonneg_of_beta_nonneg hb |
| have hθ1 := Real.tanh_lt_one beta |
| have hθlo : -1 ≤ Real.tanh beta := by linarith |
| have hfair (s : IsingSpin) : ρ {z | S z = s} = (1 / 2 : ENNReal) := |
| hμ.planted_spin_event_mass (fun _ => gaussianReal 0 t) r s |
| have hL : ∀ᵐ z ∂ρ, |ρ[fun z => spinSign (S z) | mL] z| < 1 := by |
| have hr : r ∈ Set.range w := by |
| refine ⟨⟨0, ⟨[], rfl, List.IsChain.singleton c⟩⟩, ?_⟩ |
| exact RootedBroadcast.prefixFlip_branchRoot c |
| filter_upwards [hμ.selected_gaussian_posterior_field_bound hb t w r hr] with z hz |
| exact abs_lt.mpr hz.1 |
| have hreg := hμ.selectedPosterior_root_component hθlo hθ1.le (gaussianReal 0 t) hF c |
| have hR : ∀ᵐ z ∂ρ, |ρ[fun z => spinSign (S z) | mR] z| < 1 := by |
| filter_upwards [hreg, selectedPosterior_abs_le_one ρ F (componentIndexVertex (c := c)) |
| (RootedBroadcast.branchRoot c)] with z hz hz1 |
| change |selectedPosterior ρ F (componentIndexVertex (c := c)) r z| < 1 |
| change selectedPosterior ρ F (componentIndexVertex (c := c)) r z = |
| Real.tanh beta * selectedPosterior ρ F (componentIndexVertex (c := c)) |
| (RootedBroadcast.branchRoot c) z at hz |
| rw [hz, abs_mul, abs_of_nonneg hθ0] |
| exact (mul_le_mul_of_nonneg_left hz1 hθ0).trans_lt (by simpa using hθ1) |
| have hCI := hμ.condIndepFun_component_flip_observations hθlo hθ1.le (gaussianReal 0 t) hF c |
| have hInd (s : IsingSpin) : Indep mL mR (cond ρ {z | S z = s}) := by |
| exact indepFun_cond_fiber_of_condIndepFun hS |
| (show Measurable (fun z : (TreeVertex d → IsingSpin) × (TreeVertex d → ℝ) => |
| fun u : ComponentIndex c => F (z.1 (w u)) (z.2 (w u))) from |
| Measurable.of_eval (fun u => hF.comp (show Measurable |
| (fun z : (TreeVertex d → IsingSpin) × (TreeVertex d → ℝ) => |
| (z.1 (w u), z.2 (w u))) by fun_prop))) |
| (show Measurable (fun z : (TreeVertex d → IsingSpin) × (TreeVertex d → ℝ) => |
| fun u : ComponentIndex c => F (z.1 (componentIndexVertex u)) (z.2 (componentIndexVertex u))) from |
| Measurable.of_eval (fun u => hF.comp (show Measurable |
| (fun z : (TreeVertex d → IsingSpin) × (TreeVertex d → ℝ) => |
| (z.1 (componentIndexVertex u), z.2 (componentIndexVertex u))) by fun_prop))) hCI s |
| have hsym := hμ.selected_gaussian_posteriorLaw_neg_invariant t t |
| (componentIndexVertex (c := c)) r |
| have hsum := spinInformation_sup_le_add (selectedObservationField_le hF w) |
| (selectedObservationField_le hF (componentIndexVertex (c := c))) hS hL hR hfair hInd hsym |
| have hfield := selectedObservationField_eq_component_sup_flip F c |
| change selectedObservationField F id = mL ⊔ mR at hfield |
| rw [← hfield] at hsum |
| have hleft : spinInformation ρ S mL = gaussianComponentInformation μ t c := by |
| have h := selectedPosterior_secondMoment_relabel hμ (gaussianReal 0 t) hF |
| (componentIndexVertex (c := c)) (RootedBroadcast.branchRoot c) (prefixTreeAut c) |
| rw [RootedBroadcast.prefixTreeAut_symm_branchRoot] at h |
| exact h.symm |
| have hright : spinInformation ρ S mR = |
| (Real.tanh beta) ^ 2 * gaussianComponentInformation μ t c := by |
| have h := integral_congr_ae (hreg.fun_comp (fun x : ℝ => x ^ 2)) |
| simp only [Function.comp_apply, mul_pow, integral_const_mul] at h |
| exact h |
| rw [hleft, hright] at hsum |
| change (∫ z, (PlantedSymmetry.posteriorMagnetization ρ t r z) ^ 2 ∂ρ) ≤ _ at hsum |
| nlinarith [hsum] |
|
|
| theorem HasFreeIsingLaw.gaussian_site_information_le_component |
| {d : ℕ} {beta : ℝ} {μ : Measure (TreeVertex d → IsingSpin)} |
| (hμ : HasFreeIsingLaw (Real.tanh beta) μ) (hb : 0 ≤ beta) |
| (t : ℝ≥0) (c : Fin d) (v : TreeVertex d) : |
| (∫ z, (PlantedSymmetry.posteriorMagnetization |
| (μ.prod (PlantedSymmetry.gaussianNoiseLaw (TreeVertex d) t)) t v z) ^ 2 |
| ∂μ.prod (PlantedSymmetry.gaussianNoiseLaw (TreeVertex d) t)) ≤ |
| (1 + (Real.tanh beta) ^ 2) * gaussianComponentInformation μ t c := by |
| let F : IsingSpin → ℝ → ℝ := fun s x => (t : ℝ) * spinSign s + x |
| have hF : Measurable (Function.uncurry F) := |
| ((PlantedInformation.measurable_spinSign.comp measurable_fst).const_mul _).add measurable_snd |
| obtain ⟨g, hg⟩ := exists_treeAut_map (RootedBroadcast.root d) v |
| have hroot : g.toEquiv.symm v = RootedBroadcast.root d := by rw [← hg]; simp |
| have hregion : Set.range (fun i : TreeVertex d => g.toEquiv.symm (id i)) = Set.range id := by |
| rw [Set.range_id] |
| exact Set.range_eq_univ.mpr g.toEquiv.symm.surjective |
| have h := selectedPosterior_identDistrib_of_range_relabel hμ (gaussianReal 0 t) |
| hF id id v (RootedBroadcast.root d) g hregion hroot |
| have heq := (h.comp (show Measurable (fun x : ℝ => x ^ 2) by fun_prop)).integral_eq |
| change (∫ z, (PlantedSymmetry.posteriorMagnetization |
| (μ.prod (PlantedSymmetry.gaussianNoiseLaw (TreeVertex d) t)) t v z) ^ 2 |
| ∂μ.prod (PlantedSymmetry.gaussianNoiseLaw (TreeVertex d) t)) = _ at heq |
| rw [heq] |
| exact hμ.gaussian_root_information_le_component hb t c |
|
|
| theorem HasFreeIsingLaw.gaussian_site_critical_information_upper |
| {d : ℕ} (hd : 3 ≤ d) {beta : ℝ} |
| {μ : Measure (TreeVertex d → IsingSpin)} |
| (hμ : HasFreeIsingLaw (Real.tanh beta) μ) (hb : 0 ≤ beta) |
| (hcritical : ((d - 1 : ℕ) : ℝ) * (Real.tanh beta) ^ 2 = 1) |
| (t : ℝ≥0) (ht : (t : ℝ) ≤ 1) (v : TreeVertex d) : |
| (∫ z, (PlantedSymmetry.posteriorMagnetization |
| (μ.prod (PlantedSymmetry.gaussianNoiseLaw (TreeVertex d) t)) t v z) ^ 2 |
| ∂μ.prod (PlantedSymmetry.gaussianNoiseLaw (TreeVertex d) t)) ≤ |
| ((1 + (Real.tanh beta) ^ 2) * |
| Real.sqrt (1 / ((1 - (Real.tanh beta) ^ 2) * (Real.tanh beta) ^ 4))) * |
| Real.sqrt (t : ℝ) := by |
| let c : Fin d := ⟨0, by omega⟩ |
| have h := (hμ.gaussian_site_information_le_component hb t c v).trans |
| (mul_le_mul_of_nonneg_left |
| (hμ.gaussian_component_critical_information_upper hd hb hcritical t ht c) |
| (by positivity : 0 ≤ 1 + (Real.tanh beta) ^ 2)) |
| simpa only [mul_assoc] using h |
|
|
| theorem HasFreeIsingLaw.infiniteGibbsSpinMean_critical_secondMoment |
| {d : ℕ} (hd : 3 ≤ d) {beta : ℝ} |
| {μ : Measure (TreeVertex d → IsingSpin)} |
| (hμ : HasFreeIsingLaw (Real.tanh beta) μ) (hb : 0 ≤ beta) |
| (hcritical : ((d - 1 : ℕ) : ℝ) * (Real.tanh beta) ^ 2 = 1) |
| (t : ℝ≥0) (ht : (t : ℝ) ≤ 1) (v : TreeVertex d) : |
| (∫ z, (infiniteGibbsSpinMean beta v (PlantedSymmetry.observation t z)) ^ 2 |
| ∂μ.prod (PlantedSymmetry.gaussianNoiseLaw (TreeVertex d) t)) ≤ |
| ((1 + (Real.tanh beta) ^ 2) * |
| Real.sqrt (1 / ((1 - (Real.tanh beta) ^ 2) * (Real.tanh beta) ^ 4))) * |
| Real.sqrt (t : ℝ) := by |
| have hEq := integral_congr_ae |
| ((hμ.infiniteGibbsSpinMean_eq_posterior t v).fun_comp (fun x : ℝ => x ^ 2)) |
| simp only [Function.comp_apply] at hEq |
| rw [hEq] |
| exact hμ.gaussian_site_critical_information_upper hd hb hcritical t ht v |
|
|
| end Problem367 |
|
|
| end |
|
|
| end OAI |
|
|
