Download data/lean/OAI/Combinatorics/MatchingCount/Graphs/PathStrength.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 18.2 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Combinatorics/MatchingCount/Graphs/PathStrength.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Combinatorics/MatchingCount/Graphs/PathStrength.lean
-
curl -L -o PathStrength.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Combinatorics/MatchingCount/Graphs/PathStrength.lean
18.2 kB
| import Mathlib | |
| import OAI.Combinatorics.MatchingCount.Graphs.Edge | |
| namespace OAI | |
| namespace MatchingFPRAS.Switching | |
| open Finset | |
| open scoped Classical symmDiff | |
| variable {V : Type*} | |
| theorem sdiff_pair_card [DecidableEq V] (S : Finset V) (a b : V) | |
| (ha : a β S) (hb : b β S) (hab : a β b) : | |
| (S \ {a,b}).card = S.card - 2 := by | |
| have hsub : ({a,b} : Finset V) β S := by | |
| intro x hx | |
| rcases Finset.mem_insert.mp hx with h | h | |
| Β· subst x | |
| exact ha | |
| Β· have he := Finset.mem_singleton.mp h | |
| subst x | |
| exact hb | |
| rw [Finset.card_sdiff_of_subset hsub, Finset.card_pair hab] | |
| theorem relocated_card [DecidableEq V] (S : Finset V) (a b : V) | |
| (ha : a β S) (hb : b β S) : (insert b (S.erase a)).card = S.card := by | |
| have hba : b β S.erase a := fun h => hb (Finset.mem_of_mem_erase h) | |
| rw [Finset.card_insert_of_notMem hba, Finset.card_erase_add_one ha] | |
| theorem pair_fill_holeRatio [Fintype V] [LinearOrder V] | |
| (w : V β V β β) (hw : β v z, 0 β€ w v z) (hz : 0 < partition w β ) | |
| (a b : V) (hab : a β b) : | |
| edgeActivity w a b * holeRatio w {a,b} β€ 1 := by | |
| have h := edge_fill_holeRatio w hw hz {a,b} a b (by simp) (by simp) hab | |
| simpa [holeRatio_empty w hz] using h | |
| theorem adjacent_hole_fill [Fintype V] [LinearOrder V] | |
| (hcard : 2 β€ Fintype.card V) (w : V β V β β) | |
| (hw : β v z, 0 β€ w v z) (hz : 0 < partition w β ) | |
| (hrlo : β a, (1:β)/8 β€ rowMax hcard w a) | |
| (hrhi : β a, rowMax hcard w a β€ 4) | |
| (S : Finset V) (hS : S.card = 2 β¨ S.card = 4) | |
| (a b : V) (ha : a β S) (hb : b β S) (hab : a β b) | |
| (B : β) (hB : 0 < B) (hBa : B β€ edgeActivity w a b) : | |
| holeRatio w S / rowMax hcard w a β€ 32 / B := by | |
| have hfill := edge_fill_holeRatio w hw hz S a b ha hb hab | |
| have hhole := holeRatio_nonneg w hw S | |
| have hp : B * holeRatio w S β€ holeRatio w (S \ {a,b}) := | |
| (mul_le_mul_of_nonneg_right hBa hhole).trans hfill | |
| have hs : (S \ {a,b}).card = 0 β¨ (S \ {a,b}).card = 2 := by | |
| rw [sdiff_pair_card S a b ha hb hab] | |
| omega | |
| have hg := zero_or_two_holes_le_four hcard w hz hrhi (S \ {a,b}) hs | |
| have hra := hrlo a | |
| have hrap : 0 < rowMax hcard w a := by linarith | |
| apply (div_le_iffβ hrap).mpr | |
| rw [div_mul_eq_mul_div] | |
| apply (le_div_iffβ hB).mpr | |
| nlinarith only [hp,hg,hra] | |
| theorem toggle_small_holes_card [DecidableEq V] (S : Finset V) (a b : V) | |
| (ha : a β S) (hab : a β b) (hS : S.card = 2 β¨ S.card = 4) : | |
| (S β {a,b}).card = 0 β¨ (S β {a,b}).card = 2 β¨ (S β {a,b}).card = 4 := by | |
| by_cases hb : b β S | |
| Β· rw [symmDiff_pair_of_mem_mem S a b ha hb, sdiff_pair_card S a b ha hb hab] | |
| omega | |
| Β· rw [symmDiff_pair_of_mem_notMem S a b ha hb, relocated_card S a b ha hb] | |
| omega | |
| theorem normalized_relocation [Fintype V] [LinearOrder V] | |
| (hcard : 2 β€ Fintype.card V) (w : V β V β β) | |
| (hw : β v z, 0 β€ w v z) (hz : 0 < partition w β ) | |
| (hrlo : β a, (1:β)/8 β€ rowMax hcard w a) | |
| (hrhi : β a, rowMax hcard w a β€ 4) | |
| (S : Finset V) (hS : S.card = 2 β¨ S.card = 4) | |
| (a z : V) (ha : a β S) (hzS : z β S) | |
| (B : β) (hB8 : 8 < B) (hBa : B β€ edgeActivity w a z) : | |
| holeRatio w S / rowMax hcard w a β€ | |
| holeRatio w (insert z (S.erase a)) / rowMax hcard w z + 6144 / B := by | |
| have hB : 0 < B := by linarith | |
| have haz : a β z := fun h => hzS (h βΈ ha) | |
| have hrap : β v, 0 < rowMax hcard w v := fun v => by linarith [hrlo v] | |
| obtain β¨p,hpz,hprβ© := rowMax_attained hcard w z | |
| have hfill := pair_fill_holeRatio w hw hz a z haz | |
| have hpair : B * holeRatio w {a,z} β€ 1 := | |
| (mul_le_mul_of_nonneg_right hBa (holeRatio_nonneg w hw {a,z})).trans hfill | |
| have hpa : p β a := by | |
| intro h | |
| subst p | |
| rw [holeRatio_pair_comm w z a] at hpr | |
| have hlo := hrlo z | |
| rw [β hpr] at hlo | |
| nlinarith | |
| let R := S \ {a,p} | |
| let F := fun b => holeRatio w (S β {a,b}) * holeRatio w ({z,p} β {a,b}) | |
| have hF : β b, 0 β€ F b := fun b => mul_nonneg | |
| (holeRatio_nonneg w hw _) (holeRatio_nonneg w hw _) | |
| have hcmp := mixed_holeRatio_comparison w hw hz S {z,p} a ha | |
| (by simp [haz, Ne.symm hpa]) | |
| change holeRatio w S * holeRatio w {z,p} β€ | |
| β b β (S β {z,p}).erase a, F b at hcmp | |
| rw [hpr] at hcmp | |
| have hsub : (S β {z,p}).erase a β insert z (insert p R) := by | |
| intro x hx | |
| simp only [Finset.mem_erase, Finset.mem_symmDiff, Finset.mem_insert, | |
| Finset.mem_singleton, R, Finset.mem_sdiff] at hx β’ | |
| grind | |
| have hcmp' : holeRatio w S * rowMax hcard w z β€ β b β insert z (insert p R), F b := | |
| hcmp.trans (Finset.sum_le_sum_of_subset_of_nonneg hsub (fun b _ _ => hF b)) | |
| have hzR : z β R := fun h => hzS (Finset.mem_sdiff.mp h).1 | |
| have hpR : p β R := by simp [R] | |
| rw [Finset.sum_insert (by simp [hpz.symm, hzR]), Finset.sum_insert hpR] at hcmp' | |
| have htz : ({z,p} : Finset V) β {a,z} = {a,p} := by | |
| ext v | |
| simp only [Finset.mem_symmDiff, Finset.mem_insert, Finset.mem_singleton] | |
| grind | |
| have htp : ({z,p} : Finset V) β {a,p} = {a,z} := by | |
| ext v | |
| simp only [Finset.mem_symmDiff, Finset.mem_insert, Finset.mem_singleton] | |
| grind | |
| have hFz : F z β€ holeRatio w (insert z (S.erase a)) * rowMax hcard w a := by | |
| dsimp [F] | |
| rw [symmDiff_pair_of_mem_notMem S a z ha hzS, htz] | |
| exact mul_le_mul_of_nonneg_left (holeRatio_le_rowMax hcard w a p hpa.symm) | |
| (holeRatio_nonneg w hw _) | |
| have hFp : B * F p β€ 48 := by | |
| have hh := small_holes_le_fortyeight hcard w hw hz hrhi (S β {a,p}) | |
| (toggle_small_holes_card S a p ha hpa.symm hS) | |
| have hn := holeRatio_nonneg w hw (S β {a,p}) | |
| dsimp [F] | |
| rw [htp] | |
| nlinarith only [hpair, hh, hn] | |
| have hFx : β x β R, B * F x β€ 16 := by | |
| intro x hx | |
| have hxS := (Finset.mem_sdiff.mp hx).1 | |
| have hxa : x β a := by | |
| intro h | |
| exact (Finset.mem_sdiff.mp hx).2 (by simp [h]) | |
| have hxp : x β p := by | |
| intro h | |
| exact (Finset.mem_sdiff.mp hx).2 (by simp [h]) | |
| have hxz : x β z := fun h => hzS (h βΈ hxS) | |
| have ht : ({z,p} : Finset V) β {a,x} = {z,p,a,x} := by | |
| ext v | |
| simp only [Finset.mem_symmDiff, Finset.mem_insert, Finset.mem_singleton] | |
| grind | |
| have hs : (S \ {a,x}).card = 0 β¨ (S \ {a,x}).card = 2 := by | |
| rw [sdiff_pair_card S a x ha hxS hxa.symm] | |
| omega | |
| have hs4 := zero_or_two_holes_le_four hcard w hz hrhi (S \ {a,x}) hs | |
| have hs0 := holeRatio_nonneg w hw (S \ {a,x}) | |
| have hf := edge_fill_holeRatio w hw hz {z,p,a,x} a z (by simp) (by simp) haz | |
| have he : ({z,p,a,x} : Finset V) \ {a,z} = {p,x} := by | |
| ext v | |
| simp only [Finset.mem_sdiff, Finset.mem_insert, Finset.mem_singleton] | |
| grind | |
| rw [he] at hf | |
| have hf' : B * holeRatio w {z,p,a,x} β€ 4 := by | |
| exact ((mul_le_mul_of_nonneg_right hBa (holeRatio_nonneg w hw _)).trans hf).trans | |
| ((holeRatio_le_rowMax hcard w p x hxp.symm).trans (hrhi p)) | |
| dsimp [F] | |
| rw [ht, symmDiff_pair_of_mem_mem S a x ha hxS] | |
| have hm := mul_le_mul hs4 hf' (mul_nonneg hB.le (holeRatio_nonneg w hw _)) | |
| (by norm_num : (0:β) β€ 4) | |
| nlinarith only [hm] | |
| have hRsub : R β S.erase a := by | |
| intro x hx | |
| dsimp [R] at hx | |
| simp only [Finset.mem_sdiff, Finset.mem_insert, Finset.mem_singleton] at hx | |
| simp only [Finset.mem_erase] | |
| grind | |
| have hRcard : R.card β€ 3 := by | |
| have h := Finset.card_le_card hRsub | |
| have hc := Finset.card_erase_add_one ha | |
| omega | |
| have hsum : B * β x β R, F x β€ 48 := by | |
| rw [Finset.mul_sum] | |
| calc | |
| β x β R, B * F x β€ β _x β R, (16:β) := Finset.sum_le_sum hFx | |
| _ = (R.card:β) * 16 := by simp | |
| _ β€ 48 := by exact_mod_cast (by omega : R.card * 16 β€ 48) | |
| have hmain : B * holeRatio w S * rowMax hcard w z β€ | |
| B * holeRatio w (insert z (S.erase a)) * rowMax hcard w a + 96 := by | |
| have hm := mul_le_mul_of_nonneg_left hcmp' hB.le | |
| have hmz := mul_le_mul_of_nonneg_left hFz hB.le | |
| nlinarith only [hm, hmz, hFp, hsum] | |
| have hprod := mul_le_mul (hrlo a) (hrlo z) (by norm_num : (0:β) β€ 1/8) | |
| (le_of_lt (hrap a)) | |
| apply (div_le_iffβ (hrap a)).mpr | |
| apply (mul_le_mul_iff_leftβ (mul_pos hB (hrap z))).mp | |
| have he : | |
| ((holeRatio w (insert z (S.erase a)) / rowMax hcard w z + 6144 / B) * | |
| rowMax hcard w a) * (B * rowMax hcard w z) = | |
| B * holeRatio w (insert z (S.erase a)) * rowMax hcard w a + | |
| 6144 * rowMax hcard w a * rowMax hcard w z := by | |
| field_simp [ne_of_gt (hrap z), ne_of_gt hB] | |
| rw [he] | |
| nlinarith only [hmain, hprod] | |
| theorem normalized_path_relocation [Fintype V] [LinearOrder V] | |
| (hcard : 2 β€ Fintype.card V) (w : V β V β β) | |
| (hw : β v z, 0 β€ w v z) (hz : 0 < partition w β ) | |
| (hrlo : β a, (1:β)/8 β€ rowMax hcard w a) | |
| (hrhi : β a, rowMax hcard w a β€ 4) | |
| (B : β) (hB8 : 8 < B) (L : List V) (a : V) | |
| (S : Finset V) (hS : S.card = 2 β¨ S.card = 4) (ha : a β S) | |
| (hpath : List.IsChain (fun x y => B β€ edgeActivity w x y) (a :: L)) | |
| (hnodup : (a :: L).Nodup) (hend : β j β L, j β S) : | |
| holeRatio w S / rowMax hcard w a β€ 6144 * L.length / B := by | |
| have hB : 0 < B := by linarith | |
| induction L generalizing a S with | |
| | nil => simp at hend | |
| | cons z L ih => | |
| obtain β¨hazL, hndβ© := List.nodup_cons.mp hnodup | |
| have haz : a β z := fun h => hazL (by simp [h]) | |
| obtain β¨hBa, hpβ© := List.isChain_cons_cons.mp hpath | |
| by_cases hzS : z β S | |
| Β· have hf := adjacent_hole_fill hcard w hw hz hrlo hrhi S hS a z ha hzS haz B hB hBa | |
| apply hf.trans | |
| apply (div_le_div_iff_of_pos_right hB).mpr | |
| simp only [List.length_cons, Nat.cast_add, Nat.cast_one] | |
| have hlen : (0:β) β€ L.length := Nat.cast_nonneg _ | |
| linarith | |
| Β· let T := insert z (S.erase a) | |
| have hT : T.card = 2 β¨ T.card = 4 := by | |
| dsimp [T] | |
| rw [relocated_card S a z ha hzS] | |
| exact hS | |
| have he : β j β L, j β T := by | |
| obtain β¨j,hj,hjSβ© := hend | |
| have hjz : j β z := fun h => hzS (h βΈ hjS) | |
| have hja : j β a := fun h => hazL (h βΈ hj) | |
| refine β¨j, ?_, ?_β© | |
| Β· simpa [hjz] using hj | |
| Β· simp [T, hja, hjS] | |
| have hi := ih z T hT (by simp [T]) hp hnd he | |
| have hs := normalized_relocation hcard w hw hz hrlo hrhi S hS a z ha hzS B hB8 hBa | |
| calc | |
| holeRatio w S / rowMax hcard w a β€ | |
| holeRatio w T / rowMax hcard w z + 6144 / B := hs | |
| _ β€ 6144 * (L.length:β) / B + 6144 / B := add_le_add hi le_rfl | |
| _ = 6144 * ((z :: L).length:β) / B := by | |
| simp only [List.length_cons, Nat.cast_add, Nat.cast_one] | |
| ring | |
| theorem hole_relocation_of_strong_path [Fintype V] [LinearOrder V] | |
| (hcard : 2 β€ Fintype.card V) (w : V β V β β) | |
| (hw : β v z, 0 β€ w v z) (hz : 0 < partition w β ) | |
| (hrlo : β a, (1:β)/8 β€ rowMax hcard w a) | |
| (hrhi : β a, rowMax hcard w a β€ 4) | |
| (B : β) (hB : 0 < B) (S : Finset V) (hS : S.card = 2 β¨ S.card = 4) | |
| (a : V) (ha : a β S) | |
| (hpath : 8 < B β β L : List V, | |
| List.IsChain (fun x y => B β€ edgeActivity w x y) (a :: L) β§ | |
| (a :: L).Nodup β§ β j β L, j β S) : | |
| holeRatio w S β€ 100000 * Fintype.card V / B := by | |
| by_cases hB8 : 8 < B | |
| Β· obtain β¨L,hp,hn,heβ© := hpath hB8 | |
| have hb := normalized_path_relocation hcard w hw hz hrlo hrhi B hB8 L a S hS ha hp hn he | |
| have hra : 0 < rowMax hcard w a := by linarith [hrlo a] | |
| have hb' := (div_le_iffβ hra).mp hb | |
| have hlen : L.length β€ Fintype.card V := by | |
| have h := Finset.card_le_card (Finset.subset_univ (a :: L).toFinset) | |
| rw [List.toFinset_card_of_nodup hn, Finset.card_univ] at h | |
| simpa using Nat.le_trans (Nat.le_succ L.length) h | |
| have hlenR : (L.length:β) β€ Fintype.card V := by exact_mod_cast hlen | |
| apply (le_div_iffβ hB).mpr | |
| have hmul := mul_le_mul_of_nonneg_right hb' hB.le | |
| have heq : (6144 * (L.length:β) / B * rowMax hcard w a) * B = | |
| 6144 * (L.length:β) * rowMax hcard w a := by field_simp | |
| rw [heq] at hmul | |
| have hm := mul_le_mul_of_nonneg_left (hrhi a) | |
| (by positivity : (0:β) β€ 6144 * (L.length:β)) | |
| have hn0 : (0:β) β€ Fintype.card V := Nat.cast_nonneg _ | |
| nlinarith only [hmul,hm,hlenR,hn0] | |
| Β· have hc := small_holes_le_fortyeight hcard w hw hz hrhi S (by omega) | |
| have hn : (2:β) β€ Fintype.card V := by exact_mod_cast hcard | |
| have hg0 := holeRatio_nonneg w hw S | |
| apply (le_div_iffβ hB).mpr | |
| have hm := mul_le_mul_of_nonneg_right (le_of_not_gt hB8) hg0 | |
| nlinarith only [hc,hm,hn] | |
| noncomputable def pathStrength [LinearOrder V] (w : V β V β β) {a b : V} | |
| (hab : a β b) (p : (β€ : SimpleGraph V).Path a b) : β := | |
| p.val.darts.toFinset.inf' (by | |
| obtain β¨d,hdβ© := List.exists_mem_of_ne_nil p.val.darts | |
| (fun h => hab ((SimpleGraph.Walk.darts_eq_nil.mp h).eq)) | |
| exact β¨d,List.mem_toFinset.mpr hdβ©) | |
| (fun d => edgeActivity w d.fst d.snd) | |
| noncomputable def bottleneck [Fintype V] [LinearOrder V] | |
| (w : V β V β β) (a b : V) : β := | |
| if hab : a = b then 1 else | |
| max 1 ((Finset.univ : Finset ((β€ : SimpleGraph V).Path a b)).sup' | |
| (by exact β¨SimpleGraph.Path.singleton (by simpa using hab), Finset.mem_univ _β©) | |
| (pathStrength w hab)) | |
| theorem one_le_bottleneck [Fintype V] [LinearOrder V] | |
| (w : V β V β β) (a b : V) : 1 β€ bottleneck w a b := by | |
| unfold bottleneck | |
| split_ifs | |
| Β· rfl | |
| Β· exact le_max_left _ _ | |
| theorem walk_isChain_of_darts [LinearOrder V] {G : SimpleGraph V} | |
| (w : V β V β β) (B : β) {a b : V} (p : G.Walk a b) | |
| (h : β d β p.darts, B β€ edgeActivity w d.fst d.snd) : | |
| List.IsChain (fun x y => B β€ edgeActivity w x y) p.support := by | |
| induction p with | |
| | nil => simp | |
| | @cons a c b hadj p ih => | |
| rw [SimpleGraph.Walk.support_cons, β p.cons_tail_support] | |
| apply List.isChain_cons_cons.mpr | |
| constructor | |
| Β· exact h β¨(a,c),hadjβ© (by simp) | |
| Β· rw [p.cons_tail_support] | |
| apply ih | |
| intro d hd | |
| exact h d (by simp [hd]) | |
| theorem bottleneck_path [Fintype V] [LinearOrder V] | |
| (w : V β V β β) (a b : V) (hab : a β b) (hB : 1 < bottleneck w a b) : | |
| β L : List V, | |
| List.IsChain (fun x y => bottleneck w a b β€ edgeActivity w x y) (a :: L) β§ | |
| (a :: L).Nodup β§ b β L := by | |
| obtain β¨p,hp,hmaxβ© := Finset.exists_mem_eq_sup' | |
| (show (Finset.univ : Finset ((β€ : SimpleGraph V).Path a b)).Nonempty from | |
| β¨SimpleGraph.Path.singleton (by simpa using hab), Finset.mem_univ _β©) | |
| (pathStrength w hab) | |
| have he : bottleneck w a b = pathStrength w hab p := by | |
| unfold bottleneck at hB β’ | |
| rw [dite_eq_right hab, hmax] at hB β’ | |
| exact max_eq_right ((lt_max_iff.mp hB).resolve_left (lt_irrefl 1)).le | |
| have hd : β d β p.val.darts, bottleneck w a b β€ edgeActivity w d.fst d.snd := by | |
| intro d hd | |
| rw [he] | |
| exact Finset.inf'_le _ (List.mem_toFinset.mpr hd) | |
| refine β¨p.val.support.tail, ?_, ?_, ?_β© | |
| Β· rw [p.val.cons_tail_support] | |
| exact walk_isChain_of_darts w _ p.val hd | |
| Β· rw [p.val.cons_tail_support] | |
| exact p.property.support_nodup | |
| Β· exact p.val.end_mem_tail_support_of_ne hab | |
| theorem edgeActivity_mono [LinearOrder V] (w u : V β V β β) | |
| (h : β a b, w a b β€ u a b) (a b : V) : edgeActivity w a b β€ edgeActivity u a b := by | |
| unfold edgeActivity | |
| split_ifs <;> apply h | |
| theorem hole_relocation [Fintype V] [LinearOrder V] | |
| (hcard : 2 β€ Fintype.card V) (w u : V β V β β) | |
| (hu : β v z, 0 β€ u v z) (hz : 0 < partition u β ) | |
| (hwu : β a b, w a b β€ u a b) | |
| (hrlo : β a, (1:β)/8 β€ rowMax hcard u a) | |
| (hrhi : β a, rowMax hcard u a β€ 4) | |
| (S : Finset V) (hS : S.card = 2 β¨ S.card = 4) | |
| (a b : V) (ha : a β S) (hb : b β S) (hab : a β b) : | |
| holeRatio u S β€ 100000 * Fintype.card V / bottleneck w a b := by | |
| apply hole_relocation_of_strong_path hcard u hu hz hrlo hrhi | |
| (bottleneck w a b) (lt_of_lt_of_le (by norm_num) (one_le_bottleneck w a b)) S hS a ha | |
| intro hs | |
| obtain β¨L,hp,hn,hbLβ© := bottleneck_path w a b hab (by linarith) | |
| refine β¨L, ?_,hn,b,hbL,hbβ© | |
| exact hp.imp fun {x y} h => h.trans (edgeActivity_mono w u hwu x y) | |
| noncomputable def erasePair (m : Mate V) (a b : V) : Mate V := by | |
| classical | |
| by_cases h : m.1 a = b | |
| Β· refine β¨fun v => if v = a β¨ v = b then v else m.1 v, ?_β© | |
| intro v | |
| have hba : m.1 b = a := by rw [β h, mate_mate] | |
| by_cases hv : v = a β¨ v = b | |
| Β· simp [hv] | |
| Β· have hma : m.1 v β a := by | |
| intro he | |
| have hh := congrArg m.1 he | |
| rw [mate_mate, h] at hh | |
| exact hv (Or.inr hh) | |
| have hmb : m.1 v β b := by | |
| intro he | |
| have hh := congrArg m.1 he | |
| rw [mate_mate, hba] at hh | |
| exact hv (Or.inl hh) | |
| simp [hv, hma, hmb, mate_mate] | |
| Β· exact m | |
| @[simp] theorem erasePair_apply (m : Mate V) (a b v : V) (h : m.1 a = b) : | |
| (erasePair m a b).1 v = if v = a β¨ v = b then v else m.1 v := by | |
| classical | |
| simp [erasePair, h] | |
| theorem erasePair_holes [DecidableEq V] (m : Mate V) (S : Finset V) | |
| (hm : HasHoles m S) (a b : V) (h : m.1 a = b) : | |
| HasHoles (erasePair m a b) (insert a (insert b S)) := by | |
| intro v | |
| rw [erasePair_apply m a b v h] | |
| by_cases hv : v = a β¨ v = b | |
| Β· rcases hv with rfl | rfl <;> simp | |
| Β· have hva := (not_or.mp hv).1 | |
| have hvb := (not_or.mp hv).2 | |
| simp [hva, hvb, hm v] | |
| theorem withEdge_erasePair (m : Mate V) (a b : V) (h : m.1 a = b) : | |
| withEdge (erasePair m a b) a b = m := by | |
| have hba : m.1 b = a := by rw [β h, mate_mate] | |
| apply Subtype.ext | |
| funext v | |
| rw [withEdge_apply _ _ _ _ (by simp [h]) (by simp [h])] | |
| by_cases hva : v = a | |
| Β· subst v | |
| simp [h] | |
| by_cases hvb : v = b | |
| Β· subst v | |
| simp [hba, hva] | |
| simp [hva, hvb, h] | |
| theorem erasePair_withEdge (m : Mate V) (a b : V) | |
| (ha : m.1 a = a) (hb : m.1 b = b) : | |
| erasePair (withEdge m a b) a b = m := by | |
| apply Subtype.ext | |
| funext v | |
| rw [erasePair_apply _ _ _ _ (by simp [ha,hb]), withEdge_apply m a b v ha hb] | |
| by_cases hva : v = a | |
| Β· subst v | |
| simp [ha] | |
| by_cases hvb : v = b | |
| Β· subst v | |
| simp [hb] | |
| simp [hva, hvb] | |
| end MatchingFPRAS.Switching | |
| end OAI | |