| import Mathlib | |
| import OAI.Probability.ParisiFinite.GenericDegrees | |
| namespace OAI | |
| /-! Low Block. -/ | |
| noncomputable section | |
| open scoped BigOperators ComplexConjugate InnerProductSpace Topology ComplexOrder | |
| open Filter | |
| open scoped BigOperators | |
| open scoped Matrix Matrix.Norms.L2Operator ComplexConjugate | |
| open scoped InnerProductSpace ComplexConjugate | |
| open Filter Topology | |
| open Filter Set Topology | |
| open scoped InnerProductSpace ComplexConjugate Topology | |
| open scoped InnerProductSpace | |
| open scoped BigOperators Topology InnerProductSpace | |
| open scoped BigOperators InnerProductSpace | |
| open scoped BigOperators Matrix Topology ComplexConjugate | |
| open MeasureTheory ProbabilityTheory Filter | |
| open scoped BigOperators Topology | |
| open scoped BigOperators Matrix Topology | |
| open scoped BigOperators Matrix Topology Matrix.Norms.Operator | |
| open scoped Topology | |
| open Filter Asymptotics | |
| open scoped InnerProductSpace Topology | |
| open scoped InnerProductSpace BigOperators | |
| open scoped InnerProductSpace Topology BigOperators | |
| open scoped Topology BigOperators | |
| open scoped Matrix Matrix.Norms.L2Operator InnerProductSpace | |
| open scoped Matrix Matrix.Norms.L2Operator InnerProductSpace BigOperators | |
| open Filter ContinuousLinearMap | |
| open ContinuousLinearMap | |
| open scoped InnerProductSpace BigOperators Topology | |
| open ContinuousLinearMap InnerProductSpace | |
| open ContinuousLinearMap Filter | |
| open Filter MeasureTheory | |
| open scoped Topology ENNReal | |
| open MeasureTheory ProbabilityTheory | |
| open scoped BigOperators Topology RealInnerProductSpace | |
| open scoped BigOperators TensorProduct | |
| open scoped Topology InnerProductSpace | |
| open MeasureTheory Filter | |
| open MeasureTheory ProbabilityTheory Complex | |
| open scoped BigOperators Topology InnerProductSpace ComplexConjugate | |
| open scoped BigOperators Topology NNReal | |
| open scoped BigOperators NNReal Topology | |
| open scoped BigOperators NNReal | |
| open scoped NNReal Topology | |
| open scoped NNReal Topology BigOperators | |
| open MeasureTheory ProbabilityTheory Filter TopologicalSpace | |
| open scoped BigOperators Topology NNReal ENNReal | |
| open MeasureTheory ProbabilityTheory Filter TopologicalSpace | |
| open scoped BigOperators Topology NNReal ENNReal | |
| namespace SKCavity | |
| open SKQAOA SKGaussian ParisiInterpolation | |
| def lowBlock (r : ℕ) (a : ℝ) : Set (OverlapBlock r) := | |
| {T | ∀ i j, i≠j → (T i j:ℝ)≤a} | |
| def lowEvent (r : ℕ) (a : ℝ) : Set OverlapArray := (blockOfArray r) ⁻¹' lowBlock r a | |
| def lowBad (r : ℕ) (i : Fin r) (a : ℝ) : Set OverlapArray := | |
| {R | R∈lowEvent r a ∧ a<(R i r:ℝ)} | |
| lemma measurableSet_lowBlock (r : ℕ) (a : ℝ) : MeasurableSet (lowBlock r a) := by | |
| unfold lowBlock | |
| simp only [Set.ofPred_forall] | |
| exact MeasurableSet.iInter fun i => MeasurableSet.iInter fun j => | |
| MeasurableSet.iInter fun _ => measurableSet_le (by fun_prop) measurable_const | |
| lemma lowEvent_one (a : ℝ) : lowEvent 1 a=Set.univ := by | |
| ext R | |
| simp [lowEvent, lowBlock] | |
| lemma lowBad_GG {μ : ProbabilityMeasure OverlapArray} (h : GGIdentities μ) | |
| (r : ℕ) (i : Fin r) (a : ℝ) : | |
| (r:ℝ)*(μ : Measure OverlapArray).real (lowBad r i a)= | |
| (μ : Measure OverlapArray).real (lowEvent r a)*(entryLaw μ 0 1).real {x | a<(x:ℝ)} := by | |
| have he := GG_event_identity h r i (lowBlock r a) {x | a<(x:ℝ)} | |
| (measurableSet_lowBlock r a) (measurableSet_lt measurable_const (by fun_prop)) | |
| have hz (l : Fin r) (hl : l∈Finset.univ.erase i) : | |
| {R | blockOfArray r R∈lowBlock r a ∧ a<(R i l:ℝ)}=(∅ : Set OverlapArray) := by | |
| apply Set.eq_empty_iff_forall_notMem.mpr | |
| intro R hR | |
| exact (not_lt_of_ge (hR.1 i l (Finset.ne_of_mem_erase hl).symm)) hR.2 | |
| have hs : (∑ l∈Finset.univ.erase i, (μ : Measure OverlapArray).real | |
| {R | blockOfArray r R∈lowBlock r a ∧ a<(R i l:ℝ)})=0 := by | |
| apply Finset.sum_eq_zero | |
| intro l hl | |
| rw [hz l hl,measureReal_empty] | |
| simp only [Set.mem_ofPred_eq] at he | |
| rw [hs,add_zero] at he | |
| exact he | |
| lemma lowEvent_step_cover (r : ℕ) (a : ℝ) : | |
| lowEvent r a ⊆ (lowEvent (r+1) a ∪ ⋃ i, lowBad r i a) ∪ GramArraysᶜ := by | |
| classical | |
| intro R hR | |
| by_cases hG : R∈GramArrays | |
| · by_cases hb : ∃ i, R∈lowBad r i a | |
| · exact Or.inl (Or.inr (Set.mem_iUnion.mpr hb)) | |
| · have hn (i : Fin r) : (R i r:ℝ)≤a := by | |
| by_contra hh | |
| exact hb ⟨i,hR,lt_of_not_ge hh⟩ | |
| apply Or.inl ∘ Or.inl | |
| intro i j hij | |
| induction i using Fin.lastCases with | |
| | last => | |
| induction j using Fin.lastCases with | |
| | last => exact False.elim (hij rfl) | |
| | cast j => | |
| change (R r j:ℝ)≤a | |
| rw [hG.1 r j] | |
| exact hn j | |
| | cast i => | |
| induction j using Fin.lastCases with | |
| | last => exact hn i | |
| | cast j => exact hR i j (fun h => hij (congrArg Fin.castSucc h)) | |
| · exact Or.inr hG | |
| lemma lowEvent_step_bound {μ : ProbabilityMeasure OverlapArray} (hG : (μ : Measure OverlapArray) GramArrays=1) | |
| (h : GGIdentities μ) {r : ℕ} (hr : 0<r) (a : ℝ) : | |
| (μ : Measure OverlapArray).real (lowEvent r a)*(entryLaw μ 0 1).real {x | (x:ℝ)≤a} ≤ | |
| (μ : Measure OverlapArray).real (lowEvent (r+1) a) := by | |
| let ν : Measure OverlapArray := μ | |
| have hc : ν.real GramArraysᶜ=0 := by | |
| rw [measureReal_compl isClosed_GramArrays.measurableSet] | |
| simp [ν, measureReal_def, hG] | |
| have hh := measureReal_mono (μ:=ν) (lowEvent_step_cover r a) | |
| have hu := measureReal_union_le (μ:=ν) (lowEvent (r+1) a ∪ ⋃ i,lowBad r i a) GramArraysᶜ | |
| have hu' := measureReal_union_le (μ:=ν) (lowEvent (r+1) a) (⋃ i,lowBad r i a) | |
| have hs := measureReal_iUnion_fintype_le (μ:=ν) (fun i => lowBad r i a) | |
| have he : (∑ i : Fin r,ν.real (lowBad r i a))= | |
| ν.real (lowEvent r a)*(entryLaw μ 0 1).real {x | a<(x:ℝ)} := by | |
| apply mul_left_cancel₀ (Nat.cast_ne_zero.mpr hr.ne' : (r:ℝ)≠0) | |
| rw [Finset.mul_sum] | |
| simp_rw [show ∀ i : Fin r, (r:ℝ)*ν.real (lowBad r i a)= | |
| ν.real (lowEvent r a)*(entryLaw μ 0 1).real {x | a<(x:ℝ)} from fun i => lowBad_GG h r i a] | |
| simp only [Finset.sum_const, Finset.card_univ, Fintype.card_fin, nsmul_eq_mul] | |
| have hp : (entryLaw μ 0 1).real {x : OverlapEntry | (x:ℝ)≤a}+ | |
| (entryLaw μ 0 1).real {x : OverlapEntry | a<(x:ℝ)}=1 := by | |
| let := entryLaw_probability μ 0 1 | |
| have ht := measureReal_add_measureReal_compl (μ:=entryLaw μ 0 1) (s:={x : OverlapEntry | (x:ℝ)≤a}) | |
| (measurableSet_le (by fun_prop : Measurable (fun x : OverlapEntry => (x:ℝ))) measurable_const) | |
| simpa only [Set.compl_ofPred, not_le, measureReal_def, measure_univ, ENNReal.toReal_one] using ht | |
| rw [he] at hs | |
| change ν.real (lowEvent r a)*(entryLaw μ 0 1).real {x | (x:ℝ)≤a} ≤ν.real (lowEvent (r+1) a) | |
| have hm := congrArg (fun x : ℝ => ν.real (lowEvent r a)*x) hp | |
| simp only [mul_add,mul_one] at hm | |
| linarith | |
| lemma lowEvent_positive {μ : ProbabilityMeasure OverlapArray} (hG : (μ : Measure OverlapArray) GramArrays=1) | |
| (h : GGIdentities μ) (a : ℝ) (ha : 0<(entryLaw μ 0 1).real {x | (x:ℝ)≤a}) : | |
| ∀ r : ℕ, 0<(μ : Measure OverlapArray).real (lowEvent (r+1) a) := by | |
| intro r | |
| induction r with | |
| | zero => rw [Nat.zero_add,lowEvent_one]; simp | |
| | succ r ih => exact lt_of_lt_of_le (mul_pos ih ha) (lowEvent_step_bound hG h (Nat.succ_pos r) a) | |
| end SKCavity | |
| open MeasureTheory ProbabilityTheory Filter TopologicalSpace | |
| open scoped BigOperators Topology NNReal ENNReal | |
| namespace SKCavity | |
| open SKQAOA SKGaussian ParisiInterpolation | |
| lemma gram_clique_bound {R : OverlapArray} (hG : R∈GramArrays) {r : ℕ} {a : ℝ} | |
| (hl : R∈lowEvent (r+1) a) : 0≤1+(r:ℝ)*a := by | |
| have hr (i : Fin (r+1)) : (∑ j : Fin (r+1), (R i j:ℝ)) ≤ 1+(r:ℝ)*a := by | |
| calc | |
| _ = (∑ j∈Finset.univ.erase i, (R i j:ℝ))+(R i i:ℝ) := | |
| (Finset.sum_erase_add _ _ (Finset.mem_univ i)).symm | |
| _ ≤ (∑ j∈Finset.univ.erase i,a)+1 := by | |
| apply add_le_add | |
| · exact Finset.sum_le_sum (fun j hj => hl i j (Finset.ne_of_mem_erase hj).symm) | |
| · exact le_of_eq (hG.2.1 i) | |
| _ = _ := by simp; ring | |
| have hh := Finset.sum_le_sum (fun i (_ : i∈(Finset.univ : Finset (Fin (r+1)))) => hr i) | |
| simp only [Finset.sum_const, Finset.card_univ, Fintype.card_fin, nsmul_eq_mul] at hh | |
| have hp := hG.2.2 (r+1) (fun _ => 1) | |
| simp only [one_mul] at hp | |
| have hh' : 0≤((r+1:ℕ):ℝ)*(1+(r:ℝ)*a) := hp.trans hh | |
| have hp' : (0:ℝ)<(r+1:ℕ) := by positivity | |
| nlinarith | |
| lemma exists_negative_clique_impossible {a : ℝ} (ha : a<0) : | |
| ∃ r : ℕ, lowEvent (r+1) a ⊆ GramArraysᶜ := by | |
| obtain ⟨r,hr⟩ := exists_nat_gt ((-1:ℝ)/a) | |
| refine ⟨r,fun R hl hG => ?_⟩ | |
| have hg := gram_clique_bound hG hl | |
| have hh := (div_lt_iff_of_neg ha).mp hr | |
| linarith | |
| theorem GG_negative_threshold_zero {μ : ProbabilityMeasure OverlapArray} | |
| (hG : (μ : Measure OverlapArray) GramArrays=1) (h : GGIdentities μ) {a : ℝ} (ha : a<0) : | |
| (entryLaw μ 0 1).real {x | (x:ℝ)≤a}=0 := by | |
| by_contra hh | |
| have hp : 0<(entryLaw μ 0 1).real {x | (x:ℝ)≤a} := lt_of_le_of_ne measureReal_nonneg (Ne.symm hh) | |
| obtain ⟨r,hr⟩ := exists_negative_clique_impossible ha | |
| have hc : (μ : Measure OverlapArray).real GramArraysᶜ=0 := by | |
| rw [measureReal_compl isClosed_GramArrays.measurableSet] | |
| simp [measureReal_def,hG] | |
| have he := measureReal_mono (μ:=(μ:Measure OverlapArray)) hr | |
| rw [hc] at he | |
| exact (not_lt_of_ge he) (lowEvent_positive hG h a hp r) | |
| lemma GG_negative_overlap_zero {μ : ProbabilityMeasure OverlapArray} | |
| (hG : (μ : Measure OverlapArray) GramArrays=1) (h : GGIdentities μ) : | |
| (entryLaw μ 0 1) {x | (x:ℝ)<0}=0 := by | |
| let Q := {q : ℚ // (q:ℝ)<0} | |
| have hz (q : Q) : (entryLaw μ 0 1) {x | (x:ℝ)≤(q.1:ℝ)}=0 := | |
| (measureReal_eq_zero_iff).mp (GG_negative_threshold_zero hG h q.2) | |
| have hc : {x : OverlapEntry | (x:ℝ)<0} ⊆ ⋃ q : Q, {x | (x:ℝ)≤(q.1:ℝ)} := by | |
| intro x hx | |
| obtain ⟨q,hxq,hq⟩ := exists_rat_btwn (show (x:ℝ)<0 from hx) | |
| exact Set.mem_iUnion.mpr ⟨⟨q,hq⟩,le_of_lt hxq⟩ | |
| exact measure_mono_null hc (measure_iUnion_null hz) | |
| lemma GG_nonnegative_overlap {μ : ProbabilityMeasure OverlapArray} | |
| (hG : (μ : Measure OverlapArray) GramArrays=1) (h : GGIdentities μ) : | |
| ∀ᵐ R ∂(μ : Measure OverlapArray), 0≤(R 0 1:ℝ) := by | |
| have he := GG_negative_overlap_zero hG h | |
| rw [entryLaw, Measure.map_apply (by fun_prop) (measurableSet_lt (by fun_prop) measurable_const)] at he | |
| apply ae_iff.mpr | |
| simpa only [Set.preimage_ofPred_eq, not_le] using he | |
| end SKCavity | |
| open MeasureTheory ProbabilityTheory Filter TopologicalSpace | |
| open scoped BigOperators Topology NNReal ENNReal | |
| namespace SKCavity | |
| theorem urn_growth_contradiction {r : ℕ} (hr : 0<r) {z : ℝ} (hz : 0<z) | |
| (f : ℕ → ℝ) (hf : ∀ m, 0≤f m) (h₀ : 0<f 0) | |
| (hrec : ∀ m, ((r+m+1:ℕ):ℝ)*f (m+1)=(((r+m:ℕ):ℝ)+z)*f m) | |
| (hub : ∀ m, ((m+1:ℕ):ℝ)*f m≤1) : False := by | |
| let u : ℕ → ℝ := fun m => ((r+m:ℕ):ℝ)*f m | |
| have hu0 : 0<u 0 := by dsimp [u]; positivity | |
| have hus (m : ℕ) : u (m+1)=u m+z*f m := by | |
| dsimp [u] | |
| have he := hrec m | |
| push_cast at he ⊢ | |
| nlinarith only [he] | |
| have hum : Monotone u := monotone_nat_of_le_succ fun m => by rw [hus]; nlinarith [hf m] | |
| have hub' (m : ℕ) : u m≤r := by | |
| have hh := hub m | |
| have hr' : (1:ℝ)≤r := by exact_mod_cast hr | |
| dsimp [u] | |
| push_cast at hh ⊢ | |
| have hm : (r:ℝ)*m*f m≥(m:ℝ)*f m := by | |
| simpa only [one_mul] using mul_le_mul_of_nonneg_right | |
| (mul_le_mul_of_nonneg_right hr' (Nat.cast_nonneg m)) (hf m) | |
| have hb := mul_le_mul_of_nonneg_left hh (Nat.cast_nonneg r) | |
| nlinarith only [hm,hb] | |
| have hs (k : ℕ) : u k=u 0+z*∑ m∈Finset.range k,f m := by | |
| induction k with | |
| | zero => simp | |
| | succ k ih => rw [hus,ih,Finset.sum_range_succ]; ring | |
| have hsum : Summable f := summable_of_sum_range_le hf (c:=(r:ℝ)/z) fun k => by | |
| apply (le_div_iff₀ hz).mpr | |
| have hh := hub' k | |
| rw [hs] at hh | |
| nlinarith | |
| have hl (m : ℕ) : (1:ℝ)/((m+r:ℕ):ℝ)≤f m/u 0 := by | |
| have hu := hum (Nat.zero_le m) | |
| have hp : (0:ℝ)<((m+r:ℕ):ℝ) := by positivity | |
| apply (div_le_div_iff₀ hp hu0).mpr | |
| change u 0≤((r+m:ℕ):ℝ)*f m at hu | |
| simpa only [one_mul,mul_one,Nat.add_comm,mul_comm] using hu | |
| have htail : Summable (fun m : ℕ => (1:ℝ)/((m+r:ℕ):ℝ)) := | |
| Summable.of_nonneg_of_le (fun _ => by positivity) hl (hsum.div_const (u 0)) | |
| exact Real.not_summable_one_div_natCast ((summable_nat_add_iff r).mp htail) | |
| end SKCavity | |
| open MeasureTheory ProbabilityTheory Filter TopologicalSpace | |
| open scoped BigOperators Topology NNReal ENNReal | |
| namespace SKCavity | |
| open SKQAOA SKGaussian ParisiInterpolation | |
| def initialBlock {s t : ℕ} (h : s≤t) (T : OverlapBlock t) : OverlapBlock s := | |
| fun i j => T (Fin.castLE h i) (Fin.castLE h j) | |
| lemma continuous_initialBlock {s t : ℕ} (h : s≤t) : Continuous (initialBlock h) := by | |
| unfold initialBlock | |
| fun_prop | |
| def rowSurvival (r m : ℕ) (D : Set (OverlapBlock (r+1))) (q : ℝ) : Set OverlapArray := | |
| {R | blockOfArray (r+1) R∈D ∧ ∀ j : ℕ, j<r+m+1 → j≠r → (R r j:ℝ)≤q} | |
| def survivalBlock (r m : ℕ) (D : Set (OverlapBlock (r+1))) (q : ℝ) : Set (OverlapBlock (r+m+1)) := | |
| {T | initialBlock (show r+1≤r+m+1 by omega) T∈D ∧ | |
| ∀ j : Fin (r+m+1), (j:ℕ)≠r → (T ⟨r,by omega⟩ j:ℝ)≤q} | |
| lemma rowSurvival_eq_preimage (r m : ℕ) (D : Set (OverlapBlock (r+1))) (q : ℝ) : | |
| rowSurvival r m D q=(blockOfArray (r+m+1)) ⁻¹' survivalBlock r m D q := by | |
| ext R | |
| change (_ ∧ _) ↔ (_ ∧ _) | |
| constructor <;> rintro ⟨h₁,h₂⟩ | |
| · exact ⟨h₁,fun j hj => h₂ j j.isLt hj⟩ | |
| · exact ⟨h₁,fun j hj hne => h₂ ⟨j,hj⟩ hne⟩ | |
| lemma measurableSet_survivalBlock (r m : ℕ) {D : Set (OverlapBlock (r+1))} | |
| (hD : MeasurableSet D) (q : ℝ) : MeasurableSet (survivalBlock r m D q) := by | |
| change MeasurableSet ((initialBlock (show r+1≤r+m+1 by omega)) ⁻¹' D ∩ | |
| {T | ∀ j : Fin (r+m+1), (j:ℕ)≠r → (T ⟨r,by omega⟩ j:ℝ)≤q}) | |
| apply MeasurableSet.inter (hD.preimage (continuous_initialBlock _).measurable) | |
| simp only [Set.ofPred_forall] | |
| exact MeasurableSet.iInter fun j => MeasurableSet.iInter fun _ => measurableSet_le (by fun_prop) measurable_const | |
| lemma measurableSet_rowSurvival (r m : ℕ) {D : Set (OverlapBlock (r+1))} | |
| (hD : MeasurableSet D) (q : ℝ) : MeasurableSet (rowSurvival r m D q) := by | |
| rw [rowSurvival_eq_preimage] | |
| exact (measurableSet_survivalBlock r m hD q).preimage (continuous_blockOfArray _).measurable | |
| lemma rowSurvival_succ (r m : ℕ) (D : Set (OverlapBlock (r+1))) (q : ℝ) : | |
| rowSurvival r (m+1) D q={R | R∈rowSurvival r m D q ∧ (R r (r+m+1):ℝ)≤q} := by | |
| ext R | |
| constructor | |
| · rintro ⟨hD,h⟩ | |
| exact ⟨⟨hD,fun j hj hne => h j (by omega) hne⟩,h (r+m+1) (by omega) (by omega)⟩ | |
| · rintro ⟨⟨hD,h⟩,hn⟩ | |
| refine ⟨hD,fun j hj hne => ?_⟩ | |
| by_cases hh : j<r+m+1 | |
| · exact h j hh hne | |
| · have he : j=r+m+1 := by omega | |
| simpa only [he] using hn | |
| lemma rowSurvival_GG {μ : ProbabilityMeasure OverlapArray} (h : GGIdentities μ) | |
| (r m : ℕ) {D : Set (OverlapBlock (r+1))} (hD : MeasurableSet D) (q : ℝ) : | |
| ((r+m+1:ℕ):ℝ)*(μ : Measure OverlapArray).real (rowSurvival r (m+1) D q)= | |
| (((r+m:ℕ):ℝ)+(entryLaw μ 0 1).real {x | (x:ℝ)≤q})* | |
| (μ : Measure OverlapArray).real (rowSurvival r m D q) := by | |
| let i : Fin (r+m+1) := ⟨r,by omega⟩ | |
| have he := GG_event_identity h (r+m+1) i (survivalBlock r m D q) {x | (x:ℝ)≤q} | |
| (measurableSet_survivalBlock r m hD q) (measurableSet_le (by fun_prop) measurable_const) | |
| have hz (l : Fin (r+m+1)) (hl : l∈Finset.univ.erase i) : | |
| {R | blockOfArray (r+m+1) R∈survivalBlock r m D q ∧ R i l∈{x : OverlapEntry | (x:ℝ)≤q}}= | |
| rowSurvival r m D q := by | |
| ext R | |
| have hh : blockOfArray (r+m+1) R∈survivalBlock r m D q ↔ R∈rowSurvival r m D q := by | |
| rw [rowSurvival_eq_preimage]; rfl | |
| constructor | |
| · exact fun hR => hh.mp hR.1 | |
| · intro hR | |
| refine ⟨hh.mpr hR, hR.2 l l.isLt ?_⟩ | |
| intro hc | |
| exact Finset.ne_of_mem_erase hl (Fin.ext hc) | |
| have hs : (∑ l∈Finset.univ.erase i,(μ : Measure OverlapArray).real | |
| {R | blockOfArray (r+m+1) R∈survivalBlock r m D q ∧ R i l∈{x : OverlapEntry | (x:ℝ)≤q}})= | |
| ((r+m:ℕ):ℝ)*(μ : Measure OverlapArray).real (rowSurvival r m D q) := by | |
| simp_rw [Finset.sum_congr rfl (fun l hl => congrArg (μ : Measure OverlapArray).real (hz l hl))] | |
| simp | |
| rw [hs,← rowSurvival_eq_preimage] at he | |
| have heSet : {R | blockOfArray (r+m+1) R∈survivalBlock r m D q ∧ R i (r+m+1)∈{x : OverlapEntry | (x:ℝ)≤q}}= | |
| rowSurvival r (m+1) D q := by | |
| rw [rowSurvival_succ, rowSurvival_eq_preimage r m] | |
| rfl | |
| rw [heSet] at he | |
| linarith | |
| end SKCavity | |
| open MeasureTheory ProbabilityTheory Filter TopologicalSpace | |
| open scoped BigOperators Topology NNReal ENNReal | |
| namespace SKCavity | |
| open SKQAOA SKGaussian ParisiInterpolation | |
| def FiniteExchangeable (μ : ProbabilityMeasure OverlapArray) : Prop := | |
| ∀ (r : ℕ) (e : Fin r → ℕ), Function.Injective e → | |
| (μ : Measure OverlapArray).map (selectedBlock e)=blockLaw μ r | |
| lemma genericOverlap_limit_FiniteExchangeable (β : ℝ) {μ : ProbabilityMeasure OverlapArray} {φ : ℕ → ℕ} | |
| (hφ : StrictMono φ) (hμ : Tendsto (fun k => genericOverlapLaw (φ k) β) atTop (𝓝 μ)) : | |
| FiniteExchangeable μ := genericOverlap_limit_exchangeable β hφ hμ | |
| lemma exchangeable_event {μ : ProbabilityMeasure OverlapArray} (h : FiniteExchangeable μ) | |
| {r : ℕ} (e : Fin r → ℕ) (he : Function.Injective e) {B : Set (OverlapBlock r)} (hB : MeasurableSet B) : | |
| (μ : Measure OverlapArray) ((selectedBlock e) ⁻¹' B)=(μ : Measure OverlapArray) ((blockOfArray r) ⁻¹' B) := by | |
| have hh := congrArg (fun ν : Measure (OverlapBlock r) => ν B) (h r e he) | |
| rw [Measure.map_apply (continuous_selectedBlock e).measurable hB, | |
| blockLaw, Measure.map_apply (continuous_blockOfArray r).measurable hB] at hh | |
| exact hh | |
| lemma exchangeable_event_real {μ : ProbabilityMeasure OverlapArray} (h : FiniteExchangeable μ) | |
| {r : ℕ} (e : Fin r → ℕ) (he : Function.Injective e) {B : Set (OverlapBlock r)} (hB : MeasurableSet B) : | |
| (μ : Measure OverlapArray).real ((selectedBlock e) ⁻¹' B)= | |
| (μ : Measure OverlapArray).real ((blockOfArray r) ⁻¹' B) := | |
| congrArg ENNReal.toReal (exchangeable_event h e he hB) | |
| def tailPerm (r : ℕ) {k : ℕ} (q : Equiv.Perm (Fin k)) : Equiv.Perm (Fin (r+k)) := | |
| finSumFinEquiv.symm.trans ((Equiv.sumCongr (Equiv.refl (Fin r)) q).trans finSumFinEquiv) | |
| @[simp] lemma tailPerm_old (r : ℕ) {k : ℕ} (q : Equiv.Perm (Fin k)) (i : Fin r) : | |
| tailPerm r q (Fin.castAdd k i)=Fin.castAdd k i := by simp [tailPerm] | |
| @[simp] lemma tailPerm_new (r : ℕ) {k : ℕ} (q : Equiv.Perm (Fin k)) (i : Fin k) : | |
| tailPerm r q (Fin.natAdd r i)=Fin.natAdd r (q i) := by simp [tailPerm] | |
| def newRow {r k : ℕ} (T : OverlapBlock (r+k)) (j : Fin k) : Fin r → OverlapEntry := | |
| fun i => T (Fin.natAdd r j) (Fin.castAdd k i) | |
| lemma continuous_newRow {r k : ℕ} (j : Fin k) : Continuous (fun T : OverlapBlock (r+k) => newRow T j) := by | |
| unfold newRow | |
| fun_prop | |
| def uniqueMark (r k : ℕ) (B : Set (Fin r → OverlapEntry)) (j : Fin k) : Set (OverlapBlock (r+k)) := | |
| {T | newRow T j∈B ∧ ∀ l : Fin k, l≠j → newRow T l∉B} | |
| lemma measurableSet_uniqueMark (r k : ℕ) {B : Set (Fin r → OverlapEntry)} (hB : MeasurableSet B) (j : Fin k) : | |
| MeasurableSet (uniqueMark r k B j) := by | |
| change MeasurableSet ((fun T : OverlapBlock (r+k) => newRow T j) ⁻¹' B ∩ | |
| {T | ∀ l : Fin k, l≠j → newRow T l∉B}) | |
| apply MeasurableSet.inter (hB.preimage (continuous_newRow j).measurable) | |
| simp only [Set.ofPred_forall] | |
| exact MeasurableSet.iInter fun l => MeasurableSet.iInter fun _ => | |
| (hB.preimage (continuous_newRow l).measurable).compl | |
| lemma uniqueMark_disjoint (r k : ℕ) (B : Set (Fin r → OverlapEntry)) : | |
| Pairwise (fun i j => Disjoint ((blockOfArray (r+k)) ⁻¹' uniqueMark r k B i) ((blockOfArray (r+k)) ⁻¹' uniqueMark r k B j)) := by | |
| intro i j hij | |
| apply Set.disjoint_left.mpr | |
| intro R hi hj | |
| exact hi.2 j hij.symm hj.1 | |
| lemma uniqueMark_relabel {r k : ℕ} (B : Set (Fin r → OverlapEntry)) (q : Equiv.Perm (Fin k)) (j : Fin k) : | |
| (selectedBlock (fun i : Fin (r+k) => (tailPerm r q i:ℕ))) ⁻¹' uniqueMark r k B j= | |
| (blockOfArray (r+k)) ⁻¹' uniqueMark r k B (q j) := by | |
| ext R | |
| have he (l : Fin k) : newRow (selectedBlock (fun i : Fin (r+k) => (tailPerm r q i:ℕ)) R) l= | |
| newRow (blockOfArray (r+k) R) (q l) := by | |
| funext i | |
| simp only [newRow,selectedBlock,tailPerm_old,tailPerm_new,blockOfArray] | |
| change (_ ∧ _) ↔ (_ ∧ _) | |
| simp_rw [he] | |
| constructor | |
| · rintro ⟨hj,hh⟩ | |
| refine ⟨hj,fun l hl => ?_⟩ | |
| have hl' : q.symm l≠j := fun h => hl (by simpa using congrArg q h) | |
| simpa only [q.apply_symm_apply] using hh (q.symm l) hl' | |
| · rintro ⟨hj,hh⟩ | |
| exact ⟨hj,fun l hl => hh (q l) (fun he => hl (q.injective he))⟩ | |
| lemma uniqueMark_equal {μ : ProbabilityMeasure OverlapArray} (h : FiniteExchangeable μ) | |
| (r k : ℕ) {B : Set (Fin r → OverlapEntry)} (hB : MeasurableSet B) (i j : Fin k) : | |
| (μ : Measure OverlapArray).real ((blockOfArray (r+k)) ⁻¹' uniqueMark r k B i)= | |
| (μ : Measure OverlapArray).real ((blockOfArray (r+k)) ⁻¹' uniqueMark r k B j) := by | |
| let q : Equiv.Perm (Fin k) := Equiv.swap j i | |
| have hh := exchangeable_event_real h (fun l : Fin (r+k) => (tailPerm r q l:ℕ)) | |
| (Fin.val_injective.comp (tailPerm r q).injective) (measurableSet_uniqueMark r k hB j) | |
| rw [uniqueMark_relabel] at hh | |
| simpa [q] using hh | |
| lemma uniqueMark_bound {μ : ProbabilityMeasure OverlapArray} (h : FiniteExchangeable μ) | |
| (r k : ℕ) {B : Set (Fin r → OverlapEntry)} (hB : MeasurableSet B) (i : Fin k) : | |
| (k:ℝ)*(μ : Measure OverlapArray).real ((blockOfArray (r+k)) ⁻¹' uniqueMark r k B i)≤1 := by | |
| have hh := measureReal_iUnion_fintype (μ:=(μ:Measure OverlapArray)) | |
| (uniqueMark_disjoint r k B) (fun j => (measurableSet_uniqueMark r k hB j).preimage (continuous_blockOfArray _).measurable) | |
| have he : (∑ j : Fin k, (μ : Measure OverlapArray).real ((blockOfArray (r+k)) ⁻¹' uniqueMark r k B j))= | |
| (k:ℝ)*(μ : Measure OverlapArray).real ((blockOfArray (r+k)) ⁻¹' uniqueMark r k B i) := by | |
| simp_rw [uniqueMark_equal h r k hB _ i] | |
| simp | |
| rw [he] at hh | |
| rw [← hh] | |
| exact measureReal_le_one | |
| end SKCavity | |
| open MeasureTheory ProbabilityTheory Filter TopologicalSpace | |
| open scoped BigOperators Topology NNReal ENNReal | |
| namespace SKCavity | |
| open SKQAOA SKGaussian ParisiInterpolation | |
| def arrayRow (r j : ℕ) (R : OverlapArray) : Fin r → OverlapEntry := fun i => R j i | |
| lemma continuous_arrayRow (r j : ℕ) : Continuous (arrayRow r j) := by | |
| unfold arrayRow | |
| fun_prop | |
| def patternBlock (r : ℕ) (C : Set (OverlapBlock r)) (B : Set (Fin r → OverlapEntry)) : | |
| Set (OverlapBlock (r+1)) := | |
| {T | initialBlock (Nat.le_succ r) T∈C ∧ newRow T (0 : Fin 1)∈B} | |
| lemma measurableSet_patternBlock {r : ℕ} {C : Set (OverlapBlock r)} {B : Set (Fin r → OverlapEntry)} | |
| (hC : MeasurableSet C) (hB : MeasurableSet B) : MeasurableSet (patternBlock r C B) := | |
| (hC.preimage (continuous_initialBlock _).measurable).inter | |
| (hB.preimage (continuous_newRow _).measurable) | |
| @[simp] lemma patternBlock_preimage (r : ℕ) (C : Set (OverlapBlock r)) (B : Set (Fin r → OverlapEntry)) : | |
| (blockOfArray (r+1)) ⁻¹' patternBlock r C B= | |
| {R | blockOfArray r R∈C ∧ arrayRow r r R∈B} := by | |
| rfl | |
| def doubleMarkBlock (r : ℕ) (C : Set (OverlapBlock r)) (B : Set (Fin r → OverlapEntry)) (q : ℝ) : | |
| Set (OverlapBlock (r+2)) := | |
| {T | initialBlock (by omega : r≤r+2) T∈C ∧ newRow T (0 : Fin 2)∈B ∧ | |
| newRow T (1 : Fin 2)∈B ∧ (T ⟨r,by omega⟩ ⟨r+1,by omega⟩:ℝ)≤q} | |
| lemma measurableSet_doubleMarkBlock {r : ℕ} {C : Set (OverlapBlock r)} {B : Set (Fin r → OverlapEntry)} | |
| (hC : MeasurableSet C) (hB : MeasurableSet B) (q : ℝ) : MeasurableSet (doubleMarkBlock r C B q) := by | |
| exact (hC.preimage (continuous_initialBlock _).measurable).inter | |
| ((hB.preimage (continuous_newRow _).measurable).inter | |
| ((hB.preimage (continuous_newRow _).measurable).inter (measurableSet_le (f := fun T : OverlapBlock (r+2) => (T ⟨r,by omega⟩ ⟨r+1,by omega⟩:ℝ)) (by fun_prop) measurable_const))) | |
| def doubleMarkAt (r j : ℕ) (C : Set (OverlapBlock r)) (B : Set (Fin r → OverlapEntry)) (q : ℝ) : | |
| Set OverlapArray := | |
| {R | blockOfArray r R∈C ∧ arrayRow r r R∈B ∧ arrayRow r j R∈B ∧ (R r j:ℝ)≤q} | |
| lemma measurableSet_doubleMarkAt {r j : ℕ} {C : Set (OverlapBlock r)} {B : Set (Fin r → OverlapEntry)} | |
| (hC : MeasurableSet C) (hB : MeasurableSet B) (q : ℝ) : MeasurableSet (doubleMarkAt r j C B q) := by | |
| exact (hC.preimage (continuous_blockOfArray _).measurable).inter | |
| ((hB.preimage (continuous_arrayRow _ _).measurable).inter | |
| ((hB.preimage (continuous_arrayRow _ _).measurable).inter (measurableSet_le (f := fun R : OverlapArray => (R r j:ℝ)) (by fun_prop) measurable_const))) | |
| def prefixFresh (s j : ℕ) : Fin (s+1) → ℕ := fun i => if (i:ℕ)<s then i else j | |
| lemma prefixFresh_injective {s j : ℕ} (hj : s≤j) : Function.Injective (prefixFresh s j) := by | |
| intro a b h | |
| unfold prefixFresh at h | |
| split_ifs at h with ha hb hb | |
| · exact Fin.ext h | |
| · omega | |
| · omega | |
| · apply Fin.ext; omega | |
| @[simp] lemma prefixFresh_old {s j : ℕ} (i : Fin s) : prefixFresh s j i.castSucc=i := by | |
| simp [prefixFresh,i.isLt] | |
| @[simp] lemma prefixFresh_last (s j : ℕ) : prefixFresh s j (Fin.last s)=j := by simp [prefixFresh] | |
| lemma doubleMarkAt_preimage (r j : ℕ) (C : Set (OverlapBlock r)) (B : Set (Fin r → OverlapEntry)) (q : ℝ) : | |
| (selectedBlock (prefixFresh (r+1) j)) ⁻¹' doubleMarkBlock r C B q=doubleMarkAt r j C B q := by | |
| have he (i : ℕ) (hi : i<r+1) : prefixFresh (r+1) j ⟨i,by omega⟩=i := by simp [prefixFresh,hi] | |
| ext R | |
| change (_ ∧ _ ∧ _ ∧ _) ↔ (_ ∧ _ ∧ _ ∧ _) | |
| have h₁ : initialBlock (show r≤r+2 by omega) (selectedBlock (prefixFresh (r+1) j) R)=blockOfArray r R := by | |
| funext a b | |
| simp [initialBlock,selectedBlock,blockOfArray, prefixFresh,show (a:ℕ)<r+1 by omega,show (b:ℕ)<r+1 by omega] | |
| have h₂ : newRow (r:=r) (k:=2) (selectedBlock (prefixFresh (r+1) j) R) (0:Fin 2)=arrayRow r r R := by | |
| funext i | |
| simp [newRow,selectedBlock,arrayRow,prefixFresh,show (i:ℕ)<r+1 by omega] | |
| have h₃ : newRow (r:=r) (k:=2) (selectedBlock (prefixFresh (r+1) j) R) (1:Fin 2)=arrayRow r j R := by | |
| funext i | |
| simp [newRow,selectedBlock,arrayRow,prefixFresh,show (i:ℕ)<r+1 by omega] | |
| simp only [h₁,h₂,h₃,selectedBlock,he r (by omega)] | |
| simp [prefixFresh] | |
| lemma doubleMarkAt_equal {μ : ProbabilityMeasure OverlapArray} (hex : FiniteExchangeable μ) | |
| {r j : ℕ} (hj : r+1≤j) {C : Set (OverlapBlock r)} {B : Set (Fin r → OverlapEntry)} | |
| (hC : MeasurableSet C) (hB : MeasurableSet B) (q : ℝ) : | |
| (μ : Measure OverlapArray) (doubleMarkAt r j C B q)= | |
| (μ : Measure OverlapArray) (doubleMarkAt r (r+1) C B q) := by | |
| have hh := exchangeable_event hex (prefixFresh (r+1) j) (prefixFresh_injective hj) | |
| (measurableSet_doubleMarkBlock hC hB q) | |
| rw [doubleMarkAt_preimage] at hh | |
| exact hh | |
| lemma rowSurvival_zero (r : ℕ) {C : Set (OverlapBlock r)} {B : Set (Fin r → OverlapEntry)} | |
| (q : ℝ) (hB : ∀ x∈B, ∀ i, (x i:ℝ)≤q) : | |
| rowSurvival r 0 (patternBlock r C B) q=(blockOfArray (r+1)) ⁻¹' patternBlock r C B := by | |
| ext R | |
| constructor | |
| · exact fun h => h.1 | |
| · intro h | |
| refine ⟨h,fun j hj hne => ?_⟩ | |
| have hb : arrayRow r r R∈B := h.2 | |
| exact hB _ hb ⟨j,by omega⟩ | |
| theorem GG_duplication {μ : ProbabilityMeasure OverlapArray} (hgg : GGIdentities μ) | |
| (hex : FiniteExchangeable μ) {r : ℕ} (hr : 0<r) | |
| {C : Set (OverlapBlock r)} {B : Set (Fin r → OverlapEntry)} | |
| (hC : MeasurableSet C) (hB : MeasurableSet B) (q : ℝ) | |
| (hrow : ∀ x∈B, ∀ i, (x i:ℝ)≤q) | |
| (hz : 0<(entryLaw μ 0 1).real {x | (x:ℝ)≤q}) | |
| (hpos : 0<(μ : Measure OverlapArray).real ((blockOfArray (r+1)) ⁻¹' patternBlock r C B)) : | |
| 0<(μ : Measure OverlapArray).real (doubleMarkAt r (r+1) C B q) := by | |
| by_contra hn | |
| have hzero : (μ : Measure OverlapArray) (doubleMarkAt r (r+1) C B q)=0 := by | |
| apply (measureReal_eq_zero_iff).mp | |
| exact le_antisymm (le_of_not_gt hn) measureReal_nonneg | |
| have hall : ∀ᵐ R ∂(μ : Measure OverlapArray), ∀ j : ℕ, r+1≤j → R∉doubleMarkAt r j C B q := by | |
| apply eventually_countable_forall.mpr | |
| intro j | |
| by_cases hj : r+1≤j | |
| · have hzj : (μ : Measure OverlapArray) (doubleMarkAt r j C B q)=0 := by | |
| rw [doubleMarkAt_equal hex hj hC hB q,hzero] | |
| have ha : ∀ᵐ R ∂(μ : Measure OverlapArray), R∉doubleMarkAt r j C B q := by | |
| apply ae_iff.mpr | |
| simpa only [not_not,Set.ofPred_mem_eq] using hzj | |
| exact ha.mono fun R hR _ => hR | |
| · exact Filter.Eventually.of_forall fun _ h => (hj h).elim | |
| let f : ℕ → ℝ := fun m => (μ : Measure OverlapArray).real (rowSurvival r m (patternBlock r C B) q) | |
| have h₀ : 0<f 0 := by | |
| dsimp [f] | |
| rw [rowSurvival_zero r q hrow] | |
| exact hpos | |
| have hrec : ∀ m, ((r+m+1:ℕ):ℝ)*f (m+1)= | |
| (((r+m:ℕ):ℝ)+(entryLaw μ 0 1).real {x | (x:ℝ)≤q})*f m := | |
| fun m => rowSurvival_GG hgg r m (measurableSet_patternBlock hC hB) q | |
| have hub (m : ℕ) : ((m+1:ℕ):ℝ)*f m≤1 := by | |
| have hs : ∀ᵐ R ∂(μ : Measure OverlapArray), R∈rowSurvival r m (patternBlock r C B) q → | |
| R∈(blockOfArray (r+(m+1))) ⁻¹' uniqueMark r (m+1) B 0 := by | |
| filter_upwards [hall] with R hR hsur | |
| refine ⟨hsur.1.2,fun j hj hBj => ?_⟩ | |
| have hj' : r+1≤r+(j:ℕ) := by | |
| have : (j:ℕ)≠0 := fun he => hj (Fin.ext he) | |
| omega | |
| apply hR (r+j) hj' | |
| exact ⟨hsur.1.1,hsur.1.2,hBj,hsur.2 (r+j) (by omega) (by omega)⟩ | |
| have hm : f m≤(μ : Measure OverlapArray).real | |
| ((blockOfArray (r+(m+1))) ⁻¹' uniqueMark r (m+1) B 0) := | |
| ENNReal.toReal_mono (measure_ne_top _ _) (measure_mono_ae hs) | |
| exact (mul_le_mul_of_nonneg_left hm (Nat.cast_nonneg _)).trans (uniqueMark_bound hex r (m+1) hB 0) | |
| exact urn_growth_contradiction hr hz f (fun _ => measureReal_nonneg) h₀ hrec hub | |
| lemma exchangeable_pair_event {μ : ProbabilityMeasure OverlapArray} (hex : FiniteExchangeable μ) | |
| {i j : ℕ} (hij : i≠j) {A : Set OverlapEntry} (hA : MeasurableSet A) : | |
| (μ : Measure OverlapArray).real {R | R i j∈A}=(entryLaw μ 0 1).real A := by | |
| let e : Fin 2 → ℕ := ![i,j] | |
| have he : Function.Injective e := by | |
| intro a b hab | |
| fin_cases a <;> fin_cases b | |
| · rfl | |
| · exact (hij hab).elim | |
| · exact (hij hab.symm).elim | |
| · rfl | |
| have hh := exchangeable_event_real hex e he (hA.preimage (show Measurable (fun T : OverlapBlock 2 => T 0 1) by fun_prop)) | |
| change (μ : Measure OverlapArray).real {R | R i j∈A}=(μ : Measure OverlapArray).real {R | R 0 1∈A} at hh | |
| rw [hh,measureReal_def,measureReal_def,entryLaw,Measure.map_apply (by fun_prop) hA] | |
| rfl | |
| theorem GG_duplication_of_positive {μ : ProbabilityMeasure OverlapArray} (hgg : GGIdentities μ) | |
| (hex : FiniteExchangeable μ) {r : ℕ} (hr : 0<r) | |
| {C : Set (OverlapBlock r)} {B : Set (Fin r → OverlapEntry)} | |
| (hC : MeasurableSet C) (hB : MeasurableSet B) (q : ℝ) | |
| (hrow : ∀ x∈B, ∀ i, (x i:ℝ)≤q) | |
| (hpos : 0<(μ : Measure OverlapArray).real ((blockOfArray (r+1)) ⁻¹' patternBlock r C B)) : | |
| 0<(μ : Measure OverlapArray).real (doubleMarkAt r (r+1) C B q) := by | |
| have hs : (blockOfArray (r+1)) ⁻¹' patternBlock r C B ⊆ {R : OverlapArray | (R r 0:ℝ)≤q} := by | |
| intro R hR | |
| exact hrow _ hR.2 ⟨0,hr⟩ | |
| have hh := hpos.trans_le (measureReal_mono hs) | |
| have he := exchangeable_pair_event hex (by omega : r≠0) | |
| (A:={x : OverlapEntry | (x:ℝ)≤q}) (measurableSet_le (by fun_prop) measurable_const) | |
| change (μ : Measure OverlapArray).real {R | (R r 0:ℝ)≤q}=_ at he | |
| rw [he] at hh | |
| exact GG_duplication hgg hex hr hC hB q hrow hh hpos | |
| end SKCavity | |
| end | |
| end OAI | |