| import Mathlib |
| import OAI.Combinatorics.MatchingCount.Graphs.RatWeight |
|
|
| namespace OAI |
|
|
| noncomputable section |
| namespace MatchingFPRAS.RealStage |
|
|
| open Finset |
|
|
| variable {n : ℕ} |
|
|
| lemma scalingTrace_invariant (hn : 2 ≤ n) (G : Fin n → Fin n → ℝ) |
| (hsym : ∀ i j, G i j=G j i) (hG : ∀ i j, i≠j → alpha ≤ G i j ∧ G i j ≤ 3) |
| (k : ℕ) : ScaleInvariant G (scalingTrace hn G k) ∧ |
| ∀ i, i.val<k → ∃ j, j≠i ∧ scalingTrace hn G k i*scalingTrace hn G k j=G i j := by |
| induction k with |
| | zero => |
| constructor |
| · constructor |
| · intro i; norm_num [scalingTrace,alpha] |
| · intro i; simp [scalingTrace] |
| · intro i j h; have := (hG i j h).2; simp only [scalingTrace]; linarith |
| · intro i hi; omega |
| | succ k ih => |
| by_cases hk : k<n |
| · let i : Fin n := ⟨k,hk⟩ |
| have hinv := scaleUpdate_invariant hn G (scalingTrace hn G k) hsym (fun i j h => (hG i j h).1) ih.1 i |
| have htrace : scalingTrace hn G (k+1)=scaleUpdate hn G (scalingTrace hn G k) i := by |
| simp [scalingTrace,hk,i] |
| rw [htrace] |
| refine ⟨hinv,?_⟩ |
| intro a ha |
| by_cases hak : a.val<k |
| · obtain ⟨j,hj,he⟩ := ih.2 a hak |
| refine ⟨j,hj,?_⟩ |
| exact tight_persists G _ _ ih.1 hinv (scaleUpdate_le hn G _ ih.1 i) a j hj he |
| · have hai : a=i := Fin.ext (by dsimp [i]; omega) |
| subst a |
| exact scaleUpdate_tight hn G _ ih.1 i |
| · have htrace : scalingTrace hn G (k+1)=scalingTrace hn G k := by simp [scalingTrace,hk] |
| rw [htrace] |
| refine ⟨ih.1,?_⟩ |
| intro i _ |
| exact ih.2 i (by have := i.isLt; omega) |
|
|
|
|
|
|
| open Finset |
|
|
| theorem one_pass_scaling {n : ℕ} (hn : 2 ≤ n) (G : Fin n → Fin n → ℝ) |
| (hsym : ∀ i j, G i j=G j i) (hG : ∀ i j, i≠j → alpha ≤ G i j ∧ G i j ≤ 3) : |
| (∀ k i, scalingTrace hn G (k+1) i ≤ scalingTrace hn G k i) ∧ |
| (∀ i, alpha/2 ≤ scalingTrace hn G n i ∧ scalingTrace hn G n i ≤ 2) ∧ |
| (∀ i j, i≠j → G i j ≤ scalingTrace hn G n i * scalingTrace hn G n j) ∧ |
| (∀ i, ∃ j, j≠i ∧ scalingTrace hn G n i * scalingTrace hn G n j=G i j) := by |
| have htrace := scalingTrace_invariant hn G hsym hG |
| refine ⟨?_,(htrace n).1.lower |> fun h => ?_⟩ |
| · intro k i |
| by_cases hk : k<n |
| · change (if h : k<n then scaleUpdate hn G (scalingTrace hn G k) ⟨k,h⟩ else scalingTrace hn G k) i ≤ _ |
| rw [dite_eq_left hk] |
| exact scaleUpdate_le hn G _ (htrace k).1 ⟨k,hk⟩ i |
| · simp [scalingTrace,hk] |
| · refine ⟨fun i => ⟨h i,(htrace n).1.upper i⟩,(htrace n).1.feasible,?_⟩ |
| intro i |
| exact (htrace n).2 i i.isLt |
|
|
|
|
|
|
|
|
| def rowPeak {n : ℕ} (hn : 2 ≤ n) (g : Fin n → Fin n → ℝ) (i : Fin n) : ℝ := |
| (univ.erase i).sup' (others_nonempty hn i) (g i) |
|
|
| def scaledHoleMatrix {n : ℕ} (g : Fin n → Fin n → ℝ) (v : Fin n → ℝ) (i j : Fin n) : ℝ := |
| g i j/(v i*v j) |
|
|
| def BalancedRows {n : ℕ} (hn : 2 ≤ n) (g : Fin n → Fin n → ℝ) : Prop := |
| ∀ i, (1:ℝ)/4 ≤ rowPeak hn g i ∧ rowPeak hn g i ≤ 1 |
|
|
|
|
|
|
|
|
| theorem one_pass_restores_balance {n : ℕ} (hn : 2 ≤ n) (g G : Fin n → Fin n → ℝ) |
| (hGsym : ∀ i j, G i j=G j i) |
| (hG : ∀ i j, i≠j → alpha ≤ G i j ∧ G i j ≤ 3) |
| (hpre : ∀ i, (1:ℝ)/8 ≤ rowPeak hn g i) |
| (haccuracy : ∀ i j, i≠j → g i j ≤ G i j ∧ G i j ≤ g i j+2*alpha) : |
| (∀ i, (1:ℝ)/16 ≤ scalingTrace hn G n i) ∧ |
| BalancedRows hn (scaledHoleMatrix g (scalingTrace hn G n)) := by |
| let v := scalingTrace hn G n |
| have hv := (scalingTrace_invariant hn G hGsym hG n).1 |
| have hlow (i : Fin n) : (1:ℝ)/16 ≤ v i := by |
| obtain ⟨j,hj,heq⟩ := Finset.exists_mem_eq_sup' (others_nonempty hn i) (g i) |
| have hji := (mem_erase.mp hj).1 |
| change rowPeak hn g i=g i j at heq |
| have hgij : (1:ℝ)/8 ≤ g i j := by rw [← heq]; exact hpre i |
| have hGi := (haccuracy i j hji.symm).1 |
| have hfeas := hv.feasible i j hji.symm |
| have hup := mul_le_mul_of_nonneg_left (hv.upper j) (hv.pos i).le |
| dsimp [v] |
| linarith |
| refine ⟨hlow,?_⟩ |
| intro i |
| constructor |
| · obtain ⟨j,hji,heq⟩ := (one_pass_scaling hn G hGsym hG).2.2.2 i |
| have hprod : (1:ℝ)/256 ≤ v i*v j := by |
| calc |
| (1:ℝ)/256 = ((1:ℝ)/16)*((1:ℝ)/16) := by norm_num |
| _ ≤ v i*v j := mul_le_mul (hlow i) (hlow j) (by norm_num) (hv.pos i).le |
| have hacc := (haccuracy i j hji.symm).2 |
| have hg : (1:ℝ)/4 ≤ scaledHoleMatrix g v i j := by |
| apply (le_div_iff₀ (mul_pos (hv.pos i) (hv.pos j))).mpr |
| change v i*v j=G i j at heq |
| norm_num [alpha] at hacc |
| nlinarith |
| apply hg.trans |
| exact Finset.le_sup' (scaledHoleMatrix g v i) (mem_erase.mpr ⟨hji,mem_univ _⟩) |
| · apply Finset.sup'_le |
| intro j hj |
| have hji := (mem_erase.mp hj).1 |
| apply (div_le_one (mul_pos (hv.pos i) (hv.pos j))).mpr |
| exact ((haccuracy i j hji.symm).1).trans (hv.feasible i j hji.symm) |
|
|
|
|
|
|
| def sigma (D K : ℕ) (epsilon : ℝ) : ℝ := min (alpha/(100*D)) (epsilon/(1000*K)) |
|
|
| def ratioEstimate (abar dbar : ℝ) : ℝ := if 0<abar then dbar/abar else 1 |
|
|
| def upperEstimate (D : ℕ) (dbar zbar : ℝ) : ℝ := |
| if 0<dbar then max alpha (min 3 ((D:ℝ)*zbar/dbar+alpha)) else 1 |
|
|
|
|
|
|
| lemma sigma_nonneg (D K : ℕ) (epsilon : ℝ) (he : 0 ≤ epsilon) : 0 ≤ sigma D K epsilon := by |
| unfold sigma alpha; positivity |
|
|
| lemma sigma_small (D K : ℕ) (hD : 1 ≤ D) (epsilon : ℝ) : sigma D K epsilon ≤ (1:ℝ)/10000000 := by |
| have hDr : (1:ℝ) ≤ D := by exact_mod_cast hD |
| apply (min_le_left _ _).trans |
| apply (div_le_iff₀ (by positivity : 0 < (100:ℝ)*D)).mpr |
| norm_num [alpha] |
| linarith |
|
|
| lemma sigma_times_D (D K : ℕ) (hD : 1 ≤ D) (epsilon : ℝ) : (D:ℝ)*sigma D K epsilon ≤ alpha/100 := by |
| have hDr : (1:ℝ) ≤ D := by exact_mod_cast hD |
| have hs : sigma D K epsilon ≤ alpha/(100*D) := min_le_left _ _ |
| have hm := (le_div_iff₀ (by positivity : 0 < (100:ℝ)*D)).mp hs |
| norm_num [alpha] at hm ⊢ |
| nlinarith only [hm] |
|
|
| lemma sigma_relative (D K : ℕ) (epsilon : ℝ) : 10*sigma D K epsilon ≤ epsilon/(100*K) := by |
| have h : sigma D K epsilon ≤ epsilon/(1000*K) := min_le_right _ _ |
| calc |
| _ ≤ 10*(epsilon/(1000*K)) := mul_le_mul_of_nonneg_left h (by norm_num) |
| _ = _ := by ring |
|
|
| lemma ratio_error (s a d abar dbar : ℝ) (hs : 0 ≤ s) (hs1 : s ≤ (1:ℝ)/100) |
| (ha : (1:ℝ)/2 ≤ a) (hR : (1:ℝ)/2 ≤ d/a ∧ d/a ≤ 1) |
| (haerr : |abar-a| ≤ s) (hderr : |dbar-d| ≤ s) : |
| |ratioEstimate abar dbar/(d/a)-1| ≤ 10*s := by |
| have hab := abs_le.mp haerr |
| have hdb := abs_le.mp hderr |
| have hap : 0 < a := by linarith |
| have habp : 0 < abar := by linarith |
| have hRp : 0 < d/a := by linarith [hR.1] |
| have hden : (1:ℝ)/5 ≤ (d/a)*abar := by |
| have hbar : (1:ℝ)/2-s ≤ abar := by linarith |
| have hm := mul_le_mul hR.1 hbar (by linarith : 0 ≤ (1:ℝ)/2-s) hRp.le |
| nlinarith |
| have hnum : |dbar-(d/a)*abar| ≤ 2*s := by |
| have hid : dbar-(d/a)*abar=(dbar-d)+(d/a)*(a-abar) := by |
| have hm : (d/a)*a=d := div_mul_cancel₀ d hap.ne' |
| nlinarith |
| rw [hid] |
| calc |
| _ ≤ |dbar-d|+|(d/a)*(a-abar)| := abs_add_le _ _ |
| _ = |dbar-d|+(d/a)*|abar-a| := by rw [abs_mul,abs_of_pos hRp,abs_sub_comm a abar] |
| _ ≤ s+(d/a)*s := add_le_add hderr (mul_le_mul_of_nonneg_left haerr hRp.le) |
| _ ≤ 2*s := by nlinarith [mul_le_mul_of_nonneg_right hR.2 hs] |
| have hid : ratioEstimate abar dbar/(d/a)-1=(dbar-(d/a)*abar)/((d/a)*abar) := by |
| simp only [ratioEstimate, ite_eq_left habp] |
| have hdne : d ≠ 0 := by intro hh; simp [hh] at hRp |
| field_simp [hap.ne', habp.ne', hdne] |
| rw [hid,abs_div,abs_of_pos (mul_pos hRp habp)] |
| apply (div_le_iff₀ (mul_pos hRp habp)).mpr |
| nlinarith [mul_le_mul_of_nonneg_right hden (show 0 ≤ 10*s by positivity)] |
|
|
|
|
|
|
| lemma upper_error (D : ℕ) (hD : 1 ≤ D) (s d z dbar zbar : ℝ) |
| (hs : 0 ≤ s) (hs1 : s ≤ (1:ℝ)/100) |
| (hDs : (D:ℝ)*s ≤ alpha/100) (hd : (1:ℝ)/4 ≤ d) |
| (hg : 0 ≤ (D:ℝ)*z/d ∧ (D:ℝ)*z/d ≤ 2) |
| (hderr : |dbar-d| ≤ s) (hzerr : |zbar-z| ≤ s) : |
| alpha ≤ upperEstimate D dbar zbar ∧ upperEstimate D dbar zbar ≤ 3 ∧ |
| (D:ℝ)*z/d ≤ upperEstimate D dbar zbar ∧ |
| upperEstimate D dbar zbar ≤ (D:ℝ)*z/d+2*alpha := by |
| have hDr : (1:ℝ) ≤ D := by exact_mod_cast hD |
| have hdp : 0 < d := by linarith |
| have hdb := abs_le.mp hderr |
| have hbar : (1:ℝ)/5 ≤ dbar := by linarith |
| have hbarp : 0 < dbar := by linarith |
| let g := (D:ℝ)*z/d |
| have hg0 : 0 ≤ g := hg.1 |
| have hg2 : g ≤ 2 := hg.2 |
| have hnum : |(D:ℝ)*(zbar-z)+g*(d-dbar)| ≤ ((D:ℝ)+2)*s := by |
| calc |
| _ ≤ |(D:ℝ)*(zbar-z)|+|g*(d-dbar)| := abs_add_le _ _ |
| _ = (D:ℝ)*|zbar-z|+g*|dbar-d| := by |
| rw [abs_mul, abs_mul, abs_of_nonneg (Nat.cast_nonneg D), abs_of_nonneg hg0, |
| abs_sub_comm d dbar] |
| _ ≤ (D:ℝ)*s+g*s := add_le_add (mul_le_mul_of_nonneg_left hzerr (Nat.cast_nonneg D)) |
| (mul_le_mul_of_nonneg_left hderr hg0) |
| _ ≤ ((D:ℝ)+2)*s := by nlinarith [mul_le_mul_of_nonneg_right hg2 hs] |
| have hid : (D:ℝ)*zbar/dbar-g=((D:ℝ)*(zbar-z)+g*(d-dbar))/dbar := by |
| dsimp [g] |
| field_simp [hdp.ne', hbarp.ne'] |
| ring |
| have hraw : |(D:ℝ)*zbar/dbar-g| ≤ alpha := by |
| rw [hid, abs_div, abs_of_pos hbarp] |
| apply (div_le_iff₀ hbarp).mpr |
| have hsm : s ≤ (D:ℝ)*s := by nlinarith [mul_le_mul_of_nonneg_right hDr hs] |
| have ha : 0 < alpha := by norm_num [alpha] |
| have hm := mul_le_mul_of_nonneg_left hbar ha.le |
| norm_num [alpha] at hDs hm ⊢ |
| nlinarith only [hDs, hm, hnum, hsm] |
| have hbounds := abs_le.mp hraw |
| unfold upperEstimate |
| rw [ite_eq_left hbarp] |
| refine ⟨le_max_left _ _, ?_, ?_, ?_⟩ |
| · apply max_le |
| · norm_num [alpha] |
| · exact min_le_left _ _ |
| · apply le_max_of_le_right |
| exact le_min (by linarith) (by linarith) |
| · apply max_le |
| · have ha : 0 ≤ alpha := by norm_num [alpha] |
| linarith |
| · exact (min_le_right _ _).trans (by linarith) |
|
|
|
|
|
|
| theorem successful_stage_estimates (D K : ℕ) (hD : 1 ≤ D) (_hK : 1 ≤ K) |
| (epsilon : ℝ) (he : 0<epsilon) (he1 : epsilon<1) |
| (a d z abar dbar zbar : ℝ) (ha : (1:ℝ)/2 ≤ a) (hd : (1:ℝ)/4 ≤ d) |
| (hR : (1:ℝ)/2 ≤ d/a ∧ d/a ≤ 1) |
| (hg : 0 ≤ (D:ℝ)*z/d ∧ (D:ℝ)*z/d ≤ 2) |
| (haerr : |abar-a| ≤ sigma D K epsilon) |
| (hderr : |dbar-d| ≤ sigma D K epsilon) |
| (hzerr : |zbar-z| ≤ sigma D K epsilon) : |
| 0<abar ∧ 0<dbar ∧ |
| |ratioEstimate abar dbar/(d/a)-1| ≤ 10*sigma D K epsilon ∧ |
| 10*sigma D K epsilon ≤ epsilon/(100*K) ∧ |
| alpha ≤ upperEstimate D dbar zbar ∧ upperEstimate D dbar zbar ≤ 3 ∧ |
| (D:ℝ)*z/d ≤ upperEstimate D dbar zbar ∧ |
| upperEstimate D dbar zbar ≤ (D:ℝ)*z/d+2*alpha := by |
| have hs := sigma_nonneg D K epsilon he.le |
| have hs1 : sigma D K epsilon ≤ (1:ℝ)/100 := |
| (sigma_small D K hD epsilon).trans (by norm_num) |
| have hab := abs_le.mp haerr |
| have hdb := abs_le.mp hderr |
| refine ⟨by linarith, by linarith, ?_, sigma_relative D K epsilon, ?_⟩ |
| · exact ratio_error _ _ _ _ _ hs hs1 ha hR haerr hderr |
| · exact upper_error D hD _ _ _ _ _ hs hs1 (sigma_times_D D K hD epsilon) hd hg hderr hzerr |
|
|
| end MatchingFPRAS.RealStage |
|
|
| end |
|
|
| namespace MatchingFPRAS.Enlargement |
|
|
| open MatchingFPRAS.Switching MatchingFPRAS.Subdivision MatchingFPRAS.RealGeometry |
| open MatchingFPRAS.Hierarchy MatchingFPRAS.Transport MatchingFPRAS.StageAnalysis Finset |
| open scoped Classical |
|
|
| variable {V : Type*} [Fintype V] [LinearOrder V] |
|
|
| def pairEdge (i j : V) (hij : i≠j) : LogicalEdge V := |
| ⟨(min i j,max i j),min_lt_max.mpr hij⟩ |
|
|
| omit [Fintype V] in |
| lemma pairEdge_swap (i j : V) (hij : i≠j) : pairEdge i j hij=pairEdge j i hij.symm := by |
| apply Subtype.ext |
| simp [pairEdge,min_comm,max_comm] |
|
|
| omit [Fintype V] in |
| lemma pairEdge_holes (i j : V) (hij : i≠j) : |
| ({source (pairEdge i j hij),target (pairEdge i j hij)} : Finset V)={i,j} := by |
| rcases le_total i j with h|h |
| · simp [pairEdge,source,target,min_eq_left h,max_eq_right h] |
| · simp [pairEdge,source,target,min_eq_right h,max_eq_left h,Finset.pair_comm] |
|
|
| noncomputable def probeMatrix (z : LogicalEdge V → ℝ) (i j : V) : ℝ := |
| if hij : i=j then 0 else z (pairEdge i j hij) |
|
|
| omit [Fintype V] in |
| lemma probeMatrix_off (z : LogicalEdge V → ℝ) (i j : V) (hij : i≠j) : |
| probeMatrix z i j=z (pairEdge i j hij) := dite_eq_right hij |
|
|
| omit [Fintype V] in |
| lemma probeMatrix_symm (z : LogicalEdge V → ℝ) (i j : V) : probeMatrix z i j=probeMatrix z j i := by |
| by_cases hij : i=j |
| · subst j; rfl |
| · rw [probeMatrix_off _ _ _ hij,probeMatrix_off _ _ _ (Ne.symm hij),pairEdge_swap] |
|
|
| noncomputable def estimateMatrix (D : ℕ) (dbar : ℝ) (zbar : LogicalEdge V → ℝ) (i j : V) : ℝ := |
| RealStage.upperEstimate D dbar (probeMatrix zbar i j) |
|
|
| omit [Fintype V] in |
| lemma estimateMatrix_symm (D : ℕ) (dbar : ℝ) (zbar : LogicalEdge V → ℝ) (i j : V) : |
| estimateMatrix D dbar zbar i j=estimateMatrix D dbar zbar j i := by |
| rw [estimateMatrix,estimateMatrix,probeMatrix_symm] |
|
|
| lemma rowMax_cooling_lower (hn : 2 ≤ Fintype.card V) (w w₁ : V → V → ℝ) |
| (hw : ∀ x y,0 ≤ w x y) (hz : 0 < partition w ∅) |
| (hr : ∀ i,(1:ℝ)/4 ≤ rowMax hn w i) |
| (hc : ∀ R,partition w R/2 ≤ partition w₁ R ∧ partition w₁ R ≤ partition w R) (i : V) : |
| (1:ℝ)/8 ≤ rowMax hn w₁ i := by |
| obtain ⟨j,hji,hj⟩ := rowMax_attained hn w i |
| have h := (holeRatio_cooling w w₁ hw hz hc {i,j}).1 |
| have hu := holeRatio_le_rowMax hn w₁ i j hji.symm |
| rw [hj] at h |
| linarith [hr i] |
|
|
| variable [Nontrivial V] |
|
|
| noncomputable local instance (w : V → V → ℝ) (K : ℕ) : DecidableEq (SourceLabel w K) := Classical.decEq _ |
|
|
| noncomputable local instance (w : V → V → ℝ) (K : ℕ) : Fintype (BagEdge (sourceBags w K)) := Fintype.ofFinite _ |
|
|
| noncomputable def meanA (w : V → V → ℝ) (K : ℕ) : ℝ := |
| ∑ q : SourceMarked w K,sourceLaw w K (sourceD (V:=V) K) q*observableA w K q |
|
|
| noncomputable def meanD (w w₁ : V → V → ℝ) (K : ℕ) : ℝ := |
| ∑ q : SourceMarked w K,sourceLaw w K (sourceD (V:=V) K) q*observableD w w₁ K q |
|
|
| noncomputable def meanProbe (w w₁ : V → V → ℝ) (K : ℕ) (e : LogicalEdge (V)) : ℝ := |
| ∑ q : SourceMarked w K,sourceLaw w K (sourceD (V:=V) K) q*observableProbe w w₁ K e q |
|
|
| variable {n : ℕ} [Nontrivial (Fin n)] |
|
|
| noncomputable local instance (w : Fin n → Fin n → ℝ) (K : ℕ) : DecidableEq (SourceLabel w K) := Classical.decEq _ |
|
|
| noncomputable local instance (w : Fin n → Fin n → ℝ) (K : ℕ) : Fintype (BagEdge (sourceBags w K)) := Fintype.ofFinite _ |
|
|
| omit [Nontrivial (Fin n)] in |
| lemma rowPeak_holeMatrix (hn : 2 ≤ n) (w : Fin n → Fin n → ℝ) (i : Fin n) : |
| RealStage.rowPeak hn (fun i j => Switching.holeRatio w {i,j}) i= |
| rowMax (by simpa using hn) w i := rfl |
|
|
| structure StageData (n K T : ℕ) where |
| hn : 2 ≤ n |
| w : Fin n → Fin n → ℝ |
| next : Fin n → Fin n → ℝ |
| positive : ∀ i j,0 < w i j |
| next_positive : ∀ i j,0 < next i j |
| partition_positive : 0 < partition w ∅ |
| lower : ∀ i,(1:ℝ)/4 ≤ rowMax (by simpa using hn) w i |
| upper : ∀ i,rowMax (by simpa using hn) w i ≤ 1 |
| cool_lower : ∀ i j,i≠j → (1+1/(n:ℝ))⁻¹*w i j ≤ next i j |
| cool_upper : ∀ i j,i≠j → next i j ≤ w i j |
| cap : ∀ i j,i≠j → edgeActivity w i j ≤ (4:ℝ)^K |
| stages : 1 ≤ T |
| epsilon : ℝ |
| epsilon_positive : 0 < epsilon |
| epsilon_lt_one : epsilon < 1 |
|
|
| variable {K T : ℕ} |
|
|
| structure EmpiricalData (c : StageData n K T) where |
| abar : ℝ |
| dbar : ℝ |
| zbar : LogicalEdge (Fin n) → ℝ |
| errorA : |abar-meanA c.w K| ≤ RealStage.sigma (sourceD (V:=Fin n) K) T c.epsilon |
| errorD : |dbar-meanD c.w c.next K| ≤ RealStage.sigma (sourceD (V:=Fin n) K) T c.epsilon |
| errorProbe : ∀ e,|zbar e-meanProbe c.w c.next K e| ≤ RealStage.sigma (sourceD (V:=Fin n) K) T c.epsilon |
|
|
| omit [Nontrivial (Fin n)] in |
| lemma StageData.cooling (c : StageData n K T) (R : Finset (Fin n)) : |
| partition c.w R/2 ≤ partition c.next R ∧ partition c.next R ≤ partition c.w R := by |
| apply partition_cooling (by simpa using c.hn) c.w c.next (fun i j => (c.positive i j).le) |
| · simpa using c.cool_lower |
| · exact c.cool_upper |
|
|
| lemma StageData.mean_bounds (c : StageData n K T) : |
| (1:ℝ)/2 ≤ meanA c.w K ∧ (1:ℝ)/4 ≤ meanD c.w c.next K ∧ |
| meanD c.w c.next K/meanA c.w K=partition c.next ∅/partition c.w ∅ ∧ |
| (1:ℝ)/2 ≤ meanD c.w c.next K/meanA c.w K ∧ meanD c.w c.next K/meanA c.w K ≤ 1 ∧ |
| (∀ e,(sourceD (V:=Fin n) K:ℝ)*meanProbe c.w c.next K e/meanD c.w c.next K= |
| Switching.holeRatio c.next {source e,target e}) := by |
| have h := source_observable_means (V:=Fin n) (by simpa using c.hn) c.w c.next c.positive c.partition_positive |
| c.lower c.upper (by simpa using c.cool_lower) c.cool_upper K c.cap |
| unfold meanA meanD meanProbe |
| exact h.2.2 |
|
|
| omit [Nontrivial (Fin n)] in |
| lemma StageData.hole_upper (c : StageData n K T) (i j : Fin n) (hij : i≠j) : |
| Switching.holeRatio c.next {i,j} ≤ 2 := by |
| have h := (holeRatio_cooling c.w c.next (fun i j => (c.positive i j).le) |
| c.partition_positive c.cooling {i,j}).2 |
| have hr := (holeRatio_le_rowMax (by simpa using c.hn) c.w i j hij).trans (c.upper i) |
| linarith |
|
|
| theorem actual_stage_statistics (c : StageData n K T) (b : EmpiricalData c) (i j : Fin n) (hij : i≠j) : |
| let G := estimateMatrix (sourceD (V:=Fin n) K) b.dbar b.zbar |
| 0 < b.abar ∧ 0 < b.dbar ∧ |
| |RealStage.ratioEstimate b.abar b.dbar/(partition c.next ∅/partition c.w ∅)-1| ≤ c.epsilon/(100*T) ∧ |
| RealStage.alpha ≤ G i j ∧ G i j ≤ 3 ∧ |
| Switching.holeRatio c.next {i,j} ≤ G i j ∧ |
| G i j ≤ Switching.holeRatio c.next {i,j}+2*RealStage.alpha := by |
| dsimp only |
| have hm := c.mean_bounds |
| have hem := hm.2.2.2.2.2 (pairEdge i j hij) |
| rw [pairEdge_holes] at hem |
| have hg0 := holeRatio_nonneg c.next (fun x y => (c.next_positive x y).le) {i,j} |
| have h := RealStage.successful_stage_estimates (sourceD (V:=Fin n) K) T (sourceD_one K) |
| c.stages c.epsilon c.epsilon_positive c.epsilon_lt_one |
| (meanA c.w K) (meanD c.w c.next K) (meanProbe c.w c.next K (pairEdge i j hij)) |
| b.abar b.dbar (b.zbar (pairEdge i j hij)) hm.1 hm.2.1 |
| ⟨hm.2.2.2.1,hm.2.2.2.2.1⟩ |
| ⟨by rw [hem]; exact hg0,by rw [hem]; exact c.hole_upper i j hij⟩ |
| b.errorA b.errorD (b.errorProbe _) |
| refine ⟨h.1,h.2.1,?_,?_⟩ |
| · have he := h.2.2.1.trans h.2.2.2.1 |
| rwa [hm.2.2.1] at he |
| · simpa only [estimateMatrix,probeMatrix_off _ _ _ hij,hem] using h.2.2.2.2 |
|
|
| theorem actual_successful_stage (c : StageData n K T) (b : EmpiricalData c) : |
| let G := estimateMatrix (sourceD (V:=Fin n) K) b.dbar b.zbar |
| let v := RealStage.scalingTrace c.hn G n |
| (∀ i,(1:ℝ)/16 ≤ v i ∧ v i ≤ 2) ∧ |
| (∀ i,(1:ℝ)/4 ≤ rowMax (by simpa using c.hn) (fun x y => c.next x y*v x*v y) i ∧ |
| rowMax (by simpa using c.hn) (fun x y => c.next x y*v x*v y) i ≤ 1) ∧ |
| |RealStage.ratioEstimate b.abar b.dbar/(partition c.next ∅/partition c.w ∅)-1| ≤ c.epsilon/(100*T) := by |
| dsimp only |
| let G := estimateMatrix (sourceD (V:=Fin n) K) b.dbar b.zbar |
| let g := fun i j => Switching.holeRatio c.next {i,j} |
| have hest := actual_stage_statistics c b |
| have hGs := estimateMatrix_symm (sourceD (V:=Fin n) K) b.dbar b.zbar |
| have hGb : ∀ i j,i≠j → RealStage.alpha ≤ G i j ∧ G i j ≤ 3 := by |
| intro i j hij |
| exact ⟨(hest i j hij).2.2.2.1,(hest i j hij).2.2.2.2.1⟩ |
| have hGa : ∀ i j,i≠j → g i j ≤ G i j ∧ G i j ≤ g i j+2*RealStage.alpha := by |
| intro i j hij |
| exact (hest i j hij).2.2.2.2.2 |
| have hpre : ∀ i,(1:ℝ)/8 ≤ RealStage.rowPeak c.hn g i := by |
| intro i |
| rw [show g=(fun i j => Switching.holeRatio c.next {i,j}) from rfl,rowPeak_holeMatrix] |
| exact rowMax_cooling_lower (by simpa using c.hn) c.w c.next (fun x y => (c.positive x y).le) |
| c.partition_positive c.lower c.cooling i |
| have hb := RealStage.one_pass_restores_balance c.hn g G hGs hGb hpre hGa |
| let v := RealStage.scalingTrace c.hn G n |
| have hv := (RealStage.scalingTrace_invariant c.hn G hGs hGb n).1 |
| have heq (i j : Fin n) (hij : i≠j) : |
| Switching.holeRatio (fun x y => c.next x y*v x*v y) {i,j}=RealStage.scaledHoleMatrix g v i j := by |
| rw [holeRatio_vertex_scaling c.next v (fun x => hv.pos x),Finset.prod_pair hij] |
| rfl |
| have hb' (i : Fin n) : (1:ℝ)/4 ≤ rowMax (by simpa using c.hn) (fun x y => c.next x y*v x*v y) i ∧ |
| rowMax (by simpa using c.hn) (fun x y => c.next x y*v x*v y) i ≤ 1 := by |
| have he : rowMax (by simpa using c.hn) (fun x y => c.next x y*v x*v y) i= |
| RealStage.rowPeak c.hn (RealStage.scaledHoleMatrix g v) i := by |
| unfold rowMax RealStage.rowPeak |
| apply Finset.sup'_congr _ rfl |
| intro j hj |
| exact heq i j (Finset.mem_erase.mp hj).1.symm |
| rw [he] |
| exact hb.2 i |
| refine ⟨fun i => ⟨hb.1 i,hv.upper i⟩,hb',?_⟩ |
| let i : Fin n := ⟨0,by have := c.hn; omega⟩ |
| let j : Fin n := ⟨1,by have := c.hn; omega⟩ |
| have hij : i≠j := by intro h; have := Fin.val_eq_of_eq h; dsimp [i,j] at this; omega |
| exact (hest i j hij).2.2.1 |
|
|
| end MatchingFPRAS.Enlargement |
|
|
| end OAI |
|
|
