File size: 10,408 Bytes
e5a97c6 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 | import Mathlib
import OAI.Combinatorics.MatchingCount.Algorithm.AffineWeights
namespace OAI
namespace MatchingFPRAS.Switching
open Finset
open scoped Classical symmDiff
variable {V : Type*}
theorem mate_mem_holes_iff [DecidableEq V] (m : Mate V) (S : Finset V)
(hm : HasHoles m S) (v : V) : m.1 v ∈ S ↔ v ∈ S := by
rw [← hm (m.1 v), ← hm v, mate_mate]
exact eq_comm
noncomputable def fillHoles [Fintype V] [DecidableEq V] (m q : Mate V) (S : Finset V)
(hm : HasHoles m S) (hq : HasHoles q Sᶜ) : Mate V := by
classical
refine ⟨fun v => if v ∈ S then q.1 v else m.1 v, ?_⟩
intro v
by_cases hv : v ∈ S
· have hqv : q.1 v ∈ S := by
have h := mate_mem_holes_iff q Sᶜ hq v
have he : q.1 v ∈ S ↔ v ∈ S := by
simpa only [Finset.mem_compl, not_iff_not] using h
exact he.mpr hv
simp [hv,hqv,mate_mate]
· have hmv : m.1 v ∉ S := fun h => hv ((mate_mem_holes_iff m S hm v).mp h)
simp [hv,hmv,mate_mate]
@[simp] theorem fillHoles_apply [Fintype V] [DecidableEq V] (m q : Mate V) (S : Finset V)
(hm : HasHoles m S) (hq : HasHoles q Sᶜ) (v : V) :
(fillHoles m q S hm hq).1 v = if v ∈ S then q.1 v else m.1 v := rfl
theorem fillHoles_perfect [Fintype V] [DecidableEq V] (m q : Mate V) (S : Finset V)
(hm : HasHoles m S) (hq : HasHoles q Sᶜ) : HasHoles (fillHoles m q S hm hq) ∅ := by
classical
intro v
simp only [fillHoles_apply, Finset.notMem_empty, iff_false]
by_cases hv : v ∈ S
· rw [ite_eq_left hv]
intro he
exact (Finset.mem_compl.mp ((hq v).mp he)) hv
· rw [ite_eq_right hv]
intro he
exact hv ((hm v).mp he)
theorem fillHoles_injective [Fintype V] [DecidableEq V] (q : Mate V) (S : Finset V)
(hq : HasHoles q Sᶜ) : Function.Injective
(fun m : {m : Mate V // HasHoles m S} => fillHoles m.1 q S m.2 hq) := by
classical
intro m n he
apply Subtype.ext
apply Subtype.ext
funext v
by_cases hv : v ∈ S
· exact ((m.2 v).mpr hv).trans ((n.2 v).mpr hv).symm
· have h := congrArg (fun r : Mate V => r.1 v) he
simpa [hv] using h
theorem fillHoles_weight_le [Fintype V] [LinearOrder V]
(w d u : V → V → ℝ) (hw : ∀ a b, 0 ≤ w a b) (hd : ∀ a b, 0 ≤ d a b)
(hwu : ∀ a b, w a b ≤ u a b) (hdu : ∀ a b, d a b ≤ u a b)
(m q : Mate V) (S : Finset V) (hm : HasHoles m S) (hq : HasHoles q Sᶜ) :
weight w m * weight d q ≤ weight u (fillHoles m q S hm hq) := by
classical
unfold weight
rw [← Finset.prod_mul_distrib]
apply Finset.prod_le_prod₀
· intro v _
exact mul_nonneg (by split_ifs; exact hw _ _; norm_num)
(by split_ifs; exact hd _ _; norm_num)
· intro v _
rw [fillHoles_apply]
by_cases hv : v ∈ S
· have hmfix := (hm v).mpr hv
simp only [hv, ite_true, hmfix, lt_self_iff_false, ite_false, one_mul]
split_ifs
· exact hdu _ _
· rfl
· have hqfix := (hq v).mpr (Finset.mem_compl.mpr hv)
simp only [hv, ite_false, hqfix, lt_self_iff_false, mul_one]
split_ifs
· exact hwu _ _
· rfl
theorem fillHoles_partition_le [Fintype V] [LinearOrder V]
(w d u : V → V → ℝ) (hw : ∀ a b, 0 ≤ w a b) (hd : ∀ a b, 0 ≤ d a b)
(hwu : ∀ a b, w a b ≤ u a b) (hdu : ∀ a b, d a b ≤ u a b)
(q : Mate V) (S : Finset V) (hq : HasHoles q Sᶜ) :
partition w S * weight d q ≤ partition u ∅ := by
classical
let f : Mate V → Mate V := fun m =>
if hm : HasHoles m S then fillHoles m q S hm hq else m
have hi : Set.InjOn f (matchings S) := by
intro m hm n hn he
have hm' := (mem_matchings m S).mp hm
have hn' := (mem_matchings n S).mp hn
have h : (⟨m,hm'⟩ : {m : Mate V // HasHoles m S}) = ⟨n,hn'⟩ :=
fillHoles_injective q S hq (by simpa [f,hm',hn'] using he)
exact congrArg Subtype.val h
have hsub : (matchings S).image f ⊆ matchings ∅ := by
intro m hm
obtain ⟨n,hn,rfl⟩ := Finset.mem_image.mp hm
have hn' := (mem_matchings n S).mp hn
simp only [f,dite_eq_left hn',mem_matchings]
exact fillHoles_perfect n q S hn' hq
calc
partition w S * weight d q = ∑ m ∈ matchings S, weight w m * weight d q :=
Finset.sum_mul _ _ _
_ ≤ ∑ m ∈ matchings S, weight u (f m) := by
apply Finset.sum_le_sum
intro m hm
have hm' := (mem_matchings m S).mp hm
simpa [f,hm'] using fillHoles_weight_le w d u hw hd hwu hdu m q S hm' hq
_ = ∑ m ∈ (matchings S).image f, weight u m := (Finset.sum_image hi).symm
_ ≤ partition u ∅ := Finset.sum_le_sum_of_subset_of_nonneg hsub
(fun m _ _ => weight_nonneg u (fun a b => (hw a b).trans (hwu a b)) m)
theorem mate_edge_count [Fintype V] [LinearOrder V] (q : Mate V) (S : Finset V)
(hq : HasHoles q Sᶜ) :
2 * (Finset.univ.filter (fun v => v < q.1 v)).card = S.card := by
let L := Finset.univ.filter (fun v => v < q.1 v)
let R := Finset.univ.filter (fun v => q.1 v < v)
have himg : L.image q.1 = R := by
ext v
simp only [Finset.mem_image, L,R,Finset.mem_filter,Finset.mem_univ,true_and]
constructor
· rintro ⟨a,ha,rfl⟩
simpa using ha
· intro hv
exact ⟨q.1 v,by simpa using hv,mate_mate q v⟩
have hcard : L.card = R.card := by
rw [← himg]
exact (Finset.card_image_of_injective L q.2.injective).symm
have hdis : Disjoint L R := by
apply Finset.disjoint_left.mpr
intro v hl hr
have hl' : v < q.1 v := (Finset.mem_filter.mp hl).2
have hr' : q.1 v < v := (Finset.mem_filter.mp hr).2
exact (lt_asymm hl' hr')
have hunion : L ∪ R = S := by
ext v
simp only [L,R,Finset.mem_union,Finset.mem_filter,Finset.mem_univ,true_and]
rw [← ne_iff_lt_or_gt]
have h := hq v
simp only [Finset.mem_compl] at h
simpa only [ne_eq, eq_comm, not_not] using (not_congr h)
have hc := Finset.card_union_of_disjoint hdis
rw [hunion,← hcard] at hc
change 2 * L.card = S.card
omega
theorem weight_div_const [Fintype V] [LinearOrder V]
(w : V → V → ℝ) (c : ℝ) (q : Mate V) (S : Finset V) (hq : HasHoles q Sᶜ) :
weight (fun a b => w a b / c) q = weight w q / c^(S.card/2) := by
have hc : (Finset.univ.filter (fun v => v < q.1 v)).card = S.card/2 := by
have := mate_edge_count q S hq
omega
unfold weight
rw [← Finset.prod_filter, ← Finset.prod_filter, Finset.prod_div_distrib]
simp only [Finset.prod_const, hc]
theorem pairing_exists [Fintype V] [DecidableEq V] (S : Finset V) (hS : Even S.card) :
∃ q : Mate V, HasHoles q Sᶜ := by
classical
induction S using Finset.strongInductionOn with
| _ S ih =>
by_cases hEmpty : S = ∅
· subst S
refine ⟨⟨id,fun _ => rfl⟩,?_⟩
intro v
simp
· obtain ⟨a,ha⟩ := Finset.nonempty_iff_ne_empty.mpr hEmpty
have hcardpos := Finset.card_pos.mpr (show S.Nonempty from ⟨a,ha⟩)
have hcard2 : 2 ≤ S.card := by obtain ⟨k,hk⟩ := hS; omega
have herase : (S.erase a).Nonempty := by
apply Finset.card_pos.mp
rw [Finset.card_erase_of_mem ha]
omega
obtain ⟨b,hb⟩ := herase
have hba := (Finset.mem_erase.mp hb).1
have hbS := (Finset.mem_erase.mp hb).2
let T := S \ {a,b}
have hTcard : T.card + 2 = S.card := by
have h := sdiff_pair_card S a b ha hbS hba.symm
change T.card = S.card - 2 at h
omega
have hTeven : Even T.card := by
obtain ⟨k,hk⟩ := hS
refine ⟨k-1,?_⟩
omega
have hTsub : T ⊂ S := Finset.ssubset_iff_subset_ne.mpr
⟨Finset.sdiff_subset,by intro he; have := congrArg Finset.card he; omega⟩
obtain ⟨q,hq⟩ := ih T hTsub hTeven
have haT : a ∈ Tᶜ := by simp [T]
have hbT : b ∈ Tᶜ := by simp [T]
refine ⟨withEdge q a b,?_⟩
have hh := withEdge_holes q Tᶜ hq a b haT hbT hba.symm
have he : Tᶜ \ {a,b} = Sᶜ := by
ext v
simp only [T,Finset.mem_sdiff,Finset.mem_compl,Finset.mem_insert,Finset.mem_singleton]
have hsub : ({a,b} : Finset V) ⊆ S := by
intro x hx
simp only [Finset.mem_insert,Finset.mem_singleton] at hx
rcases hx with rfl | rfl <;> assumption
constructor
· intro h
tauto
· intro hv
constructor
· tauto
· intro hvp
exact hv (hsub (by simpa using hvp))
rwa [he] at hh
noncomputable def pairingCapacity [Fintype V] [LinearOrder V]
(B : V → V → ℝ) (S : Finset V) (hS : Even S.card) : ℝ :=
(matchings Sᶜ).sup' (by
obtain ⟨q,hq⟩ := pairing_exists S hS
exact ⟨q,(mem_matchings q Sᶜ).mpr hq⟩) (weight B)
theorem logical_hole_bound [Fintype V] [LinearOrder V]
(hn : 2 ≤ Fintype.card V) (w : V → V → ℝ)
(hw : ∀ a b, 0 ≤ w a b) (hz : 0 < partition w ∅)
(hrlo : ∀ a, (1:ℝ)/4 ≤ rowMax hn w a) (hrhi : ∀ a, rowMax hn w a ≤ 1)
(S : Finset V) (hS : Even S.card) :
holeRatio w S * pairingCapacity (bottleneck w) S hS ≤
2 * holeScale V ^ (S.card / 2) := by
classical
obtain ⟨q,hq,hmax⟩ := Finset.exists_mem_eq_sup'
(show (matchings Sᶜ).Nonempty from by
obtain ⟨q,hq⟩ := pairing_exists S hS
exact ⟨q,(mem_matchings _ _).mpr hq⟩) (weight (bottleneck w))
have hq' := (mem_matchings q Sᶜ).mp hq
have hc : pairingCapacity (bottleneck w) S hS = weight (bottleneck w) q := hmax
let d := holeAugmentation w
let u := affineWeights w d 1
have hd : ∀ a b, 0 ≤ d a b := holeAugmentation_nonneg w
have hfill := fillHoles_partition_le w d u hw hd
(fun a b => by change w a b ≤ w a b + 1*d a b; linarith [hd a b])
(fun a b => by change d a b ≤ w a b + 1*d a b; linarith [hw a b]) q S hq'
have hinfl := logical_inflation hn w hw hz hrlo hrhi
have hdiv : weight d q = weight (bottleneck w) q / holeScale V ^ (S.card/2) :=
weight_div_const (bottleneck w) (holeScale V) q S hq'
rw [hdiv] at hfill
rw [hc,holeRatio]
have hpow : 0 < holeScale V ^ (S.card/2) := pow_pos holeScale_pos _
have hmain : partition w S * weight (bottleneck w) q ≤
2 * partition w ∅ * holeScale V ^ (S.card/2) := by
have h' := hfill.trans hinfl.le
rw [← mul_div_assoc, div_le_iff₀ hpow] at h'
exact h'
rw [div_mul_eq_mul_div, div_le_iff₀ hz]
nlinarith only [hmain]
end MatchingFPRAS.Switching
end OAI
|