| import OAI.Probability.GaussianPropeller.Configuration |
|
|
| namespace OAI |
|
|
| open MeasureTheory ProbabilityTheory |
| open scoped ENNReal |
| open scoped RealInnerProductSpace |
| open scoped RealInnerProductSpace |
| open MeasureTheory ProbabilityTheory Set |
| open scoped ENNReal RealInnerProductSpace |
| open Filter |
| open scoped Topology |
| open MeasureTheory ProbabilityTheory Set Filter |
| open scoped Topology |
| open scoped RealInnerProductSpace |
| open Set Filter |
| open scoped Topology RealInnerProductSpace |
| open scoped NNReal |
| open Set Filter |
| open scoped Topology RealInnerProductSpace NNReal |
| open MeasureTheory ProbabilityTheory Set Filter |
| open scoped Topology RealInnerProductSpace |
| open MeasureTheory Set Filter |
| open scoped Topology BigOperators |
| open MeasureTheory ProbabilityTheory Set Filter |
| open scoped RealInnerProductSpace Topology |
| open MeasureTheory ProbabilityTheory Set Filter |
| open scoped RealInnerProductSpace Topology ENNReal |
| open MeasureTheory ProbabilityTheory Set Filter |
| open scoped RealInnerProductSpace Topology ENNReal |
| open Metric |
| open MeasureTheory ProbabilityTheory Set |
| open scoped RealInnerProductSpace ENNReal |
| open MeasureTheory ProbabilityTheory Set Filter |
| open scoped ENNReal RealInnerProductSpace |
|
|
| namespace GaussianPropeller.Reduction.Configuration |
| variable {d k:ℕ} |
|
|
| lemma impossible_five_or_more (D:Configuration d k) (hk:5≤k) : False := by |
| classical |
| let r:ℕ→ℝ := fun i=>if hi:i<k then ‖D.z ⟨i,hi⟩‖ else 0 |
| let P:ℕ→ℝ := fun i=>if hi:i<k then D.P ⟨i,hi⟩ else 0 |
| have hr:∀ i:Fin k,r i=‖D.z i‖ := by intro i; simp [r,i.isLt] |
| have hp:∀ i:Fin k,P i=D.P i := by intro i; simp [P,i.isLt] |
| have hnorm:∑ i∈Finset.range k,r i^2=1 := by |
| rw [Finset.sum_range] |
| simpa only [hr] using D.norm |
| have hprob:∑ i∈Finset.range k,P i=1 := by |
| rw [Finset.sum_range] |
| simpa only [hp] using D.probability |
| let i:Fin k:=⟨k-1,by omega⟩ |
| let j:Fin k:=⟨0,by omega⟩ |
| let l:Fin k:=⟨1,by omega⟩ |
| let q:Fin k:=⟨2,by omega⟩ |
| have hdet:=configuration_determinants D.z D.zero D.obtuse i (D.pos i) |
| (j:=j) (l:=l) (q:=q) (by dsimp [i,j]; intro h; have:=congrArg Fin.val h; simp at this; omega) |
| (by dsimp [i,l]; intro h; have:=congrArg Fin.val h; simp at this; omega) |
| (by dsimp [i,q]; intro h; have:=congrArg Fin.val h; simp at this; omega) |
| (by simp [j,l,Fin.ext_iff]) (by simp [j,q,Fin.ext_iff]) (by simp [l,q,Fin.ext_iff]) |
| (D.order (by simp [j,q])) (D.order (by simp [l,q])) |
| (D.order (by change 2≤k-1; omega)) (D.pair i) |
| apply Scalar.scalar_incompatibility hk r P |
| · intro a ha |
| simp only [r,dite_eq_left ha] |
| exact norm_pos_iff.mpr (D.pos _) |
| · intro a ha b hb hab |
| simp only [Set.mem_Iio] at ha hb |
| simp only [r,dite_eq_left ha,dite_eq_left hb] |
| exact D.order (show (⟨a,ha⟩:Fin k)≤⟨b,hb⟩ from hab) |
| · intro a ha |
| simpa only [r,dite_eq_left ha] using D.cap ⟨a,ha⟩ |
| · exact hnorm |
| · exact hprob |
| · intro a ha |
| simpa only [r,P,dite_eq_left ha] using D.quadratic ⟨a,ha⟩ |
| · intro a ha |
| simpa only [r,P,dite_eq_left ha] using D.linear ⟨a,ha⟩ |
| · simpa only [r,dite_eq_left (show 0<k by omega),dite_eq_left (show 1<k by omega), |
| dite_eq_left (show 2<k by omega),dite_eq_left (show k-1<k by omega),i,j,l,q] using hdet.1 |
| · simpa only [r,dite_eq_left (show 2<k by omega),dite_eq_left (show k-1<k by omega),i,q] using hdet.2 |
|
|
| lemma impossible_four (D:Configuration d 4) : False := |
| four_incompatibility D.z D.P D.zero D.norm D.pos D.order D.obtuse D.cap |
| D.probability D.half (D.cap3 rfl) D.linear (D.loss4 rfl) D.pair |
|
|
| end GaussianPropeller.Reduction.Configuration |
|
|
| namespace GaussianPropeller.Reduction |
| variable {d k:ℕ} |
|
|
| lemma remove_null_partition {A:Fin (k+1)→Set (Space d)} (hA:IsPartition A) |
| (i:Fin (k+1)) (hi:gaussian d (A i)=0) : |
| IsPartition (fun j:Fin k=>A (i.succAbove j)) := by |
| constructor |
| · intro j; exact hA.1 _ |
| have hn:∀ᵐ x∂gaussian d,x∉A i := by |
| exact (ae_iff.mpr (by simpa using hi)) |
| filter_upwards [hA.2,hn] with x hx hxi |
| obtain ⟨j,hj,huniq⟩:=hx |
| have hji:j≠i := by intro hh; subst j; contradiction |
| obtain ⟨a,ha⟩:=Fin.exists_succAbove_eq hji |
| refine ⟨a,?_,?_⟩ |
| · simpa only [ha] using hj |
| · intro b hb |
| apply Fin.succAbove_right_injective |
| exact (huniq _ hb).trans ha.symm |
|
|
| lemma remove_null_value {A:Fin (k+1)→Set (Space d)} (i:Fin (k+1)) |
| (hi:gaussian d (A i)=0) : value (fun j:Fin k=>A (i.succAbove j))=value A := by |
| unfold value |
| rw [Fin.sum_univ_succAbove (fun j=>‖centroid (A j)‖^2) i,centroid_eq_zero_of_null hi] |
| simp |
|
|
| lemma partition_bound_small {A:Fin k→Set (Space d)} (hk:k≤3) (hA:IsPartition A) : |
| value A≤9/(8*Real.pi) := by |
| have he:∃ B:Fin 3→Set (Space d), IsPartition B ∧ value B=value A := by |
| have hc:∀ m, k ≤ m → ∃ B:Fin m→Set (Space d), IsPartition B ∧ value B=value A := by |
| intro m hm |
| induction m,hm using Nat.le_induction with |
| | base => exact ⟨A,hA,rfl⟩ |
| | succ m hm ih => |
| obtain ⟨B,hB,hv⟩:=ih |
| let B' : Fin (m+1) → Set (Space d) := Fin.lastCases ∅ B |
| have hp : IsPartition B' := append_empty_partition (A := B) hB |
| have he : value B' = value B := append_empty_value B |
| exact ⟨B',hp,he.trans hv⟩ |
| exact hc 3 hk |
| obtain ⟨B,hB,hv⟩:=he |
| rw [←hv] |
| exact three_partition_bound hB |
|
|
| end GaussianPropeller.Reduction |
|
|
| end OAI |
|
|
