openAI-math-dataset / lean /OAI /Combinatorics /HadwigerCounterexample /ConditionedCorrelations.lean
| import OAI.Combinatorics.HadwigerCounterexample.BilinearBlockCorrelation | |
| namespace OAI | |
| /-! # Conditioned Correlations -/ | |
| noncomputable section | |
| namespace HadwigerCounterexample | |
| open Finset Real Filter Matrix LinearMap Function | |
| open scoped BigOperators | |
| variable {p : Shape} {I A : Type} [Fintype I] [Fintype A] | |
| variable {n : ℕ} | |
| set_option maxHeartbeats 600000 in | |
| theorem spark_condition (p : Shape) (M : Moment p n) (s t : Label p.b) (l j : Tag p.g) | |
| (f g : Flavor p.g) (B) (hB : f.keeps l B) (hB' : g.keeps j B) | |
| (w u : Wgt (Knobs p.g n)) (hw : ∀ i,|w i|≤1) (hu : ∀ i,|u i|≤1) | |
| (μ δ : Wgt (Knobs p.g n)) (hμ : IsLaw μ) (hδ : IsLaw δ) | |
| (C : ℝ) (hC : 0<C) | |
| (hc : ∀ i,μ i ≤ C*unif i) (hc' : ∀ i,δ i ≤ C*unif i) | |
| (hM : n ≤ 5*blockRank B s t M) : | |
| let Q i z := evmat M (spring p l s f i) (spring p j t g z) | |
| |avg (pairW μ δ) (fun x => wsign (Q x.1 x.2)*(w x.1*u x.2))|≤ | |
| C^2*bp (-(n:ℝ)/10) := by | |
| classical | |
| intro Q | |
| let V := Knobs p.g n | |
| let fit (f p : Wgt V) := fun i => p i*f i/(C*unif i) | |
| have h0 (i : V) : 0<C*unif i := by rw [unif_apply]; positivity | |
| have hh (t p : Wgt V) (ht : ∀ i, |t i|≤1) (hp : IsLaw p) (h : ∀ i,p i≤C*unif i) i : | |
| |fit t p i|≤1 := by | |
| unfold fit; rw [abs_div,abs_of_pos (h0 i),abs_mul,abs_of_nonneg (hp.nz _)] | |
| refine (div_le_one (h0 i)).mpr ?_ | |
| exact ((mul_le_mul_of_nonneg_left (ht _) (hp.nz _)).trans_eq (mul_one _)).trans (h _) | |
| let F (x : V×V) := wsign (Q x.1 x.2)*(w x.1*u x.2) | |
| let Z (x : V×V) := wsign (Q x.1 x.2)*(fit w μ x.1*fit u δ x.2) | |
| have he : | |
| avg (pairW μ δ) F=C^2 * avg (pairW unif unif) Z := by | |
| unfold avg; rw [Finset.mul_sum] | |
| refine sum_congr rfl fun i _ => ?_ | |
| unfold Z F fit pairW | |
| have h1 := h0 i.1; have h2 := h0 i.2 | |
| have h3 : unif i.1 ≠ 0 := by rw [unif_apply]; positivity | |
| have h4 : unif i.2 ≠ 0 := by rw [unif_apply]; positivity | |
| field_simp | |
| change |avg (pairW μ δ) F|≤_ | |
| rw [he,abs_mul,abs_of_nonneg (sq_nonneg _)] | |
| have hi : (n:ℝ)≤5*blockRank B s t M := by exact_mod_cast hM | |
| exact mul_le_mul_of_nonneg_left ((spark_uncap p M s t l j f g B hB hB' | |
| _ _ (hh w μ hw hμ hc) (hh u δ hu hδ hc')).trans (bp_le (by linarith only [hi]))) (sq_nonneg _) | |
| def litFire (p : Shape) {n N : ℕ} (x : UnitType p n N) := | |
| ∀ (s t : Label p.b) (c : Vec (Notches p)), c≠0 → | |
| n≤5*blockRank Block.Z s t (issue p c x) | |
| theorem litFire_calendar (p : Shape) (C : ℝ) (M : ℕ) (hM : 4≤M) : | |
| ∀ᶠ n : ℕ in atTop, let N := M*n; ∀ (m : Mixer p n), 2*num (Full p n)<N → | |
| ∀ w : Wgt (UnitType p n N), | |
| (∀ i,w i ≤ bp (C*N)*pairW (raw m N) (raw m N) i) → | |
| pr w (fun i => ¬litFire p i) ≤ bp (-(n:ℝ)*n/8) := by | |
| classical | |
| let I := Label p.b × Label p.b × Vec (Notches p) | |
| have ht := bp_poly_dom_nat (a:=1) zero_lt_one (num I) 0 | |
| filter_upwards [issue_live p,ht,(tendsto_natCast_atTop_atTop (R:=ℝ)).eventually | |
| (eventually_ge_atTop (8*(C*M+1)))] | |
| with n hn hp hab N m hN w h | |
| change 8*(C*M+1)≤ (n:ℝ) at hab | |
| refine (pr_cap h _).trans ?_ | |
| let Q (i : I) (x : UnitType p n N) := | |
| i.2.2≠0 ∧ 5*blockRank Block.Z i.1 i.2.1 (issue p i.2.2 x)<n | |
| let v := pairW (raw m N) (raw m N) | |
| have hv : IsLaw v := pairW_law (raw_law m hN) (raw_law m hN) | |
| have he (i : I) : pr v (Q i)≤bp (-(n:ℝ)*n/4) := by | |
| by_cases h : i.2.2=0 | |
| · simp only [Q,h,ne_eq,not_true,false_and,pr_false]; exact (bp_pos _).le | |
| exact (pr_mono hv.nz fun x h => h.2).trans | |
| (hn N (by unfold N; nlinarith only [Nat.mul_le_mul_right n hM]) hN m _ _ i.2.2 h) | |
| have hh (x : UnitType p n N) (h : ¬litFire p x) : ∃ i,Q i x := by | |
| unfold litFire at h | |
| push Not at h | |
| obtain ⟨s,t,c,hc,h⟩ := h; exact ⟨(s,t,c),hc,h⟩ | |
| have hi : pr v (fun x=> ¬litFire p x) ≤ num I*bp (-(n:ℝ)*n/4) := | |
| (le_trans (pr_mono hv.nz hh) (pr_exists_le hv.nz Q)).trans ((sum_le_sum | |
| fun i _ => he i).trans_eq (by simp [num])) | |
| refine (mul_le_mul_of_nonneg_left hi (bp_pos _).le).trans ?_ | |
| simp only [pow_zero,mul_one,one_mul] at hp | |
| apply (mul_le_mul_of_nonneg_left (mul_le_mul_of_nonneg_right hp.le | |
| (bp_pos (-(n:ℝ)*n/4)).le) (bp_pos (C*N)).le).trans | |
| rw [← bp_add,← bp_add] | |
| apply bp_le | |
| unfold N; push_cast | |
| nlinarith only [mul_le_mul_of_nonneg_right hab (Nat.cast_nonneg n : 0≤(n:ℝ))] | |
| end HadwigerCounterexample | |
| end | |
| end OAI | |