| import Mathlib |
| import OAI.Combinatorics.MatchingCount.Graphs.Mate |
|
|
| namespace OAI |
|
|
| namespace MatchingFPRAS.Switching |
| open Finset |
| open scoped Classical symmDiff |
|
|
| variable {V : Type*} |
| theorem switched_holes [Fintype V] [DecidableEq V] |
| (m n : Mate V) (S T : Finset V) (hm : HasHoles m S) (hn : HasHoles n T) |
| (a : V) (ha : a ∈ S) (hTa : a ∉ T) : |
| ∃ b, b ≠ a ∧ b ∈ S ∆ T ∧ |
| HasHoles (switched m n a) (S ∆ {a, b}) ∧ |
| HasHoles (switched n m a) (T ∆ {a, b}) := by |
| classical |
| have hma : m.1 a = a := (hm a).mpr ha |
| have hna : n.1 a ≠ a := fun h => hTa ((hn a).mp h) |
| have ham : m.1 a ≠ n.1 a := by rw [hma] |
| obtain ⟨b, hba, hab, he⟩ := active_component_endpoints m n a hma hna |
| have hnBoth : ∀ v, (overlay m n).Reachable a v → ¬(v ∈ S ∧ v ∈ T) := by |
| intro v hv ⟨hs, ht⟩ |
| exact mates_ne_of_reachable m n hv ham (((hm v).mpr hs).trans ((hn v).mpr ht).symm) |
| have hb : b ∈ S ∨ b ∈ T := by |
| simpa only [hm b, hn b] using (he b hab).mpr (Or.inr rfl) |
| refine ⟨b, hba, ?_, ?_, ?_⟩ |
| · simp only [Finset.mem_symmDiff] |
| have := hnBoth b hab |
| tauto |
| · intro v |
| by_cases hv : (overlay m n).Reachable a v |
| · have hvEnd : (v ∈ S ∨ v ∈ T) ↔ (v = a ∨ v = b) := by |
| simpa only [hm v, hn v] using he v hv |
| have hnb := hnBoth v hv |
| simp only [switched_apply, ite_eq_left hv, hn v, Finset.mem_symmDiff, |
| Finset.mem_insert, Finset.mem_singleton] |
| tauto |
| · have hva : v ≠ a := by rintro rfl |
| have hvb : v ≠ b := by rintro rfl |
| simp [switched_apply, hv, hm v, Finset.mem_symmDiff, hva, hvb] |
| · intro v |
| by_cases hv : (overlay m n).Reachable a v |
| · have hvEnd : (v ∈ S ∨ v ∈ T) ↔ (v = a ∨ v = b) := by |
| simpa only [hm v, hn v] using he v hv |
| have hnb := hnBoth v hv |
| simp only [switched_apply, overlay_comm n m, ite_eq_left hv, hm v, |
| Finset.mem_symmDiff, Finset.mem_insert, Finset.mem_singleton] |
| tauto |
| · have hva : v ≠ a := by rintro rfl |
| have hvb : v ≠ b := by rintro rfl |
| simp [switched_apply, overlay_comm n m, hv, hn v, Finset.mem_symmDiff, hva, hvb] |
|
|
| theorem mixed_hole_partition_comparison [Fintype V] [LinearOrder V] |
| (w : V → V → ℝ) (hw : ∀ v z, 0 ≤ w v z) (S T : Finset V) |
| (a : V) (ha : a ∈ S) (hTa : a ∉ T) : |
| partition w S * partition w T ≤ |
| ∑ b ∈ (S ∆ T).erase a, |
| partition w (S ∆ {a, b}) * partition w (T ∆ {a, b}) := by |
| classical |
| let H := (S ∆ T).erase a |
| let inputs := (matchings S) ×ˢ (matchings T) |
| let Q := fun b : V => (matchings (S ∆ {a, b})) ×ˢ (matchings (T ∆ {a, b})) |
| let f := fun p : Mate V × Mate V => (switched p.1 p.2 a, switched p.2 p.1 a) |
| let W := fun p : Mate V × Mate V => weight w p.1 * weight w p.2 |
| have hi : Function.Injective f := switch_injective a |
| have hd : (↑H : Set V).PairwiseDisjoint Q := by |
| intro b hb c hc hbc |
| apply Finset.disjoint_left.mpr |
| intro p hp hq |
| have hpb : HasHoles p.1 (S ∆ {a, b}) := |
| (mem_matchings p.1 _).mp (Finset.mem_product.mp hp).1 |
| have hpc : HasHoles p.1 (S ∆ {a, c}) := |
| (mem_matchings p.1 _).mp (Finset.mem_product.mp hq).1 |
| have heq : (S ∆ {a, b}) = (S ∆ {a, c}) := hasHoles_unique p.1 hpb hpc |
| have habc : ({a, b} : Finset V) = {a, c} := symmDiff_right_injective S heq |
| have hbm : b ∈ ({a, c} : Finset V) := by rw [← habc] |
| have hba : b ≠ a := (Finset.mem_erase.mp hb).1 |
| simp only [Finset.mem_insert, Finset.mem_singleton] at hbm |
| exact hbc (hbm.resolve_left hba) |
| have himage : inputs.image f ⊆ H.biUnion Q := by |
| intro p hp |
| obtain ⟨⟨m, n⟩, hmn, rfl⟩ := Finset.mem_image.mp hp |
| obtain ⟨hm, hn⟩ := Finset.mem_product.mp hmn |
| obtain ⟨b, hba, hb, hmb, hnb⟩ := switched_holes m n S T |
| ((mem_matchings m S).mp hm) ((mem_matchings n T).mp hn) a ha hTa |
| exact Finset.mem_biUnion.mpr ⟨b, Finset.mem_erase.mpr ⟨hba, hb⟩, |
| Finset.mem_product.mpr ⟨(mem_matchings _ _).mpr hmb, (mem_matchings _ _).mpr hnb⟩⟩ |
| calc |
| partition w S * partition w T = ∑ p ∈ inputs, W p := by |
| simp only [inputs, W, partition, Finset.sum_product, Finset.sum_mul_sum] |
| _ = ∑ p ∈ inputs.image f, W p := by |
| rw [Finset.sum_image hi.injOn] |
| apply Finset.sum_congr rfl |
| intro p _ |
| exact (switched_weight w p.1 p.2 a).symm |
| _ ≤ ∑ p ∈ H.biUnion Q, W p := |
| Finset.sum_le_sum_of_subset_of_nonneg himage |
| (fun p _ _ => mul_nonneg (weight_nonneg w hw p.1) (weight_nonneg w hw p.2)) |
| _ = _ := by |
| rw [Finset.sum_biUnion hd] |
| apply Finset.sum_congr rfl |
| intro b _ |
| simp only [Q, W, partition, Finset.sum_product, Finset.sum_mul_sum] |
|
|
| noncomputable def withEdge (m : Mate V) (a b : V) : Mate V := by |
| classical |
| by_cases h : m.1 a = a ∧ m.1 b = b |
| · refine ⟨fun v => if v = a then b else if v = b then a else m.1 v, ?_⟩ |
| intro v |
| by_cases hva : v = a |
| · subst v |
| by_cases hab : a = b < |
| by_cases hvb : v = b |
| · subst v |
| by_cases hab : a = b < |
| have hma : m.1 v ≠ a := by |
| intro hv |
| have he := congrArg m.1 hv |
| rw [mate_mate, h.1] at he |
| exact hva he |
| have hmb : m.1 v ≠ b := by |
| intro hv |
| have he := congrArg m.1 hv |
| rw [mate_mate, h.2] at he |
| exact hvb he |
| simp [hva, hvb, hma, hmb] |
| · exact m |
|
|
| @[simp] theorem withEdge_apply (m : Mate V) (a b v : V) |
| (ha : m.1 a = a) (hb : m.1 b = b) : |
| (withEdge m a b).1 v = if v = a then b else if v = b then a else m.1 v := by |
| classical |
| simp [withEdge, ha, hb] |
|
|
| theorem withEdge_holes [DecidableEq V] (m : Mate V) (S : Finset V) |
| (hm : HasHoles m S) (a b : V) (ha : a ∈ S) (hb : b ∈ S) (hab : a ≠ b) : |
| HasHoles (withEdge m a b) (S \ {a, b}) := by |
| classical |
| intro v |
| rw [withEdge_apply m a b v ((hm a).mpr ha) ((hm b).mpr hb)] |
| by_cases hva : v = a |
| · subst v |
| simp [hab, Ne.symm hab] |
| by_cases hvb : v = b |
| · subst v |
| simp [hab, Ne.symm hab] |
| simp [hva, hvb, hm v] |
|
|
| theorem withEdge_injOn [Fintype V] (S : Finset V) (a b : V) |
| (ha : a ∈ S) (hb : b ∈ S) : |
| Set.InjOn (fun m : Mate V => withEdge m a b) (matchings S) := by |
| classical |
| intro m hm n hn he |
| have hm := (mem_matchings m S).mp hm |
| have hn := (mem_matchings n S).mp hn |
| apply Subtype.ext |
| funext v |
| by_cases hva : v = a |
| · subst v |
| exact ((hm a).mpr ha).trans ((hn a).mpr ha).symm |
| by_cases hvb : v = b |
| · subst v |
| exact ((hm b).mpr hb).trans ((hn b).mpr hb).symm |
| have hv := congrArg (fun p : Mate V => p.1 v) he |
| simpa [withEdge_apply, (hm a).mpr ha, (hm b).mpr hb, |
| (hn a).mpr ha, (hn b).mpr hb, hva, hvb] using hv |
|
|
| def edgeActivity [LinearOrder V] (w : V → V → ℝ) (a b : V) : ℝ := |
| if a < b then w a b else w b a |
|
|
| theorem edgeActivity_comm [LinearOrder V] (w : V → V → ℝ) (a b : V) : |
| edgeActivity w a b = edgeActivity w b a := by |
| rcases lt_trichotomy a b with h | rfl | h |
| · simp [edgeActivity, h, h.not_gt] |
| · rfl |
| · simp [edgeActivity, h, h.not_gt] |
|
|
| theorem withEdge_comm (m : Mate V) (a b : V) : withEdge m a b = withEdge m b a := by |
| classical |
| by_cases h : m.1 a = a ∧ m.1 b = b |
| · apply Subtype.ext |
| funext v |
| simp only [withEdge_apply, h.1, h.2] |
| by_cases hv : v = a |
| · subst v |
| by_cases hab : a = b < |
| · simp [hv] |
| · have h' : ¬(m.1 b = b ∧ m.1 a = a) := by tauto |
| simp [withEdge, h, h'] |
|
|
| theorem withEdge_weight_of_lt [Fintype V] [LinearOrder V] |
| (w : V → V → ℝ) (m : Mate V) (a b : V) |
| (ha : m.1 a = a) (hb : m.1 b = b) (hab : a < b) : |
| weight w (withEdge m a b) = w a b * weight w m := by |
| classical |
| have hf : ∀ v : V, |
| (if v < (withEdge m a b).1 v then w v ((withEdge m a b).1 v) else 1) = |
| (if v = a then w a b else 1) * (if v < m.1 v then w v (m.1 v) else 1) := by |
| intro v |
| by_cases hva : v = a |
| · subst v |
| simp [withEdge_apply, ha, hb, hab] |
| by_cases hvb : v = b |
| · subst v |
| simp [withEdge_apply, ha, hb, hab.ne', hab.not_gt] |
| simp [withEdge_apply, ha, hb, hva, hvb] |
| simp only [weight, hf, Finset.prod_mul_distrib] |
| simp |
| |
| theorem withEdge_weight [Fintype V] [LinearOrder V] |
| (w : V → V → ℝ) (m : Mate V) (a b : V) |
| (ha : m.1 a = a) (hb : m.1 b = b) (hab : a ≠ b) : |
| weight w (withEdge m a b) = edgeActivity w a b * weight w m := by |
| rcases lt_or_gt_of_ne hab with h | h |
| · simpa [edgeActivity, h] using withEdge_weight_of_lt w m a b ha hb h |
| · rw [withEdge_comm, edgeActivity_comm] |
| simpa [edgeActivity, h] using withEdge_weight_of_lt w m b a hb ha h |
| |
| theorem edge_fill_partition [Fintype V] [LinearOrder V] |
| (w : V → V → ℝ) (hw : ∀ v z, 0 ≤ w v z) (S : Finset V) |
| (a b : V) (ha : a ∈ S) (hb : b ∈ S) (hab : a ≠ b) : |
| edgeActivity w a b * partition w S ≤ partition w (S \ {a, b}) := by |
| classical |
| let f := fun m : Mate V => withEdge m a b |
| have hi := withEdge_injOn S a b ha hb |
| have hsub : (matchings S).image f ⊆ matchings (S \ {a, b}) := by |
| intro m hm |
| obtain ⟨n, hn, rfl⟩ := Finset.mem_image.mp hm |
| exact (mem_matchings _ _).mpr |
| (withEdge_holes n S ((mem_matchings n S).mp hn) a b ha hb hab) |
| calc |
| edgeActivity w a b * partition w S = ∑ m ∈ matchings S, weight w (f m) := by |
| rw [partition, Finset.mul_sum] |
| apply Finset.sum_congr rfl |
| intro m hm |
| have hh := (mem_matchings m S).mp hm |
| exact (withEdge_weight w m a b ((hh a).mpr ha) ((hh b).mpr hb) hab).symm |
| _ = ∑ m ∈ (matchings S).image f, weight w m := (Finset.sum_image hi).symm |
| _ ≤ partition w (S \ {a, b}) := |
| Finset.sum_le_sum_of_subset_of_nonneg hsub (fun m _ _ => weight_nonneg w hw m) |
| |
| noncomputable def holeRatio [Fintype V] [LinearOrder V] |
| (w : V → V → ℝ) (U : Finset V) : ℝ := partition w U / partition w ∅ |
| |
| theorem holeRatio_nonneg [Fintype V] [LinearOrder V] |
| (w : V → V → ℝ) (hw : ∀ v z, 0 ≤ w v z) (U : Finset V) : |
| 0 ≤ holeRatio w U := div_nonneg (partition_nonneg w hw U) (partition_nonneg w hw ∅) |
| |
| theorem holeRatio_empty [Fintype V] [LinearOrder V] |
| (w : V → V → ℝ) (hz : 0 < partition w ∅) : holeRatio w ∅ = 1 := div_self hz.ne' |
|
|
| theorem holeRatio_pair_comm [Fintype V] [LinearOrder V] |
| (w : V → V → ℝ) (a b : V) : holeRatio w {a, b} = holeRatio w {b, a} := by |
| rw [Finset.pair_comm] |
|
|
| theorem holeRatio_comparison [Fintype V] [LinearOrder V] |
| (w : V → V → ℝ) (hw : ∀ v z, 0 ≤ w v z) (hz : 0 < partition w ∅) |
| (U : Finset V) (a : V) (ha : a ∈ U) : |
| holeRatio w U ≤ ∑ b ∈ U.erase a, holeRatio w (U \ {a, b}) * holeRatio w {a, b} := by |
| have h := hole_partition_comparison w hw U a ha |
| have hzz : 0 ≤ partition w ∅ * partition w ∅ := mul_nonneg hz.le hz.le |
| calc |
| holeRatio w U = (partition w U * partition w ∅) / (partition w ∅ * partition w ∅) := by |
| unfold holeRatio |
| field_simp |
| _ ≤ (∑ b ∈ U.erase a, partition w (U \ {a, b}) * partition w {a, b}) / |
| (partition w ∅ * partition w ∅) := div_le_div_of_nonneg_right h hzz |
| _ = _ := by |
| rw [Finset.sum_div] |
| apply Finset.sum_congr rfl |
| intro b _ |
| exact mul_div_mul_comm _ _ _ _ |
|
|
| theorem four_holes [Fintype V] [LinearOrder V] |
| (w : V → V → ℝ) (hw : ∀ v z, 0 ≤ w v z) (hz : 0 < partition w ∅) |
| (a b c d : V) (hab : a ≠ b) (hac : a ≠ c) (had : a ≠ d) |
| (hbc : b ≠ c) (hbd : b ≠ d) (hcd : c ≠ d) : |
| holeRatio w {a, b, c, d} ≤ |
| holeRatio w {a, b} * holeRatio w {c, d} + |
| holeRatio w {a, c} * holeRatio w {b, d} + |
| holeRatio w {a, d} * holeRatio w {b, c} := by |
| classical |
| have h := holeRatio_comparison w hw hz {a,b,c,d} a (by simp) |
| have he : ({a,b,c,d} : Finset V).erase a = {b,c,d} := by |
| ext v |
| simp only [Finset.mem_erase, Finset.mem_insert, Finset.mem_singleton] |
| grind |
| have hab' : ({a,b,c,d} : Finset V) \ {a,b} = {c,d} := by |
| ext v |
| simp only [Finset.mem_sdiff, Finset.mem_insert, Finset.mem_singleton] |
| grind |
| have hac' : ({a,b,c,d} : Finset V) \ {a,c} = {b,d} := by |
| ext v |
| simp only [Finset.mem_sdiff, Finset.mem_insert, Finset.mem_singleton] |
| grind |
| have had' : ({a,b,c,d} : Finset V) \ {a,d} = {b,c} := by |
| ext v |
| simp only [Finset.mem_sdiff, Finset.mem_insert, Finset.mem_singleton] |
| grind |
| rw [he, Finset.sum_insert (by simp [hbc, hbd]), |
| Finset.sum_insert (by simp [hcd]), Finset.sum_singleton, |
| hab', hac', had'] at h |
| nlinarith only [h] |
|
|
| theorem mixed_holeRatio_comparison [Fintype V] [LinearOrder V] |
| (w : V → V → ℝ) (hw : ∀ v z, 0 ≤ w v z) (hz : 0 < partition w ∅) |
| (S T : Finset V) (a : V) (ha : a ∈ S) (hTa : a ∉ T) : |
| holeRatio w S * holeRatio w T ≤ |
| ∑ b ∈ (S ∆ T).erase a, |
| holeRatio w (S ∆ {a, b}) * holeRatio w (T ∆ {a, b}) := by |
| have h := mixed_hole_partition_comparison w hw S T a ha hTa |
| have hzz : 0 ≤ partition w ∅ * partition w ∅ := mul_nonneg hz.le hz.le |
| calc |
| holeRatio w S * holeRatio w T = |
| (partition w S * partition w T) / (partition w ∅ * partition w ∅) := |
| (mul_div_mul_comm _ _ _ _).symm |
| _ ≤ (∑ b ∈ (S ∆ T).erase a, |
| partition w (S ∆ {a, b}) * partition w (T ∆ {a, b})) / |
| (partition w ∅ * partition w ∅) := div_le_div_of_nonneg_right h hzz |
| _ = _ := by |
| rw [Finset.sum_div] |
| apply Finset.sum_congr rfl |
| intro b _ |
| exact mul_div_mul_comm _ _ _ _ |
|
|
| theorem edge_fill_holeRatio [Fintype V] [LinearOrder V] |
| (w : V → V → ℝ) (hw : ∀ v z, 0 ≤ w v z) (hz : 0 < partition w ∅) |
| (S : Finset V) (a b : V) (ha : a ∈ S) (hb : b ∈ S) (hab : a ≠ b) : |
| edgeActivity w a b * holeRatio w S ≤ holeRatio w (S \ {a, b}) := by |
| simpa only [holeRatio, mul_div_assoc] using |
| div_le_div_of_nonneg_right (edge_fill_partition w hw S a b ha hb hab) hz.le |
|
|
| noncomputable def rowMax [Fintype V] [LinearOrder V] |
| (hcard : 2 ≤ Fintype.card V) (w : V → V → ℝ) (a : V) : ℝ := |
| ((Finset.univ.erase a).sup' (by |
| apply Finset.card_pos.mp |
| rw [Finset.card_erase_of_mem (Finset.mem_univ a), Finset.card_univ] |
| omega) fun b => holeRatio w {a,b}) |
| |
| theorem holeRatio_le_rowMax [Fintype V] [LinearOrder V] |
| (hcard : 2 ≤ Fintype.card V) (w : V → V → ℝ) (a b : V) (hab : a ≠ b) : |
| holeRatio w {a,b} ≤ rowMax hcard w a := by |
| exact Finset.le_sup' (fun b => holeRatio w {a,b}) (by simp [Ne.symm hab]) |
|
|
| theorem rowMax_attained [Fintype V] [LinearOrder V] |
| (hcard : 2 ≤ Fintype.card V) (w : V → V → ℝ) (a : V) : |
| ∃ b, b ≠ a ∧ holeRatio w {a,b} = rowMax hcard w a := by |
| unfold rowMax |
| obtain ⟨b,hb,he⟩ := Finset.exists_mem_eq_sup' |
| (show (Finset.univ.erase a).Nonempty by |
| apply Finset.card_pos.mp |
| rw [Finset.card_erase_of_mem (Finset.mem_univ a), Finset.card_univ] |
| omega) (fun b => holeRatio w {a,b}) |
| exact ⟨b,(Finset.mem_erase.mp hb).1,he.symm⟩ |
| |
| theorem two_holes_le_four [Fintype V] [LinearOrder V] |
| (hcard : 2 ≤ Fintype.card V) (w : V → V → ℝ) |
| (hr : ∀ a, rowMax hcard w a ≤ 4) (U : Finset V) (hU : U.card = 2) : |
| holeRatio w U ≤ 4 := by |
| obtain ⟨a,b,hab,rfl⟩ := Finset.card_eq_two.mp hU |
| exact (holeRatio_le_rowMax hcard w a b hab).trans (hr a) |
| |
| theorem four_holes_le_fortyeight [Fintype V] [LinearOrder V] |
| (hcard : 2 ≤ Fintype.card V) (w : V → V → ℝ) |
| (hw : ∀ v z, 0 ≤ w v z) (hz : 0 < partition w ∅) |
| (hr : ∀ a, rowMax hcard w a ≤ 4) (U : Finset V) (hU : U.card = 4) : |
| holeRatio w U ≤ 48 := by |
| obtain ⟨a,b,c,d,hab,hac,had,hbc,hbd,hcd,rfl⟩ := Finset.card_eq_four.mp hU |
| have hpair : ∀ a b : V, a ≠ b → holeRatio w {a,b} ≤ 4 := |
| fun a b hab => (holeRatio_le_rowMax hcard w a b hab).trans (hr a) |
| have hmul : ∀ (a b c d : V), a ≠ b → c ≠ d → |
| holeRatio w {a,b} * holeRatio w {c,d} ≤ 16 := by |
| intro a b c d hab hcd |
| have h := mul_le_mul (hpair a b hab) (hpair c d hcd) |
| (holeRatio_nonneg w hw {c,d}) (by norm_num : (0:ℝ) ≤ 4) |
| norm_num at h ⊢ |
| exact h |
| have hf := four_holes w hw hz a b c d hab hac had hbc hbd hcd |
| have h1 := hmul a b c d hab hcd |
| have h2 := hmul a c b d hac hbd |
| have h3 := hmul a d b c had hbc |
| linarith |
| |
| theorem zero_or_two_holes_le_four [Fintype V] [LinearOrder V] |
| (hcard : 2 ≤ Fintype.card V) (w : V → V → ℝ) (hz : 0 < partition w ∅) |
| (hr : ∀ a, rowMax hcard w a ≤ 4) (U : Finset V) |
| (hU : U.card = 0 ∨ U.card = 2) : holeRatio w U ≤ 4 := by |
| rcases hU with h | h |
| · have he : U = ∅ := Finset.card_eq_zero.mp h |
| rw [he, holeRatio_empty w hz] |
| norm_num |
| · exact two_holes_le_four hcard w hr U h |
| |
| theorem small_holes_le_fortyeight [Fintype V] [LinearOrder V] |
| (hcard : 2 ≤ Fintype.card V) (w : V → V → ℝ) |
| (hw : ∀ v z, 0 ≤ w v z) (hz : 0 < partition w ∅) |
| (hr : ∀ a, rowMax hcard w a ≤ 4) (U : Finset V) |
| (hU : U.card = 0 ∨ U.card = 2 ∨ U.card = 4) : holeRatio w U ≤ 48 := by |
| rcases hU with h | h | h |
| · exact (zero_or_two_holes_le_four hcard w hz hr U (Or.inl h)).trans (by norm_num) |
| · exact (two_holes_le_four hcard w hr U h).trans (by norm_num) |
| · exact four_holes_le_fortyeight hcard w hw hz hr U h |
| |
| theorem symmDiff_pair_of_mem_mem [DecidableEq V] (S : Finset V) (a b : V) |
| (ha : a ∈ S) (hb : b ∈ S) : S ∆ {a,b} = S \ {a,b} := by |
| ext v |
| simp only [Finset.mem_symmDiff, Finset.mem_sdiff, Finset.mem_insert, Finset.mem_singleton] |
| grind |
| |
| theorem symmDiff_pair_of_mem_notMem [DecidableEq V] (S : Finset V) (a b : V) |
| (ha : a ∈ S) (hb : b ∉ S) : S ∆ {a,b} = insert b (S.erase a) := by |
| ext v |
| simp only [Finset.mem_symmDiff, Finset.mem_erase, Finset.mem_insert, Finset.mem_singleton] |
| grind |
| |
| end MatchingFPRAS.Switching |
| |
| end OAI |
| |
