| import OAI.Combinatorics.HadwigerCounterexample.FiniteConditioning |
| import OAI.Combinatorics.HadwigerCounterexample.ConditionalProductLaws |
|
|
| namespace OAI |
|
|
| /-! # Cell Pruning -/ |
|
|
| noncomputable section |
| namespace HadwigerCounterexample |
| open scoped BigOperators |
| open Finset |
| variable {A B I J : Type} [Fintype A] [Fintype B] [Fintype I] [Fintype J] |
|
|
| theorem sum_pr_tag (w : Wgt A) (P : A → Prop) (f : A→I) : |
| ∑ i:I,pr w (fun x => P x ∧ f x=i) = pr w P := by |
| classical |
| unfold pr |
| rw [← avg_sum] |
| refine avg_congr fun x _ => ?_ |
| simp only [ind_and, ← Finset.mul_sum] |
| rw [Finset.sum_eq_single (f x)] |
| · rw [ind_one rfl,mul_one] |
| · intro j _ hj; exact ind_zero hj.symm |
| simp |
|
|
| /-- implication needed only almost surely for finite measures. -/ |
| theorem pr_on_mono {w : Wgt A} (hw : ∀ x,0≤w x) {P Q : A→Prop} |
| (h : ∀ x,w x≠0→ P x→ Q x) : pr w P ≤ pr w Q := |
| Finset.sum_le_sum (fun x _ => by |
| by_cases he : w x=0 |
| · simp [he] |
| exact mul_le_mul_of_nonneg_left (ind_mono (h x he)) (hw x)) |
|
|
| theorem sum_pr_cells (w : Wgt (A × B)) (P : A × B → Prop) (f : A→I) (g : B→J) : |
| ∑ i:I,∑ j:J,pr w (fun x => P x ∧ f x.1=i ∧ g x.2=j) = pr w P := by |
| classical |
| rw [← sum_pr_tag w P (fun x => (f x.1,g x.2)), Fintype.sum_prod_type] |
| simp only [Prod.mk.injEq] |
|
|
| /-- restore the full pair-event probability in a specified cell. -/ |
| theorem pair_restore (u : Wgt A) (v : Wgt B) (P : A → Prop) (Q : B → Prop) |
| (hP : 0 < pr u P) (hQ : 0 < pr v Q) |
| (c : A × B → Prop) : |
| pr (pairW u v) (fun x => P x.1 ∧ Q x.2 ∧ c x)= |
| pr u P * pr v Q * pr (pairW (onW u P) (onW v Q)) c := by |
| classical |
| let D := pr u P * pr v Q |
| let d := pairW (onW u P) (onW v Q) |
| change avg _ _ = D*avg d _ |
| unfold avg |
| rw [Finset.mul_sum] |
| refine Finset.sum_congr rfl fun i _ => ?_ |
| simp only [pairW,d,onW_val,D,ind_and] |
| field_simp |
|
|
| def memberC (p : A→Prop) (f : A→I) (i : I) (x : A) := p x ∧ f x=i |
|
|
| /-- heavy cells criterion. Loss charged to τ times opposite mass |
| rather than τ alone (key q fixed). -/ |
| theorem prune_pairs (w : Wgt A) (v : Wgt B) (hw : SubLaw w) (hv : SubLaw v) |
| (P : A → Prop) (Q : B→Prop) (f : A→I) (g : B→J) |
| (C : A×B→Prop) (H T : ℝ) (hH : 0≤H) (hT : 0<T) |
| {L : ℝ} (hi : (Fintype.card I : ℝ) ≤ L) |
| (hj : (Fintype.card J : ℝ) ≤ L) |
| (h : ∀ i j,T ≤ pr w (memberC P f i) → T ≤ pr v (memberC Q g j) → |
| H≤ pr (pairW (onW w (memberC P f i)) (onW v (memberC Q g j))) C) : |
| H * (pr w P * pr v Q) ≤ pr (pairW w v) (fun x => P x.1 ∧ Q x.2 ∧ C x) + |
| (H*T*L)*(pr w P+pr v Q) := by |
| classical |
| let a (i:I) := pr w (memberC P f i) |
| let b (i:J) := pr v (memberC Q g i) |
| let d (i:I) (j:J) := pr (pairW w v) (fun x => memberC P f i x.1 ∧ memberC Q g j x.2 ∧ C x) |
| have ha i : 0≤a i := pr_nonneg hw.nz |
| have hb i : 0≤b i := pr_nonneg hv.nz |
| have he i j : H*(a i*b j) ≤ d i j+ H*T*b j + H*T*a i := by |
| have hz : 0≤ d i j := pr_nonneg (subLaw_pair hw hv).nz |
| have ha' := mul_nonneg (mul_nonneg hH hT.le) (ha i) |
| have hb' := mul_nonneg (mul_nonneg hH hT.le) (hb j) |
| by_cases ht : T ≤ a i |
| · by_cases hh : T ≤ b j |
| · have hc := mul_le_mul_of_nonneg_right (h i j ht hh) (mul_nonneg (ha i) (hb j)) |
| have h1 := pair_restore w v _ _ (lt_of_lt_of_le hT ht) (lt_of_lt_of_le hT hh) C |
| refine hc.trans ?_ |
| rw [mul_comm (pr _ C)] |
| change _ ≤ d i j + _ + _ |
| unfold d |
| rw [h1] |
| change _ ≤ a i*b j * _ + _+_ |
| linarith |
| · have hg := mul_le_mul_of_nonneg_left (le_of_not_ge hh) (mul_nonneg hH (ha i)) |
| calc H*(a i*b j) ≤ H*T*a i := by linarith only [hg] |
| _ ≤ _ := by linarith only [hb',hz] |
| have hg := mul_le_mul_of_nonneg_left (le_of_not_ge ht) (mul_nonneg hH (hb j)) |
| calc H*(a i*b j) ≤ H*T*b j := by linarith only [hg] |
| _ ≤ _ := by linarith only [ha',hz] |
| have hA : pr w P=∑ i,a i := (sum_pr_tag w P f).symm |
| have hB : pr v Q=∑ j,b j := (sum_pr_tag v Q g).symm |
| have hC : |
| pr (pairW w v) (fun x => P x.1 ∧ Q x.2 ∧ C x) = ∑ i,∑ j,d i j := by |
| rw [← sum_pr_cells (pairW w v) _ f g] |
| refine Finset.sum_congr rfl fun i _ => Finset.sum_congr rfl fun j _ => ?_ |
| unfold d; congr 1; unfold memberC; ext; tauto |
| have h1 : H * (pr w P * pr v Q)=∑ i,∑ j,H*(a i*b j) := by |
| rw [hA,hB] |
| simp only [Finset.sum_mul,Finset.mul_sum] |
| exact Finset.sum_comm; |
| have h2 : ∑ i:I,∑ j:J,H*T*b j=(Fintype.card I:ℝ)*(H*T*pr v Q) := by |
| simp only [← Finset.mul_sum,←hB,Finset.sum_const, Finset.card_univ, nsmul_eq_mul] |
| ring |
| have h3 : ∑ i:I,∑ j:J,H*T*a i=(Fintype.card J:ℝ)*(H*T*pr w P) := by |
| rw [Finset.sum_comm] |
| simp only [← Finset.mul_sum,←hA,Finset.sum_const,Finset.card_univ,nsmul_eq_mul] |
| ring |
| rw [h1] |
| refine (Finset.sum_le_sum fun i _ => Finset.sum_le_sum fun j _ => he i j).trans ?_ |
| simp only [Finset.sum_add_distrib] |
| rw [h2,h3,← hC] |
| have hh := mul_le_mul_of_nonneg_right hj (show 0≤H*T*pr w P from |
| mul_nonneg (mul_nonneg hH hT.le) (pr_nonneg hw.nz)) |
| have hh' := mul_le_mul_of_nonneg_right hi (show 0≤H*T*pr v Q from |
| mul_nonneg (mul_nonneg hH hT.le) (pr_nonneg hv.nz)) |
| linarith only [hh,hh'] |
|
|
| end HadwigerCounterexample |
|
|
| end |
|
|
| end OAI |
|
|
