| import OAI.Combinatorics.PerfectMatching.Violation |
|
|
| namespace OAI |
|
|
| section |
|
|
| namespace BinaryMatching.Algorithm |
| noncomputable section |
| open Finset |
|
|
| lemma foldl_max_le (l : List ℕ) (a b : ℕ) (ha : a≤b) (hl : ∀ x∈l,x≤b) : |
| l.foldl max a≤b := by |
| induction l generalizing a with |
| | nil => exact ha |
| | cons x xs ih => |
| exact ih (max a x) (max_le ha (hl x (by simp))) (fun y hy => hl y (by simp [hy])) |
|
|
| lemma le_foldl_max (l : List ℕ) (a : ℕ) : a≤l.foldl max a := by |
| induction l generalizing a with |
| | nil => rfl |
| | cons x xs ih => exact (le_max_left a x).trans (ih (max a x)) |
|
|
| lemma mem_le_foldl_max (l : List ℕ) (a x : ℕ) (hx : x∈l) : x≤l.foldl max a := by |
| induction l generalizing a with |
| | nil => simp at hx |
| | cons y ys ih => |
| rcases List.mem_cons.mp hx with rfl|h |
| · exact (le_max_right a x).trans (le_foldl_max ys (max a x)) |
| · exact ih (max a y) h |
|
|
| lemma record_log_le_B (G : Input) (r : Record) (hr : r∈G.records) : Nat.log2 r.multiplicity≤B G := |
| mem_le_foldl_max _ 0 _ (List.mem_map.mpr ⟨r,hr,rfl⟩) |
|
|
| lemma multiplicity_log_le_B (G : Input) (e : Pair G.n) : Nat.log2 (multiplicity G e)≤B G := by |
| unfold multiplicity |
| cases he : G.records.find? (fun r => r.left=e.val.1.val && r.right=e.val.2.val) with |
| | none => simp |
| | some r => exact record_log_le_B G r (List.mem_of_find?_eq_some he) |
|
|
| lemma B_le_L (G : Input) : B G≤L G := by |
| have h : B G≤G.n+B G+1 := by omega |
| have hp : 1≤G.n+B G+1 := by omega |
| have hpow : G.n+B G+1≤(G.n+B G+1)^3 := by exact Nat.le_self_pow (by omega) _ |
| unfold L |
| omega |
|
|
| lemma beta_bound (G : Input) (e : Pair G.n) : |(beta G e:ℝ)|≤L G := by |
| unfold beta |
| split_ifs |
| · simp |
| · have hh := (multiplicity_log_le_B G e).trans (B_le_L G) |
| norm_cast |
|
|
| lemma piece_slope_bound (k : ℕ) (p : Piece) (hp : p∈pieces k) : |(p.slope:ℝ)|≤k := by |
| rcases (mem_pieces k p).1 hp with rfl|⟨j,hj,rfl⟩ |
| · simp |
| · simp only [Int.cast_sub,Int.cast_natCast,Int.cast_one] |
| have hj' : (j:ℝ)+1≤k := by exact_mod_cast hj |
| have hj0 : (0:ℝ)≤j := by positivity |
| rw [abs_le]; constructor <;> linarith |
|
|
| lemma piece_supergradient (k : ℕ) (p : Piece) (hp : p∈pieces k) (x : ℝ) |
| (ha : p.evalReal x=psiReal k x) (z : ℝ) : |
| psiReal k z≤psiReal k x+(p.slope:ℝ)*(z-x) := by |
| have hh := psiReal_le_piece k z p hp |
| rw [←ha] |
| calc |
| _ ≤ p.evalReal z := hh |
| _ = p.evalReal x+(p.slope:ℝ)*(z-x) := by unfold Piece.evalReal; ring |
|
|
| lemma selectedPiece_supergradient (k : ℕ) (x : ℚ) (z : ℝ) : |
| psiReal k z≤psiReal k (x:ℝ)+(slope k x:ℝ)*(z-(x:ℝ)) := by |
| apply piece_supergradient k (selectedPiece k x) |
| (List.argmin_mem (selectedPiece_mem_argmin k x)) (x:ℝ) _ z |
| rw [realPsi_cast] |
| simp [Piece.evalReal,Piece.eval,psi] |
|
|
| lemma psiReal_abs_sub (k : ℕ) (x y : ℝ) : |psiReal k x-psiReal k y|≤k*|x-y| := by |
| have h (a b : ℝ) : psiReal k a-psiReal k b≤k*|a-b| := by |
| have hm := List.argmin_mem (selectedReal_mem_argmin k b) |
| have hh := piece_supergradient k (selectedReal k b) hm b rfl a |
| have hb := piece_slope_bound k _ hm |
| have hab := le_abs_self ((selectedReal k b).slope*(a-b)) |
| rw [abs_mul] at hab |
| have hu := mul_le_mul_of_nonneg_right hb (abs_nonneg (a-b)) |
| linarith |
| rw [abs_le] |
| have hx := h x y |
| have hy := h y x |
| rw [abs_sub_comm y x] at hy |
| exact ⟨by linarith,hx⟩ |
|
|
| def objective (G : Input) (x : Pair G.n → ℝ) : ℝ := |
| ∑ e, (psiReal (K G.n) (x e)+(beta G e:ℝ)*x e) |
|
|
| def penalized (G : Input) (x : Pair G.n → ℝ) : ℝ := |
| objective G x-(M₀ G:ℝ)*violation x |
|
|
| lemma objective_lipschitz (G : Input) (x y : Pair G.n → ℝ) : |
| |objective G x-objective G y|≤(K G.n+L G:ℝ)*∑ e,|x e-y e| := by |
| unfold objective |
| rw [←sum_sub_distrib,mul_sum] |
| apply (abs_sum_le_sum_abs _ _).trans |
| apply sum_le_sum; intro e _ |
| have he : psiReal (K G.n) (x e)+(beta G e:ℝ)*x e- |
| (psiReal (K G.n) (y e)+(beta G e:ℝ)*y e)= |
| (psiReal (K G.n) (x e)-psiReal (K G.n) (y e))+(beta G e:ℝ)*(x e-y e) := by ring |
| rw [he] |
| have hb := mul_le_mul_of_nonneg_right (beta_bound G e) (abs_nonneg (x e-y e)) |
| have hh := abs_add_le (psiReal (K G.n) (x e)-psiReal (K G.n) (y e)) ((beta G e:ℝ)*(x e-y e)) |
| rw [abs_mul] at hh |
| linarith [psiReal_abs_sub (K G.n) (x e) (y e)] |
|
|
| lemma exact_penalty (G : Input) (hn : 4≤G.n) (heven : Even G.n) |
| (x : Pair G.n → ℝ) (hx : ∀ e,x e∈Set.Icc (0:ℝ) 1) : |
| ∃ y∈(completeGraph G.n).polytope,penalized G x≤objective G y := by |
| obtain ⟨y,hy,hdist⟩ := violation_repair hn heven x hx |
| refine ⟨y,hy,?_⟩ |
| have hsum : (∑ e,|x e-y e|)≤(q G.n:ℝ)*(2+10*(G.n:ℝ)^2)*violation x := by |
| calc |
| _ ≤ ∑ _e : Pair G.n,(2+10*(G.n:ℝ)^2)*violation x := by |
| apply sum_le_sum; intro e _; rw [abs_sub_comm]; exact hdist e |
| _ = _ := by simp [q,mul_assoc] |
| have hh := objective_lipschitz G x y |
| have hmul := mul_le_mul_of_nonneg_left hsum (show (0:ℝ)≤K G.n+L G by positivity) |
| have hM : (M₀ G:ℝ)=(q G.n:ℝ)*(K G.n+L G)*(2+10*(G.n:ℝ)^2) := by |
| simp [M₀,A₀] |
| unfold penalized |
| rw [hM] |
| have hab := le_abs_self (objective G x-objective G y) |
| nlinarith |
|
|
| lemma penalized_feasible (G : Input) (heven : Even G.n) {x : Pair G.n → ℝ} |
| (hx : x∈(completeGraph G.n).polytope) : penalized G x=objective G x := by |
| simp [penalized,violation_feasible heven hx] |
|
|
| lemma trialValue_cast (G : Input) (a : Table G.n ℤ) (r : Affine G.n) : |
| (trialValue G a r:ℝ)=objective G (fun e => (coordinates (D₀ G) a e:ℝ))- |
| (M₀ G:ℝ)*r.evalReal (fun e => (coordinates (D₀ G) a e:ℝ)) := by |
| simp [trialValue,objective,realPsi_cast,eval_cast] |
|
|
| lemma trialValue_correct (G : Input) (hn : 2≤G.n) (heven : Even G.n) |
| (hD : 0<D₀ G) (a : Table G.n ℤ) (ha : ∀ e,0≤entry a e) : |
| (trialValue G a (activeRow (D₀ G) a):ℝ)= |
| penalized G (fun e => (coordinates (D₀ G) a e:ℝ)) := by |
| rw [trialValue_cast,(activeRow_correct hn heven hD a ha).2] |
| rfl |
|
|
| lemma gradient_supergradient (G : Input) (hn : 2≤G.n) (heven : Even G.n) |
| (hD : 0<D₀ G) (a : Table G.n ℤ) (ha : ∀ e,0≤entry a e) |
| (z : Pair G.n → ℝ) : |
| penalized G z≤penalized G (fun e => (coordinates (D₀ G) a e:ℝ))+ |
| ∑ e,(gradient G a (activeRow (D₀ G) a) e:ℝ)*(z e-(coordinates (D₀ G) a e:ℝ)) := by |
| let x := fun e => (coordinates (D₀ G) a e:ℝ) |
| let r := activeRow (D₀ G) a |
| obtain ⟨hr,hract⟩ := activeRow_correct hn heven hD a ha |
| have hrow := active_row_subgradient x r hr hract z |
| have hf : objective G z≤objective G x+ |
| ∑ e,((slope (K G.n) (coordinates (D₀ G) a e):ℝ)+(beta G e:ℝ))*(z e-x e) := by |
| rw [objective,objective,←sum_add_distrib] |
| apply sum_le_sum; intro e _ |
| have hh := selectedPiece_supergradient (K G.n) (coordinates (D₀ G) a e) (z e) |
| dsimp [x] at *; nlinarith |
| have hm := mul_le_mul_of_nonneg_left hrow (show (0:ℝ)≤M₀ G by positivity) |
| have hgrad : (∑ e,(gradient G a r e:ℝ)*(z e-x e))= |
| (∑ e,((slope (K G.n) (coordinates (D₀ G) a e):ℝ)+(beta G e:ℝ))*(z e-x e))- |
| (M₀ G:ℝ)*∑ e,(r.coeff e:ℝ)*(z e-x e) := by |
| simp only [gradient,Int.cast_sub,Int.cast_add,Int.cast_mul,Int.cast_natCast, |
| sub_mul,sum_sub_distrib,mul_assoc,mul_sum] |
| change penalized G z≤penalized G x+∑ e,(gradient G a r e:ℝ)*(z e-x e) |
| rw [hgrad] |
| unfold penalized |
| linarith |
|
|
| lemma gradient_bound (G : Input) (hn : 2≤G.n) (heven : Even G.n) |
| (hD : 0<D₀ G) (a : Table G.n ℤ) (ha : ∀ e,0≤entry a e) (e : Pair G.n) : |
| |(gradient G a (activeRow (D₀ G) a) e:ℝ)|≤K G.n+L G+M₀ G := by |
| have hrow := row_coeff_bound _ (activeRow_correct hn heven hD a ha).1 e |
| have hs := piece_slope_bound (K G.n) _ (List.argmin_mem |
| (selectedPiece_mem_argmin (K G.n) (coordinates (D₀ G) a e))) |
| change |(slope (K G.n) (coordinates (D₀ G) a e):ℝ)|≤K G.n at hs |
| have hm := mul_le_mul_of_nonneg_left hrow (show (0:ℝ)≤M₀ G by positivity) |
| have hcast : (gradient G a (activeRow (D₀ G) a) e:ℝ)= |
| (slope (K G.n) (coordinates (D₀ G) a e):ℝ)+(beta G e:ℝ)- |
| (M₀ G:ℝ)*((activeRow (D₀ G) a).coeff e:ℝ) := by simp [gradient] |
| rw [hcast] |
| have hh := abs_sub ((slope (K G.n) (coordinates (D₀ G) a e):ℝ)+(beta G e:ℝ)) |
| ((M₀ G:ℝ)*((activeRow (D₀ G) a).coeff e:ℝ)) |
| rw [abs_mul,abs_of_nonneg (show (0:ℝ)≤M₀ G by positivity)] at hh |
| linarith [abs_add_le (slope (K G.n) (coordinates (D₀ G) a e):ℝ) (beta G e:ℝ),beta_bound G e] |
|
|
| lemma gradient_square_bound (G : Input) (hn : 2≤G.n) (heven : Even G.n) |
| (hD : 0<D₀ G) (a : Table G.n ℤ) (ha : ∀ e,0≤entry a e) : |
| (∑ e,(gradient G a (activeRow (D₀ G) a) e:ℝ)^2)≤D₀ G := by |
| calc |
| _ ≤ ∑ _e : Pair G.n,(K G.n+L G+M₀ G:ℝ)^2 := by |
| apply sum_le_sum; intro e _ |
| have hh := (sq_le_sq₀ (abs_nonneg _) (by positivity)).2 (gradient_bound G hn heven hD a ha e) |
| simpa only [sq_abs] using hh |
| _ = D₀ G := by simp [D₀,q] |
|
|
| end |
| end BinaryMatching.Algorithm |
| end |
|
|
| end OAI |
|
|
