| import OAI.Combinatorics.MatchingPSD.PolynomialInterpolation |
|
|
| namespace OAI |
|
|
| universe u_1 u_2 |
|
|
| namespace MatchingInterpolation |
| open MatchingSmoothing Matrix PerfectMatchingPSD |
| open scoped BigOperators MatrixOrder |
| attribute [local instance] Classical.propDecidable |
|
|
| noncomputable def specialPoint : Fin 5 → Point := |
| ![origin, origin+dirP, origin+dirStar, origin+dirA, origin+dirB] |
| def specialCoeff : Fin 5 → ℝ := ![1,-2,-1,1,1] |
| noncomputable def scaledNode {d : ℕ} (L : ℝ) (g : GridIndex d) : Point := |
| fun a => origin a+L*(g a:ℝ) |
| noncomputable def weightMass (d : ℕ) (L : ℝ) : ℝ := ∑ g, |weight d L g| |
|
|
| lemma weightMass_nonneg (d : ℕ) (L : ℝ) : 0 ≤ weightMass d L := |
| Finset.sum_nonneg (fun _ _ => abs_nonneg _) |
|
|
| lemma sum_abs_specialCoeff : (∑ j, |specialCoeff j|) = 6 := by |
| norm_num [specialCoeff, Fin.sum_univ_succ] |
|
|
| lemma five_interpolation {d : ℕ} (P : Point → ℝ) (hP : P ∈ lowDegree coord d) |
| {L : ℝ} (hL : L ≠ 0) : |
| (∑ j, specialCoeff j * P (specialPoint j)) = ∑ g, weight d L g * P (scaledNode L g) := by |
| have h := weighted_interpolation d P hP L hL |
| simp only [specialCoeff, specialPoint, Fin.sum_univ_succ, Matrix.cons_val_zero, |
| Matrix.cons_val_succ, one_mul, neg_mul, Fin.sum_univ_zero, add_zero] at * |
| change _ = ∑ g, weight d L g * P (fun a => origin a+L*(g a:ℝ)) |
| linarith |
|
|
| lemma finite_weighted_error {X : Type u_1} [Fintype X] |
| (c e : X → ℝ) {η : ℝ} (he : ∀ x, |e x| ≤ η) : |
| |∑ x, c x*e x| ≤ (∑ x, |c x|)*η := by |
| calc |
| _ ≤ ∑ x, |c x*e x| := Finset.abs_sum_le_sum_abs _ _ |
| _ ≤ ∑ x, |c x| *η := by |
| apply Finset.sum_le_sum |
| intro x _ |
| rw [abs_mul] |
| exact mul_le_mul_of_nonneg_left (he x) (abs_nonneg _) |
| _ = _ := (Finset.sum_mul _ _ _).symm |
|
|
| lemma interpolation_error {d : ℕ} (F P : Point → ℝ) |
| (hP : P ∈ lowDegree coord d) {L η : ℝ} (hL : L ≠ 0) |
| (hs : ∀ j, |F (specialPoint j)-P (specialPoint j)| ≤ η) |
| (hg : ∀ g : GridIndex d, |F (scaledNode L g)-P (scaledNode L g)| ≤ η) : |
| |(∑ j, specialCoeff j*F (specialPoint j)) - |
| ∑ g, weight d L g*F (scaledNode L g)| ≤ (6+weightMass d L)*η := by |
| have hidentity : (∑ j, specialCoeff j*F (specialPoint j)) - |
| ∑ g, weight d L g*F (scaledNode L g) = |
| (∑ j, specialCoeff j*(F (specialPoint j)-P (specialPoint j))) - |
| ∑ g, weight d L g*(F (scaledNode L g)-P (scaledNode L g)) := by |
| simp only [mul_sub, Finset.sum_sub_distrib, five_interpolation P hP hL] |
| ring |
| rw [hidentity] |
| have h1 := finite_weighted_error specialCoeff (fun j => F (specialPoint j)-P (specialPoint j)) hs |
| have h2 := finite_weighted_error (weight d L) (fun g => F (scaledNode L g)-P (scaledNode L g)) hg |
| rw [sum_abs_specialCoeff] at h1 |
| calc |
| _ ≤ |∑ j, specialCoeff j*(F (specialPoint j)-P (specialPoint j))| + |
| |∑ g, weight d L g*(F (scaledNode L g)-P (scaledNode L g))| := abs_sub _ _ |
| _ ≤ 6*η + weightMass d L*η := add_le_add h1 h2 |
| _ = _ := by ring |
|
|
| section Matrices |
| variable {R : Type u_2} [Fintype R] [DecidableEq R] |
|
|
| lemma interpolation_matrix_domination (d : ℕ) |
| (B : Point → Matrix R R ℝ) (hB : ∀ x, (B x).PosSemidef) |
| (P : R → R → Point → ℝ) (hP : ∀ u v, P u v ∈ lowDegree coord d) |
| {L η : ℝ} (hL : L ≠ 0) (hη : 0 ≤ η) |
| (hs : ∀ j u v, |B (specialPoint j) u v-P u v (specialPoint j)| ≤ η) |
| (hg : ∀ g : GridIndex d, ∀ u v, |B (scaledNode L g) u v-P u v (scaledNode L g)| ≤ η) : |
| ∃ E : Matrix R R ℝ, E.PosSemidef ∧ |
| B (origin+dirA)+B (origin+dirB) ≤ B (origin+dirStar)+(2:ℝ) • B (origin+dirP)+E ∧ |
| ∀ (Q : Matrix R R ℝ) (m k : ℝ), Q.trace ≤ m → |
| (∀ g : GridIndex d, (Q*B (scaledNode L g)).trace ≤ k) → |
| (Q*E).trace ≤ weightMass d L*k + |
| (Fintype.card R : ℝ)*(6+weightMass d L)*η*m := by |
| let H := (∑ j, specialCoeff j • B (specialPoint j)) - |
| ∑ g, weight d L g • B (scaledNode L g) |
| let b := (6+weightMass d L)*η |
| let c := (Fintype.card R : ℝ)*b |
| let W := ∑ g, |weight d L g| • B (scaledNode L g) |
| have hb : 0 ≤ b := mul_nonneg (by linarith [weightMass_nonneg d L]) hη |
| have hc : 0 ≤ c := mul_nonneg (Nat.cast_nonneg _) hb |
| have hH : H.IsHermitian := by |
| have hh (x : Point) := (hB x).isHermitian.eq |
| simp only [H, Matrix.IsHermitian, Matrix.conjTranspose_sub, Matrix.conjTranspose_sum, |
| Matrix.conjTranspose_smul, star_trivial, hh] |
| have hentry (u v : R) : |H u v| ≤ b := by |
| simpa only [H, Matrix.sub_apply, Matrix.sum_apply, Matrix.smul_apply, smul_eq_mul] using |
| interpolation_error (fun x => B x u v) (P u v) (hP u v) hL (fun j => hs j u v) (fun g => hg g u v) |
| have hbound : H ≤ c • (1 : Matrix R R ℝ) := le_card_entry_bound hH hb hentry |
| have hW : W.PosSemidef := matrix_sum_psd _ _ (fun g _ => (hB _).smul (abs_nonneg _)) |
| let E := W+c • (1 : Matrix R R ℝ) |
| have hE : E.PosSemidef := hW.add (Matrix.PosSemidef.one.smul hc) |
| refine ⟨E,hE,?_,?_⟩ |
| · apply sub_nonneg.mp |
| apply Matrix.PosSemidef.nonneg |
| have hdiff : (∑ g : GridIndex d, (|weight d L g|-weight d L g) • B (scaledNode L g)).PosSemidef := |
| matrix_sum_psd _ _ (fun g _ => (hB _).smul (sub_nonneg.mpr (le_abs_self _))) |
| convert ((sub_nonneg.mpr hbound).posSemidef.add (hB origin)).add hdiff using 1 |
| dsimp [E,W,H] |
| simp only [sub_smul, Finset.sum_sub_distrib, specialPoint, specialCoeff, Fin.sum_univ_succ, |
| Matrix.cons_val_zero, Matrix.cons_val_succ, one_smul, neg_smul, |
| Fin.sum_univ_zero, add_zero] |
| module |
| · intro Q m k hm hk |
| change (Q*(W+c • (1 : Matrix R R ℝ))).trace ≤ _ |
| rw [mul_add, Matrix.trace_add, mul_smul_comm, Matrix.trace_smul, mul_one] |
| have hWt : (Q*W).trace ≤ weightMass d L*k := by |
| dsimp [W,weightMass] |
| rw [Finset.mul_sum, Matrix.trace_sum, Finset.sum_mul] |
| apply Finset.sum_le_sum |
| intro g _ |
| rw [mul_smul_comm, Matrix.trace_smul] |
| exact mul_le_mul_of_nonneg_left (hk g) (abs_nonneg _) |
| have he := add_le_add hWt (mul_le_mul_of_nonneg_left hm hc) |
| calc |
| _ ≤ weightMass d L*k + c*m := he |
| _ = _ := by dsimp [c,b]; ring |
|
|
| end Matrices |
| end MatchingInterpolation |
|
|
| end OAI |
|
|
