introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
17.9 kB
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]; exact Ne.symm hna
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; exact hv .rfl
have hvb : v β‰  b := by rintro rfl; exact hv hab
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; exact hv .rfl
have hvb : v β‰  b := by rintro rfl; exact hv hab
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]; simp
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 <;> simp [hab]
by_cases hvb : v = b
Β· subst v
by_cases hab : a = b <;> simp [hab, hva]
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 [hab]
Β· 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