| import Mathlib |
| import OAI.Probability.IsingPerceptron.ArraySynchronization |
| import OAI.Probability.IsingPerceptron.EnrichedGGFinite |
|
|
| namespace OAI |
|
|
| /-! Array Geometry. -/ |
|
|
| noncomputable section |
|
|
| open MeasureTheory ProbabilityTheory Filter |
| open scoped BigOperators Topology ENNReal Matrix |
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped BigOperators Topology ENNReal NNReal Matrix |
| namespace IsingPerceptron |
|
|
| lemma spinOverlap_symm {N : ℕ} (x y : Spin N) : spinOverlap x y = spinOverlap y x := by |
| simp only [spinOverlap,mul_comm] |
|
|
| lemma spinOverlap_posSemidef {N m : ℕ} (x : Fin m → Spin N) : |
| Matrix.PosSemidef (fun i j => spinOverlap (x i) (x j)) := by |
| let A : Matrix (Fin m) (Fin N) ℝ := fun i k => spinValue (x i k) |
| have hp := (Matrix.posSemidef_self_mul_conjTranspose A).smul (inv_nonneg.mpr (Nat.cast_nonneg N : (0:ℝ) ≤ N)) |
| have he : (show Matrix (Fin m) (Fin m) ℝ from fun i j => spinOverlap (x i) (x j)) = (N:ℝ)⁻¹ • (A*Aᴴ) := by |
| ext i j |
| change (∑ k, spinValue (x i k)*spinValue (x j k))/(N:ℝ) = |
| (N:ℝ)⁻¹ * ∑ k, spinValue (x i k)*spinValue (x j k) |
| ring |
| rw [he] |
| exact hp |
|
|
| lemma labeledCommonDepth_symm (n : ℕ) (x y : LabeledLeaf n) : |
| labeledCommonDepth n x y = labeledCommonDepth n y x := by |
| induction n with |
| | zero => rfl |
| | succ n ih => |
| simp only [labeledCommonDepth,eq_comm,ih] |
|
|
| lemma labeledCommonDepth_ultra (n : ℕ) (x y z : LabeledLeaf n) : |
| min (labeledCommonDepth n x z) (labeledCommonDepth n y z) ≤ labeledCommonDepth n x y := by |
| let d := min (labeledCommonDepth n x z) (labeledCommonDepth n y z) |
| have hd : d ≤ n := (min_le_left _ _).trans (labeledCommonDepth_le n x z) |
| apply (labeled_prefix_eq_iff n x y hd).mp |
| exact ((labeled_prefix_eq_iff n x z hd).mpr (min_le_left _ _)).trans |
| ((labeled_prefix_eq_iff n y z hd).mpr (min_le_right _ _)).symm |
|
|
| lemma treeOverlap_symm (n : ℕ) (x y : LabeledLeaf n) : treeOverlap n x y = treeOverlap n y x := by |
| simp only [treeOverlap,labeledCommonDepth_symm n x y] |
|
|
| lemma treeOverlap_self (n : ℕ) (x : LabeledLeaf n) : treeOverlap n x x = (n:ℝ)/(n+1:ℕ) := by |
| simp only [treeOverlap,labeledCommonDepth_self] |
|
|
| lemma treeOverlap_ultra (n : ℕ) (x : ℕ → LabeledLeaf n) : |
| IsUltrametricArray (fun i j => treeOverlap n (x i) (x j)) := by |
| intro i j k |
| have ht := labeledCommonDepth_ultra n (x i) (x j) (x k) |
| have ht' : min (labeledCommonDepth n (x i) (x k) : ℝ) (labeledCommonDepth n (x j) (x k)) ≤ |
| labeledCommonDepth n (x i) (x j) := by exact_mod_cast ht |
| simpa only [treeOverlap,min_div_div_right (by positivity : (0:ℝ) ≤ (n+1:ℕ))] using |
| div_le_div_of_nonneg_right ht' (by positivity : (0:ℝ) ≤ (n+1:ℕ)) |
|
|
| lemma labeledCommonDepth_sum (n : ℕ) (x y : LabeledLeaf n) : |
| (∑ d ∈ Finset.range n, if (labeledAddress n x).take (d+1) = |
| (labeledAddress n y).take (d+1) then (1:ℝ) else 0) = labeledCommonDepth n x y := by |
| have hc := labeledCommonDepth_le n x y |
| calc |
| _ = ∑ d ∈ Finset.range n, if d < labeledCommonDepth n x y then (1:ℝ) else 0 := by |
| apply Finset.sum_congr rfl |
| intro d hd |
| simp only [labeled_prefix_eq_iff n x y (d := d+1) (by have := Finset.mem_range.mp hd; omega), Nat.add_one_le_iff] |
| _ = labeledCommonDepth n x y := by |
| simp only [Finset.sum_boole] |
| congr 1 |
| have he : (Finset.range n).filter (fun d => d < labeledCommonDepth n x y) = |
| Finset.range (labeledCommonDepth n x y) := by |
| ext d |
| simp only [Finset.mem_filter,Finset.mem_range] |
| omega |
| rw [he,Finset.card_range] |
| |
| lemma treeOverlap_posSemidef (n : ℕ) {m : ℕ} (x : Fin m → LabeledLeaf n) : |
| Matrix.PosSemidef (fun i j => treeOverlap n (x i) (x j)) := by |
| classical |
| let A : ℕ → Matrix (Fin m) (Fin m) ℝ := fun d => |
| Matrix.submatrix (1 : Matrix (List ChildLabel) (List ChildLabel) ℝ) |
| (fun i => (labeledAddress n (x i)).take (d+1)) (fun i => (labeledAddress n (x i)).take (d+1)) |
| have hp (d : ℕ) : (A d).PosSemidef := Matrix.PosSemidef.one.submatrix _ |
| have hs := (Matrix.posSemidef_sum (Finset.range n) (fun d _ => hp d)).smul |
| (inv_nonneg.mpr (Nat.cast_nonneg (n+1) : (0:ℝ) ≤ (n+1:ℕ))) |
| have he : (fun i j => treeOverlap n (x i) (x j)) = |
| ((n+1:ℕ):ℝ)⁻¹ • (∑ d ∈ Finset.range n, A d) := by |
| ext i j |
| simp only [Matrix.smul_apply,smul_eq_mul,Matrix.sum_apply,A,Matrix.submatrix_apply,Matrix.one_apply] |
| rw [labeledCommonDepth_sum] |
| simp only [treeOverlap,div_eq_mul_inv,mul_comm] |
| rw [he] |
| exact hs |
|
|
| end IsingPerceptron |
|
|
| |
|
|
| |
|
|
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped BigOperators Topology ENNReal NNReal Matrix |
| namespace IsingPerceptron |
|
|
| lemma replicaLaw_map_reindex {Ω X : Type*} [MeasurableSpace Ω] [MeasurableSpace X] |
| [Countable X] [MeasurableSingletonClass X] (P : Measure Ω) [IsProbabilityMeasure P] |
| (ν : Ω → Measure X) (hν : Measurable ν) [∀ ω, IsProbabilityMeasure (ν ω)] |
| (e : ℕ → ℕ) (he : Function.Injective e) : |
| (replicaLaw P ν hν).map (fun σ i => σ (e i)) = replicaLaw P ν hν := by |
| unfold replicaLaw |
| rw [Measure.map_comp P _ (by fun_prop)] |
| congr 1 |
| funext ω |
| rw [Kernel.map_apply _ (by fun_prop)] |
| exact Measure.map_infinitePi_infinitePi_of_inj he |
|
|
| def permuteJointArray (e : ℕ → ℕ) (x : JointArray) : JointArray := |
| fun ij => x (e ij.1,e ij.2) |
|
|
| lemma continuous_permuteJointArray (e : ℕ → ℕ) : Continuous (permuteJointArray e) := by |
| unfold permuteJointArray |
| fun_prop |
|
|
| lemma overlapArrayLaw_map_reindex {Ω X : Type*} [MeasurableSpace Ω] [MeasurableSpace X] |
| [Countable X] [MeasurableSingletonClass X] (P : Measure Ω) [IsProbabilityMeasure P] |
| (ν : Ω → Measure X) (hν : Measurable ν) [∀ ω, IsProbabilityMeasure (ν ω)] |
| (κ : X → X → JointEntry) (e : ℕ → ℕ) (he : Function.Injective e) : |
| (overlapArrayLaw P ν hν κ : Measure JointArray).map (permuteJointArray e) = |
| (overlapArrayLaw P ν hν κ : Measure JointArray) := by |
| change ((replicaLaw P ν hν).map (sampledOverlapArray κ)).map _ = _ |
| rw [Measure.map_map (continuous_permuteJointArray e).measurable (measurable_sampledOverlapArray κ)] |
| have hh : permuteJointArray e ∘ sampledOverlapArray κ = |
| sampledOverlapArray κ ∘ (fun σ i => σ (e i)) := rfl |
| rw [hh,← Measure.map_map (measurable_sampledOverlapArray κ) (by fun_prop),replicaLaw_map_reindex P ν hν e he] |
| rfl |
|
|
| lemma jointArray_limit_reindex {L : ℕ → ProbabilityMeasure JointArray} |
| {μ : ProbabilityMeasure JointArray} (hL : Tendsto L atTop (𝓝 μ)) |
| (e : ℕ → ℕ) (hE : ∀ k, (L k : Measure JointArray).map (permuteJointArray e) = L k) : |
| (μ : Measure JointArray).map (permuteJointArray e) = μ := by |
| have hc := (ProbabilityMeasure.continuous_map (continuous_permuteJointArray e)).tendsto μ |
| have he : (fun k => (L k).map (permuteJointArray e)) = L := by |
| funext k |
| exact Subtype.ext (hE k) |
| have ht := hc.comp hL |
| change Tendsto (fun k => (L k).map (permuteJointArray e)) _ _ at ht |
| rw [he] at ht |
| have h := tendsto_nhds_unique ht hL |
| exact congrArg Subtype.val h |
|
|
| lemma scalar_of_joint_exchangeable {μ : ProbabilityMeasure JointArray} |
| (hE : ∀ e : Equiv.Perm ℕ, (μ : Measure JointArray).map (permuteJointArray e) = μ) |
| (f : JointEntry → ℝ) (hf : Measurable f) : |
| WeaklyExchangeable (fun x i j => f (x (i,j))) (μ : Measure JointArray) := by |
| intro e _ |
| have hm : Measurable (fun x : JointArray => fun i j => f (x (i,j))) := by fun_prop |
| refine ⟨hm.aemeasurable,(hm.comp (continuous_permuteJointArray e).measurable).aemeasurable,?_⟩ |
| calc |
| _ = ((μ : Measure JointArray).map (permuteJointArray e)).map (fun x i j => f (x (i,j))) := |
| congrArg (Measure.map (fun x i j => f (x (i,j)))) (hE e).symm |
| _ = _ := Measure.map_map hm (continuous_permuteJointArray e).measurable |
|
|
| lemma ae_closed_of_weak_limit {X : Type*} [MeasurableSpace X] [TopologicalSpace X] |
| [BorelSpace X] [HasOuterApproxClosed X] {L : ℕ → ProbabilityMeasure X} |
| {μ : ProbabilityMeasure X} (hL : Tendsto L atTop (𝓝 μ)) {S : Set X} (hS : IsClosed S) |
| (hA : ∀ k, ∀ᵐ x ∂(L k : Measure X), x ∈ S) : ∀ᵐ x ∂(μ : Measure X), x ∈ S := by |
| have he : ∀ k, (L k : Measure X) S = 1 := fun k => by |
| simpa using (ae_iff_measure_eq (μ := (L k : Measure X)) (p := fun x => x ∈ S) hS.measurableSet.nullMeasurableSet).mp (hA k) |
| have hh := ProbabilityMeasure.limsup_measure_closed_le_of_tendsto hL hS |
| simp only [he,limsup_const] at hh |
| apply (ae_iff_measure_eq (μ := (μ : Measure X)) (p := fun x => x ∈ S) hS.measurableSet.nullMeasurableSet).mpr |
| rw [measure_univ] |
| exact le_antisymm prob_le_one hh |
|
|
| end IsingPerceptron |
|
|
| |
|
|
| |
|
|
| |
|
|
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped BigOperators Topology ENNReal Matrix |
| namespace IsingPerceptron |
|
|
| lemma HasGhirlandaGuerra.congr_ae {Ω : Type*} [MeasurableSpace Ω] |
| {B C : Ω → RealArray} {μ : Measure Ω} (h : HasGhirlandaGuerra B μ) (he : B =ᵐ[μ] C) : |
| HasGhirlandaGuerra C μ := by |
| have hm (P : RealArray → Prop) : μ.real {ω | P (C ω)} = μ.real {ω | P (B ω)} := by |
| apply measureReal_congr |
| filter_upwards [he] with ω hω |
| rw [hω] |
| intro n hn i A hA t ht |
| change μ.real {ω | (fun j k : Fin n => C ω j k) ∈ A ∧ C ω i n ∈ t} = |
| (μ.real {ω | (fun j k : Fin n => C ω j k) ∈ A} * μ.real {ω | C ω 0 1 ∈ t}) / n + |
| (∑ j ∈ Finset.univ.erase i, μ.real {ω | (fun j k : Fin n => C ω j k) ∈ A ∧ C ω i j ∈ t}) / n |
| rw [hm (fun b => (fun j k : Fin n => b j k) ∈ A ∧ b i n ∈ t), |
| hm (fun b => (fun j k : Fin n => b j k) ∈ A), hm (fun b => b 0 1 ∈ t)] |
| have hs : (∑ j ∈ Finset.univ.erase i, μ.real {ω | (fun j k : Fin n => C ω j k) ∈ A ∧ C ω i j ∈ t}) = |
| ∑ j ∈ Finset.univ.erase i, μ.real {ω | (fun j k : Fin n => B ω j k) ∈ A ∧ B ω i j ∈ t} := by |
| apply Finset.sum_congr rfl |
| intro j _ |
| exact hm (fun b => (fun j k : Fin n => b j k) ∈ A ∧ b i j ∈ t) |
| rw [hs] |
| exact h n hn i A hA t ht |
|
|
| def GramDiagonal (D : ℝ) (B : RealArray) : Prop := |
| (∀ n, Matrix.PosSemidef (fun i j : Fin n => B i j)) ∧ ∀ i, B i i = D |
|
|
| lemma isClosed_gramDiagonal (D : ℝ) : IsClosed {B | GramDiagonal D B} := by |
| change IsClosed ({B : RealArray | ∀ n, Matrix.PosSemidef (fun i j : Fin n => B i j)} ∩ |
| {B | ∀ i, B i i = D}) |
| apply IsClosed.inter |
| · simp only [Set.ofPred_forall] |
| apply isClosed_iInter |
| intro n |
| exact (isClosed_setOf_posSemidef n).preimage (by fun_prop) |
| · simp only [Set.ofPred_forall] |
| exact isClosed_iInter (fun i => isClosed_eq (by fun_prop) continuous_const) |
|
|
| lemma GramDiagonal.symm {D : ℝ} {B : RealArray} (h : GramDiagonal D B) (i j : ℕ) : B i j = B j i := by |
| let n := max i j+1 |
| let ii : Fin n := ⟨i,by omega⟩ |
| let jj : Fin n := ⟨j,by omega⟩ |
| exact real_posSemidef_symm (h.1 n) ii jj |
|
|
| lemma GramDiagonal.default {D : ℝ} (hD : 0 ≤ D) : |
| GramDiagonal D (fun i j => if i=j then D else 0) := by |
| constructor |
| · intro n |
| have he : (fun i j : Fin n => if (i:ℕ)=(j:ℕ) then D else 0) = |
| Matrix.diagonal (fun _ : Fin n => D) := by |
| ext i j |
| simp only [Matrix.diagonal_apply,Fin.val_inj] |
| rw [he] |
| exact Matrix.PosSemidef.diagonal (fun _ => hD) |
| · intro i |
| simp |
|
|
| |
|
|
| lemma gg_ultrametric_ae {Ω : Type*} [MeasurableSpace Ω] |
| {B : Ω → RealArray} {μ : Measure Ω} [IsProbabilityMeasure μ] |
| (hm : Measurable B) (hwe : WeaklyExchangeable B μ) (hgg : HasGhirlandaGuerra B μ) |
| {D : ℝ} (hD : 0 ≤ D) (hG : ∀ᵐ ω ∂μ, GramDiagonal D (B ω)) : |
| ∀ᵐ ω ∂μ, IsUltrametricArray (B ω) := by |
| classical |
| let C : Ω → RealArray := fun ω => if GramDiagonal D (B ω) then B ω else fun i j => if i=j then D else 0 |
| have hc : Measurable C := hm.ite ((isClosed_gramDiagonal D).measurableSet.preimage hm) measurable_const |
| have he : B =ᵐ[μ] C := hG.mono (fun ω hω => by simp only [C,ite_eq_left hω]) |
| have hCG : ∀ ω, GramDiagonal D (C ω) := by |
| intro ω |
| by_cases h : GramDiagonal D (B ω) |
| · simpa only [C,ite_eq_left h] using h |
| · simpa only [C,ite_eq_right h] using GramDiagonal.default hD |
| have hcwe : WeaklyExchangeable C μ := by |
| intro e hefin |
| have ht := (IdentDistrib.of_ae_eq hm.aemeasurable he).comp |
| (u := permuteArray e) (by unfold permuteArray; fun_prop) |
| exact (IdentDistrib.of_ae_eq hm.aemeasurable he).symm.trans ((hwe e hefin).trans ht) |
| have ht := gg_ultrametric hc (fun ω => (hCG ω).symm) hcwe (hgg.congr_ae he) |
| (fun ω => (hCG ω).1) (fun ω => (hCG ω).2) |
| filter_upwards [ht,he] with ω ht he |
| simpa only [he] using ht |
|
|
| |
| lemma gg_pair_nonnegative_ae {Ω : Type*} [MeasurableSpace Ω] |
| {B : Ω → RealArray} {μ : Measure Ω} [IsProbabilityMeasure μ] |
| (hm : Measurable B) (hgg : HasGhirlandaGuerra B μ) |
| {D : ℝ} (hD : 0 ≤ D) (hG : ∀ᵐ ω ∂μ, GramDiagonal D (B ω)) : |
| ∀ᵐ ω ∂μ, 0 ≤ B ω 0 1 := by |
| classical |
| let C : Ω → RealArray := fun ω => if GramDiagonal D (B ω) then B ω else fun i j => if i=j then D else 0 |
| have hc : Measurable C := hm.ite ((isClosed_gramDiagonal D).measurableSet.preimage hm) measurable_const |
| have he : B =ᵐ[μ] C := hG.mono (fun ω hω => by simp only [C,ite_eq_left hω]) |
| have hCG : ∀ ω, GramDiagonal D (C ω) := by |
| intro ω |
| by_cases h : GramDiagonal D (B ω) |
| · simpa only [C,ite_eq_left h] using h |
| · simpa only [C,ite_eq_right h] using GramDiagonal.default hD |
| have ht := gg_pair_nonnegative (fun i j => by fun_prop) (fun ω => (hCG ω).symm) |
| (hgg.congr_ae he) (ae_of_all _ (fun ω => (hCG ω).1)) (ae_of_all _ (fun ω => (hCG ω).2)) |
| filter_upwards [ht,he] with ω ht he |
| simpa only [he] using ht |
|
|
| end IsingPerceptron |
|
|
| |
|
|
| |
|
|
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped BigOperators Topology ENNReal NNReal Matrix |
| namespace IsingPerceptron |
|
|
| def spinArray (x : JointArray) : RealArray := fun i j => (x (i,j)).1.1 |
| def treeArray (x : JointArray) : RealArray := fun i j => (x (i,j)).2.1 |
|
|
| lemma continuous_spinArray : Continuous spinArray := by unfold spinArray; fun_prop |
| lemma continuous_treeArray : Continuous treeArray := by unfold treeArray; fun_prop |
|
|
| lemma isClosed_ultrametricArray : IsClosed {B : RealArray | IsUltrametricArray B} := by |
| change IsClosed {B : RealArray | ∀ i j k, min (B i k) (B j k) ≤ B i j} |
| simp only [Set.ofPred_forall] |
| exact isClosed_iInter (fun i => isClosed_iInter (fun j => isClosed_iInter (fun k => |
| isClosed_le (by fun_prop) (by fun_prop)))) |
|
|
| def JointGeometry (n : ℕ) (x : JointArray) : Prop := |
| GramDiagonal 1 (spinArray x) ∧ GramDiagonal ((n:ℝ)/(n+1:ℕ)) (treeArray x) ∧ |
| IsUltrametricArray (treeArray x) |
|
|
| lemma isClosed_jointGeometry (n : ℕ) : IsClosed {x | JointGeometry n x} := |
| ((isClosed_gramDiagonal 1).preimage continuous_spinArray).inter |
| (((isClosed_gramDiagonal ((n:ℝ)/(n+1:ℕ))).preimage continuous_treeArray).inter |
| (isClosed_ultrametricArray.preimage continuous_treeArray)) |
|
|
| lemma sampledJoint_geometry {N : ℕ} (hN : 0 < N) (n : ℕ) |
| (σ : ℕ → Spin N × LabeledLeaf n) : |
| JointGeometry n (sampledOverlapArray (enrichedJointEntry n) σ) := by |
| constructor |
| · constructor |
| · intro m |
| exact spinOverlap_posSemidef (fun i : Fin m => (σ i).1) |
| · intro i |
| exact spinOverlap_self hN _ |
| · constructor |
| · constructor |
| · intro m |
| exact treeOverlap_posSemidef n (fun i : Fin m => (σ i).2) |
| · intro i |
| exact treeOverlap_self n _ |
| · exact treeOverlap_ultra n (fun i => (σ i).2) |
|
|
| lemma enrichedArrayLaw_geometry {N : ℕ} (hN : 0 < N) {A : Type*} [MeasurableSpace A] |
| (P : Measure A) [IsProbabilityMeasure P] (r : ℝ≥0) (n : ℕ) (b h : ℕ → ℝ) |
| (u : Fin N → ℝ) (ν : Measure (Spin N)) [IsProbabilityMeasure ν] |
| {φ : A → Spin N → ℝ} (hm : Measurable φ) : |
| ∀ᵐ x ∂(enrichedArrayLaw P r n b h u ν hm : Measure JointArray), JointGeometry n x := by |
| apply (ae_map_iff (measurable_sampledOverlapArray (enrichedJointEntry n)).aemeasurable |
| (isClosed_jointGeometry n).measurableSet).mpr |
| exact ae_of_all _ (sampledJoint_geometry hN n) |
|
|
| lemma enrichedArrayLaw_reindex {N : ℕ} {A : Type*} [MeasurableSpace A] |
| (P : Measure A) [IsProbabilityMeasure P] (r : ℝ≥0) (n : ℕ) (b h : ℕ → ℝ) |
| (u : Fin N → ℝ) (ν : Measure (Spin N)) [IsProbabilityMeasure ν] |
| {φ : A → Spin N → ℝ} (hm : Measurable φ) (e : ℕ → ℕ) (he : Function.Injective e) : |
| (enrichedArrayLaw P r n b h u ν hm : Measure JointArray).map (permuteJointArray e) = |
| enrichedArrayLaw P r n b h u ν hm := |
| overlapArrayLaw_map_reindex _ _ _ _ e he |
|
|
| lemma jointGeometry_sum {n : ℕ} {x : JointArray} (hx : JointGeometry n x) : |
| GramDiagonal (1+(n:ℝ)/(n+1:ℕ)) (fun i j => spinArray x i j + treeArray x i j) := by |
| exact ⟨fun m => (hx.1.1 m).add (hx.2.1.1 m),fun i => by |
| change spinArray x i i + treeArray x i i = _ |
| rw [hx.1.2 i,hx.2.1.2 i]⟩ |
|
|
| |
|
|
| lemma joint_limit_support_ordered {n : ℕ} {μ : ProbabilityMeasure JointArray} |
| (hgg : HasEntryGhirlandaGuerra (fun x i j => x (i,j)) (μ : Measure JointArray)) |
| (hG : ∀ᵐ x ∂(μ : Measure JointArray), JointGeometry n x) |
| (hE : ∀ e : Equiv.Perm ℕ, (μ : Measure JointArray).map (permuteJointArray e) = μ) : |
| let ν := (μ : Measure JointArray).map (fun x => (spinArray x 0 1,treeArray x 0 1)) |
| ∀ x ∈ ν.support, ∀ y ∈ ν.support, x.1 < y.1 → x.2 ≤ y.2 := by |
| have hr := gg_ultrametric_ae continuous_spinArray.measurable |
| (scalar_of_joint_exchangeable hE (fun x => x.1.1) (by fun_prop)) |
| (hgg.real_map (f := fun x => x.1.1) (by fun_prop)) (by norm_num : (0:ℝ) ≤ 1) |
| (hG.mono (fun _ h => h.1)) |
| have hmS : Measurable (fun x i j => spinArray x i j + treeArray x i j) := by |
| unfold spinArray treeArray; fun_prop |
| have hs := gg_ultrametric_ae hmS |
| (scalar_of_joint_exchangeable hE (fun x => x.1.1+x.2.1) (by fun_prop)) |
| (hgg.real_map (f := fun x => x.1.1+x.2.1) (by fun_prop)) (by positivity : (0:ℝ) ≤ 1+(n:ℝ)/(n+1:ℕ)) |
| (hG.mono (fun _ h => jointGeometry_sum h)) |
| exact jointGG_support_ordered continuous_spinArray.measurable continuous_treeArray.measurable |
| (hgg.map (f := fun x => (x.1.1,x.2.1)) (by fun_prop)) hr (hG.mono (fun _ h => h.2.2)) hs |
| (hG.mono (fun _ h => h.1.symm)) (hG.mono (fun _ h => h.2.1.symm)) |
|
|
| lemma joint_limit_pair_nonnegative {n : ℕ} {μ : ProbabilityMeasure JointArray} |
| (hgg : HasEntryGhirlandaGuerra (fun x i j => x (i,j)) (μ : Measure JointArray)) |
| (hG : ∀ᵐ x ∂(μ : Measure JointArray), JointGeometry n x) : |
| ∀ᵐ x ∂(μ : Measure JointArray), 0 ≤ spinArray x 0 1 := |
| gg_pair_nonnegative_ae continuous_spinArray.measurable |
| (hgg.real_map (f := fun x => x.1.1) (by fun_prop)) (by norm_num : (0:ℝ) ≤ 1) |
| (hG.mono (fun _ h => h.1)) |
|
|
| lemma enrichedArrayLaw_limit_geometry |
| (N : ℕ → ℕ) (hN : ∀ k, 0 < N k) (n : ℕ) (b : ℕ → ℝ) |
| (h : ℕ → ℕ → ℝ) (u : (k : ℕ) → Fin (N k) → ℝ) |
| (ν : (k : ℕ) → Measure (Spin (N k))) [∀ k, IsProbabilityMeasure (ν k)] |
| (A : ℕ → Type*) [∀ k, MeasurableSpace (A k)] |
| (P : (k : ℕ) → Measure (A k)) [∀ k, IsProbabilityMeasure (P k)] |
| (φ : (k : ℕ) → A k → Spin (N k) → ℝ) (hm : ∀ k, Measurable (φ k)) |
| (r : ℕ → ℝ≥0) (μ : ProbabilityMeasure JointArray) |
| (hL : Tendsto (fun k => enrichedArrayLaw (P k) (r k) n b (h k) (u k) (ν k) (hm k)) atTop (𝓝 μ)) : |
| (∀ᵐ x ∂(μ : Measure JointArray), JointGeometry n x) ∧ |
| ∀ e : Equiv.Perm ℕ, (μ : Measure JointArray).map (permuteJointArray e) = μ := by |
| constructor |
| · exact ae_closed_of_weak_limit hL (isClosed_jointGeometry n) |
| (fun k => enrichedArrayLaw_geometry (hN k) (P k) (r k) n b (h k) (u k) (ν k) (hm k)) |
| · intro e |
| exact jointArray_limit_reindex hL e (fun k => |
| enrichedArrayLaw_reindex (P k) (r k) n b (h k) (u k) (ν k) (hm k) e e.injective) |
|
|
| end IsingPerceptron |
|
|
| |
|
|
| |
|
|
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped BigOperators Topology ENNReal NNReal |
| namespace IsingPerceptron |
|
|
| |
|
|
| theorem enriched_minimizers_ordered |
| (N : ℕ → ℕ) (hN : ∀ k, 0 < N k) (hNlim : Tendsto N atTop atTop) |
| (n : ℕ) (b : ℕ → ℝ) (hb : CascadeExponents n b) |
| (h : ℕ → ℕ → ℝ) (hh : ∀ k, Monotone (h k)) (h0 : ∀ k, 0 ≤ h k 0) |
| (H : ℝ) (hH : ∀ k, h k n ≤ H) |
| (u : (k : ℕ) → Fin (N k) → ℝ) (hu : ∀ k j, u k j ∈ Icc (1:ℝ) 2) |
| (ν : (k : ℕ) → Measure (Spin (N k))) [∀ k, IsProbabilityMeasure (ν k)] |
| (A : ℕ → Type*) [∀ k, MeasurableSpace (A k)] |
| (P : (k : ℕ) → Measure (A k)) [∀ k, IsProbabilityMeasure (P k)] |
| (φ : (k : ℕ) → A k → Spin (N k) → ℝ) (hm : ∀ k, Measurable (φ k)) |
| (K : ℝ) (hK : 0 ≤ K) (hφ : ∀ k y x, |φ k y x| ≤ K) |
| (r : ℕ → ℝ≥0) (α : ℝ) (hr : ∀ k, (r k:ℝ) ≤ α*N k) |
| (hmin : ∀ k (v : Fin (N k) → ℝ), (∀ j, v j ∈ Icc (1:ℝ) 2) → |
| enrichedPerturbationObjective (P k) (r k) n b (h k) (ν k) (φ k) (u k) ≤ |
| enrichedPerturbationObjective (P k) (r k) n b (h k) (ν k) (φ k) v) |
| (μ : ProbabilityMeasure JointArray) |
| (hL : Tendsto (fun k => enrichedArrayLaw (P k) (r k) n b (h k) (u k) (ν k) (hm k)) atTop (𝓝 μ)) : |
| (∀ᵐ x ∂(μ : Measure JointArray), 0 ≤ spinArray x 0 1) ∧ |
| let ν₂ := (μ : Measure JointArray).map (fun x => (spinArray x 0 1,treeArray x 0 1)) |
| ∀ x ∈ ν₂.support, ∀ y ∈ ν₂.support, x.1 < y.1 → x.2 ≤ y.2 := by |
| have hgg := enriched_minimizers_jointGG N hN hNlim n b hb h hh h0 H hH u hu ν A P φ hm K hK hφ r α hr hmin μ hL |
| obtain ⟨hG,hE⟩ := enrichedArrayLaw_limit_geometry N hN n b h u ν A P φ hm r μ hL |
| exact ⟨joint_limit_pair_nonnegative hgg hG,joint_limit_support_ordered hgg hG hE⟩ |
|
|
| end IsingPerceptron |
|
|
| |
|
|
| |
|
|
| |
|
|
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped BigOperators Topology ENNReal |
| namespace IsingPerceptron |
|
|
| def overlapQuantile (μ : Measure ℝ) (u : ℝ) : ℝ := |
| sInf {x : ℝ | x ∈ Icc (0:ℝ) 1 ∧ u ≤ cdf μ x} |
|
|
| lemma cdf_one_of_unit_support {μ : Measure ℝ} [IsProbabilityMeasure μ] |
| (hs : ∀ᵐ x ∂μ, x ∈ Icc (0:ℝ) 1) : cdf μ 1 = 1 := by |
| rw [cdf_eq_real] |
| have he : μ (Iic (1:ℝ)) = 1 := by |
| have he' := (ae_iff_measure_eq (μ := μ) (p := fun x : ℝ => x ∈ Iic (1:ℝ)) measurableSet_Iic.nullMeasurableSet).mp |
| (hs.mono (fun _ h => h.2)) |
| rw [measure_univ] at he' |
| exact he' |
| simp [Measure.real,he] |
| |
| lemma quantileSet_nonempty {μ : Measure ℝ} [IsProbabilityMeasure μ] |
| (hs : ∀ᵐ x ∂μ, x ∈ Icc (0:ℝ) 1) {u : ℝ} (hu : u ≤ 1) : |
| {x : ℝ | x ∈ Icc (0:ℝ) 1 ∧ u ≤ cdf μ x}.Nonempty := |
| ⟨1,⟨by norm_num,by simpa only [cdf_one_of_unit_support hs] using hu⟩⟩ |
| |
| lemma quantileSet_bddBelow (μ : Measure ℝ) (u : ℝ) : |
| BddBelow {x : ℝ | x ∈ Icc (0:ℝ) 1 ∧ u ≤ cdf μ x} := ⟨0,fun _ h => h.1.1⟩ |
| |
| lemma overlapQuantile_mem {μ : Measure ℝ} [IsProbabilityMeasure μ] |
| (hs : ∀ᵐ x ∂μ, x ∈ Icc (0:ℝ) 1) {u : ℝ} (hu : u ≤ 1) : |
| overlapQuantile μ u ∈ Icc (0:ℝ) 1 := by |
| exact ⟨le_csInf (quantileSet_nonempty hs hu) (fun _ h => h.1.1), |
| (csInf_le (quantileSet_bddBelow μ u) (quantileSet_nonempty hs hu).choose_spec).trans |
| (quantileSet_nonempty hs hu).choose_spec.1.2⟩ |
| |
| lemma le_cdf_overlapQuantile {μ : Measure ℝ} [IsProbabilityMeasure μ] |
| (hs : ∀ᵐ x ∂μ, x ∈ Icc (0:ℝ) 1) {u : ℝ} (hu : u ≤ 1) : |
| u ≤ cdf μ (overlapQuantile μ u) := by |
| rw [← (cdf μ).iInf_Ioi_eq] |
| apply le_ciInf |
| intro y |
| obtain ⟨x,hx,hxy⟩ := exists_lt_of_csInf_lt (quantileSet_nonempty hs hu) y.2 |
| exact hx.2.trans ((monotone_cdf μ) hxy.le) |
| |
| lemma overlapQuantile_le_iff {μ : Measure ℝ} [IsProbabilityMeasure μ] |
| (hs : ∀ᵐ x ∂μ, x ∈ Icc (0:ℝ) 1) {u x : ℝ} (hu : u ∈ Ioo (0:ℝ) 1) |
| (hx : x ∈ Icc (0:ℝ) 1) : overlapQuantile μ u ≤ x ↔ u ≤ cdf μ x := by |
| constructor |
| · intro h |
| exact (le_cdf_overlapQuantile hs hu.2.le).trans ((monotone_cdf μ) h) |
| · intro h |
| exact csInf_le (quantileSet_bddBelow μ u) ⟨hx,h⟩ |
| |
| lemma monotoneOn_overlapQuantile {μ : Measure ℝ} [IsProbabilityMeasure μ] |
| (hs : ∀ᵐ x ∂μ, x ∈ Icc (0:ℝ) 1) : MonotoneOn (overlapQuantile μ) (Ioo (0:ℝ) 1) := by |
| intro u hu v hv huv |
| exact csInf_le_csInf (quantileSet_bddBelow μ u) (quantileSet_nonempty hs hv.2.le) |
| (fun x hx => ⟨hx.1,huv.trans hx.2⟩) |
| |
| |
| def quantileFunction (μ : Measure ℝ) (u : ℝ) : ℝ := overlapQuantile μ (min u 1) |
| |
| lemma monotone_quantileFunction {μ : Measure ℝ} [IsProbabilityMeasure μ] |
| (hs : ∀ᵐ x ∂μ, x ∈ Icc (0:ℝ) 1) : Monotone (quantileFunction μ) := by |
| intro u v huv |
| exact csInf_le_csInf (quantileSet_bddBelow μ (min u 1)) |
| (quantileSet_nonempty hs (min_le_right v 1)) |
| (fun x hx => ⟨hx.1,(min_le_min_right 1 huv).trans hx.2⟩) |
| |
| lemma quantileFunction_mem {μ : Measure ℝ} [IsProbabilityMeasure μ] |
| (hs : ∀ᵐ x ∂μ, x ∈ Icc (0:ℝ) 1) (u : ℝ) : quantileFunction μ u ∈ Icc (0:ℝ) 1 := |
| overlapQuantile_mem hs (min_le_right u 1) |
| |
| lemma cdf_of_lt_zero {μ : Measure ℝ} [IsProbabilityMeasure μ] |
| (hs : ∀ᵐ x ∂μ, x ∈ Icc (0:ℝ) 1) {x : ℝ} (hx : x < 0) : cdf μ x = 0 := by |
| rw [cdf_eq_real,Measure.real] |
| have he : μ (Iic x) = 0 := by |
| apply measure_mono_null (t := {y : ℝ | ¬y ∈ Icc (0:ℝ) 1}) _ (ae_iff.mp hs) |
| intro y hy hy' |
| exact (not_le.mpr (hx.trans_le hy'.1)) hy |
| rw [he,ENNReal.toReal_zero] |
| |
| lemma quantileFunction_le_iff {μ : Measure ℝ} [IsProbabilityMeasure μ] |
| (hs : ∀ᵐ x ∂μ, x ∈ Icc (0:ℝ) 1) {u x : ℝ} (hu : u ∈ Ioo (0:ℝ) 1) : |
| quantileFunction μ u ≤ x ↔ u ≤ cdf μ x := by |
| by_cases hx : x < 0 |
| · rw [cdf_of_lt_zero hs hx] |
| exact iff_of_false (not_le.mpr (hx.trans_le (quantileFunction_mem hs u).1)) |
| (not_le.mpr hu.1) |
| · by_cases hx' : x ≤ 1 |
| · simpa only [quantileFunction,min_eq_left hu.2.le] using overlapQuantile_le_iff hs hu ⟨le_of_not_gt hx,hx'⟩ |
| · have hc : cdf μ x = 1 := le_antisymm (cdf_le_one μ x) |
| (by simpa only [cdf_one_of_unit_support hs] using (monotone_cdf μ) (le_of_not_ge hx')) |
| rw [hc] |
| exact iff_of_true ((quantileFunction_mem hs u).2.trans (le_of_not_ge hx')) hu.2.le |
| |
| def unitUniform : Measure ℝ := volume.restrict (Ioo (0:ℝ) 1) |
| |
| instance unitUniform_probability : IsProbabilityMeasure unitUniform := by |
| constructor |
| simp [unitUniform,Real.volume_Ioo] |
| |
| lemma unitUniform_Iic {a : ℝ} (ha : a ∈ Icc (0:ℝ) 1) : |
| unitUniform (Iic a) = ENNReal.ofReal a := by |
| rw [unitUniform,Measure.restrict_congr_set (Ioo_ae_eq_Ioc (μ := volume)), |
| Measure.restrict_apply measurableSet_Iic,inter_comm,Set.Ioc_inter_Iic] |
| simp only [inf_eq_right.mpr ha.2,Real.volume_Ioc,sub_zero] |
| |
| lemma quantile_preimage_Iic {μ : Measure ℝ} [IsProbabilityMeasure μ] |
| (hs : ∀ᵐ x ∂μ, x ∈ Icc (0:ℝ) 1) (x : ℝ) : |
| quantileFunction μ ⁻¹' Iic x =ᵐ[unitUniform] Iic (cdf μ x) := by |
| filter_upwards [ae_restrict_mem measurableSet_Ioo] with u hu |
| exact propext (quantileFunction_le_iff hs hu) |
|
|
| |
| lemma quantileFunction_law {μ : Measure ℝ} [IsProbabilityMeasure μ] |
| (hs : ∀ᵐ x ∂μ, x ∈ Icc (0:ℝ) 1) : unitUniform.map (quantileFunction μ) = μ := by |
| apply Measure.ext_of_Iic |
| intro x |
| rw [Measure.map_apply (monotone_quantileFunction hs).measurable measurableSet_Iic, |
| measure_congr (quantile_preimage_Iic hs x),unitUniform_Iic ⟨cdf_nonneg μ x,cdf_le_one μ x⟩, |
| ofReal_cdf] |
|
|
| end IsingPerceptron |
|
|
| end |
|
|
| end OAI |
|
|
