File size: 6,007 Bytes
f61e547 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 | import OAI.Probability.FreeIsing.Estimates.FiniteComponentGeometry
import OAI.Probability.FreeIsing.Estimates.FiniteIsingSplit
import OAI.Probability.FreeIsing.Posterior.ComponentPosteriorStationarity
import OAI.Probability.FreeIsing.Posterior.SelectedPosteriorLimit
namespace OAI
noncomputable section
open MeasureTheory ProbabilityTheory Filter
open scoped NNReal Topology
namespace Problem367
def rootComponentIndices {d : ℕ} (D : Finset (TreeVertex d)) (c : Fin d) :
Finset (ComponentIndex c) := by
classical
exact D.preimage componentIndexVertex (componentIndexVertex_injective c).injOn
@[simp] theorem mem_rootComponentIndices {d : ℕ} {D : Finset (TreeVertex d)}
{c : Fin d} {u : ComponentIndex c} :
u ∈ rootComponentIndices D c ↔ componentIndexVertex u ∈ D := by
classical
exact Finset.mem_preimage
theorem rootComponentIndices_monotone {d : ℕ} (c : Fin d) :
Monotone (fun D : Finset (TreeVertex d) => rootComponentIndices D c) := by
intro D E hDE u hu
exact mem_rootComponentIndices.mpr (hDE (mem_rootComponentIndices.mp hu))
theorem selectedObservationField_rootComponentIndices {d : ℕ} {A B : Type*}
[MeasurableSpace A] [MeasurableSpace B]
(F : IsingSpin → A → B) (D : Finset (TreeVertex d)) (c : Fin d) :
selectedObservationField F (fun u : rootComponentIndices D c => componentIndexVertex u.1) =
selectedObservationField F (fun v : rootComponentFinset D c => v.1) := by
apply selectedObservationField_eq_of_range_eq
ext v
constructor
· rintro ⟨u, rfl⟩
refine ⟨⟨componentIndexVertex u.1, mem_rootComponentFinset.mpr
⟨mem_rootComponentIndices.mp u.2, ?_⟩⟩, rfl⟩
apply (singleton_prefix_iff_cons c _).mpr
exact ⟨u.1.2.1, rfl⟩
· rintro ⟨v, rfl⟩
have hv := mem_rootComponentFinset.mp v.2
obtain ⟨u, hu⟩ := mem_range_componentIndexVertex.mpr
((singleton_prefix_iff_cons c v.1).mp hv.2)
refine ⟨⟨u, mem_rootComponentIndices.mpr ?_⟩, hu⟩
exact hu.symm ▸ hv.1
theorem HasFreeIsingLaw.rootComponent_gibbsMean_eq_selectedPosterior
{d : ℕ} {β : ℝ} {μ : Measure (TreeVertex d → IsingSpin)}
(hμ : HasFreeIsingLaw (Real.tanh β) μ) (D : Finset (TreeVertex d))
(hD : ConnectedFinset D) (hroot : ConnectedHull.root d ∈ D) (c : Fin d)
(hc : (⟨[c], List.IsChain.singleton c⟩ : TreeVertex d) ∈ D) (t : ℝ≥0) :
(fun p => FiniteIsingSplit.mean β (rootComponentFinset D c)
⟨⟨[c], List.IsChain.singleton c⟩, rootComponentFinset_root_mem c hc⟩
(PlantedSymmetry.observation t p)) =ᵐ[μ.prod
(PlantedSymmetry.gaussianNoiseLaw (TreeVertex d) t)]
selectedPosterior (μ.prod (PlantedSymmetry.gaussianNoiseLaw (TreeVertex d) t))
(fun s z => (t : ℝ) * spinSign s + z)
(fun u : rootComponentIndices D c => componentIndexVertex u.1)
⟨[c], List.IsChain.singleton c⟩ := by
let E := rootComponentFinset D c
let r : E := ⟨⟨[c], List.IsChain.singleton c⟩, rootComponentFinset_root_mem c hc⟩
have hce := hμ.finiteObservation_condExp E
(rootComponentFinset_connected hD hroot c hc) t (fun eta => spinSign (eta r))
simp only [selectedPosterior, selectedObservationField_rootComponentIndices]
have hsigma : selectedObservationField (fun s z => (t : ℝ) * spinSign s + z)
(fun v : E => v.1) = MeasurableSpace.comap (finiteObservation E t) inferInstance := rfl
rw [hsigma]
simp only [FiniteIsingSplit.mean_eq_fieldMean]
convert hce.symm using 1 <;> rfl
theorem HasFreeIsingLaw.rootComponent_gibbsField_limit
{d : ℕ} {β : ℝ} {μ : Measure (TreeVertex d → IsingSpin)}
(hμ : HasFreeIsingLaw (Real.tanh β) μ) (hβ : 0 ≤ β) (t : ℝ≥0) (c : Fin d)
(D : ℕ → Finset (TreeVertex d)) (hmono : Monotone D)
(hconn : ∀ n, ConnectedFinset (D n)) (hex : ∀ v, ∃ n, v ∈ D n)
(hroot : ∀ n, ConnectedHull.root d ∈ D n)
(hc : ∀ n, (⟨[c], List.IsChain.singleton c⟩ : TreeVertex d) ∈ D n) :
let ρ := μ.prod (PlantedSymmetry.gaussianNoiseLaw (TreeVertex d) t)
let H : ℕ → ((TreeVertex d → IsingSpin) × (TreeVertex d → ℝ)) → ℝ :=
fun n p => Real.artanh (FiniteIsingSplit.mean β (rootComponentFinset (D n) c)
⟨⟨[c], List.IsChain.singleton c⟩, rootComponentFinset_root_mem c (hc n)⟩
(PlantedSymmetry.observation t p))
let Z := fun p => Real.artanh (selectedPosterior ρ
(fun s z => (t : ℝ) * spinSign s + z) (componentIndexVertex (c := c))
⟨[c], List.IsChain.singleton c⟩ p)
(∀ᵐ p ∂ρ, Tendsto (fun n => H n p) atTop (𝓝 (Z p))) ∧
Tendsto (fun n => ∫ p, (H n p - Z p) ^ 2 ∂ρ) atTop (𝓝 0) := by
let ρ := μ.prod (PlantedSymmetry.gaussianNoiseLaw (TreeVertex d) t)
let F : IsingSpin → ℝ → ℝ := fun s z => (t : ℝ) * spinSign s + z
let r : TreeVertex d := ⟨[c], List.IsChain.singleton c⟩
let I := fun n => rootComponentIndices (D n) c
have hI : Monotone I := fun _ _ hnm => rootComponentIndices_monotone c (hmono hnm)
have hexI : ∀ u : ComponentIndex c, ∃ n, u ∈ I n := by
intro u
obtain ⟨n, hn⟩ := hex (componentIndexVertex u)
exact ⟨n, mem_rootComponentIndices.mpr hn⟩
have hrI : ∀ n, r ∈ Set.range (fun u : I n => componentIndexVertex u.1) := by
intro n
let u : ComponentIndex c := ⟨0, ⟨[], rfl, List.IsChain.singleton c⟩⟩
exact ⟨⟨u, mem_rootComponentIndices.mpr (hc n)⟩, rfl⟩
have hlim := hμ.selected_gaussian_posterior_field_limit hβ t
(componentIndexVertex (c := c)) r I hI hexI hrI
have hce (n : ℕ) := hμ.rootComponent_gibbsMean_eq_selectedPosterior
(D n) (hconn n) (hroot n) c (hc n) t
constructor
· filter_upwards [hlim.1, ae_all_iff.mpr hce] with p hp hce
convert hp using 1
funext n
exact congrArg Real.artanh (hce n)
· convert hlim.2 using 1
funext n
apply integral_congr_ae
filter_upwards [hce n] with p hp
rw [hp]
end Problem367
end
end OAI
|