| import Mathlib |
| import OAI.Combinatorics.MatchingCount.Probability.Variance |
|
|
| namespace OAI |
|
|
| namespace MatchingFPRAS.Transport |
|
|
| section |
|
|
| noncomputable def tierClamp (c : ℝ) (t : ℕ) (w : ℝ) : ℝ := |
| max (c^t)⁻¹ (min (c^t) w) |
|
|
| lemma tierClamp_pos {c : ℝ} (hc : 0 < c) (t : ℕ) (w : ℝ) : 0 < tierClamp c t w := |
| lt_of_lt_of_le (inv_pos.mpr (pow_pos hc t)) (le_max_left _ _) |
|
|
| lemma clamp_comparison {c lo hi lo' hi' w : ℝ} (hc : 0 ≤ c) |
| (hlo : lo' ≤ c*lo) (hhi : hi' ≤ c*hi) (hw : w ≤ c*w) : |
| max lo' (min hi' w) ≤ c*max lo (min hi w) := by |
| rw [mul_max_of_nonneg _ _ hc,mul_min_of_nonneg _ _ hc] |
| exact max_le_max hlo (min_le_min hhi hw) |
|
|
| lemma tierClamp_adjacent {c : ℝ} (hc : 1 ≤ c) (t : ℕ) {w : ℝ} (hw : 0 ≤ w) : |
| tierClamp c (t+1) w ≤ c*tierClamp c t w ∧ |
| tierClamp c t w ≤ c*tierClamp c (t+1) w := by |
| have hc0 : 0 < c := lt_of_lt_of_le (by norm_num) hc |
| have ht : 0 < c^t := pow_pos hc0 t |
| have ht1 : 0 < c^(t+1) := pow_pos hc0 _ |
| have hpow : c^t ≤ c^(t+1) := pow_le_pow_right₀ hc (by omega) |
| have hi : (c^(t+1))⁻¹ ≤ (c^t)⁻¹ := inv_anti₀ ht hpow |
| have hwc : w ≤ c*w := by nlinarith |
| constructor |
| · apply clamp_comparison hc0.le _ _ hwc |
| · exact hi.trans (by nlinarith [inv_pos.mpr ht]) |
| · rw [pow_succ]; nlinarith |
| · apply clamp_comparison hc0.le _ _ hwc |
| · have he : (c^t)⁻¹ = c*(c^(t+1))⁻¹ := by |
| rw [pow_succ,mul_inv_rev]; field_simp |
| exact he.le |
| · exact hpow.trans (by nlinarith) |
|
|
| lemma ladder_base_pow_bound (N : ℕ) (hN : 2 ≤ N) : |
| (1+((N:ℝ)^2)⁻¹)^N ≤ 2 := by |
| have hn2 : (2:ℝ) ≤ N := by exact_mod_cast hN |
| have hn : (0:ℝ) < N := by positivity |
| have hx : 0 ≤ ((N:ℝ)^2)⁻¹ := by positivity |
| have hbase : 0 ≤ 1+((N:ℝ)^2)⁻¹ := by positivity |
| have hb : 1+((N:ℝ)^2)⁻¹ ≤ Real.exp (((N:ℝ)^2)⁻¹) := by simpa [add_comm] using Real.add_one_le_exp (((N:ℝ)^2)⁻¹) |
| have hp := pow_le_pow_left₀ hbase hb N |
| have he : (Real.exp (((N:ℝ)^2)⁻¹))^N = Real.exp ((N:ℝ)⁻¹) := by |
| rw [← Real.exp_nat_mul] |
| congr 1 |
| field_simp |
| rw [he] at hp |
| have hinv : (N:ℝ)⁻¹ ≤ 1/2 := (inv_le_comm₀ hn (by norm_num)).mpr (by nlinarith) |
| have hexp : Real.exp (1/2:ℝ) < 2 := by |
| have hs : (Real.exp (1/2:ℝ))^2 = Real.exp 1 := by |
| rw [← Real.exp_nat_mul]; norm_num |
| have h := Real.exp_one_lt_three |
| have hpos := Real.exp_pos (1/2:ℝ) |
| nlinarith |
| exact hp.trans ((Real.exp_le_exp.mpr hinv).trans hexp.le) |
|
|
| variable {V E : Type*} [Fintype V] [DecidableEq V] [Fintype E] [DecidableEq E] |
|
|
| variable (ends : E → Sym2 V) (hloop : ∀ e, ¬(ends e).IsDiag) |
|
|
| include hloop |
|
|
| omit [DecidableEq E] in |
| theorem adjacent_gibbs (hN : 2 ≤ Fintype.card V) (w : E → ℝ) (hw : ∀ e, 0 < w e) |
| (t : ℕ) (A : PM (fun e v => v ∈ ends e)) : |
| let c : ℝ := 1+((Fintype.card V:ℝ)^2)⁻¹ |
| let πt := gibbs (fun e => tierClamp c t (w e)) A |
| let πnext := gibbs (fun e => tierClamp c (t+1) (w e)) A |
| πnext/2 ≤ πt ∧ πt ≤ 2*πnext := by |
| let c : ℝ := 1+((Fintype.card V:ℝ)^2)⁻¹ |
| have hc : 1 ≤ c := by |
| dsimp [c] |
| have : 0 ≤ ((Fintype.card V:ℝ)^2)⁻¹ := by positivity |
| linarith |
| have hc0 : 0 < c := lt_of_lt_of_le (by norm_num) hc |
| let z := fun e => tierClamp c t (w e) |
| let z' := fun e => tierClamp c (t+1) (w e) |
| have hz : ∀ e, 0 < z e := fun e => tierClamp_pos hc0 t (w e) |
| have hz' : ∀ e, 0 < z' e := fun e => tierClamp_pos hc0 (t+1) (w e) |
| have hh := fun e => tierClamp_adjacent hc t (hw e).le |
| have h1 := gibbs_compare ends hloop hz hz' c hc0.le (fun e => (hh e).2) (fun e => (hh e).1) A |
| have h2 := gibbs_compare ends hloop hz' hz c hc0.le (fun e => (hh e).1) (fun e => (hh e).2) A |
| have hb : c^(Fintype.card V) ≤ 2 := ladder_base_pow_bound _ hN |
| have hp := gibbs_pos z hz A |
| have hp' := gibbs_pos z' hz' A |
| change gibbs z' A/2 ≤ gibbs z A ∧ gibbs z A ≤ 2*gibbs z' A |
| constructor <;> nlinarith [mul_nonneg (sub_nonneg.mpr hb) hp.le, |
| mul_nonneg (sub_nonneg.mpr hb) hp'.le] |
|
|
| end |
|
|
| section |
|
|
| open Finset |
|
|
| variable {V E : Type*} [Fintype V] [DecidableEq V] [Fintype E] [DecidableEq E] |
|
|
| variable {inc : E → V → Prop} |
|
|
| omit [Fintype E] in |
| lemma exchange_inter (M N S : Finset E) : |
| exchange M N S ∩ exchange N M S = M ∩ N := by |
| ext e |
| simp only [Finset.mem_inter,mem_exchange] |
| tauto |
|
|
| noncomputable def cycleMove (p : PM inc × PM inc) (S : Finset E) : PM inc × PM inc := by |
| classical |
| exact if h : S ∈ components (inc := inc) (p.1.val ∪ p.2.val) then |
| (⟨exchange p.1.val p.2.val S, exchange_matching p.1.property p.2.property |
| (component_exchange_compatible h)⟩, |
| ⟨exchange p.2.val p.1.val S, exchange_matching p.2.property p.1.property |
| (component_exchange_compatible h).symm⟩) else p |
|
|
| omit [DecidableEq V] [Fintype E] in |
| lemma cycleMove_val (p : PM inc × PM inc) (S : Finset E) |
| (h : S ∈ components (inc := inc) (p.1.val ∪ p.2.val)) : |
| (cycleMove p S).1.val = exchange p.1.val p.2.val S ∧ |
| (cycleMove p S).2.val = exchange p.2.val p.1.val S := by |
| classical |
| simp only [cycleMove,dite_eq_left h,Subtype.coe_mk,and_self] |
|
|
| omit [DecidableEq V] [Fintype E] in |
| lemma cycleMove_union (p : PM inc × PM inc) (S : Finset E) : |
| (cycleMove p S).1.val ∪ (cycleMove p S).2.val = p.1.val ∪ p.2.val := by |
| classical |
| unfold cycleMove |
| split_ifs with h |
| · exact exchange_union _ _ _ |
| · rfl |
|
|
| omit [DecidableEq V] [Fintype E] in |
| lemma cycleMove_inter (p : PM inc × PM inc) (S : Finset E) : |
| (cycleMove p S).1.val ∩ (cycleMove p S).2.val = p.1.val ∩ p.2.val := by |
| classical |
| unfold cycleMove |
| split_ifs with h |
| · exact exchange_inter _ _ _ |
| · rfl |
|
|
| omit [DecidableEq V] [Fintype E] in |
| lemma cycleMove_discrepancy (p : PM inc × PM inc) (S : Finset E) : |
| discrepancyComponents (cycleMove p S).1 (cycleMove p S).2 = discrepancyComponents p.1 p.2 := by |
| classical |
| unfold discrepancyComponents |
| rw [cycleMove_union,cycleMove_inter] |
|
|
| omit [DecidableEq V] [Fintype E] in |
| lemma cycleMove_involution (p : PM inc × PM inc) (S : Finset E) : |
| cycleMove (cycleMove p S) S = p := by |
| classical |
| by_cases h : S ∈ components (inc := inc) (p.1.val ∪ p.2.val) |
| · have h' : S ∈ components (inc := inc) ((cycleMove p S).1.val ∪ (cycleMove p S).2.val) := by |
| rwa [cycleMove_union] |
| apply Prod.ext <;> apply Subtype.ext |
| · rw [(cycleMove_val _ _ h').1,(cycleMove_val _ _ h).1,(cycleMove_val _ _ h).2] |
| exact exchange_involution _ _ _ |
| · rw [(cycleMove_val _ _ h').2,(cycleMove_val _ _ h).1,(cycleMove_val _ _ h).2] |
| exact exchange_involution _ _ _ |
| · simp only [cycleMove,dite_eq_right h] |
|
|
| omit [DecidableEq V] [Fintype E] in |
| lemma cycleMove_eq_iff (p q : PM inc × PM inc) (S : Finset E) : |
| cycleMove p S = q ↔ cycleMove q S = p := by |
| constructor <;> intro h <;> rw [← h,cycleMove_involution] |
|
|
| omit [DecidableEq V] in |
| lemma cycleMove_gibbs (w : E → ℝ) (p : PM inc × PM inc) (S : Finset E) : |
| gibbs w (cycleMove p S).1*gibbs w (cycleMove p S).2 = gibbs w p.1*gibbs w p.2 := by |
| classical |
| by_cases h : S ∈ components (inc := inc) (p.1.val ∪ p.2.val) |
| · unfold gibbs matchingWeight |
| rw [(cycleMove_val _ _ h).1,(cycleMove_val _ _ h).2,div_mul_div_comm,exchange_weight] |
| rw [div_mul_div_comm] |
| · simp only [cycleMove,dite_eq_right h] |
|
|
| noncomputable def cycleTerm (p q : PM inc × PM inc) (S : Finset E) : ℝ := by |
| classical |
| exact if S ∈ discrepancyComponents p.1 p.2 ∧ cycleMove p S = q then |
| ((discrepancyComponents p.1 p.2).card : ℝ)⁻¹ else 0 |
|
|
| noncomputable def cycleProposal (p q : PM inc × PM inc) : ℝ := by |
| classical |
| exact if (discrepancyComponents p.1 p.2).Nonempty then ∑ S, cycleTerm p q S |
| else if p = q then 1 else 0 |
|
|
| omit [DecidableEq V] [Fintype E] in |
| lemma cycleTerm_symmetric (p q : PM inc × PM inc) (S : Finset E) : |
| cycleTerm p q S = cycleTerm q p S := by |
| classical |
| have he : (S ∈ discrepancyComponents p.1 p.2 ∧ cycleMove p S = q) ↔ |
| (S ∈ discrepancyComponents q.1 q.2 ∧ cycleMove q S = p) := by |
| constructor |
| · rintro ⟨h,rfl⟩ |
| exact ⟨by rwa [cycleMove_discrepancy],cycleMove_involution _ _⟩ |
| · rintro ⟨h,rfl⟩ |
| exact ⟨by rwa [cycleMove_discrepancy],cycleMove_involution _ _⟩ |
| unfold cycleTerm |
| by_cases h : S ∈ discrepancyComponents p.1 p.2 ∧ cycleMove p S = q |
| · rw [ite_eq_left h,ite_eq_left (he.mp h),← h.2,cycleMove_discrepancy] |
| · rw [ite_eq_right h,ite_eq_right (mt he.mpr h)] |
|
|
| omit [DecidableEq V] [Fintype E] in |
| lemma cycleTerm_nonneg (p q : PM inc × PM inc) (S : Finset E) : 0 ≤ cycleTerm p q S := by |
| classical |
| unfold cycleTerm |
| split_ifs <;> positivity |
|
|
| omit [DecidableEq V] in |
| lemma cycleTerm_sum (p : PM inc × PM inc) (S : Finset E) : |
| (∑ q, cycleTerm p q S) = if S ∈ discrepancyComponents p.1 p.2 then |
| ((discrepancyComponents p.1 p.2).card : ℝ)⁻¹ else 0 := by |
| classical |
| by_cases h : S ∈ discrepancyComponents p.1 p.2 |
| · simp only [cycleTerm,h,true_and] |
| simp |
| · simp [cycleTerm,h] |
|
|
| omit [DecidableEq V] [Fintype E] in |
| lemma cycleTerm_zero (p q : PM inc × PM inc) (h : ¬(discrepancyComponents p.1 p.2).Nonempty) |
| (S : Finset E) : cycleTerm p q S = 0 := by |
| classical |
| have he := Finset.not_nonempty_iff_eq_empty.mp h |
| simp [cycleTerm,he] |
|
|
| omit [DecidableEq V] in |
| lemma cycleProposal_nonneg (p q : PM inc × PM inc) : 0 ≤ cycleProposal p q := by |
| classical |
| unfold cycleProposal |
| split_ifs |
| · exact Finset.sum_nonneg (fun S _ => cycleTerm_nonneg p q S) |
| · norm_num |
| · norm_num |
|
|
| omit [DecidableEq V] in |
| lemma cycleProposal_row (p : PM inc × PM inc) : (∑ q, cycleProposal p q) = 1 := by |
| classical |
| by_cases h : (discrepancyComponents p.1 p.2).Nonempty |
| · simp only [cycleProposal,ite_eq_left h] |
| rw [Finset.sum_comm] |
| simp_rw [cycleTerm_sum] |
| rw [← Finset.sum_filter] |
| simp only [Finset.filter_mem_eq_inter,Finset.univ_inter,Finset.sum_const,nsmul_eq_mul] |
| exact mul_inv_cancel₀ (by exact_mod_cast ne_of_gt (Finset.card_pos.mpr h)) |
| · simp [cycleProposal,h] |
|
|
| omit [DecidableEq V] in |
| lemma cycleProposal_symmetric (p q : PM inc × PM inc) : cycleProposal p q = cycleProposal q p := by |
| classical |
| by_cases hp : (discrepancyComponents p.1 p.2).Nonempty <;> |
| by_cases hq : (discrepancyComponents q.1 q.2).Nonempty |
| · simp only [cycleProposal,ite_eq_left hp,ite_eq_left hq,cycleTerm_symmetric p q] |
| · have hpq : p ≠ q := by rintro rfl; exact hq hp |
| simp only [cycleProposal,ite_eq_left hp,ite_eq_right hq,ite_eq_right (Ne.symm hpq)] |
| apply Finset.sum_eq_zero; intro S _ |
| rw [cycleTerm_symmetric,cycleTerm_zero _ _ hq] |
| · exact (by |
| have hpq : q ≠ p := by rintro rfl; exact hp hq |
| simp only [cycleProposal,ite_eq_right hp,ite_eq_left hq,ite_eq_right (Ne.symm hpq)] |
| symm; apply Finset.sum_eq_zero; intro S _ |
| rw [cycleTerm_symmetric,cycleTerm_zero _ _ hp]) |
| · simp only [cycleProposal,ite_eq_right hp,ite_eq_right hq,eq_comm] |
|
|
| omit [DecidableEq V] in |
| lemma cycleProposal_gibbs (w : E → ℝ) (p q : PM inc × PM inc) : |
| gibbs w p.1*gibbs w p.2*cycleProposal p q = |
| gibbs w q.1*gibbs w q.2*cycleProposal q p := by |
| classical |
| rw [cycleProposal_symmetric q p] |
| by_cases h : (discrepancyComponents p.1 p.2).Nonempty |
| · simp only [cycleProposal,ite_eq_left h,Finset.mul_sum] |
| apply Finset.sum_congr rfl |
| intro S _ |
| unfold cycleTerm |
| split_ifs with he |
| · rw [← he.2,cycleMove_gibbs] |
| · simp |
| · by_cases he : p = q |
| · subst q; rfl |
| · simp [cycleProposal,h,he] |
|
|
| omit [DecidableEq V] in |
| lemma cycleProposal_expectation (p : PM inc × PM inc) (F : PM inc × PM inc → ℝ) : |
| (∑ q, cycleProposal p q * F q) = |
| if (discrepancyComponents p.1 p.2).Nonempty then |
| (∑ S ∈ discrepancyComponents p.1 p.2, F (cycleMove p S)) / |
| (discrepancyComponents p.1 p.2).card else F p := by |
| classical |
| by_cases h : (discrepancyComponents p.1 p.2).Nonempty |
| · simp only [cycleProposal,ite_eq_left h,Finset.sum_mul] |
| rw [Finset.sum_comm] |
| have hs (S : Finset E) : (∑ q, cycleTerm p q S*F q) = |
| if S ∈ discrepancyComponents p.1 p.2 then |
| F (cycleMove p S) / (discrepancyComponents p.1 p.2).card else 0 := by |
| by_cases hm : S ∈ discrepancyComponents p.1 p.2 |
| · simp only [cycleTerm,hm,true_and,ite_eq_left,ite_mul,zero_mul] |
| simp [div_eq_mul_inv,mul_comm] |
| · simp [cycleTerm,hm] |
| simp_rw [hs] |
| rw [← Finset.sum_filter] |
| simp only [Finset.filter_mem_eq_inter,Finset.univ_inter,Finset.sum_div] |
| · simp [cycleProposal,h] |
|
|
|
|
|
|
|
|
| omit [DecidableEq V] in |
| theorem cycleProposal_dirichlet (w : E → ℝ) (f g : Finset E → ℝ) : |
| (∑ A : PM inc, ∑ B : PM inc, gibbs w A*gibbs w B * |
| (∑ q : PM inc × PM inc, cycleProposal (A,B) q * |
| ((f A.val+g B.val)-(f q.1.val+g q.2.val))^2)) / 6 = |
| cycleDirichlet (inc := inc) w f g := by |
| classical |
| unfold cycleDirichlet |
| rw [Finset.sum_div] |
| apply Finset.sum_congr rfl; intro A _ |
| rw [Finset.sum_div] |
| apply Finset.sum_congr rfl; intro B _ |
| rw [mul_div_assoc] |
| congr 1 |
| rw [cycleProposal_expectation] |
| by_cases h : (discrepancyComponents A B).Nonempty |
| · rw [ite_eq_left h,div_div] |
| rw [Finset.sum_div] |
| apply Finset.sum_congr rfl; intro S hS |
| have hc : S ∈ components (inc := inc) (A.val ∪ B.val) := (Finset.mem_filter.mp hS).1 |
| rw [(cycleMove_val (A,B) S hc).1,(cycleMove_val (A,B) S hc).2] |
| dsimp only [cycleSquare] |
| rw [mul_comm ((discrepancyComponents A B).card:ℝ)] |
| · have he := Finset.not_nonempty_iff_eq_empty.mp h |
| simp [he] |
|
|
| end |
|
|
| section |
|
|
| open Finset |
|
|
| variable {V L : Type*} [Fintype V] [DecidableEq V] [Fintype L] [DecidableEq L] |
|
|
| variable {bags : V → Finset L} |
|
|
| noncomputable local instance tierClampBagEdgeFintype : Fintype (BagEdge bags) := |
| Fintype.ofFinite _ |
|
|
| namespace BagEdge |
|
|
| noncomputable def parallels (e : BagEdge bags) : Finset (BagEdge bags) := by |
| classical |
| exact Finset.univ.filter (fun f => f.val.val.1 = e.val.val.1) |
|
|
| omit [DecidableEq L] in |
| lemma parallels_card_le (hb : ∀ v, (bags v).card ≤ 2) (e : BagEdge bags) : |
| (parallels e).card ≤ 2 := by |
| classical |
| obtain ⟨v,hv⟩ := e.exists_incident |
| let colorMap : ↥(parallels e) → ↥(bags v) := fun f => ⟨f.val.color, by |
| apply f.val.color_mem |
| change v ∈ f.val.val.val.1 |
| rw [(Finset.mem_filter.mp f.property).2] |
| exact hv⟩ |
| have hinj : Function.Injective colorMap := by |
| intro f g h |
| apply Subtype.ext; apply Subtype.ext; apply Subtype.ext |
| apply Prod.ext |
| · exact (Finset.mem_filter.mp f.property).2.trans (Finset.mem_filter.mp g.property).2.symm |
| · exact congrArg Subtype.val h |
| have hc : (parallels e).card ≤ (bags v).card := by |
| simpa only [Fintype.card_coe] using Fintype.card_le_of_injective colorMap hinj |
| exact hc.trans (hb v) |
|
|
| end BagEdge |
|
|
| end |
|
|
| open Finset |
|
|
| variable {V E : Type*} [Fintype V] [DecidableEq V] [Fintype E] [DecidableEq E] |
|
|
| variable (ends : E → Sym2 V) |
|
|
| omit [DecidableEq V] [Fintype E] in |
| lemma ColorChange.symm {A B : PM (fun e v => v ∈ ends e)} (h : ColorChange ends A B) : |
| ColorChange ends B A := by |
| obtain ⟨e,f,R,hef,hA,hB⟩ := h |
| exact ⟨f,e,R,hef.symm,hB,hA⟩ |
|
|
| omit [DecidableEq V] [Fintype E] in |
| lemma ColorChange.edit {A B : PM (fun e v => v ∈ ends e)} (h : ColorChange ends A B) : |
| ∃ e ∈ A.val, ∃ f, ends f = ends e ∧ B.val = insert f (A.val.erase e) := by |
| classical |
| obtain ⟨e,f,R,hef,hA,hB⟩ := h |
| have he : e ∈ A.val := by rw [hA]; simp |
| refine ⟨e,he,f,hef.symm,?_⟩ |
| by_cases h : e = f |
| · subst f |
| rw [Finset.insert_erase he] |
| exact hB.trans hA.symm |
| · obtain ⟨v,hv⟩ : ∃ v, v ∈ ends e := Sym2.inductionOn (ends e) (fun u v => ⟨u,by simp⟩) |
| have hr : e ∉ R := by |
| intro hr |
| exact h (B.property.unique (Finset.mem_univ v) (by rw [hB]; simp [hr]) hv |
| (by rw [hB]; simp) (hef ▸ hv)) |
| rw [hA,hB] |
| ext a |
| simp only [Finset.mem_union,Finset.mem_singleton,Finset.mem_insert,Finset.mem_erase] |
| by_cases ha : a = e |
| · subst a; simp [hr,h] |
| · tauto |
|
|
| lemma colorDestinations_card_bound |
| (hpar : ∀ e, (Finset.univ.filter (fun f => ends f = ends e)).card ≤ 2) |
| (A : PM (fun e v => v ∈ ends e)) : (colorDestinations ends A).card ≤ 2*A.val.card := by |
| classical |
| let options (e : E) : Finset (Finset E) := |
| (Finset.univ.filter (fun f => ends f = ends e)).image (fun f => insert f (A.val.erase e)) |
| have hsub : (colorDestinations ends A).image Subtype.val ⊆ A.val.biUnion options := by |
| intro B hB |
| obtain ⟨C,hC,hCB⟩ := Finset.mem_image.mp hB |
| rw [← hCB] |
| obtain ⟨e,he,f,hf,hval⟩ := ColorChange.edit ends ((Finset.mem_filter.mp hC).2) |
| apply Finset.mem_biUnion.mpr |
| exact ⟨e,he,Finset.mem_image.mpr ⟨f,Finset.mem_filter.mpr ⟨Finset.mem_univ _,hf⟩,hval.symm⟩⟩ |
| have hi : (colorDestinations ends A).card = ((colorDestinations ends A).image Subtype.val).card := by |
| symm; exact Finset.card_image_of_injective _ Subtype.val_injective |
| calc |
| _ = _ := hi |
| _ ≤ (A.val.biUnion options).card := Finset.card_le_card hsub |
| _ ≤ ∑ e ∈ A.val, (options e).card := Finset.card_biUnion_le |
| _ ≤ ∑ e ∈ A.val, 2 := Finset.sum_le_sum (fun e _ => (Finset.card_image_le).trans (hpar e)) |
| _ = _ := by simp [Nat.mul_comm] |
|
|
| end MatchingFPRAS.Transport |
|
|
| end OAI |
|
|
