Download data/lean/OAI/Combinatorics/MatchingCount/Graphs/ThresholdGraph.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 28.6 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Combinatorics/MatchingCount/Graphs/ThresholdGraph.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Combinatorics/MatchingCount/Graphs/ThresholdGraph.lean
-
curl -L -o ThresholdGraph.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Combinatorics/MatchingCount/Graphs/ThresholdGraph.lean
28.6 kB
| import Mathlib | |
| import OAI.Combinatorics.MatchingCount.Graphs.FillHoles | |
| namespace OAI | |
| namespace MatchingFPRAS.Switching | |
| open Finset | |
| variable {V : Type*} | |
| lemma edgeActivity_of_symmetric [LinearOrder V] (B : V β V β β) | |
| (hB : β a b, B a b = B b a) (a b : V) : edgeActivity B a b = B a b := by | |
| unfold edgeActivity | |
| split_ifs | |
| Β· rfl | |
| Β· exact hB b a | |
| theorem erasePair_factor [Fintype V] [LinearOrder V] (B : V β V β β) | |
| (hB : β a b, B a b = B b a) (q : Mate V) (a b : V) | |
| (hq : q.val a = b) (hab : a β b) : | |
| weight B q = B a b * weight B (erasePair q a b) := by | |
| have ha : (erasePair q a b).val a = a := by simp [hq] | |
| have hb : (erasePair q a b).val b = b := by simp [hq] | |
| have hw := withEdge_weight B (erasePair q a b) a b ha hb hab | |
| rw [withEdge_erasePair q a b hq,edgeActivity_of_symmetric B hB] at hw | |
| exact hw | |
| lemma ultrametric_vertex_charge {A C D T : β} (hA : 0 β€ A) (hC : 0 β€ C) | |
| (hD : 0 β€ D) (hAT : A β€ T) (hCT : C β€ T) (htri : min A C β€ D) : | |
| A*C β€ T*D := by | |
| rcases le_total A C with h | h | |
| Β· rw [min_eq_left h] at htri | |
| exact (mul_le_mul htri hCT hC hD).trans_eq (mul_comm D T) | |
| Β· rw [min_eq_right h] at htri | |
| exact mul_le_mul hAT htri hC (hA.trans hAT) | |
| lemma ultrametric_pair_charge {A B C D Tj Tk : β} | |
| (hA : 0 β€ A) (hB : 0 β€ B) (hC : 0 β€ C) (hD : 0 β€ D) | |
| (hAj : A β€ Tj) (hBk : B β€ Tk) (hCj : C β€ Tj) (hCk : C β€ Tk) | |
| (htri : min A (min C B) β€ D) : A*B*C β€ Tj*Tk*D := by | |
| have hj0 := hA.trans hAj | |
| have hk0 := hB.trans hBk | |
| rcases le_total A (min C B) with h | h | |
| Β· rw [min_eq_left h] at htri | |
| calc | |
| A*B*C β€ D*Tk*Tj := by gcongr | |
| _ = Tj*Tk*D := by ring | |
| Β· rw [min_eq_right h] at htri | |
| rcases le_total C B with hcb | hbc | |
| Β· rw [min_eq_left hcb] at htri | |
| gcongr | |
| Β· rw [min_eq_right hbc] at htri | |
| calc | |
| A*B*C β€ Tj*D*Tk := by gcongr | |
| _ = Tj*Tk*D := by ring | |
| lemma pairing_mate_mem [Fintype V] [DecidableEq V] (q : Mate V) (U : Finset V) | |
| (hq : HasHoles q UαΆ) (v : V) : q.val v β U β v β U := by | |
| have h := mate_mem_holes_iff q UαΆ hq v | |
| simpa only [Finset.mem_compl, not_iff_not] using h | |
| theorem pairing_replace_vertex [Fintype V] [LinearOrder V] | |
| (B : V β V β β) (hB : β a b, B a b = B b a) | |
| (hB0 : β a b, 0 β€ B a b) | |
| (htri : β a b c, a β b β a β c β b β c β min (B a c) (B c b) β€ B a b) | |
| (U : Finset V) (j u : V) (hj : j β U) (hu : u β U) | |
| (T : β) (hT : β a, a β j β B j a β€ T) | |
| (q : Mate V) (hq : HasHoles q UαΆ) : | |
| β q' : Mate V, HasHoles q' (insert u (U.erase j))αΆ β§ | |
| weight B q * B j u β€ T * weight B q' := by | |
| classical | |
| let a := q.val j | |
| have hja : j β a := by | |
| intro h | |
| exact (Finset.mem_compl.mp ((hq j).mp h.symm)) hj | |
| have haU : a β U := (pairing_mate_mem q U hq j).mpr hj | |
| have hua : u β a := fun h => hu (h βΈ haU) | |
| have huj : u β j := fun h => hu (h βΈ hj) | |
| have hqj : q.val j = a := rfl | |
| have hqa : q.val a = j := mate_mate q j | |
| have hqu : q.val u = u := (hq u).mpr (Finset.mem_compl.mpr hu) | |
| let r := erasePair q j a | |
| have hra : r.val a = a := by simp [r,hqj] | |
| have hru : r.val u = u := by simp [r,hqj,huj,hua,hqu] | |
| let q' := withEdge r u a | |
| have he (v) : q'.val v = if v = u then a else if v = a then u | |
| else if v = j β¨ v = a then v else q.val v := by | |
| rw [show q'.val v = (withEdge r u a).val v from rfl, | |
| withEdge_apply r u a v hru hra,erasePair_apply q j a v hqj] | |
| split_ifs <;> rfl | |
| refine β¨q',?_,?_β© | |
| Β· intro v | |
| rw [he] | |
| by_cases hvu : v = u | |
| Β· subst v | |
| simp [hua.symm] | |
| by_cases hva : v = a | |
| Β· subst v | |
| simp [hvu,hua,haU,hja.symm] | |
| by_cases hvj : v = j | |
| Β· subst v | |
| simp [hvu,hva] | |
| simp only [hvu,hva,hvj,false_or,βreduceIte] | |
| rw [hq] | |
| simp [hvu,hvj] | |
| Β· have hwq := erasePair_factor B hB q j a hqj hja | |
| have hwq' : weight B q' = B u a * weight B r := by | |
| simpa only [q',edgeActivity_of_symmetric B hB] using withEdge_weight B r u a hru hra hua | |
| have ht : min (B j a) (B j u) β€ B u a := by | |
| have hh := htri u a j hua huj hja.symm | |
| simpa only [hB u j,min_comm] using hh | |
| have hh := ultrametric_vertex_charge (hB0 j a) (hB0 j u) (hB0 u a) | |
| (hT a hja.symm) (hT u huj) ht | |
| have hr0 := weight_nonneg B hB0 r | |
| have hf := mul_le_mul_of_nonneg_right hh hr0 | |
| rw [hwq,hwq'] | |
| dsimp only [r] at hf | |
| nlinarith only [hf] | |
| theorem pairing_remove_pair [Fintype V] [LinearOrder V] | |
| (B : V β V β β) (hB : β a b, B a b = B b a) | |
| (hB0 : β a b, 0 β€ B a b) | |
| (htri : β a b c, a β b β a β c β b β c β min (B a c) (B c b) β€ B a b) | |
| (U : Finset V) (j k : V) (hj : j β U) (hk : k β U) (hjk : j β k) | |
| (Tj Tk : β) (hTj : β a, a β j β B j a β€ Tj) | |
| (hTk : β a, a β k β B k a β€ Tk) | |
| (q : Mate V) (hq : HasHoles q UαΆ) : | |
| β q' : Mate V, HasHoles q' (U \ {j,k})αΆ β§ | |
| weight B q * B j k β€ Tj * Tk * weight B q' := by | |
| classical | |
| have hcj : B j k β€ Tj := hTj k hjk.symm | |
| have hck : B j k β€ Tk := (hB j k).trans_le (hTk j hjk) | |
| by_cases hqjk : q.val j = k | |
| Β· let q' := erasePair q j k | |
| refine β¨q',?_,?_β© | |
| Β· have hh := erasePair_holes q UαΆ hq j k hqjk | |
| have he : insert j (insert k UαΆ) = (U \ {j,k})αΆ := by ext v; simp; tauto | |
| rwa [he] at hh | |
| Β· rw [erasePair_factor B hB q j k hqjk hjk] | |
| have hv := weight_nonneg B hB0 q' | |
| change (B j k * weight B q') * B j k β€ _ | |
| calc | |
| _ = (B j k * B j k) * weight B q' := by ring | |
| _ β€ (Tj*Tk) * weight B q' := by | |
| exact mul_le_mul_of_nonneg_right (mul_le_mul hcj hck (hB0 j k) ((hB0 j k).trans hcj)) hv | |
| Β· let a := q.val j | |
| let b := q.val k | |
| have hqj : q.val j = a := rfl | |
| have hqk : q.val k = b := rfl | |
| have hqa : q.val a = j := mate_mate q j | |
| have hqb : q.val b = k := mate_mate q k | |
| have hja : j β a := by | |
| intro h | |
| exact (Finset.mem_compl.mp ((hq j).mp h.symm)) hj | |
| have hkb : k β b := by | |
| intro h | |
| exact (Finset.mem_compl.mp ((hq k).mp h.symm)) hk | |
| have hak : a β k := hqjk | |
| have hbj : b β j := by | |
| intro h | |
| have hh := congrArg q.val h | |
| rw [hqb,hqj] at hh | |
| exact hak hh.symm | |
| have hab : a β b := by | |
| intro h | |
| have hh := congrArg q.val h | |
| rw [hqa,hqb] at hh | |
| exact hjk hh | |
| have haU : a β U := (pairing_mate_mem q U hq j).mpr hj | |
| have hbU : b β U := (pairing_mate_mem q U hq k).mpr hk | |
| let r := erasePair q j a | |
| have hrk : r.val k = b := by simp [r,hqj,hjk.symm,hak.symm,hqk] | |
| let z := erasePair r k b | |
| have hza : z.val a = a := by | |
| rw [show z.val a = (erasePair r k b).val a from rfl, erasePair_apply r k b a hrk] | |
| simp [hak,hab,r,hqj] | |
| have hzb : z.val b = b := by simp [z,hrk] | |
| let q' := withEdge z a b | |
| have he (v) : q'.val v = if v = a then b else if v = b then a | |
| else if v = k β¨ v = b then v else if v = j β¨ v = a then v else q.val v := by | |
| rw [show q'.val v = (withEdge z a b).val v from rfl, | |
| withEdge_apply z a b v hza hzb,erasePair_apply r k b v hrk, | |
| erasePair_apply q j a v hqj] | |
| split_ifs <;> rfl | |
| refine β¨q',?_,?_β© | |
| Β· intro v | |
| rw [he] | |
| by_cases hva : v = a | |
| Β· subst v | |
| simp [hab.symm,haU,hja.symm,hak] | |
| by_cases hvb : v = b | |
| Β· subst v | |
| simp [hva,hab,hbU,hbj,hkb.symm] | |
| by_cases hvj : v = j | |
| Β· subst v | |
| simp [hva,hvb] | |
| by_cases hvk : v = k | |
| Β· subst v | |
| simp [hva,hvb] | |
| simp only [hva,hvb,hvj,hvk,false_or,βreduceIte] | |
| rw [hq] | |
| simp [hvj,hvk] | |
| Β· have hwq := erasePair_factor B hB q j a hqj hja | |
| have hwr := erasePair_factor B hB r k b hrk hkb | |
| have hwq' : weight B q' = B a b * weight B z := by | |
| simpa only [q',edgeActivity_of_symmetric B hB] using withEdge_weight B z a b hza hzb hab | |
| have ht : min (B j a) (min (B j k) (B k b)) β€ B a b := by | |
| calc | |
| _ β€ min (B j a) (B j b) := | |
| min_le_min_left _ (htri j b k hbj.symm hjk hkb.symm) | |
| _ = min (B a j) (B j b) := by rw [hB j a] | |
| _ β€ _ := htri a b j hab hja.symm hbj | |
| have hh := ultrametric_pair_charge (hB0 j a) (hB0 k b) (hB0 j k) (hB0 a b) | |
| (hTj a hja.symm) (hTk b hkb.symm) hcj hck ht | |
| have hz0 := weight_nonneg B hB0 z | |
| have hf := mul_le_mul_of_nonneg_right hh hz0 | |
| rw [hwq,show weight B (erasePair q j a) = weight B r from rfl,hwr,hwq'] | |
| change (B j a * (B k b * weight B z)) * B j k β€ Tj*Tk*(B a b*weight B z) | |
| nlinarith only [hf] | |
| lemma weight_le_pairingCapacity [Fintype V] [LinearOrder V] | |
| (B : V β V β β) (U : Finset V) (hU : Even U.card) | |
| (q : Mate V) (hq : HasHoles q UαΆ) : weight B q β€ pairingCapacity B U hU := by | |
| exact Finset.le_sup' _ ((mem_matchings q UαΆ).mpr hq) | |
| lemma pairingCapacity_nonneg [Fintype V] [LinearOrder V] | |
| (B : V β V β β) (hB : β a b, 0 β€ B a b) | |
| (U : Finset V) (hU : Even U.card) : 0 β€ pairingCapacity B U hU := by | |
| obtain β¨q,hqβ© := pairing_exists U hU | |
| exact (weight_nonneg B hB q).trans (weight_le_pairingCapacity B U hU q hq) | |
| theorem capacity_replace_vertex [Fintype V] [LinearOrder V] | |
| (B : V β V β β) (hB : β a b, B a b = B b a) | |
| (hB0 : β a b, 0 β€ B a b) | |
| (htri : β a b c, a β b β a β c β b β c β min (B a c) (B c b) β€ B a b) | |
| (U : Finset V) (hU : Even U.card) (j u : V) (hj : j β U) (hu : u β U) | |
| (hU' : Even (insert u (U.erase j)).card) | |
| (T : β) (hT0 : 0 β€ T) (hT : β a, a β j β B j a β€ T) : | |
| pairingCapacity B U hU * B j u β€ T * pairingCapacity B (insert u (U.erase j)) hU' := by | |
| classical | |
| obtain β¨q,hq,hmaxβ© := Finset.exists_mem_eq_sup' | |
| (show (matchings UαΆ).Nonempty from by | |
| obtain β¨q,hqβ© := pairing_exists U hU | |
| exact β¨q,(mem_matchings _ _).mpr hqβ©) (weight B) | |
| have hcap : pairingCapacity B U hU = weight B q := hmax | |
| obtain β¨q',hq',hleβ© := pairing_replace_vertex B hB hB0 htri U j u hj hu T hT q | |
| ((mem_matchings _ _).mp hq) | |
| rw [hcap] | |
| exact hle.trans (mul_le_mul_of_nonneg_left | |
| (weight_le_pairingCapacity B _ hU' q' hq') hT0) | |
| theorem capacity_remove_pair [Fintype V] [LinearOrder V] | |
| (B : V β V β β) (hB : β a b, B a b = B b a) | |
| (hB0 : β a b, 0 β€ B a b) | |
| (htri : β a b c, a β b β a β c β b β c β min (B a c) (B c b) β€ B a b) | |
| (U : Finset V) (hU : Even U.card) (j k : V) (hj : j β U) (hk : k β U) (hjk : j β k) | |
| (hU' : Even (U \ {j,k}).card) | |
| (Tj Tk : β) (hj0 : 0 β€ Tj) (hk0 : 0 β€ Tk) | |
| (hTj : β a, a β j β B j a β€ Tj) (hTk : β a, a β k β B k a β€ Tk) : | |
| pairingCapacity B U hU * B j k β€ Tj * Tk * pairingCapacity B (U \ {j,k}) hU' := by | |
| classical | |
| obtain β¨q,hq,hmaxβ© := Finset.exists_mem_eq_sup' | |
| (show (matchings UαΆ).Nonempty from by | |
| obtain β¨q,hqβ© := pairing_exists U hU | |
| exact β¨q,(mem_matchings _ _).mpr hqβ©) (weight B) | |
| have hcap : pairingCapacity B U hU = weight B q := hmax | |
| obtain β¨q',hq',hleβ© := pairing_remove_pair B hB hB0 htri U j k hj hk hjk Tj Tk hTj hTk q | |
| ((mem_matchings _ _).mp hq) | |
| rw [hcap] | |
| exact hle.trans (mul_le_mul_of_nonneg_left | |
| (weight_le_pairingCapacity B _ hU' q' hq') (mul_nonneg hj0 hk0)) | |
| def thresholdGraph [LinearOrder V] (w : V β V β β) (t : β) : SimpleGraph V where | |
| Adj a b := a β b β§ t β€ edgeActivity w a b | |
| symm := β¨by | |
| intro a b h | |
| exact β¨h.1.symm,by simpa only [edgeActivity_comm w b a] using h.2β©β© | |
| loopless := β¨by intro a h; exact h.1 rflβ© | |
| lemma strong_walk_reachable [LinearOrder V] (w : V β V β β) (t : β) | |
| {a b : V} (p : (β€ : SimpleGraph V).Walk a b) | |
| (hp : β d β p.darts, t β€ edgeActivity w d.fst d.snd) : | |
| (thresholdGraph w t).Reachable a b := by | |
| induction p with | |
| | nil => exact SimpleGraph.Reachable.refl _ | |
| | @cons a c b hac p ih => | |
| have he : t β€ edgeActivity w a c := hp β¨(a,c),hacβ© (by simp) | |
| have htail : β d β p.darts, t β€ edgeActivity w d.fst d.snd := by | |
| intro d hd | |
| exact hp d (by simp [hd]) | |
| exact (SimpleGraph.Adj.reachable (G := thresholdGraph w t) | |
| β¨by simpa using hac,heβ©).trans (ih htail) | |
| lemma threshold_map_strong [LinearOrder V] (w : V β V β β) (t : β) | |
| {a b : V} (p : (thresholdGraph w t).Walk a b) : | |
| β d β (p.map (SimpleGraph.Hom.ofLE le_top)).darts, | |
| t β€ edgeActivity w d.fst d.snd := by | |
| intro d hd | |
| rw [SimpleGraph.Walk.darts_map] at hd | |
| obtain β¨e,he,rflβ© := List.mem_map.mp hd | |
| exact e.adj.2 | |
| theorem bottleneck_threshold [Fintype V] [LinearOrder V] | |
| (w : V β V β β) (a b : V) (hab : a β b) (t : β) (ht : 1 < t) : | |
| t β€ bottleneck w a b β (thresholdGraph w t).Reachable a b := by | |
| classical | |
| constructor | |
| Β· intro h | |
| 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 : t β€ pathStrength w hab p := by | |
| unfold bottleneck at h | |
| rw [dite_eq_right hab,hmax] at h | |
| exact (le_max_iff.mp h).resolve_left (not_le_of_gt ht) | |
| apply strong_walk_reachable w t p.val | |
| intro d hd | |
| exact he.trans (Finset.inf'_le _ (List.mem_toFinset.mpr hd)) | |
| Β· intro h | |
| obtain β¨p,hpβ© := h.exists_isPath | |
| let q : (β€ : SimpleGraph V).Path a b := | |
| β¨p.map (SimpleGraph.Hom.ofLE le_top),hp.map Function.injective_idβ© | |
| have hstr : t β€ pathStrength w hab q := by | |
| apply Finset.le_inf' | |
| intro d hd | |
| exact threshold_map_strong w t p d (List.mem_toFinset.mp hd) | |
| unfold bottleneck | |
| rw [dite_eq_right hab] | |
| exact hstr.trans ((Finset.le_sup' _ (Finset.mem_univ q)).trans (le_max_right _ _)) | |
| theorem bottleneck_comm [Fintype V] [LinearOrder V] (w : V β V β β) (a b : V) : | |
| bottleneck w a b = bottleneck w b a := by | |
| by_cases hab : a = b | |
| Β· subst b; rfl | |
| apply le_antisymm | |
| Β· by_cases h : 1 < bottleneck w a b | |
| Β· exact (bottleneck_threshold w b a (Ne.symm hab) _ h).mpr | |
| (((bottleneck_threshold w a b hab _ h).mp le_rfl).symm) | |
| Β· exact (le_of_not_gt h).trans (one_le_bottleneck w b a) | |
| Β· by_cases h : 1 < bottleneck w b a | |
| Β· exact (bottleneck_threshold w a b hab _ h).mpr | |
| (((bottleneck_threshold w b a (Ne.symm hab) _ h).mp le_rfl).symm) | |
| Β· exact (le_of_not_gt h).trans (one_le_bottleneck w a b) | |
| theorem bottleneck_ultrametric [Fintype V] [LinearOrder V] | |
| (w : V β V β β) (a b c : V) (hab : a β b) (hac : a β c) (hbc : b β c) : | |
| min (bottleneck w a c) (bottleneck w c b) β€ bottleneck w a b := by | |
| let t := min (bottleneck w a c) (bottleneck w c b) | |
| by_cases ht : 1 < t | |
| Β· apply (bottleneck_threshold w a b hab t ht).mpr | |
| exact ((bottleneck_threshold w a c hac t ht).mp (min_le_left _ _)).trans | |
| ((bottleneck_threshold w c b hbc.symm t ht).mp (min_le_right _ _)) | |
| Β· exact (le_of_not_gt ht).trans (one_le_bottleneck w a b) | |
| theorem capacity_charged_remove [Fintype V] [LinearOrder V] | |
| (B : V β V β β) (hB : β a b, B a b = B b a) (hB0 : β a b, 0 β€ B a b) | |
| (htri : β a b c, a β b β a β c β b β c β min (B a c) (B c b) β€ B a b) | |
| (U : Finset V) (hU : Even U.card) (j k : V) (hj : j β U) (hk : k β U) | |
| (hjk : j β k) (hU' : Even (U \ {j,k}).card) (Tj Tk f : β) | |
| (hj0 : 0 < Tj) (hk0 : 0 < Tk) (hTj : β a, a β j β B j a β€ Tj) | |
| (hTk : β a, a β k β B k a β€ Tk) (hf : f*Tj*Tk β€ B j k) : | |
| pairingCapacity B U hU * f β€ pairingCapacity B (U \ {j,k}) hU' := by | |
| have hc := capacity_remove_pair B hB hB0 htri U hU j k hj hk hjk hU' | |
| Tj Tk hj0.le hk0.le hTj hTk | |
| have hs := mul_le_mul_of_nonneg_left hf (pairingCapacity_nonneg B hB0 U hU) | |
| have hprod : 0 < Tj*Tk := mul_pos hj0 hk0 | |
| apply (mul_le_mul_iff_of_pos_right hprod).mp | |
| calc | |
| _ = pairingCapacity B U hU * (f*Tj*Tk) := by ring | |
| _ β€ pairingCapacity B U hU * B j k := hs | |
| _ β€ _ := by nlinarith only [hc] | |
| theorem capacity_charged_replace [Fintype V] [LinearOrder V] | |
| (B : V β V β β) (hB : β a b, B a b = B b a) (hB0 : β a b, 0 β€ B a b) | |
| (htri : β a b c, a β b β a β c β b β c β min (B a c) (B c b) β€ B a b) | |
| (U : Finset V) (hU : Even U.card) (j u : V) (hj : j β U) (hu : u β U) | |
| (hU' : Even (insert u (U.erase j)).card) (T f : β) | |
| (hT0 : 0 < T) (hT : β a, a β j β B j a β€ T) (hf : f*T β€ B j u) : | |
| pairingCapacity B U hU * f β€ pairingCapacity B (insert u (U.erase j)) hU' := by | |
| have hc := capacity_replace_vertex B hB hB0 htri U hU j u hj hu hU' T hT0.le hT | |
| have hs := mul_le_mul_of_nonneg_left hf (pairingCapacity_nonneg B hB0 U hU) | |
| apply (mul_le_mul_iff_of_pos_right hT0).mp | |
| calc | |
| _ = pairingCapacity B U hU * (f*T) := by ring | |
| _ β€ pairingCapacity B U hU * B j u := hs | |
| _ β€ _ := by nlinarith only [hc] | |
| inductive ChargeTrace [DecidableEq V] (B : V β V β β) : | |
| Finset V β Finset V β β β Prop | |
| | done (U) : ChargeTrace B U U 1 | |
| | remove (U W : Finset V) (j k : V) (hj : j β U) (hk : k β U) (hjk : j β k) | |
| (Tj Tk f F : β) (hj0 : 0 < Tj) (hk0 : 0 < Tk) (hf0 : 0 β€ f) (hF0 : 0 β€ F) | |
| (hTj : β a, a β j β B j a β€ Tj) (hTk : β a, a β k β B k a β€ Tk) | |
| (hf : f*Tj*Tk β€ B j k) (next : ChargeTrace B (U \ {j,k}) W F) : | |
| ChargeTrace B U W (f*F) | |
| | replace (U W : Finset V) (j u : V) (hj : j β U) (hu : u β U) | |
| (T f F : β) (hT0 : 0 < T) (hf0 : 0 β€ f) (hF0 : 0 β€ F) | |
| (hT : β a, a β j β B j a β€ T) (hf : f*T β€ B j u) | |
| (next : ChargeTrace B (insert u (U.erase j)) W F) : | |
| ChargeTrace B U W (f*F) | |
| lemma ChargeTrace.card_le [DecidableEq V] {B : V β V β β} | |
| {U W : Finset V} {F : β} (h : ChargeTrace B U W F) : W.card β€ U.card := by | |
| induction h with | |
| | done => rfl | |
| | remove U W j k hj hk hjk Tj Tk f F hj0 hk0 hf0 hF0 hTj hTk hf next ih => | |
| exact ih.trans (Finset.card_le_card Finset.sdiff_subset) | |
| | replace U W j u hj hu T f F hT0 hf0 hF0 hT hf next ih => | |
| have hnu : u β U.erase j := fun h => hu (Finset.mem_of_mem_erase h) | |
| rw [Finset.card_insert_of_notMem hnu,Finset.card_erase_of_mem hj] at ih | |
| have : 0 < U.card := Finset.card_pos.mpr β¨j,hjβ© | |
| omega | |
| lemma even_remove_two [DecidableEq V] (U : Finset V) (hU : Even U.card) | |
| (j k : V) (hj : j β U) (hk : k β U) (hjk : j β k) : | |
| Even (U \ {j,k}).card := by | |
| have he : U \ {j,k} = (U.erase j).erase k := by ext a; simp; tauto | |
| have hk' : k β U.erase j := Finset.mem_erase.mpr β¨hjk.symm,hkβ© | |
| rw [he,Finset.card_erase_of_mem hk',Finset.card_erase_of_mem hj] | |
| have h2 : 2 β€ U.card := by | |
| apply (Finset.card_pair hjk).symm.trans_le | |
| apply Finset.card_le_card | |
| intro a ha | |
| simp only [Finset.mem_insert,Finset.mem_singleton] at ha | |
| rcases ha with rfl | rfl <;> assumption | |
| exact (Nat.even_iff.mpr (by have := Nat.even_iff.mp hU; omega)) | |
| lemma even_replace_one [DecidableEq V] (U : Finset V) (hU : Even U.card) | |
| (j u : V) (hj : j β U) (hu : u β U) : Even (insert u (U.erase j)).card := by | |
| have hnu : u β U.erase j := fun h => hu (Finset.mem_of_mem_erase h) | |
| rw [Finset.card_insert_of_notMem hnu,Finset.card_erase_of_mem hj] | |
| have : 0 < U.card := Finset.card_pos.mpr β¨j,hjβ© | |
| simpa only [Nat.sub_add_cancel (by omega : 1 β€ U.card)] using hU | |
| theorem ChargeTrace.capacity_bound [Fintype V] [LinearOrder V] | |
| {B : V β V β β} (hB : β a b, B a b = B b a) (hB0 : β a b, 0 β€ B a b) | |
| (htri : β a b c, a β b β a β c β b β c β min (B a c) (B c b) β€ B a b) | |
| {U W : Finset V} {F : β} (h : ChargeTrace B U W F) (hU : Even U.card) : | |
| β hW : Even W.card, pairingCapacity B U hU * F β€ pairingCapacity B W hW := by | |
| induction h with | |
| | done U => exact β¨hU,by simpβ© | |
| | remove U W j k hj hk hjk Tj Tk f F hj0 hk0 hf0 hF0 hTj hTk hf next ih => | |
| have he := even_remove_two U hU j k hj hk hjk | |
| obtain β¨hW,hWbβ© := ih he | |
| refine β¨hW,?_β© | |
| calc | |
| _ = (pairingCapacity B U hU * f) * F := by ring | |
| _ β€ pairingCapacity B (U \ {j,k}) he * F := mul_le_mul_of_nonneg_right | |
| (capacity_charged_remove B hB hB0 htri U hU j k hj hk hjk he Tj Tk f | |
| hj0 hk0 hTj hTk hf) hF0 | |
| _ β€ _ := hWb | |
| | replace U W j u hj hu T f F hT0 hf0 hF0 hT hf next ih => | |
| have he := even_replace_one U hU j u hj hu | |
| obtain β¨hW,hWbβ© := ih he | |
| refine β¨hW,?_β© | |
| calc | |
| _ = (pairingCapacity B U hU * f) * F := by ring | |
| _ β€ pairingCapacity B (insert u (U.erase j)) he * F := mul_le_mul_of_nonneg_right | |
| (capacity_charged_replace B hB hB0 htri U hU j u hj hu he T f hT0 hT hf) hF0 | |
| _ β€ _ := hWb | |
| theorem edgeActivity_le_bottleneck [Fintype V] [LinearOrder V] | |
| (w : V β V β β) (a b : V) (hab : a β b) : | |
| edgeActivity w a b β€ bottleneck w a b := by | |
| by_cases h : 1 < edgeActivity w a b | |
| Β· exact (bottleneck_threshold w a b hab _ h).mpr | |
| (SimpleGraph.Adj.reachable (G := thresholdGraph w _) β¨hab,le_rflβ©) | |
| Β· exact (le_of_not_gt h).trans (one_le_bottleneck w a b) | |
| theorem bottleneck_le_row_bound [Fintype V] [LinearOrder V] | |
| (w : V β V β β) (a : V) (T : β) (hT : 1 β€ T) | |
| (hrow : β b, a β b β edgeActivity w a b β€ T) (b : V) : | |
| bottleneck w a b β€ T := by | |
| by_cases hab : a = b | |
| Β· subst b; simpa [bottleneck] using hT | |
| by_cases hB : 1 < bottleneck w a b | |
| Β· obtain β¨L,hL,hnd,hbβ© := bottleneck_path w a b hab hB | |
| cases L with | |
| | nil => simp at hb | |
| | cons c L => | |
| have hne : a β c := by | |
| have h := (List.nodup_cons.mp hnd).1 | |
| simp only [List.mem_cons,not_or] at h | |
| exact h.1 | |
| have he := (List.isChain_cons_cons.mp hL).1 | |
| exact he.trans (hrow c hne) | |
| Β· exact (le_of_not_gt hB).trans hT | |
| theorem bottleneck_eq_of_threshold_iff | |
| {W : Type*} [Fintype V] [LinearOrder V] [Fintype W] [LinearOrder W] | |
| (w : V β V β β) (w' : W β W β β) (a b : V) (a' b' : W) | |
| (hab : a β b) (hab' : a' β b') | |
| (h : β t : β, 1 < t β | |
| ((thresholdGraph w t).Reachable a b β (thresholdGraph w' t).Reachable a' b')) : | |
| bottleneck w a b = bottleneck w' a' b' := by | |
| apply le_antisymm | |
| Β· by_cases ht : 1 < bottleneck w a b | |
| Β· exact (bottleneck_threshold w' a' b' hab' _ ht).mpr | |
| ((h _ ht).mp ((bottleneck_threshold w a b hab _ ht).mp le_rfl)) | |
| Β· exact (le_of_not_gt ht).trans (one_le_bottleneck w' a' b') | |
| Β· by_cases ht : 1 < bottleneck w' a' b' | |
| Β· exact (bottleneck_threshold w a b hab _ ht).mpr | |
| ((h _ ht).mpr ((bottleneck_threshold w' a' b' hab' _ ht).mp le_rfl)) | |
| Β· exact (le_of_not_gt ht).trans (one_le_bottleneck w a b) | |
| def pairVertices (xs : List (V Γ V)) : List V := xs.flatMap (fun q => [q.1,q.2]) | |
| lemma ChargeTrace.trans [DecidableEq V] {B : V β V β β} | |
| {U W X : Finset V} {F G : β} (h : ChargeTrace B U W F) | |
| (h' : ChargeTrace B W X G) (hG : 0 β€ G) : ChargeTrace B U X (F*G) := by | |
| induction h with | |
| | done U => simpa using h' | |
| | remove U W j k hj hk hjk Tj Tk f F hj0 hk0 hf0 hF0 hTj hTk hf next ih => | |
| have ht := ChargeTrace.remove U X j k hj hk hjk Tj Tk f (F*G) hj0 hk0 hf0 | |
| (mul_nonneg hF0 hG) hTj hTk hf (ih h') | |
| simpa [mul_assoc] using ht | |
| | replace U W j u hj hu T f F hT0 hf0 hF0 hT hf next ih => | |
| have ht := ChargeTrace.replace U X j u hj hu T f (F*G) hT0 hf0 | |
| (mul_nonneg hF0 hG) hT hf (ih h') | |
| simpa [mul_assoc] using ht | |
| theorem charge_remove_list [DecidableEq V] (B : V β V β β) (T : V β β) | |
| (f : V Γ V β β) (xs : List (V Γ V)) (U : Finset V) | |
| (hnd : (pairVertices xs).Nodup) (hsub : β a β pairVertices xs, a β U) | |
| (hlocal : β q β xs, | |
| 0 < T q.1 β§ 0 < T q.2 β§ 0 β€ f q β§ | |
| (β a, a β q.1 β B q.1 a β€ T q.1) β§ | |
| (β a, a β q.2 β B q.2 a β€ T q.2) β§ f q*T q.1*T q.2 β€ B q.1 q.2) : | |
| ChargeTrace B U (U \ (pairVertices xs).toFinset) (xs.map f).prod := by | |
| induction xs generalizing U with | |
| | nil => simpa [pairVertices] using ChargeTrace.done (B := B) U | |
| | cons q xs ih => | |
| obtain β¨j,kβ© := q | |
| have hn : j β k β§ j β pairVertices xs β§ k β pairVertices xs β§ (pairVertices xs).Nodup := by | |
| simpa [pairVertices,List.nodup_cons,and_assoc] using hnd | |
| have hj : j β U := hsub j (by simp [pairVertices]) | |
| have hk : k β U := hsub k (by simp [pairVertices]) | |
| have hs : β a β pairVertices xs, a β U \ {j,k} := by | |
| intro a ha | |
| have haj : a β j := fun he => hn.2.1 (he βΈ ha) | |
| have hak : a β k := fun he => hn.2.2.1 (he βΈ ha) | |
| simp only [Finset.mem_sdiff,Finset.mem_insert,Finset.mem_singleton,not_or] | |
| exact β¨hsub a (by simp [pairVertices] at ha β’; exact Or.inr (Or.inr ha)),haj,hakβ© | |
| have hl : β q β xs, | |
| 0 < T q.1 β§ 0 < T q.2 β§ 0 β€ f q β§ | |
| (β a, a β q.1 β B q.1 a β€ T q.1) β§ | |
| (β a, a β q.2 β B q.2 a β€ T q.2) β§ f q*T q.1*T q.2 β€ B q.1 q.2 := | |
| fun q hq => hlocal q (List.mem_cons_of_mem _ hq) | |
| have ht := ih (U \ {j,k}) hn.2.2.2 hs hl | |
| have hp : 0 β€ (xs.map f).prod := by | |
| apply List.prod_nonneg | |
| intro a ha | |
| obtain β¨q,hq,rflβ© := List.mem_map.mp ha | |
| exact (hl q hq).2.2.1 | |
| have he : (U \ {j,k}) \ (pairVertices xs).toFinset = | |
| U \ (pairVertices ((j,k)::xs)).toFinset := by | |
| ext a | |
| simp [pairVertices] | |
| tauto | |
| obtain β¨hTj,hTk,hf,hjrow,hkrow,hboundβ© := hlocal (j,k) (by simp) | |
| have hr := ChargeTrace.remove U _ j k hj hk hn.1 (T j) (T k) (f (j,k)) | |
| (xs.map f).prod hTj hTk hf hp hjrow hkrow hbound ht | |
| simpa only [List.map_cons,List.prod_cons,he] using hr | |
| theorem charge_replace_list [DecidableEq V] (B : V β V β β) (T : V β β) | |
| (f : V Γ V β β) (xs : List (V Γ V)) (U : Finset V) | |
| (hsrc : (xs.map Prod.fst).Nodup) (hdst : (xs.map Prod.snd).Nodup) | |
| (hsub : β q β xs, q.1 β U) (hfresh : β q β xs, q.2 β U) | |
| (hlocal : β q β xs, 0 < T q.1 β§ 0 β€ f q β§ | |
| (β a, a β q.1 β B q.1 a β€ T q.1) β§ f q*T q.1 β€ B q.1 q.2) : | |
| ChargeTrace B U ((U \ (xs.map Prod.fst).toFinset) βͺ (xs.map Prod.snd).toFinset) | |
| (xs.map f).prod := by | |
| induction xs generalizing U with | |
| | nil => simpa using ChargeTrace.done (B := B) U | |
| | cons q xs ih => | |
| obtain β¨j,uβ© := q | |
| have hsrc' : j β xs.map Prod.fst β§ (xs.map Prod.fst).Nodup := by simpa using hsrc | |
| have hdst' : u β xs.map Prod.snd β§ (xs.map Prod.snd).Nodup := by simpa using hdst | |
| have hj : j β U := hsub (j,u) (by simp) | |
| have hu : u β U := hfresh (j,u) (by simp) | |
| have hs : β q β xs, q.1 β insert u (U.erase j) := by | |
| intro q hq | |
| have hn : q.1 β j := by | |
| intro he; exact hsrc'.1 (he βΈ List.mem_map.mpr β¨q,hq,rflβ©) | |
| simp only [Finset.mem_insert,Finset.mem_erase] | |
| exact Or.inr β¨hn,hsub q (by simp [hq])β© | |
| have hf : β q β xs, q.2 β insert u (U.erase j) := by | |
| intro q hq | |
| have hn : q.2 β u := by | |
| intro he; exact hdst'.1 (he βΈ List.mem_map.mpr β¨q,hq,rflβ©) | |
| simp only [Finset.mem_insert,Finset.mem_erase,not_or,not_and] | |
| exact β¨hn,fun _ => hfresh q (by simp [hq])β© | |
| have hl : β q β xs, 0 < T q.1 β§ 0 β€ f q β§ | |
| (β a, a β q.1 β B q.1 a β€ T q.1) β§ f q*T q.1 β€ B q.1 q.2 := | |
| fun q hq => hlocal q (List.mem_cons_of_mem _ hq) | |
| have ht := ih (insert u (U.erase j)) hsrc'.2 hdst'.2 hs hf hl | |
| have hp : 0 β€ (xs.map f).prod := by | |
| apply List.prod_nonneg | |
| intro a ha | |
| obtain β¨q,hq,rflβ© := List.mem_map.mp ha | |
| exact (hl q hq).2.1 | |
| have hus : u β xs.map Prod.fst := by | |
| rintro h | |
| obtain β¨q,hq,heβ© := List.mem_map.mp h | |
| exact hu (he βΈ hsub q (by simp [hq])) | |
| have he : ((insert u (U.erase j)) \ (xs.map Prod.fst).toFinset) βͺ (xs.map Prod.snd).toFinset = | |
| (U \ (((j,u)::xs).map Prod.fst).toFinset) βͺ (((j,u)::xs).map Prod.snd).toFinset := by | |
| ext a | |
| by_cases hau : a=u | |
| Β· subst a; simp [hus] | |
| Β· simp only [List.map_cons,List.toFinset_cons,Finset.mem_union,Finset.mem_sdiff, | |
| Finset.mem_insert,Finset.mem_erase,List.mem_toFinset,hau,false_or] | |
| tauto | |
| obtain β¨hT,hf0,hrow,hboundβ© := hlocal (j,u) (by simp) | |
| have hr := ChargeTrace.replace U _ j u hj hu (T j) (f (j,u)) (xs.map f).prod | |
| hT hf0 hp hrow hbound ht | |
| simpa only [List.map_cons,List.prod_cons,he] using hr | |
| end MatchingFPRAS.Switching | |
| end OAI | |