| import OAI.Combinatorics.HadwigerCounterexample.OrientationRankBounds |
|
|
| namespace OAI |
|
|
| /-! # Basis Conditioning -/ |
|
|
| noncomputable section |
| namespace HadwigerCounterexample |
| open Matrix Module LinearMap Finset Filter Function |
| open scoped BigOperators |
| variable {p : Shape} {n N : ℕ} {I : Type} [Fintype I] [DecidableEq I] |
|
|
| theorem totalRank_pos {x : Profile p n} (h : x≠0) : |
| 0<totalRank x := by |
| obtain ⟨i,hi⟩ := Function.ne_iff.mp h |
| apply lt_of_lt_of_le _ (Finset.single_le_sum (fun i _=>Nat.zero_le ((x i).rank)) |
| (Finset.mem_univ i)) |
| apply Nat.pos_of_ne_zero; intro h |
| obtain ⟨A,B,hh⟩ := mul_factor (x i) 0 h.le |
| apply hi; ext a b; rw [←hh,Matrix.mul_apply]; simp |
|
|
| def glintRate (K : ℕ) := bp (-((K^2:ℕ):ℝ)-3) |
|
|
| theorem glint_within {K d : ℕ} (h : d≤ K^2) : |
| glintRate K ≤ (1/8:ℝ)*bp (- (d:ℝ)) := by |
| unfold glintRate |
| have hh : bp (-3)=1/8 := by norm_num [bp] |
| rw [←hh,←bp_add] |
| exact bp_le (by linarith only [(show (d:ℝ) ≤ ((K^2:ℕ):ℝ) from by exact_mod_cast h)]) |
|
|
| namespace Template |
| variable (v : Solo p) |
|
|
| def stains (m : Mixer p n) (f : Vec I →ₗ[F] Profile p n) (z : Knobs p.g n) : Vec I := |
| fun i=> Tsym m (f (Pi.single i 1)) (useAtom p (v.t ()) (v.s ()) (v.f ()) z) |
| theorem staining (m : Mixer p n) (f : Vec I→ₗ[F] Profile p n) (z : Knobs p.g n) (i : Vec I) : |
| vectorPhase i (stains v m f z)=shanty v m (f i) z := by |
| classical |
| let h := LinearMap.flip (Tsym m) (useAtom p (v.t ()) (v.s ()) (v.f ()) z) ∘ₗ f |
| have ht : h i=h (∑ j: I,i j • (Pi.single j 1 : Vec I)) := by |
| have he (j:I) : i j • (Pi.single j 1 : Vec I)=Pi.single j (i j) := by |
| funext k; by_cases hh:k=j <;> simp [hh] |
| simp_rw [he] |
| rw [Finset.univ_sum_single] |
| change wsign (∑ j:I,i j*h (Pi.single j 1))=wsign (h i) |
| rw [ht,map_sum]; simp_rw [map_smul]; rfl |
|
|
| def luminous (v : Solo p) (m : Mixer p n) (w : Wgt (Knobs p.g n)) (D : AtomKey (p:=p) (v.t ()) |
| N →Prop) (K : ℕ) (i : Orient p n N) := |
| let P := offBeat v D i |
| 0<pr w P ∧ ∀ (d : ℕ), d≤ K^2 → ∀ f : Vec (Fin d)→ₗ[F] Profile p n, |
| Injective f → (∀ x,totalRank (f x)≤K) → ∀ x, |
| (7/8:ℝ)*bp (-(d:ℝ)) ≤ pr (onW w P) (fun z=> stains v m f z=x) |
|
|
| set_option maxHeartbeats 800000 in |
| theorem glow_luminous (v : Solo p) (m : Mixer p n) (w : Wgt (Knobs p.g n)) |
| (hw : IsLaw w) |
| (S : AtomKey (p:=p) (v.t ()) N → Prop) |
| (K : ℕ) (i : Orient p n N) (δ : ℝ) (hδ : 0<δ) (he : δ ≤ pr w (offBeat v S i)) |
| (h : ∀ x, 0<totalRank x → totalRank x≤K → ¬ glow v m w S (glintRate K) δ x i) : |
| luminous v m w S K i := by |
| classical |
| let P := offBeat v S i |
| have hP : 0<pr w P := hδ.trans_le he |
| let u := onW w P; have hu : IsLaw u := on_law hw.nz hP |
| refine ⟨hP,fun d hd f hf hg x => ?_⟩ |
| let s := stains v m f |
| have heq : |
| pr u (fun z => s z=x) = avg unif (fun i => vectorPhase i x* |
| avg u (fun z => vectorPhase i (s z))) := by |
| unfold pr |
| simp_rw [vector_expand] |
| rw [avg_avg] |
| apply avg_congr |
| intro i hi |
| rw [avg_mul]; ring |
| let b := bp (-(d:ℝ)) |
| let Q (k : Vec (Fin d)) := vectorPhase k x * avg u (fun z => vectorPhase k (s z)) |
| have hb : 0 < b := bp_pos _ |
| have hh k : ind (k=0)-b/8 ≤ Q k := by |
| by_cases hk : k=0 |
| · subst k |
| have hQ : Q 0=1 := by unfold Q; simp only [vectorPhase,zero_dotProduct,wsign_zero,one_mul, |
| hu.avg_const] |
| rw [ind_one (show (0:Vec (Fin d))=0 from rfl),hQ]; linarith |
| let k' := f k |
| have hT := h k' (totalRank_pos (hf.ne hk |>.trans_eq (map_zero f))) (hg k) |
| have hz : |zsumPeak p w (v.shanty m k') P| ≤ (glintRate K)*pr w P := |
| le_of_lt (lt_of_not_ge (fun h => hT ⟨he,h⟩)) |
| have ht : |
| avg u (fun z => vectorPhase k (s z))= |
| zsumPeak p w (v.shanty m k') P/pr w P := by |
| unfold s u onW; simp_rw [staining]; rw [avg_norm,subW_tot] |
| congr 1; simp [zsumPeak,avg,subW,mul_assoc,k'] |
| have h1 : |Q k|≤b/8 := by |
| unfold Q; rw [ht,abs_mul,vectorPhase,wsign_abs,one_mul,abs_div,abs_of_pos hP] |
| refine le_trans ((div_le_iff₀ hP).mpr hz) ((glint_within hd).trans_eq (by unfold b; ring)) |
| rw [ind_zero hk,zero_sub]; exact (abs_le.mp h1).1 |
| have h0 : unif (0:Vec (Fin d))=b := by |
| unfold b; rw [unif_apply,card_space,dim_vec,bp_neg,Fintype.card_fin] |
| change _ ≤ pr u (fun z => s z=x) |
| rw [heq] |
| refine le_trans ?_ (avg_mono unif_law.nz hh) |
| rw [avg_sub,unif_law.avg_const, |
| show avg unif (fun i : Vec (Fin d)=> ind (i=0))=b from (pr_point' unif _).trans h0] |
| change 7/8*b≤_ |
| linarith |
| end Template |
| end HadwigerCounterexample |
|
|
| end |
|
|
| end OAI |
|
|
