import Mathlib import OAI.Probability.IsingPerceptron.TiltedLabelLaw namespace OAI /-! Array Synchronization. -/ noncomputable section open MeasureTheory ProbabilityTheory Filter Set open scoped BigOperators Topology ENNReal NNReal BoundedContinuousFunction open MeasureTheory ProbabilityTheory Filter open scoped BigOperators Topology ENNReal Matrix namespace IsingPerceptron def arrayBlock {Ω : Type*} (B : Ω → ℕ → ℕ → ℝ) (n : ℕ) (ω : Ω) : Fin n → Fin n → ℝ := fun i j => B ω i j def HasGhirlandaGuerra {Ω : Type*} [MeasurableSpace Ω] (B : Ω → ℕ → ℕ → ℝ) (μ : Measure Ω) : Prop := ∀ (n : ℕ), 2 ≤ n → ∀ (i : Fin n) (A : Set (Fin n → Fin n → ℝ)), MeasurableSet A → ∀ (t : Set ℝ), MeasurableSet t → μ.real ((arrayBlock B n ⁻¹' A) ∩ {ω | B ω i n ∈ t}) = (μ.real (arrayBlock B n ⁻¹' A) * μ.real {ω | B ω 0 1 ∈ t}) / n + (∑ j ∈ Finset.univ.erase i, μ.real ((arrayBlock B n ⁻¹' A) ∩ {ω | B ω i j ∈ t})) / n def negativeBlock {Ω : Type*} (B : Ω → ℕ → ℕ → ℝ) (ε : ℝ) (n : ℕ) : Set Ω := {ω | ∀ i j : Fin n, i ≠ j → B ω i j < -ε} lemma matrix_sum_le_of_offDiagonal {n : ℕ} {B : Matrix (Fin n) (Fin n) ℝ} {D ε : ℝ} (hdiag : ∀ i, B i i = D) (hoff : ∀ i j, i ≠ j → B i j ≤ -ε) : ∑ i, ∑ j, B i j ≤ (n : ℝ) * (D - (n - 1 : ℝ) * ε) := by classical have hrow : ∀ i, ∑ j, B i j ≤ D - (n - 1 : ℝ) * ε := by intro i rw [← Finset.sum_erase_add _ _ (Finset.mem_univ i), hdiag i] have hn : 0 < n := (Nat.zero_le i.val).trans_lt i.isLt have h := Finset.sum_le_sum (s := Finset.univ.erase i) (f := fun j => B i j) (g := fun _ => -ε) (fun j hj => hoff i j (Ne.symm (Finset.mem_erase.mp hj).1)) have hcard : (Finset.univ.erase i).card = n - 1 := by simp simp only [Finset.sum_const, nsmul_eq_mul, hcard] at h rw [Nat.cast_sub (by omega : 1 ≤ n), Nat.cast_one] at h linarith simpa only [Finset.sum_const, Finset.card_univ, Fintype.card_fin, nsmul_eq_mul] using Finset.sum_le_sum (s := Finset.univ) (fun i _ => hrow i) lemma posSemidef_sum_nonneg {n : ℕ} {B : Matrix (Fin n) (Fin n) ℝ} (hB : B.PosSemidef) : 0 ≤ ∑ i, ∑ j, B i j := by simpa [dotProduct, Matrix.mulVec] using hB.dotProduct_mulVec_nonneg (fun _ => (1 : ℝ)) lemma no_large_negative_block {n : ℕ} {B : Matrix (Fin n) (Fin n) ℝ} {D ε : ℝ} (hn : 0 < n) (hsize : D < (n - 1 : ℝ) * ε) (hB : B.PosSemidef) (hdiag : ∀ i, B i i = D) (hoff : ∀ i j, i ≠ j → B i j < -ε) : False := by have hs := matrix_sum_le_of_offDiagonal hdiag (fun i j h => (hoff i j h).le) have hp := posSemidef_sum_nonneg hB have hn' : (0 : ℝ) < n := by exact_mod_cast hn nlinarith lemma measurableSet_negative_finite (n : ℕ) (ε : ℝ) : MeasurableSet {b : Fin n → Fin n → ℝ | ∀ i j, i ≠ j → b i j < -ε} := by simp only [Set.ofPred_forall] refine MeasurableSet.iInter (fun i => MeasurableSet.iInter (fun j => MeasurableSet.iInter (fun _ => ?_))) exact measurableSet_lt ((measurable_pi_apply j).comp (measurable_pi_apply i)) measurable_const lemma mem_negativeBlock_succ {Ω : Type*} {B : Ω → ℕ → ℕ → ℝ} (hsym : ∀ ω i j, B ω i j = B ω j i) {ω : Ω} {ε : ℝ} {n : ℕ} : ω ∈ negativeBlock B ε (n + 1) ↔ ω ∈ negativeBlock B ε n ∧ ∀ i : Fin n, B ω i n < -ε := by constructor · intro h constructor · intro i j hij exact h i.castSucc j.castSucc (fun he => hij (Fin.ext (congrArg (fun t : Fin (n + 1) => t.val) he))) · intro i exact h i.castSucc (Fin.last n) (by intro he; have := congrArg Fin.val he; simp at this; omega) · rintro ⟨h, ht⟩ i j hij by_cases hi : i.val < n · by_cases hj : j.val < n · exact h ⟨i.val, hi⟩ ⟨j.val, hj⟩ (fun he => hij (Fin.ext (congrArg (fun t : Fin n => t.val) he))) · have hjn : j.val = n := by omega change B ω i.val j.val < -ε rw [hjn] exact ht ⟨i.val, hi⟩ · have hin : i.val = n := by omega by_cases hj : j.val < n · change B ω i.val j.val < -ε rw [hin, hsym] exact ht ⟨j.val, hj⟩ · have hjn : j.val = n := by omega exact (hij (Fin.ext (hin.trans hjn.symm))).elim lemma negativeBlock_two {Ω : Type*} {B : Ω → ℕ → ℕ → ℝ} (hsym : ∀ ω i j, B ω i j = B ω j i) (ε : ℝ) : negativeBlock B ε 2 = {ω | B ω 0 1 < -ε} := by ext ω constructor · intro h exact h 0 1 (by decide) · intro h i j hij fin_cases i <;> fin_cases j · exact (hij rfl).elim · exact h · change B ω 1 0 < -ε rw [hsym] exact h · exact (hij rfl).elim lemma negativeBlock_next_probability {Ω : Type*} [MeasurableSpace Ω] {B : Ω → ℕ → ℕ → ℝ} {μ : Measure Ω} [IsProbabilityMeasure μ] (hm : ∀ i j, Measurable (fun ω => B ω i j)) (hsym : ∀ ω i j, B ω i j = B ω j i) (hGG : HasGhirlandaGuerra B μ) (ε : ℝ) (n : ℕ) (hn : 2 ≤ n) : μ.real (negativeBlock B ε n) * μ.real {ω | B ω 0 1 < -ε} ≤ μ.real (negativeBlock B ε (n + 1)) := by classical let A := negativeBlock B ε n let Bad := fun i : Fin n => A ∩ {ω | -ε ≤ B ω i n} have hbase : μ.real {ω | -ε ≤ B ω 0 1} = 1 - μ.real {ω | B ω 0 1 < -ε} := by have hset : {ω | -ε ≤ B ω 0 1} = {ω | B ω 0 1 < -ε}ᶜ := by ext ω; simp rw [hset, measureReal_compl (measurableSet_lt (hm 0 1) measurable_const), probReal_univ] have hbad : ∀ i : Fin n, μ.real (Bad i) = μ.real A * (1 - μ.real {ω | B ω 0 1 < -ε}) / n := by intro i have h := hGG n hn i {b | ∀ i j, i ≠ j → b i j < -ε} (measurableSet_negative_finite n ε) (Set.Ici (-ε)) measurableSet_Ici have hp : arrayBlock B n ⁻¹' {b | ∀ i j, i ≠ j → b i j < -ε} = A := rfl rw [hp] at h have hz : ∀ j ∈ Finset.univ.erase i, A ∩ {ω | B ω i j ∈ Set.Ici (-ε)} = ∅ := by intro j hj apply Set.eq_empty_iff_forall_notMem.mpr rintro ω ⟨hω, hω'⟩ exact (not_le_of_gt (hω i j (Ne.symm (Finset.mem_erase.mp hj).1))) hω' have hzero : (∑ j ∈ Finset.univ.erase i, μ.real (A ∩ {ω | B ω i j ∈ Set.Ici (-ε)})) = 0 := by apply Finset.sum_eq_zero intro j hj rw [hz j hj, measureReal_empty] rw [hzero] at h simp only [zero_div, add_zero, Set.mem_Ici] at h simpa only [Bad, hbase] using h have hsub : A ⊆ negativeBlock B ε (n + 1) ∪ ⋃ i : Fin n, Bad i := by intro ω hω by_cases ht : ∀ i : Fin n, B ω i n < -ε · exact Or.inl ((mem_negativeBlock_succ hsym).mpr ⟨hω, ht⟩) · right push Not at ht obtain ⟨i, hi⟩ := ht exact Set.mem_iUnion.mpr ⟨i, hω, hi⟩ have hbound := (measureReal_mono (μ := μ) hsub).trans (measureReal_union_le (negativeBlock B ε (n + 1)) (⋃ i : Fin n, Bad i)) have hsum := measureReal_iUnion_fintype_le Bad (μ := μ) simp_rw [hbad] at hsum simp only [Finset.sum_const, Finset.card_univ, Fintype.card_fin, nsmul_eq_mul] at hsum have hn' : (n : ℝ) ≠ 0 := by exact_mod_cast (by omega : n ≠ 0) rw [mul_div_left_comm, div_self hn', mul_one] at hsum nlinarith lemma gg_negative_probability_zero {Ω : Type*} [MeasurableSpace Ω] {B : Ω → ℕ → ℕ → ℝ} {μ : Measure Ω} [IsProbabilityMeasure μ] {D : ℝ} (hm : ∀ i j, Measurable (fun ω => B ω i j)) (hsym : ∀ ω i j, B ω i j = B ω j i) (hGG : HasGhirlandaGuerra B μ) (hGram : ∀ᵐ ω ∂μ, ∀ n, Matrix.PosSemidef (arrayBlock B n ω)) (hdiag : ∀ᵐ ω ∂μ, ∀ i, B ω i i = D) {ε : ℝ} (hε : 0 < ε) : μ {ω | B ω 0 1 < -ε} = 0 := by apply (measureReal_eq_zero_iff (μ := μ)).mp by_contra hbne have hb : 0 < μ.real {ω | B ω 0 1 < -ε} := lt_of_le_of_ne measureReal_nonneg (Ne.symm hbne) have hblocks : ∀ k : ℕ, 0 < μ.real (negativeBlock B ε (k + 2)) := by intro k induction k with | zero => simpa only [Nat.zero_add, negativeBlock_two hsym] using hb | succ k ih => have h := negativeBlock_next_probability hm hsym hGG ε (k + 2) (by omega) exact (mul_pos ih hb).trans_le (by simpa only [Nat.succ_add] using h) obtain ⟨m, hmgt⟩ := exists_nat_gt (D / ε) have hsize : D < ((m + 2 : ℕ) - 1 : ℝ) * ε := by have h := (div_lt_iff₀ hε).mp hmgt simp only [Nat.cast_add, Nat.cast_ofNat] nlinarith have hnull : μ (negativeBlock B ε (m + 2)) = 0 := by have ha : ∀ᵐ ω ∂μ, ω ∉ negativeBlock B ε (m + 2) := by filter_upwards [hGram, hdiag] with ω hg hd intro hn exact no_large_negative_block (by omega : 0 < m + 2) hsize (hg (m + 2)) (fun i => hd i) hn simpa using ae_iff.mp ha have hpos := hblocks m rw [Measure.real, hnull, ENNReal.toReal_zero] at hpos exact (lt_irrefl (0 : ℝ)) hpos theorem gg_pair_nonnegative {Ω : Type*} [MeasurableSpace Ω] {B : Ω → ℕ → ℕ → ℝ} {μ : Measure Ω} [IsProbabilityMeasure μ] {D : ℝ} (hm : ∀ i j, Measurable (fun ω => B ω i j)) (hsym : ∀ ω i j, B ω i j = B ω j i) (hGG : HasGhirlandaGuerra B μ) (hGram : ∀ᵐ ω ∂μ, ∀ n, Matrix.PosSemidef (arrayBlock B n ω)) (hdiag : ∀ᵐ ω ∂μ, ∀ i, B ω i i = D) : ∀ᵐ ω ∂μ, 0 ≤ B ω 0 1 := by have ha : ∀ k : ℕ, ∀ᵐ ω ∂μ, -(1 / (k + 1 : ℝ)) ≤ B ω 0 1 := by intro k rw [ae_iff] simp only [not_le] exact gg_negative_probability_zero hm hsym hGG hGram hdiag (by positivity) filter_upwards [ae_all_iff.mpr ha] with ω hω have hlim := (tendsto_one_div_add_atTop_nhds_zero_nat (𝕜 := ℝ)).neg simp only [neg_zero] at hlim exact le_of_tendsto' hlim hω lemma polya_no_linear_cap {n : ℕ} (hn : 2 ≤ n) {b : ℝ} (hb : b < 1) {r : ℕ → ℝ} (hr : ∀ k, 0 ≤ r k) (h0 : 0 < r 0) (hrec : ∀ k, r (k+1) = r k * ((n : ℝ) + k - b) / ((n : ℝ) + k)) (hcap : ∀ k : ℕ, (k+1 : ℝ) * r k ≤ 1) : False := by have hn' : (2 : ℝ) ≤ n := by exact_mod_cast hn let t : ℕ → ℝ := fun k => ((n : ℝ) + k - 1) * r k have ht : ∀ k, t (k+1) = t k + (1-b) * r k := by intro k have hnk : (n : ℝ) + k ≠ 0 := by positivity dsimp [t] rw [hrec] push_cast field_simp ring have hbase : 0 < t 0 := by dsimp [t]; simp only [Nat.cast_zero, add_zero] exact mul_pos (by linarith) h0 have hmono : Monotone t := monotone_nat_of_le_succ (fun k => by rw [ht] nlinarith [hr k]) have hlower : ∀ k, t 0 / ((n : ℝ) + k - 1) ≤ r k := by intro k have h := hmono (Nat.zero_le k) have hden : 0 < (n : ℝ) + k - 1 := by linarith [Nat.cast_nonneg (α := ℝ) k] exact (div_le_iff₀ hden).mpr (by simpa only [t, mul_comm] using h) have hsum : ∀ k, t 0 + (1-b)*t 0 * (∑ j ∈ Finset.range k, 1 / ((n : ℝ) + j - 1)) ≤ t k := by intro k induction k with | zero => simp | succ k ih => rw [Finset.sum_range_succ, ht] have he := mul_le_mul_of_nonneg_left (hlower k) (sub_pos.mpr hb).le calc _ = (t 0 + (1-b)*t 0 * (∑ j ∈ Finset.range k, 1 / ((n : ℝ) + j - 1))) + (1-b)*(t 0 / ((n : ℝ) + k - 1)) := by ring _ ≤ _ := add_le_add ih he have hupper : ∀ k, t k ≤ (n : ℝ) - 1 := by intro k have h := hcap k have he : (n : ℝ) + k - 1 ≤ ((n : ℝ)-1) * (k+1) := by nlinarith [Nat.cast_nonneg (α := ℝ) k] have he' := mul_le_mul_of_nonneg_right he (hr k) have h' := mul_le_mul_of_nonneg_left h (by linarith : 0 ≤ (n : ℝ)-1) dsimp [t] nlinarith have hcompare : ∀ k, (∑ j ∈ Finset.range k, 1 / (j+1 : ℝ)) / n ≤ ∑ j ∈ Finset.range k, 1 / ((n : ℝ) + j - 1) := by intro k rw [Finset.sum_div] refine Finset.sum_le_sum fun j _ => ?_ have hj : (0 : ℝ) ≤ j := Nat.cast_nonneg j have hden : 0 < (n : ℝ) + j - 1 := by linarith rw [div_div] apply one_div_le_one_div_of_le hden nlinarith have hH : Tendsto (fun k => t 0 + (1-b)*t 0 * ((∑ j ∈ Finset.range k, 1 / (j+1 : ℝ)) / n)) atTop atTop := by apply tendsto_atTop_add_const_left apply Filter.Tendsto.const_mul_atTop (by positivity) exact Filter.Tendsto.atTop_div_const (by positivity) Real.tendsto_sum_range_one_div_nat_succ_atTop obtain ⟨k, hk⟩ := ((tendsto_atTop.1 hH) ((n : ℝ) - 1 + 1)).exists have he := (mul_le_mul_of_nonneg_left (hcompare k) (by positivity : 0 ≤ (1-b)*t 0)) have hs := hsum k have hu := hupper k linarith lemma equal_probability_aedisjoint_cap {Ω : Type*} [MeasurableSpace Ω] {μ : Measure Ω} [IsProbabilityMeasure μ] {k : ℕ} {s : Fin (k+1) → Set Ω} (hm : ∀ i, MeasurableSet (s i)) (hd : Pairwise (fun i j => AEDisjoint μ (s i) (s j))) {r : ℝ} (hs : ∀ i, μ.real (s i) = r) : (k+1 : ℝ)*r ≤ 1 := by have he := measureReal_biUnion_finset₀ (μ := μ) (s := Finset.univ) (fun i _ j _ hij => hd hij) (fun i _ => (hm i).nullMeasurableSet) (fun i _ => measure_ne_top μ (s i)) have hu : (⋃ i ∈ Finset.univ, s i) = ⋃ i, s i := by simp rw [hu] at he have hh : μ.real (⋃ i, s i) ≤ 1 := measureReal_le_one rw [he] at hh simpa [hs, Nat.cast_add, Nat.cast_one] using hh abbrev RealArray := ℕ → ℕ → ℝ def permuteArray (e : Equiv.Perm ℕ) (b : RealArray) : RealArray := fun i j => b (e i) (e j) def WeaklyExchangeable {Ω : Type*} [MeasurableSpace Ω] (B : Ω → RealArray) (μ : Measure Ω) : Prop := ∀ e : Equiv.Perm ℕ, {i | e i ≠ i}.Finite → IdentDistrib B (fun ω => permuteArray e (B ω)) μ μ lemma swap_hasFiniteSupport (i j : ℕ) : {a | (Equiv.swap i j) a ≠ a}.Finite := by apply ((Set.finite_singleton j).insert i).subset intro a ha by_contra hn simp only [Set.mem_insert_iff, Set.mem_singleton_iff, not_or] at hn exact ha (Equiv.swap_apply_of_ne_of_ne hn.1 hn.2) lemma measurable_permuteArray (e : Equiv.Perm ℕ) : Measurable (permuteArray e) := by exact Measurable.of_eval fun i => Measurable.of_eval fun j => (measurable_pi_apply (e j)).comp (measurable_pi_apply (e i)) def starSet (a : ℕ) (J : Finset ℕ) (A : Set (Fin a → Fin a → ℝ)) (T : Set (Fin a → ℝ)) (t : ℝ) (i : ℕ) : Set RealArray := {b | (fun x y : Fin a => b x y) ∈ A ∧ (fun x : Fin a => b x i) ∈ T ∧ ∀ j ∈ J, j ≠ i → b i j < t} def duplicateSet (a : ℕ) (A : Set (Fin a → Fin a → ℝ)) (T : Set (Fin a → ℝ)) (t : ℝ) (i j : ℕ) : Set RealArray := {b | (fun x y : Fin a => b x y) ∈ A ∧ (fun x : Fin a => b x i) ∈ T ∧ (fun x : Fin a => b x j) ∈ T ∧ b i j < t} lemma measurableSet_starSet {a : ℕ} (J : Finset ℕ) {A : Set (Fin a → Fin a → ℝ)} {T : Set (Fin a → ℝ)} (hA : MeasurableSet A) (hT : MeasurableSet T) (t : ℝ) (i : ℕ) : MeasurableSet (starSet a J A T t i) := by apply MeasurableSet.inter · exact hA.preimage (Measurable.of_eval fun x => Measurable.of_eval fun y => (measurable_pi_apply (y : ℕ)).comp (measurable_pi_apply (x : ℕ))) apply MeasurableSet.inter · exact hT.preimage (Measurable.of_eval fun x => (measurable_pi_apply i).comp (measurable_pi_apply (x : ℕ))) change MeasurableSet {b : RealArray | ∀ j ∈ J, j ≠ i → b i j < t} simp only [Set.ofPred_forall] exact MeasurableSet.iInter fun j => MeasurableSet.iInter fun _ => MeasurableSet.iInter fun _ => measurableSet_lt (by fun_prop : Measurable (fun b : RealArray => b i j)) measurable_const lemma measurableSet_duplicateSet {a : ℕ} {A : Set (Fin a → Fin a → ℝ)} {T : Set (Fin a → ℝ)} (hA : MeasurableSet A) (hT : MeasurableSet T) (t : ℝ) (i j : ℕ) : MeasurableSet (duplicateSet a A T t i j) := by apply MeasurableSet.inter · exact hA.preimage (Measurable.of_eval fun x => Measurable.of_eval fun y => (measurable_pi_apply (y : ℕ)).comp (measurable_pi_apply (x : ℕ))) apply MeasurableSet.inter · exact hT.preimage (Measurable.of_eval fun x => (measurable_pi_apply i).comp (measurable_pi_apply (x : ℕ))) exact (hT.preimage (Measurable.of_eval fun x => (measurable_pi_apply j).comp (measurable_pi_apply (x : ℕ)))).inter (measurableSet_lt (by fun_prop : Measurable (fun b : RealArray => b i j)) measurable_const) lemma starSet_permute {a : ℕ} {J : Finset ℕ} {A : Set (Fin a → Fin a → ℝ)} {T : Set (Fin a → ℝ)} {t : ℝ} {i : ℕ} {e : Equiv.Perm ℕ} (hfix : ∀ x < a, e x = x) (hJ : ∀ j, j ∈ J ↔ e j ∈ J) : permuteArray e ⁻¹' starSet a J A T t i = starSet a J A T t (e i) := by ext b have hA : (fun x y : Fin a => permuteArray e b x y) = fun x y : Fin a => b x y := by funext x y simp only [permuteArray, hfix x x.isLt, hfix y y.isLt] have hT : (fun x : Fin a => permuteArray e b x i) = fun x : Fin a => b x (e i) := by funext x simp only [permuteArray, hfix x x.isLt] change (_ ∈ A ∧ _ ∈ T ∧ _) ↔ (_ ∈ A ∧ _ ∈ T ∧ _) rw [hA, hT] constructor · rintro ⟨ha, ht, hs⟩ refine ⟨ha, ht, ?_⟩ intro j hj hji have hj' : e.symm j ∈ J := (hJ _).mpr (by simpa using hj) have hji' : e.symm j ≠ i := by intro he; apply hji; rw [← he]; simp simpa only [permuteArray, Equiv.apply_symm_apply] using hs _ hj' hji' · rintro ⟨ha, ht, hs⟩ exact ⟨ha, ht, fun j hj hji => hs (e j) ((hJ j).mp hj) (e.injective.ne hji)⟩ lemma duplicateSet_permute {a : ℕ} {A : Set (Fin a → Fin a → ℝ)} {T : Set (Fin a → ℝ)} {t : ℝ} {i j : ℕ} {e : Equiv.Perm ℕ} (hfix : ∀ x < a, e x = x) : permuteArray e ⁻¹' duplicateSet a A T t i j = duplicateSet a A T t (e i) (e j) := by ext b change (_ ∈ A ∧ _ ∈ T ∧ _ ∈ T ∧ _) ↔ (_ ∈ A ∧ _ ∈ T ∧ _ ∈ T ∧ _) have hA : (fun x y : Fin a => permuteArray e b x y) = fun x y : Fin a => b x y := by funext x y simp only [permuteArray, hfix x x.isLt, hfix y y.isLt] have hT : ∀ i, (fun x : Fin a => permuteArray e b x i) = fun x : Fin a => b x (e i) := by intro i; funext x simp only [permuteArray, hfix x x.isLt] rw [hA, hT i, hT j] rfl lemma swap_preserves_ge {a x y z : ℕ} (hx : a ≤ x) (hy : a ≤ y) (hz : a ≤ z) : a ≤ (Equiv.swap x y) z := by by_cases hzx : z = x · subst z; simpa using hy by_cases hzy : z = y · subst z; simpa using hx simpa only [Equiv.swap_apply_of_ne_of_ne hzx hzy] using hz lemma star_probability_equal {Ω : Type*} [MeasurableSpace Ω] {B : Ω → RealArray} {μ : Measure Ω} (hwe : WeaklyExchangeable B μ) {a : ℕ} {J : Finset ℕ} {A : Set (Fin a → Fin a → ℝ)} {T : Set (Fin a → ℝ)} (hA : MeasurableSet A) (hT : MeasurableSet T) {t : ℝ} {i j : ℕ} (hai : a ≤ i) (haj : a ≤ j) (hi : i ∈ J) (hj : j ∈ J) : μ (B ⁻¹' starSet a J A T t i) = μ (B ⁻¹' starSet a J A T t j) := by have h := (hwe (Equiv.swap i j) (swap_hasFiniteSupport i j)).measure_mem_eq (measurableSet_starSet J hA hT t i) change μ (B ⁻¹' starSet a J A T t i) = μ (B ⁻¹' (permuteArray (Equiv.swap i j) ⁻¹' starSet a J A T t i)) at h have hfix : ∀ x < a, (Equiv.swap i j) x = x := by intro x hx exact Equiv.swap_apply_of_ne_of_ne (by omega) (by omega) have hJ : ∀ x, x ∈ J ↔ (Equiv.swap i j) x ∈ J := by intro x by_cases hxi : x = i · subst x; simp only [Equiv.swap_apply_left]; exact iff_of_true hi hj by_cases hxj : x = j · subst x; simp only [Equiv.swap_apply_right]; exact iff_of_true hj hi rw [Equiv.swap_apply_of_ne_of_ne hxi hxj] rw [starSet_permute hfix hJ, Equiv.swap_apply_left] at h exact h lemma duplicate_probability_swap {Ω : Type*} [MeasurableSpace Ω] {B : Ω → RealArray} {μ : Measure Ω} (hwe : WeaklyExchangeable B μ) {a : ℕ} {A : Set (Fin a → Fin a → ℝ)} {T : Set (Fin a → ℝ)} (hA : MeasurableSet A) (hT : MeasurableSet T) (t : ℝ) (i j : ℕ) {x y : ℕ} (hx : a ≤ x) (hy : a ≤ y) : μ (B ⁻¹' duplicateSet a A T t i j) = μ (B ⁻¹' duplicateSet a A T t ((Equiv.swap x y) i) ((Equiv.swap x y) j)) := by have h := (hwe (Equiv.swap x y) (swap_hasFiniteSupport x y)).measure_mem_eq (measurableSet_duplicateSet hA hT t i j) change μ (B ⁻¹' duplicateSet a A T t i j) = μ (B ⁻¹' (permuteArray (Equiv.swap x y) ⁻¹' duplicateSet a A T t i j)) at h rwa [duplicateSet_permute (by intro z hz exact Equiv.swap_apply_of_ne_of_ne (by omega) (by omega))] at h lemma duplicate_probability_equal {Ω : Type*} [MeasurableSpace Ω] {B : Ω → RealArray} {μ : Measure Ω} (hwe : WeaklyExchangeable B μ) {a : ℕ} {A : Set (Fin a → Fin a → ℝ)} {T : Set (Fin a → ℝ)} (hA : MeasurableSet A) (hT : MeasurableSet T) (t : ℝ) {i j : ℕ} (hi : a ≤ i) (hj : a ≤ j) (hij : i ≠ j) : μ (B ⁻¹' duplicateSet a A T t a (a+1)) = μ (B ⁻¹' duplicateSet a A T t i j) := by let k := (Equiv.swap a i) (a+1) have hk : a ≤ k := swap_preserves_ge (le_refl a) hi (by omega) have hki : k ≠ i := by have hh : (Equiv.swap a i) (a+1) ≠ (Equiv.swap a i) a := (Equiv.swap a i).injective.ne (by omega) simpa only [Equiv.swap_apply_left] using hh have h₁ := duplicate_probability_swap hwe hA hT t a (a+1) (le_refl a) hi have h₂ := duplicate_probability_swap hwe hA hT t i k hk hj rw [Equiv.swap_apply_of_ne_of_ne hki.symm hij, Equiv.swap_apply_left] at h₂ rw [Equiv.swap_apply_left] at h₁ exact h₁.trans h₂ lemma no_duplicate_star_cap {Ω : Type*} [MeasurableSpace Ω] {B : Ω → RealArray} {μ : Measure Ω} [IsProbabilityMeasure μ] (hm : Measurable B) (hwe : WeaklyExchangeable B μ) {a : ℕ} {A : Set (Fin a → Fin a → ℝ)} {T : Set (Fin a → ℝ)} (hA : MeasurableSet A) (hT : MeasurableSet T) (t : ℝ) (hdup : μ (B ⁻¹' duplicateSet a A T t a (a+1)) = 0) (k : ℕ) : (k+1 : ℝ) * μ.real (B ⁻¹' starSet a (Finset.Ico a (a+k+1)) A T t a) ≤ 1 := by let J := Finset.Ico a (a+k+1) let s : Fin (k+1) → Set Ω := fun i => B ⁻¹' starSet a J A T t (a+i) have hmem : ∀ i : Fin (k+1), a+i ∈ J := by intro i simp only [J, Finset.mem_Ico] constructor <;> omega apply equal_probability_aedisjoint_cap (μ := μ) (s := s) · intro i exact (measurableSet_starSet J hA hT t (a+i)).preimage hm · intro i j hij have hnull : μ (B ⁻¹' duplicateSet a A T t (a+i) (a+j)) = 0 := by rw [← duplicate_probability_equal hwe hA hT t (by omega) (by omega) (by intro h; apply hij; apply Fin.ext; omega), hdup] change μ (s i ∩ s j) = 0 apply measure_mono_null (t := B ⁻¹' duplicateSet a A T t (a+i) (a+j)) ?_ hnull intro ω hω exact ⟨hω.1.1, hω.1.2.1, hω.2.2.1, hω.1.2.2 (a+j) (hmem j) (by intro h; apply hij; apply Fin.ext; omega)⟩ · intro i apply congrArg ENNReal.toReal exact star_probability_equal hwe hA hT (by omega) (le_refl a) (hmem i) (by simp only [J, Finset.mem_Ico]; constructor <;> omega) def extendArrayBlock (n : ℕ) (b : Fin n → Fin n → ℝ) : RealArray := fun i j => if hi : i < n then if hj : j < n then b ⟨i,hi⟩ ⟨j,hj⟩ else 0 else 0 lemma measurable_extendArrayBlock (n : ℕ) : Measurable (extendArrayBlock n) := by apply Measurable.of_eval intro i apply Measurable.of_eval intro j by_cases hi : i < n · by_cases hj : j < n · simpa only [extendArrayBlock, dite_eq_left hi, dite_eq_left hj, Function.comp_def] using ((measurable_pi_apply (⟨j,hj⟩ : Fin n)).comp (measurable_pi_apply (⟨i,hi⟩ : Fin n))) · simp only [extendArrayBlock, dite_eq_left hi, dite_eq_right hj]; exact measurable_const · simp only [extendArrayBlock, dite_eq_right hi]; exact measurable_const lemma starSet_dependsOn {Ω : Type*} {B : Ω → RealArray} {ω : Ω} {n a : ℕ} {J : Finset ℕ} {A : Set (Fin a → Fin a → ℝ)} {T : Set (Fin a → ℝ)} {t : ℝ} {i : ℕ} (han : a ≤ n) (hin : i < n) (hJ : ∀ j ∈ J, j < n) : extendArrayBlock n (arrayBlock B n ω) ∈ starSet a J A T t i ↔ B ω ∈ starSet a J A T t i := by have he : ∀ x y, x < n → y < n → extendArrayBlock n (arrayBlock B n ω) x y = B ω x y := by intro x y hx hy simp only [extendArrayBlock, dite_eq_left hx, dite_eq_left hy, arrayBlock] have hA : (fun x y : Fin a => extendArrayBlock n (arrayBlock B n ω) x y) = fun x y : Fin a => B ω x y := by funext x y exact he x y (x.isLt.trans_le han) (y.isLt.trans_le han) have hT : (fun x : Fin a => extendArrayBlock n (arrayBlock B n ω) x i) = fun x : Fin a => B ω x i := by funext x exact he x i (x.isLt.trans_le han) hin change (_ ∈ A ∧ _ ∈ T ∧ _) ↔ (_ ∈ A ∧ _ ∈ T ∧ _) rw [hA, hT] apply and_congr_right; intro _ apply and_congr_right; intro _ apply forall_congr'; intro j apply forall_congr'; intro hj rw [he i j hin (hJ j hj)] lemma starSet_chain_succ {a k : ℕ} {A : Set (Fin a → Fin a → ℝ)} {T : Set (Fin a → ℝ)} {t : ℝ} : starSet a (Finset.Ico a (a+(k+1)+1)) A T t a = starSet a (Finset.Ico a (a+k+1)) A T t a ∩ {b | b a (a+k+1) < t} := by ext b constructor · rintro ⟨ha, ht, hs⟩ refine ⟨⟨ha, ht, fun j hj hja => hs j ?_ hja⟩, hs (a+k+1) ?_ (by omega)⟩ · simp only [Finset.mem_Ico] at hj ⊢; omega · simp only [Finset.mem_Ico]; omega · rintro ⟨⟨ha, ht, hs⟩, hn⟩ refine ⟨ha, ht, ?_⟩ intro j hj hja by_cases hjn : j = a+k+1 · change b a (a+k+1) < t at hn simpa only [hjn] using hn · apply hs j _ hja simp only [Finset.mem_Ico] at hj ⊢; omega lemma gg_star_chain_recurrence {Ω : Type*} [MeasurableSpace Ω] {B : Ω → RealArray} {μ : Measure Ω} [IsProbabilityMeasure μ] (hsym : ∀ ω i j, B ω i j = B ω j i) (hGG : HasGhirlandaGuerra B μ) {a : ℕ} (ha : 0 < a) {A : Set (Fin a → Fin a → ℝ)} {T : Set (Fin a → ℝ)} (hA : MeasurableSet A) (hT : MeasurableSet T) (t : ℝ) (hTlow : ∀ v ∈ T, ∀ i, v i < t) (k : ℕ) : μ.real (B ⁻¹' starSet a (Finset.Ico a (a+(k+1)+1)) A T t a) = μ.real (B ⁻¹' starSet a (Finset.Ico a (a+k+1)) A T t a) * ((a+1 : ℕ) + (k : ℝ) - (1 - μ.real {ω | B ω 0 1 < t})) / ((a+1 : ℕ) + (k : ℝ)) := by classical let n := a+k+1 let J := Finset.Ico a n let C : Set Ω := B ⁻¹' starSet a J A T t a let F : Set (Fin n → Fin n → ℝ) := extendArrayBlock n ⁻¹' starSet a J A T t a let i : Fin n := ⟨a, by dsimp [n]; omega⟩ have hF : MeasurableSet F := (measurableSet_starSet J hA hT t a).preimage (measurable_extendArrayBlock n) have hC : arrayBlock B n ⁻¹' F = C := by ext ω exact starSet_dependsOn (by dsimp [n]; omega) (by dsimp [n]; omega) (by intro j hj; exact (Finset.mem_Ico.mp hj).2) have h := hGG n (by dsimp [n]; omega) i F hF (Set.Iio t) measurableSet_Iio rw [hC] at h have hevent : ∀ j ∈ Finset.univ.erase i, C ∩ {ω | B ω i j ∈ Set.Iio t} = C := by intro j hj apply Set.inter_eq_left.mpr intro ω hω have hji : j.val ≠ a := by intro he exact (Finset.mem_erase.mp hj).1 (Fin.ext he) change B ω a j.val < t by_cases hja : j.val < a · rw [hsym ω a j.val] exact hTlow _ hω.2.1 ⟨j.val,hja⟩ · exact hω.2.2 j.val (Finset.mem_Ico.mpr ⟨by omega, j.isLt⟩) hji have hsum : (∑ j ∈ Finset.univ.erase i, μ.real (C ∩ {ω | B ω i j ∈ Set.Iio t})) = (n-1 : ℝ) * μ.real C := by calc _ = ∑ _j ∈ Finset.univ.erase i, μ.real C := Finset.sum_congr rfl (fun j hj => congrArg μ.real (hevent j hj)) _ = _ := by simp only [Finset.sum_const, Finset.card_erase_of_mem (Finset.mem_univ i), Finset.card_univ, Fintype.card_fin, nsmul_eq_mul] rw [Nat.cast_sub (by dsimp [n]; omega : 1 ≤ n), Nat.cast_one] rw [hsum] at h rw [starSet_chain_succ, Set.preimage_inter] change μ.real (C ∩ {ω | B ω a n < t}) = _ change μ.real (C ∩ {ω | B ω a n < t}) = _ at h rw [h] dsimp [C, J, n] simp only [Set.mem_Iio] push_cast ring lemma low_pair_probability_equal {Ω : Type*} [MeasurableSpace Ω] {B : Ω → RealArray} {μ : Measure Ω} (hwe : WeaklyExchangeable B μ) {a : ℕ} (ha : 0 < a) (t : ℝ) : μ {ω | B ω 0 1 < t} = μ {ω | B ω 0 a < t} := by have h := (hwe (Equiv.swap 1 a) (swap_hasFiniteSupport 1 a)).measure_mem_eq (measurableSet_lt (by fun_prop : Measurable (fun b : RealArray => b 0 1)) (measurable_const (a := t))) have hz : (Equiv.swap 1 a) 0 = 0 := Equiv.swap_apply_of_ne_of_ne (by omega) (by omega) simpa only [Set.preimage_ofPred_eq, permuteArray, hz, Equiv.swap_apply_left] using h lemma starSet_base (a : ℕ) (A : Set (Fin a → Fin a → ℝ)) (T : Set (Fin a → ℝ)) (t : ℝ) : starSet a (Finset.Ico a (a+1)) A T t a = {b | (fun x y : Fin a => b x y) ∈ A ∧ (fun x : Fin a => b x a) ∈ T} := by ext b constructor · intro h; exact ⟨h.1, h.2.1⟩ · rintro ⟨hA, hT⟩ refine ⟨hA, hT, ?_⟩ intro j hj hjne simp only [Finset.mem_Ico] at hj omega theorem gg_duplication_positive {Ω : Type*} [MeasurableSpace Ω] {B : Ω → RealArray} {μ : Measure Ω} [IsProbabilityMeasure μ] (hm : Measurable B) (hsym : ∀ ω i j, B ω i j = B ω j i) (hwe : WeaklyExchangeable B μ) (hGG : HasGhirlandaGuerra B μ) {a : ℕ} (ha : 0 < a) {A : Set (Fin a → Fin a → ℝ)} {T : Set (Fin a → ℝ)} (hA : MeasurableSet A) (hT : MeasurableSet T) (t : ℝ) (hTlow : ∀ v ∈ T, ∀ i, v i < t) (hpos : 0 < μ.real (B ⁻¹' starSet a (Finset.Ico a (a+1)) A T t a)) : 0 < μ.real (B ⁻¹' duplicateSet a A T t a (a+1)) := by by_contra hn have hzero : μ (B ⁻¹' duplicateSet a A T t a (a+1)) = 0 := by apply (measureReal_eq_zero_iff (μ := μ)).mp exact le_antisymm (not_lt.mp hn) measureReal_nonneg have hp : 0 < μ.real {ω | B ω 0 1 < t} := by have he := congrArg ENNReal.toReal (low_pair_probability_equal hwe ha t) change μ.real {ω | B ω 0 1 < t} = μ.real {ω | B ω 0 a < t} at he rw [he] exact hpos.trans_le (measureReal_mono (μ := μ) (fun ω hω => hTlow _ hω.2.1 ⟨0,ha⟩)) apply polya_no_linear_cap (n := a+1) (b := 1 - μ.real {ω | B ω 0 1 < t}) (r := fun k => μ.real (B ⁻¹' starSet a (Finset.Ico a (a+k+1)) A T t a)) (by omega) (by linarith) (fun _ => measureReal_nonneg) (by simpa only [Nat.add_zero] using hpos) · exact gg_star_chain_recurrence hsym hGG ha hA hT t hTlow · exact no_duplicate_star_cap hm hwe hA hT t hzero def blockLaw {Ω : Type*} [MeasurableSpace Ω] (B : Ω → RealArray) (μ : Measure Ω) (n : ℕ) : Measure (Fin n → Fin n → ℝ) := Measure.map (arrayBlock B n) μ lemma measurable_arrayBlock {Ω : Type*} [MeasurableSpace Ω] {B : Ω → RealArray} (hm : Measurable B) (n : ℕ) : Measurable (arrayBlock B n) := by unfold arrayBlock fun_prop lemma blockLaw_support_compact {Ω : Type*} [MeasurableSpace Ω] {B : Ω → RealArray} {μ : Measure Ω} (hm : Measurable B) {D : ℝ} (hb : ∀ ω i j, |B ω i j| ≤ D) (n : ℕ) : IsCompact (blockLaw B μ n).support := by apply (isCompact_Icc (a := fun _ _ : Fin n => -D) (b := fun _ _ : Fin n => D)).of_isClosed_subset Measure.isClosed_support apply Measure.support_subset_of_isClosed isClosed_Icc rw [mem_ae_iff] rw [blockLaw, Measure.map_apply (measurable_arrayBlock hm n) isClosed_Icc.isOpen_compl.measurableSet] have he : arrayBlock B n ⁻¹' (Set.Icc (fun _ _ : Fin n => -D) (fun _ _ : Fin n => D))ᶜ = ∅ := by apply Set.eq_empty_iff_forall_notMem.mpr intro ω hω apply hω constructor · intro i j; exact (abs_le.mp (hb ω i j)).1 · intro i j; exact (abs_le.mp (hb ω i j)).2 rw [he, measure_empty] theorem gg_duplicate_supported_last {Ω : Type*} [MeasurableSpace Ω] {B : Ω → RealArray} {μ : Measure Ω} [IsProbabilityMeasure μ] (hm : Measurable B) (hsym : ∀ ω i j, B ω i j = B ω j i) (hwe : WeaklyExchangeable B μ) (hGG : HasGhirlandaGuerra B μ) {D : ℝ} (hb : ∀ ω i j, |B ω i j| ≤ D) {a : ℕ} (ha : 0 < a) {A : Fin (a+1) → Fin (a+1) → ℝ} (hA : A ∈ (blockLaw B μ (a+1)).support) {t : ℝ} (ht : ∀ i : Fin a, A i.castSucc (Fin.last a) ≤ t) : ∃ C ∈ (blockLaw B μ (a+2)).support, (∀ i j : Fin a, C i.castSucc.castSucc j.castSucc.castSucc = A i.castSucc j.castSucc) ∧ (∀ i : Fin a, C i.castSucc.castSucc (Fin.last a).castSucc = A i.castSucc (Fin.last a)) ∧ (∀ i : Fin a, C i.castSucc.castSucc (Fin.last (a+1)) = A i.castSucc (Fin.last a)) ∧ C (Fin.last a).castSucc (Fin.last (a+1)) ≤ t := by have happrox : ∀ ε : ℝ, 0 < ε → ∃ C ∈ (blockLaw B μ (a+2)).support, (∀ i j : Fin a, |C i.castSucc.castSucc j.castSucc.castSucc - A i.castSucc j.castSucc| < ε) ∧ (∀ i : Fin a, |C i.castSucc.castSucc (Fin.last a).castSucc - A i.castSucc (Fin.last a)| < ε) ∧ (∀ i : Fin a, |C i.castSucc.castSucc (Fin.last (a+1)) - A i.castSucc (Fin.last a)| < ε) ∧ C (Fin.last a).castSucc (Fin.last (a+1)) < t+ε := by intro ε hε let F : Set (Fin a → Fin a → ℝ) := {c | ∀ i j, |c i j - A i.castSucc j.castSucc| < ε} let T : Set (Fin a → ℝ) := {c | ∀ i, |c i - A i.castSucc (Fin.last a)| < ε} have hF : MeasurableSet F := by dsimp [F]; simp only [Set.ofPred_forall] exact MeasurableSet.iInter fun i => MeasurableSet.iInter fun j => measurableSet_lt (by fun_prop) measurable_const have hT : MeasurableSet T := by dsimp [T]; simp only [Set.ofPred_forall] exact MeasurableSet.iInter fun i => measurableSet_lt (by fun_prop) measurable_const have hball := (Measure.mem_support_iff_forall A).mp hA (Metric.ball A ε) (Metric.ball_mem_nhds A hε) rw [blockLaw, Measure.map_apply (measurable_arrayBlock hm (a+1)) Metric.isOpen_ball.measurableSet] at hball have hpos : 0 < μ.real (B ⁻¹' starSet a (Finset.Ico a (a+1)) F T (t+ε) a) := by have hsub : arrayBlock B (a+1) ⁻¹' Metric.ball A ε ⊆ B ⁻¹' starSet a (Finset.Ico a (a+1)) F T (t+ε) a := by intro ω hω rw [starSet_base] have hc := (dist_pi_lt_iff hε).mp hω constructor · intro i j exact (dist_pi_lt_iff hε).mp (hc i.castSucc) j.castSucc · intro i exact (dist_pi_lt_iff hε).mp (hc i.castSucc) (Fin.last a) exact ENNReal.toReal_pos (ne_of_gt (hball.trans_le (measure_mono hsub))) (measure_ne_top _ _) have hd := gg_duplication_positive hm hsym hwe hGG ha hF hT (t+ε) (by intro v hv i; have hi := (abs_lt.mp (hv i)).2; have := ht i; linarith) hpos let E : Set (Fin (a+2) → Fin (a+2) → ℝ) := {c | (∀ i j : Fin a, |c i.castSucc.castSucc j.castSucc.castSucc - A i.castSucc j.castSucc| < ε) ∧ (∀ i : Fin a, |c i.castSucc.castSucc (Fin.last a).castSucc - A i.castSucc (Fin.last a)| < ε) ∧ (∀ i : Fin a, |c i.castSucc.castSucc (Fin.last (a+1)) - A i.castSucc (Fin.last a)| < ε) ∧ c (Fin.last a).castSucc (Fin.last (a+1)) < t+ε} have hE : MeasurableSet E := by change MeasurableSet ({c : Fin (a+2) → Fin (a+2) → ℝ | ∀ i j : Fin a, |c i.castSucc.castSucc j.castSucc.castSucc - A i.castSucc j.castSucc| < ε} ∩ ({c | ∀ i : Fin a, |c i.castSucc.castSucc (Fin.last a).castSucc - A i.castSucc (Fin.last a)| < ε} ∩ ({c | ∀ i : Fin a, |c i.castSucc.castSucc (Fin.last (a+1)) - A i.castSucc (Fin.last a)| < ε} ∩ {c | c (Fin.last a).castSucc (Fin.last (a+1)) < t+ε}))) refine MeasurableSet.inter ?_ (MeasurableSet.inter ?_ (MeasurableSet.inter ?_ ?_)) · simp only [Set.ofPred_forall] exact MeasurableSet.iInter fun i => MeasurableSet.iInter fun j => measurableSet_lt (by fun_prop) measurable_const · simp only [Set.ofPred_forall] exact MeasurableSet.iInter fun i => measurableSet_lt (by fun_prop) measurable_const · simp only [Set.ofPred_forall] exact MeasurableSet.iInter fun i => measurableSet_lt (by fun_prop) measurable_const · exact measurableSet_lt (by fun_prop) measurable_const have hEp : 0 < (blockLaw B μ (a+2)) E := by rw [blockLaw, Measure.map_apply (measurable_arrayBlock hm (a+2)) hE] exact ENNReal.toReal_pos_iff.mp hd |>.1 obtain ⟨C, hCE, hCs⟩ := Measure.nonempty_inter_support_of_pos hEp exact ⟨C, hCs, hCE⟩ choose C hCs hC using fun k : ℕ => happrox (1 / (k+1)) (by positivity) obtain ⟨L, hLs, φ, hφ, hlim⟩ := (blockLaw_support_compact hm hb (a+2)).tendsto_subseq hCs have hzero : Tendsto (fun k => 1 / ((φ k : ℝ)+1)) atTop (𝓝 0) := tendsto_one_div_add_atTop_nhds_zero_nat.comp hφ.tendsto_atTop have hentry : ∀ i j, Tendsto (fun k => C (φ k) i j) atTop (𝓝 (L i j)) := by intro i j exact ((continuous_apply j).comp (continuous_apply i)).continuousAt.tendsto.comp hlim have heq : ∀ (i j : Fin (a+2)) (v : ℝ), (∀ k, |C k i j-v| < 1/((k:ℝ)+1)) → L i j = v := by intro i j v hv have hl := ((hentry i j).sub (tendsto_const_nhds (x := v))).abs have hg : |L i j-v| ≤ 0 := le_of_tendsto_of_tendsto hl hzero (Filter.Eventually.of_forall fun k => (hv (φ k)).le) exact sub_eq_zero.mp (abs_eq_zero.mp (le_antisymm hg (abs_nonneg _))) refine ⟨L, hLs, ?_, ?_, ?_, ?_⟩ · intro i j; exact heq _ _ _ (fun k => (hC k).1 i j) · intro i; exact heq _ _ _ (fun k => (hC k).2.1 i) · intro i; exact heq _ _ _ (fun k => (hC k).2.2.1 i) · have htlim := tendsto_const_nhds.add hzero (a := t) simp only [add_zero] at htlim exact le_of_tendsto_of_tendsto (hentry _ _) htlim (Filter.Eventually.of_forall fun k => (hC (φ k)).2.2.2.le) lemma support_mem_of_continuous_invariant {X : Type*} [TopologicalSpace X] [MeasurableSpace X] [OpensMeasurableSpace X] {μ : Measure X} {f : X → X} (hf : Continuous f) (hi : ∀ s, MeasurableSet s → μ (f ⁻¹' s) = μ s) {x : X} (hx : x ∈ μ.support) : f x ∈ μ.support := by apply (Measure.mem_support_iff_forall _).mpr intro U hU obtain ⟨V, hVU, hVo, hxV⟩ := mem_nhds_iff.mp hU have hp := (Measure.mem_support_iff_forall x).mp hx _ (hf.continuousAt.preimage_mem_nhds (hVo.mem_nhds hxV)) rw [hi V hVo.measurableSet] at hp exact hp.trans_le (measure_mono hVU) lemma blockLaw_support_swap {Ω : Type*} [MeasurableSpace Ω] {B : Ω → RealArray} {μ : Measure Ω} (hm : Measurable B) (hwe : WeaklyExchangeable B μ) {n : ℕ} {A : Fin n → Fin n → ℝ} (hA : A ∈ (blockLaw B μ n).support) (i j : Fin n) : (fun x y => A ((Equiv.swap i j) x) ((Equiv.swap i j) y)) ∈ (blockLaw B μ n).support := by have hcoe : ∀ x : Fin n, ((Equiv.swap i j) x).val = (Equiv.swap i.val j.val) x.val := by intro x by_cases hxi : x = i · subst x; simp by_cases hxj : x = j · subst x; simp rw [Equiv.swap_apply_of_ne_of_ne hxi hxj, Equiv.swap_apply_of_ne_of_ne (fun h => hxi (Fin.ext h)) (fun h => hxj (Fin.ext h))] let f : (Fin n → Fin n → ℝ) → (Fin n → Fin n → ℝ) := fun A x y => A ((Equiv.swap i j) x) ((Equiv.swap i j) y) have hf : Continuous f := by unfold f; fun_prop apply support_mem_of_continuous_invariant hf _ hA intro S hS rw [blockLaw, Measure.map_apply (measurable_arrayBlock hm n) (hS.preimage hf.measurable), Measure.map_apply (measurable_arrayBlock hm n) hS] have h := (hwe (Equiv.swap i.val j.val) (swap_hasFiniteSupport i.val j.val)).measure_mem_eq (s := (fun b : RealArray => arrayBlock (fun _ : Unit => b) n ()) ⁻¹' S) (hS.preimage (by unfold arrayBlock; fun_prop)) convert h.symm using 2 <;> ext ω <;> simp only [Set.mem_preimage, arrayBlock, f, hcoe] <;> rfl lemma isClosed_setOf_posSemidef (n : ℕ) : IsClosed {A : Matrix (Fin n) (Fin n) ℝ | A.PosSemidef} := by have he : {A : Matrix (Fin n) (Fin n) ℝ | A.PosSemidef} = {A : Matrix (Fin n) (Fin n) ℝ | ∀ i j, A i j = A j i} ∩ {A | ∀ v : Fin n → ℝ, 0 ≤ v ⬝ᵥ (A *ᵥ v)} := by ext A constructor · intro h refine ⟨?_, fun v => by simpa using h.dotProduct_mulVec_nonneg v⟩ intro i j have he := congrFun (congrFun h.1 i) j simpa only [Matrix.conjTranspose_apply, star_trivial] using he.symm · rintro ⟨hs, hq⟩ apply Matrix.PosSemidef.of_dotProduct_mulVec_nonneg · ext i j; exact hs j i · intro v; simpa using hq v rw [he] apply IsClosed.inter · simp only [Set.ofPred_forall] exact isClosed_iInter fun i => isClosed_iInter fun j => isClosed_eq (by fun_prop) (by fun_prop) · simp only [Set.ofPred_forall] exact isClosed_iInter fun v => isClosed_le continuous_const (by unfold dotProduct Matrix.mulVec; fun_prop) lemma blockLaw_support_gram {Ω : Type*} [MeasurableSpace Ω] {B : Ω → RealArray} {μ : Measure Ω} (hm : Measurable B) {D : ℝ} (hpsd : ∀ ω n, Matrix.PosSemidef (arrayBlock B n ω)) (hdiag : ∀ ω i, B ω i i = D) {n : ℕ} {A : Fin n → Fin n → ℝ} (hA : A ∈ (blockLaw B μ n).support) : Matrix.PosSemidef A ∧ ∀ i, A i i = D := by have hdclosed : IsClosed {A : Fin n → Fin n → ℝ | ∀ i, A i i = D} := by simp only [Set.ofPred_forall] exact isClosed_iInter fun i => isClosed_eq (by fun_prop) continuous_const have hc : IsClosed {A : Fin n → Fin n → ℝ | Matrix.PosSemidef A ∧ ∀ i, A i i = D} := (isClosed_setOf_posSemidef n).inter hdclosed apply Measure.support_subset_of_isClosed hc _ hA rw [mem_ae_iff, blockLaw, Measure.map_apply (measurable_arrayBlock hm n) hc.isOpen_compl.measurableSet] have he : arrayBlock B n ⁻¹' {A : Fin n → Fin n → ℝ | Matrix.PosSemidef A ∧ ∀ i, A i i = D}ᶜ = ∅ := by apply Set.eq_empty_iff_forall_notMem.mpr intro ω hω exact hω ⟨hpsd ω n, fun i => hdiag ω i⟩ rw [he, measure_empty] lemma real_posSemidef_symm {n : ℕ} {A : Matrix (Fin n) (Fin n) ℝ} (hA : A.PosSemidef) : ∀ i j, A i j = A j i := by intro i j have h := congrFun (congrFun hA.1 i) j simpa only [Matrix.conjTranspose_apply, star_trivial] using h.symm theorem gg_duplicate_supported {Ω : Type*} [MeasurableSpace Ω] {B : Ω → RealArray} {μ : Measure Ω} [IsProbabilityMeasure μ] (hm : Measurable B) (hsym : ∀ ω i j, B ω i j = B ω j i) (hwe : WeaklyExchangeable B μ) (hGG : HasGhirlandaGuerra B μ) {D : ℝ} (hb : ∀ ω i j, |B ω i j| ≤ D) (hpsd : ∀ ω n, Matrix.PosSemidef (arrayBlock B n ω)) (hdiag : ∀ ω i, B ω i i = D) {a : ℕ} (ha : 0 < a) {A : Fin (a+1) → Fin (a+1) → ℝ} (hA : A ∈ (blockLaw B μ (a+1)).support) (p : Fin (a+1)) {t : ℝ} (ht : ∀ i, i ≠ p → A i p ≤ t) : ∃ C ∈ (blockLaw B μ (a+2)).support, (∀ i j : Fin (a+1), C i.castSucc j.castSucc = A i j) ∧ (∀ i : Fin (a+1), i ≠ p → C i.castSucc (Fin.last (a+1)) = A i p) ∧ C p.castSucc (Fin.last (a+1)) ≤ t := by let e := Equiv.swap p (Fin.last a) let A' : Fin (a+1) → Fin (a+1) → ℝ := fun i j => A (e i) (e j) have hA' : A' ∈ (blockLaw B μ (a+1)).support := blockLaw_support_swap hm hwe hA p (Fin.last a) have ht' : ∀ i : Fin a, A' i.castSucc (Fin.last a) ≤ t := by intro i simp only [A', e, Equiv.swap_apply_right] apply ht intro he have hh := congrArg e he simp only [e, Equiv.swap_apply_self, Equiv.swap_apply_left] at hh exact Fin.castSucc_ne_last i hh obtain ⟨C, hCs, hC0, hC1, hC2, hC3⟩ := gg_duplicate_supported_last hm hsym hwe hGG hb ha hA' ht' have hgramA := blockLaw_support_gram hm hpsd hdiag hA have hgramC := blockLaw_support_gram hm hpsd hdiag hCs have hfull : ∀ i j : Fin (a+1), C i.castSucc j.castSucc = A' i j := by intro i j refine Fin.lastCases ?_ (fun ii => ?_) i · refine Fin.lastCases ?_ (fun jj => ?_) j · exact (hgramC.2 _).trans (hgramA.2 _).symm · rw [real_posSemidef_symm hgramC.1, hC1] exact real_posSemidef_symm hgramA.1 _ _ · refine Fin.lastCases ?_ (fun jj => ?_) j · exact hC1 ii · exact hC0 ii jj let e' := Equiv.swap p.castSucc (Fin.last a).castSucc have hecast : ∀ i : Fin (a+1), e' i.castSucc = (e i).castSucc := by intro i by_cases hi : i = p · subst i; simp [e', e] by_cases hil : i = Fin.last a · subst i; simp [e', e] rw [show e i = i from Equiv.swap_apply_of_ne_of_ne hi hil] exact Equiv.swap_apply_of_ne_of_ne (fun h => hi (Fin.castSucc_injective _ h)) (fun h => hil (Fin.castSucc_injective _ h)) have helast : e' (Fin.last (a+1)) = Fin.last (a+1) := by apply Equiv.swap_apply_of_ne_of_ne <;> exact (Fin.castSucc_ne_last _).symm refine ⟨fun i j => C (e' i) (e' j), blockLaw_support_swap hm hwe hCs _ _, ?_, ?_, ?_⟩ · intro i j change C (e' i.castSucc) (e' j.castSucc) = _ rw [hecast, hecast, hfull] simp only [A', e, Equiv.swap_apply_self] · intro i hip change C (e' i.castSucc) (e' (Fin.last (a+1))) = _ rw [hecast, helast] have heil : e i ≠ Fin.last a := by intro he have he' := congrArg e he simp only [e, Equiv.swap_apply_self, Equiv.swap_apply_right] at he' exact hip he' obtain ⟨ii, hii⟩ := Fin.eq_castSucc_of_ne_last heil rw [← hii, hC2] dsimp [A'] have heii : e ii.castSucc = i := by rw [hii]; exact Equiv.swap_apply_self _ _ _ rw [heii] simp [e] · change C (e' p.castSucc) (e' (Fin.last (a+1))) ≤ _ rw [hecast, helast] simpa only [e, Equiv.swap_apply_left] using hC3 lemma psd_bilinear_symm {ι : Type*} [Fintype ι] {B : Matrix ι ι ℝ} (hB : B.PosSemidef) (x y : ι → ℝ) : x ⬝ᵥ (B *ᵥ y) = y ⬝ᵥ (B *ᵥ x) := by have hs : ∀ i j, B i j = B j i := by intro i j have h := congrFun (congrFun hB.1 i) j simpa only [Matrix.conjTranspose_apply, star_trivial] using h.symm simp only [dotProduct, Matrix.mulVec, Finset.mul_sum] rw [Finset.sum_comm] apply Finset.sum_congr rfl intro i hi apply Finset.sum_congr rfl intro j hj rw [hs j i] ring lemma psd_cauchy_schwarz {ι : Type*} [Fintype ι] {B : Matrix ι ι ℝ} (hB : B.PosSemidef) (x y : ι → ℝ) : (x ⬝ᵥ (B *ᵥ y)) ^ 2 ≤ (x ⬝ᵥ (B *ᵥ x)) * (y ⬝ᵥ (B *ᵥ y)) := by have hq : ∀ t : ℝ, 0 ≤ (x ⬝ᵥ (B *ᵥ x)) * (t * t) + (2 * (x ⬝ᵥ (B *ᵥ y))) * t + (y ⬝ᵥ (B *ᵥ y)) := by intro t have h := hB.dotProduct_mulVec_nonneg (t • x + y) simp only [star_trivial, Matrix.mulVec_add, Matrix.mulVec_smul, dotProduct_add, add_dotProduct, smul_dotProduct, dotProduct_smul, smul_eq_mul] at h rw [psd_bilinear_symm hB y x] at h nlinarith have h := discrim_le_zero hq dsimp [discrim] at h nlinarith lemma psd_three_gap {B : Matrix (Fin 3) (Fin 3) ℝ} (hB : B.PosSemidef) : (B 0 2 - B 0 1) ^ 2 ≤ B 0 0 * (B 1 1 + B 2 2 - 2 * B 1 2) := by have hs : B 2 1 = B 1 2 := by have h := congrFun (congrFun hB.1 1) 2 simpa only [Matrix.conjTranspose_apply, star_trivial] using h have h := psd_cauchy_schwarz hB ![1, 0, 0] ![0, -1, 1] simp [dotProduct, Matrix.mulVec, Fin.sum_univ_succ, hs] at h nlinarith def groupAverageMatrix {m : ℕ} (B : Matrix (Fin 3 × Fin m) (Fin 3 × Fin m) ℝ) : Matrix (Fin 3) (Fin 3) ℝ := fun i j => (∑ a : Fin m, ∑ b : Fin m, B (i,a) (j,b)) / (m : ℝ)^2 lemma groupAverageMatrix_posSemidef {m : ℕ} {B : Matrix (Fin 3 × Fin m) (Fin 3 × Fin m) ℝ} (hB : B.PosSemidef) : (groupAverageMatrix B).PosSemidef := by classical let C : Matrix (Fin 3 × Fin m) (Fin 3) ℝ := fun a i => if a.1 = i then (m : ℝ)⁻¹ else 0 have h := hB.conjTranspose_mul_mul_same C have heq : C.conjTranspose * B * C = groupAverageMatrix B := by ext i j change (∑ a : Fin 3 × Fin m, (∑ b : Fin 3 × Fin m, C b i * B b a) * C a j) = _ simp only [C, Fintype.sum_prod_type, ite_mul, zero_mul, mul_ite, mul_zero] simp only [Finset.sum_mul] dsimp [groupAverageMatrix] rw [Finset.sum_comm] simp [div_eq_mul_inv, pow_two, mul_assoc, mul_comm] rw [Finset.sum_comm] simp_rw [Finset.mul_sum] rwa [heq] at h lemma groupAverageMatrix_cross {m : ℕ} (hm : 0 < m) {B : Matrix (Fin 3 × Fin m) (Fin 3 × Fin m) ℝ} {i j : Fin 3} {q : ℝ} (h : ∀ a b, B (i,a) (j,b) = q) : groupAverageMatrix B i j = q := by have hm' : (m : ℝ) ≠ 0 := by exact_mod_cast (Nat.ne_of_gt hm) simp [groupAverageMatrix, h, pow_two] field_simp lemma groupAverageMatrix_diag_le {m : ℕ} (hm : 0 < m) {B : Matrix (Fin 3 × Fin m) (Fin 3 × Fin m) ℝ} {i : Fin 3} {D q : ℝ} (hd : ∀ a, B (i,a) (i,a) = D) (ho : ∀ a b, a ≠ b → B (i,a) (i,b) ≤ q) : groupAverageMatrix B i i ≤ D / m + (1 - 1 / (m : ℝ)) * q := by classical have hm' : (0 : ℝ) < m := by exact_mod_cast hm have hr : ∀ a, ∑ b : Fin m, B (i,a) (i,b) ≤ D + (m - 1 : ℝ) * q := by intro a rw [← Finset.sum_erase_add _ _ (Finset.mem_univ a), hd a] have h := Finset.sum_le_sum (s := Finset.univ.erase a) (f := fun b => B (i,a) (i,b)) (g := fun _ => q) (fun b hb => ho a b (Ne.symm (Finset.mem_erase.mp hb).1)) simp only [Finset.sum_const, Finset.card_erase_of_mem (Finset.mem_univ a), Finset.card_univ, Fintype.card_fin, nsmul_eq_mul] at h rw [Nat.cast_sub (by omega : 1 ≤ m), Nat.cast_one] at h linarith have h := Finset.sum_le_sum (s := Finset.univ) (fun a _ => hr a) simp only [Finset.sum_const, Finset.card_univ, Fintype.card_fin, nsmul_eq_mul] at h dsimp [groupAverageMatrix] apply (div_le_iff₀ (sq_pos_of_pos hm')).mpr calc _ ≤ m * (D + (m - 1 : ℝ) * q) := h _ = _ := by field_simp lemma psd_entry_le_diagonal {ι : Type*} [Fintype ι] {B : Matrix ι ι ℝ} (hB : B.PosSemidef) {D : ℝ} (hd : ∀ i, B i i = D) (i j : ι) : B i j ≤ D := by classical have hD : 0 ≤ D := hd i ▸ hB.diag_nonneg have h := psd_cauchy_schwarz hB (Pi.single i 1) (Pi.single j 1) simp [dotProduct, Matrix.mulVec, Pi.single_apply, ite_mul, mul_ite, hd] at h nlinarith [sq_nonneg (B i j - D)] lemma groupAverageMatrix_diag_le_common {m : ℕ} (hm : 0 < m) {B : Matrix (Fin 3 × Fin m) (Fin 3 × Fin m) ℝ} {D : ℝ} (hB : B.PosSemidef) (hd : ∀ a, B a a = D) (i : Fin 3) : groupAverageMatrix B i i ≤ D := by have h := groupAverageMatrix_diag_le hm (fun a => hd (i,a)) (fun a b _ => psd_entry_le_diagonal hB hd (i,a) (i,b)) have hD : D / (m : ℝ) + (1 - 1 / (m : ℝ)) * D = D := by ring rwa [hD] at h lemma duplicated_triple_gap_bound {m : ℕ} (hm : 0 < m) {B : Matrix (Fin 3 × Fin m) (Fin 3 × Fin m) ℝ} {D a b c : ℝ} (hB : B.PosSemidef) (hd : ∀ i, B i i = D) (hab : ∀ i j, B (0,i) (1,j) = a) (hac : ∀ i j, B (0,i) (2,j) = b) (hbc : ∀ i j, B (1,i) (2,j) = c) (h22 : ∀ i j, i ≠ j → B (1,i) (1,j) ≤ c) (h33 : ∀ i j, i ≠ j → B (2,i) (2,j) ≤ c) : (b - a)^2 ≤ 2 * D * (D - c) / m := by have hG := groupAverageMatrix_posSemidef hB have h := psd_three_gap hG have h00 := groupAverageMatrix_diag_le_common hm hB hd 0 have h11 := groupAverageMatrix_diag_le hm (fun i => hd (1,i)) h22 have h22' := groupAverageMatrix_diag_le hm (fun i => hd (2,i)) h33 have h01 := groupAverageMatrix_cross hm hab have h02 := groupAverageMatrix_cross hm hac have h12 := groupAverageMatrix_cross hm hbc rw [h01, h02, h12] at h have hD : 0 ≤ D := (hG.diag_nonneg (i := 0)).trans h00 have hq : 0 ≤ groupAverageMatrix B 1 1 + groupAverageMatrix B 2 2 - 2 * c := by have h0 := hG.dotProduct_mulVec_nonneg ![0, -1, 1] have hs : groupAverageMatrix B 2 1 = groupAverageMatrix B 1 2 := by have he := congrFun (congrFun hG.1 1) 2 simpa only [Matrix.conjTranspose_apply, star_trivial] using he simp [dotProduct, Matrix.mulVec, Fin.sum_univ_succ, hs, h12] at h0 linarith calc (b - a)^2 ≤ groupAverageMatrix B 0 0 * (groupAverageMatrix B 1 1 + groupAverageMatrix B 2 2 - 2*c) := h _ ≤ D * (groupAverageMatrix B 1 1 + groupAverageMatrix B 2 2 - 2*c) := mul_le_mul_of_nonneg_right h00 hq _ ≤ D * (2 * (D / m + (1 - 1 / (m : ℝ)) * c) - 2*c) := mul_le_mul_of_nonneg_left (by linarith) hD _ = 2 * D * (D - c) / m := by ring lemma no_arbitrary_nonultrametric_duplicates {D a b c : ℝ} (hab : a < b) (hex : ∀ m : ℕ, 0 < m → ∃ B : Matrix (Fin 3 × Fin m) (Fin 3 × Fin m) ℝ, B.PosSemidef ∧ (∀ i, B i i = D) ∧ (∀ i j, B (0,i) (1,j) = a) ∧ (∀ i j, B (0,i) (2,j) = b) ∧ (∀ i j, B (1,i) (2,j) = c) ∧ (∀ i j, i ≠ j → B (1,i) (1,j) ≤ c) ∧ (∀ i j, i ≠ j → B (2,i) (2,j) ≤ c)) : False := by obtain ⟨m, hm⟩ := exists_nat_gt (2 * D * (D - c) / (b-a)^2) obtain ⟨B, hB, hd, h01, h02, h12, h11, h22⟩ := hex (m+1) (by omega) have h := duplicated_triple_gap_bound (by omega : 0 < m+1) hB hd h01 h02 h12 h11 h22 have hp : 0 < (b-a)^2 := sq_pos_of_pos (sub_pos.mpr hab) have hm' : (0 : ℝ) < (m+1 : ℕ) := by positivity have hbound := (div_lt_iff₀ hp).mp hm have hbig := (le_div_iff₀ hm').mp h simp only [Nat.cast_add, Nat.cast_one] at hbig nlinarith lemma gg_duplicate_supported_of_two_le {Ω : Type*} [MeasurableSpace Ω] {B : Ω → RealArray} {μ : Measure Ω} [IsProbabilityMeasure μ] (hm : Measurable B) (hsym : ∀ ω i j, B ω i j = B ω j i) (hwe : WeaklyExchangeable B μ) (hGG : HasGhirlandaGuerra B μ) {D : ℝ} (hb : ∀ ω i j, |B ω i j| ≤ D) (hpsd : ∀ ω n, Matrix.PosSemidef (arrayBlock B n ω)) (hdiag : ∀ ω i, B ω i i = D) {n : ℕ} (hn : 2 ≤ n) {A : Fin n → Fin n → ℝ} (hA : A ∈ (blockLaw B μ n).support) (p : Fin n) {t : ℝ} (ht : ∀ i, i ≠ p → A i p ≤ t) : ∃ C ∈ (blockLaw B μ (n+1)).support, (∀ i j : Fin n, C i.castSucc j.castSucc = A i j) ∧ (∀ i : Fin n, i ≠ p → C i.castSucc (Fin.last n) = A i p) ∧ C p.castSucc (Fin.last n) ≤ t := by cases n with | zero => omega | succ a => exact gg_duplicate_supported hm hsym hwe hGG hb hpsd hdiag (by omega) hA p ht def tripleLabel {n : ℕ} (i : Fin n) : Fin 3 := ⟨i.val % 3, Nat.mod_lt _ (by decide)⟩ lemma tripleLabel_castSucc {n : ℕ} (i : Fin n) : tripleLabel i.castSucc = tripleLabel i := rfl lemma gg_supported_populations {Ω : Type*} [MeasurableSpace Ω] {B : Ω → RealArray} {μ : Measure Ω} [IsProbabilityMeasure μ] (hm : Measurable B) (hsym : ∀ ω i j, B ω i j = B ω j i) (hwe : WeaklyExchangeable B μ) (hGG : HasGhirlandaGuerra B μ) {D : ℝ} (hb : ∀ ω i j, |B ω i j| ≤ D) (hpsd : ∀ ω n, Matrix.PosSemidef (arrayBlock B n ω)) (hdiag : ∀ ω i, B ω i i = D) {Q : Fin 3 → Fin 3 → ℝ} (hQ : Q ∈ (blockLaw B μ 3).support) {t : ℝ} (ht : ∀ i j, i ≠ j → Q i j ≤ t) : ∀ n, 3 ≤ n → ∃ A ∈ (blockLaw B μ n).support, (∀ i j, i ≠ j → A i j ≤ t) ∧ (∀ i j, tripleLabel i ≠ tripleLabel j → A i j = Q (tripleLabel i) (tripleLabel j)) := by have hQsym := real_posSemidef_symm (blockLaw_support_gram hm hpsd hdiag hQ).1 intro n hn induction n, hn using Nat.le_induction with | base => refine ⟨Q, hQ, ht, ?_⟩ intro i j _ have hh : ∀ i : Fin 3, tripleLabel i = i := fun i => Fin.ext (Nat.mod_eq_of_lt i.isLt) rw [hh, hh] | succ n hn ih => obtain ⟨A, hAs, hAo, hAc⟩ := ih let p : Fin n := ⟨n % 3, (Nat.mod_lt n (by decide : 0 < 3)).trans_le hn⟩ have hp : tripleLabel p = tripleLabel (Fin.last n) := by apply Fin.ext; exact Nat.mod_eq_of_lt (Nat.mod_lt n (by decide)) obtain ⟨C, hCs, hC0, hC1, hCp⟩ := gg_duplicate_supported_of_two_le hm hsym hwe hGG hb hpsd hdiag (by omega) hAs p (fun i hi => hAo i p hi) have hCsym := real_posSemidef_symm (blockLaw_support_gram hm hpsd hdiag hCs).1 refine ⟨C, hCs, ?_, ?_⟩ · intro i j refine Fin.lastCases ?_ (fun ii => ?_) i · refine Fin.lastCases ?_ (fun jj => ?_) j · intro hij; exact (hij rfl).elim · intro _ rw [hCsym] by_cases hj : jj = p · subst jj; exact hCp · rw [hC1 jj hj]; exact hAo jj p hj · refine Fin.lastCases ?_ (fun jj => ?_) j · intro _ by_cases hi : ii = p · subst ii; exact hCp · rw [hC1 ii hi]; exact hAo ii p hi · intro hij rw [hC0]; exact hAo ii jj (fun he => hij (congrArg Fin.castSucc he)) · intro i j refine Fin.lastCases ?_ (fun ii => ?_) i · refine Fin.lastCases ?_ (fun jj => ?_) j · intro hij; exact (hij rfl).elim · intro hij have hjp : tripleLabel jj ≠ tripleLabel p := by intro he; apply hij; exact hp.symm.trans he.symm have hjne : jj ≠ p := fun he => hjp (congrArg tripleLabel he) rw [hCsym, hC1 jj hjne, hAc jj p hjp, hp, hQsym] rfl · refine Fin.lastCases ?_ (fun jj => ?_) j · intro hij have hip : tripleLabel ii ≠ tripleLabel p := by intro he; apply hij; exact he.trans hp have hine : ii ≠ p := fun he => hip (congrArg tripleLabel he) rw [hC1 ii hine, hAc ii p hip, hp] rfl · intro hij rw [hC0]; exact hAc ii jj hij lemma gg_supported_triple_ordered {Ω : Type*} [MeasurableSpace Ω] {B : Ω → RealArray} {μ : Measure Ω} [IsProbabilityMeasure μ] (hm : Measurable B) (hsym : ∀ ω i j, B ω i j = B ω j i) (hwe : WeaklyExchangeable B μ) (hGG : HasGhirlandaGuerra B μ) {D : ℝ} (hb : ∀ ω i j, |B ω i j| ≤ D) (hpsd : ∀ ω n, Matrix.PosSemidef (arrayBlock B n ω)) (hdiag : ∀ ω i, B ω i i = D) {Q : Fin 3 → Fin 3 → ℝ} (hQ : Q ∈ (blockLaw B μ 3).support) (horder : Q 0 2 ≤ Q 1 2) : Q 0 2 ≤ Q 0 1 := by by_contra hn have hlt := lt_of_not_ge hn have hQsym := real_posSemidef_symm (blockLaw_support_gram hm hpsd hdiag hQ).1 have hQo : ∀ i j : Fin 3, i ≠ j → Q i j ≤ Q 1 2 := by intro i j hij fin_cases i <;> fin_cases j · exact (hij rfl).elim · exact hlt.le.trans horder · exact horder · exact (hQsym 1 0).le.trans (hlt.le.trans horder) · exact (hij rfl).elim · exact le_rfl · exact (hQsym 2 0).le.trans horder · exact (hQsym 2 1).le · exact (hij rfl).elim apply no_arbitrary_nonultrametric_duplicates hlt intro m hmpos obtain ⟨A, hAs, hAo, hAc⟩ := gg_supported_populations hm hsym hwe hGG hb hpsd hdiag hQ hQo (3*m) (by omega) let e : Fin 3 × Fin m → Fin (3*m) := fun x => ⟨3*x.2.val+x.1.val, by omega⟩ have he : ∀ i a, tripleLabel (e (i,a)) = i := by intro i a apply Fin.ext dsimp [tripleLabel, e] omega have hei : Function.Injective e := by intro x y hxy have hv := congrArg Fin.val hxy dsimp [e] at hv apply Prod.ext <;> apply Fin.ext <;> omega have hgram := blockLaw_support_gram hm hpsd hdiag hAs refine ⟨Matrix.submatrix A e e, Matrix.PosSemidef.submatrix hgram.1 e, fun _ => hgram.2 _, ?_, ?_, ?_, ?_, ?_⟩ · intro i j change A (e (0,i)) (e (1,j)) = _ rw [hAc _ _ (by rw [he, he]; decide), he, he] · intro i j change A (e (0,i)) (e (2,j)) = _ rw [hAc _ _ (by rw [he, he]; decide), he, he] · intro i j change A (e (1,i)) (e (2,j)) = _ rw [hAc _ _ (by rw [he, he]; decide), he, he] · intro i j hij exact hAo _ _ (fun hh => hij (congrArg Prod.snd (hei hh))) · intro i j hij exact hAo _ _ (fun hh => hij (congrArg Prod.snd (hei hh))) lemma array_entry_abs_le_diagonal {B : RealArray} {D : ℝ} (hp : ∀ n, Matrix.PosSemidef (fun i j : Fin n => B i j)) (hd : ∀ i, B i i = D) (i j : ℕ) : |B i j| ≤ D := by let n := max i j + 1 let ii : Fin n := ⟨i, by dsimp [n]; omega⟩ let jj : Fin n := ⟨j, by dsimp [n]; omega⟩ have hD : 0 ≤ D := (hp n).diag_nonneg (i := ii) |>.trans (hd i).le have hs := psd_cauchy_schwarz (hp n) (Pi.single ii 1) (Pi.single jj 1) simp [dotProduct, Matrix.mulVec, Pi.single_apply, ite_mul, mul_ite, hd] at hs change B i j ^ 2 ≤ D * D at hs apply abs_le.mpr constructor <;> nlinarith [sq_nonneg (B i j - D), sq_nonneg (B i j + D)] lemma gg_supported_triple_ultrametric {Ω : Type*} [MeasurableSpace Ω] {B : Ω → RealArray} {μ : Measure Ω} [IsProbabilityMeasure μ] (hm : Measurable B) (hsym : ∀ ω i j, B ω i j = B ω j i) (hwe : WeaklyExchangeable B μ) (hGG : HasGhirlandaGuerra B μ) {D : ℝ} (hpsd : ∀ ω n, Matrix.PosSemidef (arrayBlock B n ω)) (hdiag : ∀ ω i, B ω i i = D) {Q : Fin 3 → Fin 3 → ℝ} (hQ : Q ∈ (blockLaw B μ 3).support) : min (Q 0 2) (Q 1 2) ≤ Q 0 1 := by have hb : ∀ ω i j, |B ω i j| ≤ D := fun ω => array_entry_abs_le_diagonal (hpsd ω) (hdiag ω) by_cases ho : Q 0 2 ≤ Q 1 2 · rw [min_eq_left ho] exact gg_supported_triple_ordered hm hsym hwe hGG hb hpsd hdiag hQ ho · have ho' : Q 1 2 ≤ Q 0 2 := le_of_not_ge ho rw [min_eq_right ho'] have hQs := blockLaw_support_swap hm hwe hQ 0 1 have hqsym := real_posSemidef_symm (blockLaw_support_gram hm hpsd hdiag hQ).1 have hh : (Equiv.swap (0 : Fin 3) 1) 2 = 2 := by decide have h := gg_supported_triple_ordered hm hsym hwe hGG hb hpsd hdiag hQs (by simpa only [Equiv.swap_apply_left, Equiv.swap_apply_right, hh] using ho') simpa only [Equiv.swap_apply_left, Equiv.swap_apply_right, hh, hqsym 1 0] using h theorem gg_ultrametric_triple {Ω : Type*} [MeasurableSpace Ω] {B : Ω → RealArray} {μ : Measure Ω} [IsProbabilityMeasure μ] (hm : Measurable B) (hsym : ∀ ω i j, B ω i j = B ω j i) (hwe : WeaklyExchangeable B μ) (hGG : HasGhirlandaGuerra B μ) {D : ℝ} (hpsd : ∀ ω n, Matrix.PosSemidef (arrayBlock B n ω)) (hdiag : ∀ ω i, B ω i i = D) : ∀ᵐ ω ∂μ, min (B ω 0 2) (B ω 1 2) ≤ B ω 0 1 := by have hs : ∀ᵐ A ∂blockLaw B μ 3, A ∈ (blockLaw B μ 3).support := Measure.support_mem_ae have ht : ∀ᵐ A ∂blockLaw B μ 3, min (A 0 2) (A 1 2) ≤ A 0 1 := hs.mono (fun _ h => gg_supported_triple_ultrametric hm hsym hwe hGG hpsd hdiag h) exact (ae_map_iff (measurable_arrayBlock hm 3).aemeasurable (measurableSet_le (by fun_prop) (by fun_prop))).mp ht def IsUltrametricArray (b : RealArray) : Prop := ∀ i j k, min (b i k) (b j k) ≤ b i j lemma ultrametric_survival_rectangle {b : RealArray} (hs : ∀ i j, b i j = b j i) (hu : IsUltrametricArray b) {n : ℕ} (t : Fin n → ℝ) (k : Fin n) (hk : ∀ i, t i ≤ t k) : (∀ i : Fin n, t i ≤ b i n) ↔ (∀ i : Fin n, t i ≤ b i k) ∧ t k ≤ b k n := by constructor · intro h exact ⟨fun i => (le_min (h i) ((hk i).trans (h k))).trans (hu i k n), h k⟩ · rintro ⟨h, hkn⟩ i have hh := hu i n k rw [hs n k] at hh exact (le_min (h i) ((hk i).trans hkn)).trans hh lemma measurableSet_survival_compatible {n : ℕ} (t : Fin n → ℝ) (k : Fin n) : MeasurableSet {b : Fin n → Fin n → ℝ | ∀ i, t i ≤ b i k} := by simp only [Set.ofPred_forall] exact MeasurableSet.iInter (fun i => measurableSet_le measurable_const (by fun_prop)) lemma gg_survival_extension {Ω : Type*} [MeasurableSpace Ω] {B : Ω → RealArray} {μ : Measure Ω} [IsProbabilityMeasure μ] (hGG : HasGhirlandaGuerra B μ) (hs : ∀ᵐ ω ∂μ, ∀ i j, B ω i j = B ω j i) (hu : ∀ᵐ ω ∂μ, IsUltrametricArray (B ω)) {n : ℕ} (hn : 2 ≤ n) {A : Set (Fin n → Fin n → ℝ)} (hA : MeasurableSet A) (t : Fin n → ℝ) (k : Fin n) (hk : ∀ i, t i ≤ t k) : let A' := A ∩ {b : Fin n → Fin n → ℝ | ∀ i, t i ≤ b i k} μ.real ((arrayBlock B n ⁻¹' A) ∩ {ω | ∀ i : Fin n, t i ≤ B ω i n}) = (μ.real (arrayBlock B n ⁻¹' A') * μ.real {ω | t k ≤ B ω 0 1}) / n + (∑ j ∈ Finset.univ.erase k, μ.real ((arrayBlock B n ⁻¹' A') ∩ {ω | t k ≤ B ω k j})) / n := by dsimp only have he := hGG n hn k _ (hA.inter (measurableSet_survival_compatible t k)) (Set.Ici (t k)) measurableSet_Ici simp only [Set.mem_Ici] at he rw [← he] apply measureReal_congr filter_upwards [hs, hu] with ω hs hu apply propext change (arrayBlock B n ω ∈ A ∧ ∀ i : Fin n, t i ≤ B ω i n) ↔ ((arrayBlock B n ω ∈ A ∧ ∀ i : Fin n, t i ≤ B ω i k) ∧ t k ≤ B ω k n) rw [ultrametric_survival_rectangle hs hu t k hk] tauto lemma isCountablySpanning_real_Ici : IsCountablySpanning (Set.range (Set.Ici : ℝ → Set ℝ)) := by refine ⟨fun n => Set.Ici (-(n : ℝ)), fun n => ⟨_, rfl⟩, ?_⟩ apply Set.eq_univ_of_forall intro x obtain ⟨n, hn⟩ := exists_nat_gt (-x) exact Set.mem_iUnion.mpr ⟨n, by change -(n : ℝ) ≤ x; linarith⟩ lemma measure_eq_of_upper_orthants {ι : Type*} [Fintype ι] {μ ν : Measure (ι → ℝ)} [IsFiniteMeasure μ] (h : ∀ t : ι → ℝ, μ {x | ∀ i, t i ≤ x i} = ν {x | ∀ i, t i ≤ x i}) (hU : μ Set.univ = ν Set.univ) : μ = ν := by classical let C : Set (Set (ι → ℝ)) := Set.pi Set.univ '' Set.pi Set.univ (fun _ : ι => Set.range (Set.Ici : ℝ → Set ℝ)) have hgen : (inferInstance : MeasurableSpace (ι → ℝ)) = MeasurableSpace.generateFrom C := by exact (generateFrom_eq_pi (fun _ => by rw [← borel_eq_generateFrom_Ici]; exact BorelSpace.measurable_eq.symm) (fun _ => isCountablySpanning_real_Ici)).symm apply ext_of_generate_finite C hgen (IsPiSystem.pi (fun _ => isPiSystem_Ici)) ?_ hU rintro _ ⟨s, hs, rfl⟩ have hs' : ∀ i, ∃ t : ℝ, Set.Ici t = s i := fun i => hs i (Set.mem_univ i) choose t ht using hs' have he : Set.pi Set.univ s = {x | ∀ i, t i ≤ x i} := by ext x simp only [← ht, Set.mem_pi, Set.mem_univ, Set.mem_Ici, forall_true_left, Set.mem_ofPred_eq] rw [he] exact h t lemma finite_permutation_extending {ι β : Type*} [Fintype ι] (f g : ι → β) (hf : Function.Injective f) (hg : Function.Injective g) : ∃ e : Equiv.Perm β, {b | e b ≠ b}.Finite ∧ ∀ i, e (f i) = g i := by classical let U : Finset β := Finset.univ.image f ∪ Finset.univ.image g let f' : ι → U := fun i => ⟨f i, Finset.mem_union.mpr (Or.inl (Finset.mem_image.mpr ⟨i, Finset.mem_univ _, rfl⟩))⟩ let g' : ι → U := fun i => ⟨g i, Finset.mem_union.mpr (Or.inr (Finset.mem_image.mpr ⟨i, Finset.mem_univ _, rfl⟩))⟩ have hf' : Function.Injective f' := fun i j h => hf (congrArg Subtype.val h) have hg' : Function.Injective g' := fun i j h => hg (congrArg Subtype.val h) obtain ⟨σ, hσ⟩ := Equiv.Perm.exists_extending_pair f' g' hf' hg' let emb : U ↪ β := Function.Embedding.subtype _ refine ⟨σ.viaFintypeEmbedding emb, ?_, ?_⟩ · apply U.finite_toSet.subset intro b hb by_contra h apply hb apply Equiv.Perm.viaFintypeEmbedding_apply_notMem_range rintro ⟨a, rfl⟩ exact h a.2 · intro i change σ.viaFintypeEmbedding emb (emb (f' i)) = emb (g' i) rw [Equiv.Perm.viaFintypeEmbedding_apply_image, hσ] lemma gg_ultrametric {Ω : Type*} [MeasurableSpace Ω] {B : Ω → RealArray} {μ : Measure Ω} [IsProbabilityMeasure μ] (hm : Measurable B) (hsym : ∀ ω i j, B ω i j = B ω j i) (hwe : WeaklyExchangeable B μ) (hGG : HasGhirlandaGuerra B μ) {D : ℝ} (hpsd : ∀ ω n, Matrix.PosSemidef (arrayBlock B n ω)) (hdiag : ∀ ω i, B ω i i = D) : ∀ᵐ ω ∂μ, IsUltrametricArray (B ω) := by have ht := gg_ultrametric_triple hm hsym hwe hGG hpsd hdiag have hall : ∀ i j k, ∀ᵐ ω ∂μ, min (B ω i k) (B ω j k) ≤ B ω i j := by intro i j k by_cases hij : i = j · subst j apply ae_of_all intro ω have hb := array_entry_abs_le_diagonal (hpsd ω) (hdiag ω) i k simpa only [min_self, hdiag] using (le_abs_self (B ω i k)).trans hb by_cases hik : i = k · subst k exact ae_of_all _ (fun ω => by rw [hsym ω j i]; exact min_le_right _ _) by_cases hjk : j = k · subst k exact ae_of_all _ (fun ω => min_le_left _ _) let f : Fin 3 → ℕ := fun a => a.val let g : Fin 3 → ℕ := ![i,j,k] have hg : Function.Injective g := by intro a b hab fin_cases a <;> fin_cases b <;> simp_all [g] obtain ⟨e, he, hef⟩ := finite_permutation_extending f g Fin.val_injective hg have hh := (hwe e he).ae_mem_snd (t := {b : RealArray | min (b 0 2) (b 1 2) ≤ b 0 1}) (measurableSet_le (by fun_prop) (by fun_prop)) ht have he0 : e 0 = i := hef 0 have he1 : e 1 = j := hef 1 have he2 : e 2 = k := hef 2 simpa only [Set.mem_ofPred_eq, permuteArray, he0, he1, he2] using hh exact ae_all_iff.mpr (fun i => ae_all_iff.mpr (fun j => ae_all_iff.mpr (hall i j))) lemma blockLaw_measureReal_eq {Ω Ω' : Type*} [MeasurableSpace Ω] [MeasurableSpace Ω'] {B : Ω → RealArray} {C : Ω' → RealArray} {μ : Measure Ω} {ν : Measure Ω'} (hm : Measurable B) (hm' : Measurable C) {n : ℕ} (h : blockLaw B μ n = blockLaw C ν n) {A : Set (Fin n → Fin n → ℝ)} (hA : MeasurableSet A) : μ.real (arrayBlock B n ⁻¹' A) = ν.real (arrayBlock C n ⁻¹' A) := by rw [← map_measureReal_apply (measurable_arrayBlock hm n) hA, ← map_measureReal_apply (measurable_arrayBlock hm' n) hA] exact congrArg (fun η => η.real A) h lemma gg_survival_measure_eq {Ω Ω' : Type*} [MeasurableSpace Ω] [MeasurableSpace Ω'] {B : Ω → RealArray} {C : Ω' → RealArray} {μ : Measure Ω} {ν : Measure Ω'} [IsProbabilityMeasure μ] [IsProbabilityMeasure ν] (hm : Measurable B) (hm' : Measurable C) (hGG : HasGhirlandaGuerra B μ) (hGG' : HasGhirlandaGuerra C ν) (hs : ∀ᵐ ω ∂μ, ∀ i j, B ω i j = B ω j i) (hs' : ∀ᵐ ω ∂ν, ∀ i j, C ω i j = C ω j i) (hu : ∀ᵐ ω ∂μ, IsUltrametricArray (B ω)) (hu' : ∀ᵐ ω ∂ν, IsUltrametricArray (C ω)) {n : ℕ} (hn : 2 ≤ n) (h : blockLaw B μ n = blockLaw C ν n) {A : Set (Fin n → Fin n → ℝ)} (hA : MeasurableSet A) (t : Fin n → ℝ) : μ ((arrayBlock B n ⁻¹' A) ∩ {ω | ∀ i : Fin n, t i ≤ B ω i n}) = ν ((arrayBlock C n ⁻¹' A) ∩ {ω | ∀ i : Fin n, t i ≤ C ω i n}) := by classical obtain ⟨k, _, hk⟩ := Finset.exists_max_image Finset.univ t ⟨⟨0, by omega⟩, Finset.mem_univ _⟩ have hk' : ∀ i, t i ≤ t k := fun i => hk i (Finset.mem_univ _) apply (measureReal_eq_measureReal_iff).mp rw [gg_survival_extension hGG hs hu hn hA t k hk', gg_survival_extension hGG' hs' hu' hn hA t k hk'] have hcomp := hA.inter (measurableSet_survival_compatible t k) have hp := blockLaw_measureReal_eq hm hm' h (A := {b | t k ≤ b ⟨0, by omega⟩ ⟨1, by omega⟩}) (measurableSet_le measurable_const (by fun_prop)) change μ.real {ω | t k ≤ B ω 0 1} = ν.real {ω | t k ≤ C ω 0 1} at hp rw [blockLaw_measureReal_eq hm hm' h hcomp, hp] congr 2 apply Finset.sum_congr rfl intro j _ exact blockLaw_measureReal_eq hm hm' h (hcomp.inter (measurableSet_le measurable_const (show Measurable (fun b : Fin n → Fin n → ℝ => b k j) by fun_prop))) lemma gg_joint_extension_law {Ω Ω' : Type*} [MeasurableSpace Ω] [MeasurableSpace Ω'] {B : Ω → RealArray} {C : Ω' → RealArray} {μ : Measure Ω} {ν : Measure Ω'} [IsProbabilityMeasure μ] [IsProbabilityMeasure ν] (hm : Measurable B) (hm' : Measurable C) (hGG : HasGhirlandaGuerra B μ) (hGG' : HasGhirlandaGuerra C ν) (hs : ∀ᵐ ω ∂μ, ∀ i j, B ω i j = B ω j i) (hs' : ∀ᵐ ω ∂ν, ∀ i j, C ω i j = C ω j i) (hu : ∀ᵐ ω ∂μ, IsUltrametricArray (B ω)) (hu' : ∀ᵐ ω ∂ν, IsUltrametricArray (C ω)) {n : ℕ} (hn : 2 ≤ n) (h : blockLaw B μ n = blockLaw C ν n) : μ.map (fun ω => (arrayBlock B n ω, fun i : Fin n => B ω i n)) = ν.map (fun ω => (arrayBlock C n ω, fun i : Fin n => C ω i n)) := by have hbm : Measurable (fun ω => (arrayBlock B n ω, fun i : Fin n => B ω i n)) := (measurable_arrayBlock hm n).prodMk (by fun_prop) have hcm : Measurable (fun ω => (arrayBlock C n ω, fun i : Fin n => C ω i n)) := (measurable_arrayBlock hm' n).prodMk (by fun_prop) apply Measure.ext_prod intro A T hA hT let μA := (μ.restrict (arrayBlock B n ⁻¹' A)).map (fun ω => fun i : Fin n => B ω i n) let νA := (ν.restrict (arrayBlock C n ⁻¹' A)).map (fun ω => fun i : Fin n => C ω i n) have hr : μA = νA := by apply measure_eq_of_upper_orthants · intro t have ht : MeasurableSet {x : Fin n → ℝ | ∀ i, t i ≤ x i} := by simp only [Set.ofPred_forall] exact MeasurableSet.iInter (fun i => measurableSet_le measurable_const (by fun_prop)) dsimp [μA, νA] rw [Measure.map_apply (by fun_prop) ht, Measure.map_apply (by fun_prop) ht, Measure.restrict_apply ((by fun_prop : Measurable (fun ω => fun i : Fin n => B ω i n)) ht), Measure.restrict_apply ((by fun_prop : Measurable (fun ω => fun i : Fin n => C ω i n)) ht)] rw [Set.inter_comm, Set.inter_comm _ (arrayBlock C n ⁻¹' A)] exact gg_survival_measure_eq hm hm' hGG hGG' hs hs' hu hu' hn h hA t · dsimp [μA, νA] simp only [Measure.map_apply (by fun_prop : Measurable (fun ω => fun i : Fin n => B ω i n)) MeasurableSet.univ, Measure.map_apply (by fun_prop : Measurable (fun ω => fun i : Fin n => C ω i n)) MeasurableSet.univ, Set.preimage_univ, Measure.restrict_apply MeasurableSet.univ, Set.univ_inter] exact (measureReal_eq_measureReal_iff).mp (blockLaw_measureReal_eq hm hm' h hA) have he := congrArg (fun η => η T) hr dsimp [μA, νA] at he rw [Measure.map_apply (by fun_prop) hT, Measure.map_apply (by fun_prop) hT, Measure.restrict_apply ((by fun_prop : Measurable (fun ω => fun i : Fin n => B ω i n)) hT), Measure.restrict_apply ((by fun_prop : Measurable (fun ω => fun i : Fin n => C ω i n)) hT)] at he rw [Measure.map_apply hbm (hA.prod hT), Measure.map_apply hcm (hA.prod hT)] change μ ((arrayBlock B n ⁻¹' A) ∩ ((fun ω => fun i : Fin n => B ω i n) ⁻¹' T)) = ν ((arrayBlock C n ⁻¹' A) ∩ ((fun ω => fun i : Fin n => C ω i n) ⁻¹' T)) simpa only [Set.inter_comm] using he def augmentArrayBlock (D : ℝ) (n : ℕ) (p : (Fin n → Fin n → ℝ) × (Fin n → ℝ)) : Fin (n+1) → Fin (n+1) → ℝ := fun i j => if hi : i.val < n then if hj : j.val < n then p.1 ⟨i.val, hi⟩ ⟨j.val, hj⟩ else p.2 ⟨i.val, hi⟩ else if hj : j.val < n then p.2 ⟨j.val, hj⟩ else D lemma measurable_augmentArrayBlock (D : ℝ) (n : ℕ) : Measurable (augmentArrayBlock D n) := by apply Measurable.of_eval intro i apply Measurable.of_eval intro j unfold augmentArrayBlock split_ifs <;> fun_prop lemma augmentArrayBlock_eq {b : RealArray} (hs : ∀ i j, b i j = b j i) {D : ℝ} (hd : ∀ i, b i i = D) (n : ℕ) : augmentArrayBlock D n ((fun i j : Fin n => b i j), fun i : Fin n => b i n) = fun i j : Fin (n+1) => b i j := by funext i j unfold augmentArrayBlock split_ifs with hi hj hj · rfl · have hj' : j.val = n := by omega simp only [hj'] · have hi' : i.val = n := by omega simp only [hi', hs n j] · have hi' : i.val = n := by omega have hj' : j.val = n := by omega simp only [hi', hj', hd] lemma gg_next_blockLaw_eq {Ω Ω' : Type*} [MeasurableSpace Ω] [MeasurableSpace Ω'] {B : Ω → RealArray} {C : Ω' → RealArray} {μ : Measure Ω} {ν : Measure Ω'} [IsProbabilityMeasure μ] [IsProbabilityMeasure ν] (hm : Measurable B) (hm' : Measurable C) (hGG : HasGhirlandaGuerra B μ) (hGG' : HasGhirlandaGuerra C ν) (hs : ∀ᵐ ω ∂μ, ∀ i j, B ω i j = B ω j i) (hs' : ∀ᵐ ω ∂ν, ∀ i j, C ω i j = C ω j i) (hu : ∀ᵐ ω ∂μ, IsUltrametricArray (B ω)) (hu' : ∀ᵐ ω ∂ν, IsUltrametricArray (C ω)) {D : ℝ} (hd : ∀ᵐ ω ∂μ, ∀ i, B ω i i = D) (hd' : ∀ᵐ ω ∂ν, ∀ i, C ω i i = D) {n : ℕ} (hn : 2 ≤ n) (h : blockLaw B μ n = blockLaw C ν n) : blockLaw B μ (n+1) = blockLaw C ν (n+1) := by have he := congrArg (Measure.map (augmentArrayBlock D n)) (gg_joint_extension_law hm hm' hGG hGG' hs hs' hu hu' hn h) rw [Measure.map_map (measurable_augmentArrayBlock D n) (by exact (measurable_arrayBlock hm n).prodMk (by fun_prop)), Measure.map_map (measurable_augmentArrayBlock D n) (by exact (measurable_arrayBlock hm' n).prodMk (by fun_prop))] at he have hB : (fun ω => augmentArrayBlock D n (arrayBlock B n ω, fun i : Fin n => B ω i n)) =ᵐ[μ] arrayBlock B (n+1) := by filter_upwards [hs, hd] with ω hs hd exact augmentArrayBlock_eq hs hd n have hC : (fun ω => augmentArrayBlock D n (arrayBlock C n ω, fun i : Fin n => C ω i n)) =ᵐ[ν] arrayBlock C (n+1) := by filter_upwards [hs', hd'] with ω hs hd exact augmentArrayBlock_eq hs hd n exact (Measure.map_congr hB).symm.trans (he.trans (Measure.map_congr hC)) lemma blockLaw_two_eq_pair_map {Ω : Type*} [MeasurableSpace Ω] {B : Ω → RealArray} {μ : Measure Ω} (hm : Measurable B) {D : ℝ} (hs : ∀ᵐ ω ∂μ, ∀ i j, B ω i j = B ω j i) (hd : ∀ᵐ ω ∂μ, ∀ i, B ω i i = D) : blockLaw B μ 2 = (μ.map (fun ω => B ω 0 1)).map (fun r => fun i j : Fin 2 => if i = j then D else r) := by rw [Measure.map_map (by apply Measurable.of_eval intro i apply Measurable.of_eval intro j split_ifs <;> fun_prop) (by fun_prop)] apply Measure.map_congr filter_upwards [hs, hd] with ω hs hd funext i j fin_cases i <;> fin_cases j <;> simp [arrayBlock, hs, hd] lemma blockLaw_restrict {Ω : Type*} [MeasurableSpace Ω] {B : Ω → RealArray} {μ : Measure Ω} (hm : Measurable B) {m n : ℕ} (hmn : m ≤ n) : (blockLaw B μ n).map (fun b => fun i j : Fin m => b (Fin.castLE hmn i) (Fin.castLE hmn j)) = blockLaw B μ m := by unfold blockLaw rw [Measure.map_map (by fun_prop) (measurable_arrayBlock hm n)] rfl theorem gg_blockLaw_unique {Ω Ω' : Type*} [MeasurableSpace Ω] [MeasurableSpace Ω'] {B : Ω → RealArray} {C : Ω' → RealArray} {μ : Measure Ω} {ν : Measure Ω'} [IsProbabilityMeasure μ] [IsProbabilityMeasure ν] (hm : Measurable B) (hm' : Measurable C) (hGG : HasGhirlandaGuerra B μ) (hGG' : HasGhirlandaGuerra C ν) (hs : ∀ᵐ ω ∂μ, ∀ i j, B ω i j = B ω j i) (hs' : ∀ᵐ ω ∂ν, ∀ i j, C ω i j = C ω j i) (hu : ∀ᵐ ω ∂μ, IsUltrametricArray (B ω)) (hu' : ∀ᵐ ω ∂ν, IsUltrametricArray (C ω)) {D : ℝ} (hd : ∀ᵐ ω ∂μ, ∀ i, B ω i i = D) (hd' : ∀ᵐ ω ∂ν, ∀ i, C ω i i = D) (hp : μ.map (fun ω => B ω 0 1) = ν.map (fun ω => C ω 0 1)) : ∀ n, blockLaw B μ n = blockLaw C ν n := by have h2 : blockLaw B μ 2 = blockLaw C ν 2 := by rw [blockLaw_two_eq_pair_map hm hs hd, blockLaw_two_eq_pair_map hm' hs' hd', hp] have hind : ∀ n, 2 ≤ n → blockLaw B μ n = blockLaw C ν n := by intro n hn induction n, hn using Nat.le_induction with | base => exact h2 | succ n hn ih => exact gg_next_blockLaw_eq hm hm' hGG hGG' hs hs' hu hu' hd hd' hn ih intro n by_cases hn : 2 ≤ n · exact hind n hn · have hn' : n ≤ 2 := by omega rw [← blockLaw_restrict hm hn', ← blockLaw_restrict hm' hn', h2] lemma HasEntryGhirlandaGuerra.map {Ω E F : Type*} [MeasurableSpace Ω] [MeasurableSpace E] [MeasurableSpace F] {B : Ω → ℕ → ℕ → E} {μ : Measure Ω} (h : HasEntryGhirlandaGuerra B μ) {f : E → F} (hf : Measurable f) : HasEntryGhirlandaGuerra (fun ω i j => f (B ω i j)) μ := by intro n hn i A hA t ht exact h n hn i ((fun b j k => f (b j k)) ⁻¹' A) (hA.preimage (by fun_prop)) (f ⁻¹' t) (ht.preimage hf) lemma HasEntryGhirlandaGuerra.real_map {Ω E : Type*} [MeasurableSpace Ω] [MeasurableSpace E] {B : Ω → ℕ → ℕ → E} {μ : Measure Ω} (h : HasEntryGhirlandaGuerra B μ) {f : E → ℝ} (hf : Measurable f) : HasGhirlandaGuerra (fun ω i j => f (B ω i j)) μ := h.map hf lemma gg_two_links_positive {Ω E : Type*} [MeasurableSpace Ω] [MeasurableSpace E] {B : Ω → ℕ → ℕ → E} {μ : Measure Ω} [IsProbabilityMeasure μ] (hGG : HasEntryGhirlandaGuerra B μ) {A C : Set E} (hA : MeasurableSet A) (hC : MeasurableSet C) (hpA : 0 < μ.real {ω | B ω 0 1 ∈ A}) (hpC : 0 < μ.real {ω | B ω 0 1 ∈ C}) : 0 < μ.real ({ω | B ω 0 1 ∈ A} ∩ {ω | B ω 0 2 ∈ C}) := by have h := hGG 2 (by omega) 0 {b : Fin 2 → Fin 2 → E | b 0 1 ∈ A} (hA.preimage (by fun_prop)) C hC change μ.real ({ω | B ω 0 1 ∈ A} ∩ {ω | B ω 0 2 ∈ C}) = _ at h rw [h] exact add_pos_of_pos_of_nonneg (div_pos (mul_pos hpA hpC) (by norm_num)) (div_nonneg (Finset.sum_nonneg (fun _ _ => measureReal_nonneg)) (by norm_num)) lemma ultrametric_no_crossing {r t : RealArray} (hr : IsUltrametricArray r) (ht : IsUltrametricArray t) (hs : IsUltrametricArray (fun i j => r i j + t i j)) (hrsym : ∀ i j, r i j = r j i) (htsym : ∀ i j, t i j = t j i) : ¬ (r 0 1 < r 0 2 ∧ t 0 2 < t 0 1) := by rintro ⟨hR, hT⟩ have hr23 : r 1 2 = r 0 1 := by have h1 := hr 0 1 2 have h2 := hr 1 2 0 rw [hrsym 1 0, hrsym 2 0, min_eq_left hR.le] at h2 have : r 1 2 ≤ r 0 1 := by by_contra! hn exact (lt_min hR hn).not_ge h1 exact le_antisymm this h2 have ht23 : t 1 2 = t 0 2 := by have h1 := ht 0 2 1 have h2 := ht 1 2 0 rw [htsym 2 1] at h1 rw [htsym 1 0, htsym 2 0, min_eq_right hT.le] at h2 have : t 1 2 ≤ t 0 2 := by by_contra! hn exact (lt_min hT hn).not_ge h1 exact le_antisymm this h2 have hh := hs 1 2 0 simp only [hrsym 1 0, hrsym 2 0, htsym 1 0, htsym 2 0, hr23, ht23] at hh exact (lt_min (by linarith) (by linarith)).not_ge hh theorem jointGG_support_ordered {Ω : Type*} [MeasurableSpace Ω] {R T : Ω → RealArray} {μ : Measure Ω} [IsProbabilityMeasure μ] (hR : Measurable R) (hT : Measurable T) (hGG : HasEntryGhirlandaGuerra (fun ω i j => (R ω i j, T ω i j)) μ) (huR : ∀ᵐ ω ∂μ, IsUltrametricArray (R ω)) (huT : ∀ᵐ ω ∂μ, IsUltrametricArray (T ω)) (huS : ∀ᵐ ω ∂μ, IsUltrametricArray (fun i j => R ω i j + T ω i j)) (hsR : ∀ᵐ ω ∂μ, ∀ i j, R ω i j = R ω j i) (hsT : ∀ᵐ ω ∂μ, ∀ i j, T ω i j = T ω j i) : let ν := μ.map (fun ω => (R ω 0 1, T ω 0 1)) ∀ x ∈ ν.support, ∀ y ∈ ν.support, x.1 < y.1 → x.2 ≤ y.2 := by dsimp only intro x hx y hy hxy by_contra! hc let a := (x.1+y.1)/2 let b := (x.2+y.2)/2 let A : Set (ℝ × ℝ) := {z | z.1 < a ∧ b < z.2} let C : Set (ℝ × ℝ) := {z | a < z.1 ∧ z.2 < b} have hAo : IsOpen A := (isOpen_lt continuous_fst continuous_const).inter (isOpen_lt continuous_const continuous_snd) have hCo : IsOpen C := (isOpen_lt continuous_const continuous_fst).inter (isOpen_lt continuous_snd continuous_const) have hm : Measurable (fun ω => (R ω 0 1, T ω 0 1)) := by fun_prop have hyp : 0 < (μ.map (fun ω => (R ω 0 1,T ω 0 1))) A := (Measure.mem_support_iff_forall x).mp hx A (hAo.mem_nhds (by dsimp [A,a,b]; constructor <;> linarith)) have hxp : 0 < (μ.map (fun ω => (R ω 0 1,T ω 0 1))) C := (Measure.mem_support_iff_forall y).mp hy C (hCo.mem_nhds (by dsimp [C,a,b]; constructor <;> linarith)) rw [Measure.map_apply hm hAo.measurableSet] at hyp rw [Measure.map_apply hm hCo.measurableSet] at hxp have hp := gg_two_links_positive hGG hAo.measurableSet hCo.measurableSet (ENNReal.toReal_pos hyp.ne' (measure_ne_top _ _)) (ENNReal.toReal_pos hxp.ne' (measure_ne_top _ _)) have hz : μ ({ω | (R ω 0 1,T ω 0 1) ∈ A} ∩ {ω | (R ω 0 2,T ω 0 2) ∈ C}) = 0 := by apply measure_eq_zero_iff_ae_notMem.mpr filter_upwards [huR,huT,huS,hsR,hsT] with ω hr ht hs hsr hst rintro ⟨ha,hc⟩ exact ultrametric_no_crossing hr ht hs hsr hst ⟨ha.1.trans hc.1, hc.2.trans ha.2⟩ rw [measureReal_def, hz, ENNReal.toReal_zero] at hp exact lt_irrefl 0 hp end IsingPerceptron end end OAI