| import OAI.Combinatorics.HadwigerCounterexample.CrossPatternCounting |
|
|
| namespace OAI |
|
|
| /-! # Batch Characters -/ |
|
|
| noncomputable section |
| namespace HadwigerCounterexample |
| open scoped BigOperators |
| open Matrix Module LinearMap Function Finset |
| variable {I J A B : Type} [Fintype I] [Fintype J] [Fintype A] [Fintype B] |
| variable [DecidableEq I] [DecidableEq J] [DecidableEq A] [DecidableEq B] |
| variable {n N t : ℕ} |
|
|
| def led (i : I) (x : Rack (I×J) N) := sectionR (fun j => (i,j)) x |
| def relay (I J : Type) [Fintype I] [Fintype J] (N) : |
| Rack (I×J) N ≃ (I → Rack J N) where |
| toFun x i := led i x |
| invFun x := (Matrix.of (fun i j => (x j.1).1 i j.2), Matrix.of (fun i j => (x j.1).2 i j.2)) |
| left_inv x := by apply Prod.ext <;> rfl |
| right_inv x := funext fun _ => Prod.ext rfl rfl |
|
|
| theorem led_uniform (F : Wgt (I→Rack J N)) : |
| avg (unif : Wgt (Rack (I×J) N)) (fun x => F (fun i => led i x))= |
| avg (draws I unif) F := by |
| change avg unif (fun x => F (relay I J N x))=_ |
| rw [← mapW_avg,unif_equiv,← draws_unif] |
|
|
| theorem led_piece (T : Finset I) (p : I→Rack J N→Prop) : |
| avg unif (fun x => ∏ i∈T,ind (p i (led i x))) = |
| ∏ i∈T,pr unif (p i) := by |
| classical |
| let F (i : I) (z) := if i∈T then ind (p i z) else 1 |
| let H : Wgt (I→ Rack J N) := prodW F |
| have he x : (∏ i∈T,ind (p i (led i x))) = H (fun i => led i x) := by |
| unfold H F prodW |
| rw [← Finset.prod_filter]; simp |
| have hf i : avg unif (F i) = if i∈T then pr unif (p i) else 1 := by |
| by_cases hh : i∈T <;> simp [F,pr,hh,unif_law.avg_const] |
| simp_rw [he]; rw [led_uniform] |
| unfold H draws |
| rw [prodW_avg]; simp_rw [hf]; rw [← Finset.prod_filter]; simp |
|
|
| def heard (T : A → I×J) := Finset.univ.image (Prod.fst ∘ T) |
|
|
| omit [Fintype I] [Fintype J] [DecidableEq A] in |
| theorem heard_fresh {T : A→I × J} {i : I} (B : PlusRack A N) (h : i∉heard T) (j : J) (k) : |
| upliftR T B k (i,j)=0 := by |
| classical |
| unfold upliftR |
| rw [Matrix.mul_apply] |
| refine Finset.sum_eq_zero fun x _ => ?_ |
| have he : (i,j)≠T x := fun e => h (mem_image.mpr |
| ⟨x,mem_univ _, (congrArg Prod.fst e).symm⟩) |
| simp [embedMat,he] |
|
|
| omit [Fintype I] [Fintype J] [DecidableEq A] in |
| private theorem led_off_r (x : Rack (I×J) N) {T : A→I×J} {i : I} (B : PlusRack A N) |
| (h : i∉heard T) : |
| led i (x+(0,upliftR T B)) = led i x := by |
| apply Prod.ext |
| · ext; simp [led,sectionR] |
| ext |
| simp only [led,sectionR,Prod.snd_add,Matrix.add_apply,Matrix.submatrix_apply, |
| heard_fresh B h,add_zero] |
|
|
| omit [Fintype I] [Fintype J] [DecidableEq A] in |
| private theorem led_off_l (x : Rack (I×J) N) {T : A→I×J} {i : I} (B : PlusRack A N) |
| (h : i∉heard T) : |
| led i (x+(upliftR T B,0)) = led i x := by |
| apply Prod.ext |
| · ext |
| simp only [led,sectionR,Prod.fst_add,Matrix.add_apply,Matrix.submatrix_apply, |
| heard_fresh B h,add_zero] |
| ext; simp [led,sectionR] |
|
|
| def phot (P : I→Rack J N→Prop) (x : Rack (I×J) N) := |
| ∏ i:I,ind (P i (led i x)) |
|
|
| set_option maxHeartbeats 800000 in |
| theorem light_bound (M : Avenue I J) (P : I→Rack J N→Prop) (u : ℝ) (hu : 0 ≤ u) |
| (hp : ∀ i,bp (-u) ≤ pr unif (P i)) : |
| |avg unif (fun x => phasedBy M x*phot P x)| ≤ |
| bp ((-(N:ℝ)/2+2*u)*(peak M:ℝ)) * ∏ i,pr unif (P i) := by |
| classical |
| obtain ⟨T,U,hTU,hA⟩ := real_peak M |
| let t := peak M |
| let L := heard T |
| let R := heard U |
| let D := L∪R |
| let S := Finset.univ \ D |
| have hd : Disjoint L R := by |
| refine Finset.disjoint_left.mpr ?_ |
| intro x hx hy |
| obtain ⟨i,_,rfl⟩ := Finset.mem_image.mp hx |
| obtain ⟨j,_,he⟩ := Finset.mem_image.mp hy |
| exact hTU i j he.symm |
| let f (Z : Finset I) (x : Rack (I×J) N) := ∏ i∈Z,ind (P i (led i x)) |
| have hs (V : Finset I) x : |f V x|=f V x := abs_of_nonneg (Finset.prod_nonneg (fun i _ => |
| ind_nonneg _)) |
| have heq (V : Finset I) x : |f V x|≤1 := (hs V x).trans_le |
| ((Finset.prod_le_prod₀ (fun _ _ => ind_nonneg _) (fun _ _ => ind_le_one _)).trans_eq (by simp)) |
| have h1 : |
| (∏ i,pr unif (P i))=(∏ i∈D,pr unif (P i))*(∏ i∈S,pr unif (P i)) := by |
| rw [←Finset.prod_union (show Disjoint D S from disjoint_sdiff), |
| Finset.union_sdiff_of_subset (Finset.subset_univ D)] |
| have hf x : phot P x=f L x*f R x*f S x := by |
| unfold phot f |
| rw [←Finset.prod_union hd,←Finset.prod_union (show Disjoint D S from disjoint_sdiff), |
| Finset.union_sdiff_of_subset (Finset.subset_univ D)] |
| have hl : |
| |avg unif (fun x => phasedBy M x*phot P x)| ≤ bp (-(N:ℝ)*t/2) * avg unif (fun x => |f S x|) := by |
| have he x : phasedBy M x*phot P x=phasedBy M x*f L x*f R x*f S x := by rw [hf]; ring |
| simp_rw [he] |
| rw [←show (M.submatrix T U).rank=t from |
| (mrk_inj.mp hA).trans (Fintype.card_fin _)] |
|
|
| refine layerLeak M (f L) (f R) (f S) T U (heq _) (heq _) (fun x y => ?_) |
| (fun x y => ?_) (fun x y z => ?_) |
| · refine Finset.prod_congr rfl fun i hi => ?_ |
| rw [led_off_r x y (fun h => Finset.disjoint_left.mp hd hi h)] |
| · refine Finset.prod_congr rfl fun i hi => ?_ |
| rw [led_off_l x y (fun h => Finset.disjoint_left.mp hd h hi)] |
| · refine Finset.prod_congr rfl fun i hi => ?_ |
| have hr := (Finset.mem_sdiff.mp hi).2 |
| rw [show x+(upliftR T y,upliftR U z)=x+(0,upliftR U z)+(upliftR T y,0) from |
| by rw [add_assoc]; apply congrArg; apply Prod.ext <;> simp, |
| led_off_l _ y (fun h => hr (mem_union_left _ h)), |
| led_off_r _ z (fun h => hr (mem_union_right _ h))] |
| apply hl.trans |
| simp_rw [hs] |
| rw [show avg unif (fun x => f S x)= _ from led_piece S P,h1,← mul_assoc] |
| refine mul_le_mul_of_nonneg_right ?_ (Finset.prod_nonneg fun _ _ => pr_nonneg unif_law.nz) |
| have hc : D.card ≤ 2*t := by |
| apply le_trans (Finset.card_union_le ..) |
| have hi (T : Fin t→ I × J) : (heard T).card≤t := |
| Finset.card_image_le.trans_eq (by simp) |
| rw [two_mul]; exact add_le_add (hi T) (hi U) |
| have hQ : bp (-u*(2*(t:ℝ))) ≤ ∏ i∈D,pr unif (P i) := by |
| refine le_trans ?_ (Finset.prod_le_prod₀ (fun i _ => (bp_pos _).le) fun i _ => hp i) |
| rw [Finset.prod_const,←bp_mul_nat] |
| apply bp_le |
| apply mul_le_mul_of_nonpos_left |
| · exact_mod_cast hc |
| exact neg_nonpos.mpr hu |
| calc bp _ |
| _ = bp ((-(N:ℝ)/2+2*u)*(peak M:ℝ)) * bp (-u*(2*t)) := by rw [←bp_add]; congr 1; unfold t; ring |
| _ ≤ _ := mul_le_mul_of_nonneg_left hQ (bp_pos _).le |
| end HadwigerCounterexample |
|
|
| end |
|
|
| end OAI |
|
|
