openAI-math-dataset / lean /OAI /Combinatorics /HadwigerCounterexample /BilinearBlockCorrelation.lean
| import OAI.Combinatorics.HadwigerCounterexample.OppositeEndpointForms | |
| namespace OAI | |
| /-! # Bilinear Block Correlation -/ | |
| noncomputable section | |
| namespace HadwigerCounterexample | |
| open Finset LinearMap Module Matrix Function | |
| open scoped BigOperators | |
| variable {p : Shape} {I J A : Type} [Fintype I] [Fintype J] [Fintype A] | |
| variable {n : ℕ} | |
| def spring (p : Shape) (l : Tag p.g) (s : Label p.b) (f : Flavor p.g) | |
| (y : Knobs p.g n) := point p s (lit f l y) | |
| theorem spring_update (p : Shape) (l : Tag p.g) (s : Label p.b) (f : Flavor p.g) | |
| (y : Knobs p.g n) (B) (h : f.keeps l B) (z : Vec (Fin n)) : | |
| spring p l s f (update y B z)= spring p l s f (update y B 0)+ | |
| blockRay p n s B *ᵥ z := by | |
| classical | |
| have he : baseV (lit f l (update y B z))=baseV (lit f l (update y B 0))+blockA p n B *ᵥ z := by | |
| funext a | |
| rcases a with _|⟨d,j⟩ | |
| · simp [baseV,blockA,mulVec,dotProduct,embedMat] | |
| by_cases hk : d=B | |
| · subst d; simp [baseV,blockA,mulVec,dotProduct,embedMat,lit,h] | |
| simp [baseV,blockA,mulVec,dotProduct,embedMat,lit,hk] | |
| unfold spring point blockRay | |
| rw [he,map_add,←Matrix.mulVec_mulVec,labMat_act] | |
| private def dotLB (I : Type) [Fintype I] : Vec I →ₗ[F] Vec I→ₗ[F] F where | |
| toFun := dotL | |
| map_add' p q := LinearMap.ext fun i => add_dotProduct p q i | |
| map_smul' a p := LinearMap.ext fun i => by | |
| change dotProduct (a • p) i=a*dotProduct p i | |
| rw [smul_dotProduct]; rfl | |
| theorem spark_walsh [DecidableEq I] [DecidableEq J] (M : Mat I J) (p : Wgt (Vec I)) (q : Wgt (Vec J)) | |
| (hp : ∀ i, |p i|≤1) (hq : ∀ i, |q i|≤1) : | |
| |avg (pairW unif unif) (fun i => wsign (evmat M i.1 i.2)*(p i.1*q i.2))| ≤ | |
| bp (-(M.rank:ℝ)/2) := by | |
| classical | |
| let Q := dotLB I | |
| let L := Q ∘ₗ M.mulVecLin | |
| have he (i j) : evmat M i j=L j i := dotProduct_comm .. | |
| have hh : Injective Q := fun x y h => funext (fun i => by | |
| have hg := LinearMap.congr_fun h (Pi.single i 1) | |
| change dotProduct x (Pi.single i 1)=dotProduct y (Pi.single i 1) at hg | |
| simpa using hg) | |
| have ht : rk L=M.rank := by | |
| have h : LinearMap.ker L=LinearMap.ker M.mulVecLin := by | |
| ext x; change Q (M.mulVecLin x)=0 ↔ M.mulVecLin x=0 | |
| rw [← map_zero Q,hh.eq_iff] | |
| have hv := L.finrank_range_add_finrank_ker | |
| rw [h, ← M.mulVecLin.finrank_range_add_finrank_ker] at hv | |
| exact Nat.add_right_cancel hv | |
| rw [pairW_avg] | |
| have hz (x : Vec I) (y : Vec J) : wsign (evmat M x y)*(p x*q y)=p x*(q y*wsign (L y x)) := by | |
| rw [he]; ring | |
| simp_rw [hz,avg_mul'] | |
| rw [←ht] | |
| exact walsh_bound _ q p hq hp | |
| set_option maxHeartbeats 800000 in | |
| theorem spark_uncap (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) : | |
| let Q i z := evmat M (spring p l s f i) (spring p j t g z) | |
| |avg (pairW unif unif) (fun x => wsign (Q x.1 x.2)*(w x.1*u x.2))|≤ | |
| bp (-(blockRank B s t M:ℝ)/2) := by | |
| classical | |
| intro Q | |
| let F (x : Knobs p.g n × _) := wsign (Q x.1 x.2)*(w x.1*u x.2) | |
| let K := Wgt (Vec (Fin n)) | |
| let v : Block p.g→ K := fun _ => unif | |
| have ht := update2_avg v v B F unif_law unif_law | |
| have he : prodW v=unif := draws_unif.symm | |
| let R := blockRay p n s B; let S:=blockRay p n t B | |
| let H := pullM R S M | |
| have hi (x y : Knobs p.g n) : | |
| |avg (pairW (v B) (v B)) (fun i => F (update x B i.1,update y B i.2))|≤ | |
| bp (-(blockRank B s t M:ℝ)/2) := by | |
| let X := spring p l s f (update x B 0); let Y := spring p j t g (update y B 0) | |
| let A i := evmat M (R *ᵥ i) Y; let D j := evmat M X (S *ᵥ j)+evmat M X Y | |
| let Z i := wsign (A i)*w (update x B i); let W j := wsign (D j)*u (update y B j) | |
| have hp i j' : | |
| Q (update x B i) (update y B j')= evmat H i j'+(A i+D j') := by | |
| unfold Q; rw [spring_update _ _ _ _ _ _ hB,spring_update _ _ _ _ _ _ hB'] | |
| unfold H A D X Y; rw [evmat_pull] | |
| simp only [evmat,mulVec_add,add_dotProduct,dotProduct_add,R,S]; ac_rfl | |
| have hh i j : F (update x B i,update y B j)=wsign (evmat H i j)*(Z i*W j) := by | |
| unfold F Z W; dsimp only; rw [hp,wsign_add,wsign_add]; ring | |
| have hz i : |Z i|≤1 := by unfold Z; rw [abs_mul,wsign_abs,one_mul]; exact hw _ | |
| have hy i : |W i|≤1 := by unfold W; rw [abs_mul,wsign_abs,one_mul]; exact hu _ | |
| simp_rw [hh] | |
| exact spark_walsh _ Z W hz hy | |
| simp only [he] at ht | |
| change |avg (pairW unif unif) F|≤_ | |
| rw [ht] | |
| let hq := pairW_law (α:=Knobs p.g n) (β:=Knobs p.g n) unif_law unif_law | |
| exact (abs_avg_le hq.nz).trans (hq.avg_le fun x => hi x.1 x.2) | |
| end HadwigerCounterexample | |
| end | |
| end OAI | |