File size: 7,127 Bytes
97c3405 | 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 | import OAI.Combinatorics.CliqueFree.Optimizer
import OAI.Combinatorics.CliqueFree.SparseMultipliers
namespace OAI
noncomputable section
open scoped BigOperators
open Finset
attribute [local instance] Classical.propDecidable
namespace CliqueFreeIndependence.WeightedGraph
open Lottery
universe u
variable {V : Type u} [Fintype V]
lemma edgeForm_smul_left (G : SimpleGraph V) (a b : V → ℝ) (t : ℝ) :
edgeForm G (fun v ↦ t*a v) b = t*edgeForm G a b := by
unfold edgeForm
simp only [mul_sum,mul_ite,mul_zero]
apply sum_congr rfl
intro u _
apply sum_congr rfl
intro v _
split_ifs <;> ring
lemma edgeForm_smul_right (G : SimpleGraph V) (a b : V → ℝ) (t : ℝ) :
edgeForm G a (fun v ↦ t*b v) = t*edgeForm G a b := by
rw [edgeForm_symm,edgeForm_smul_left,edgeForm_symm G b a]
lemma edgeMass_lin_sub (G : SimpleGraph V) (a b : V → ℝ) (k : ℝ) :
edgeMass G (fun v ↦ k*a v-b v) =
k^2*edgeMass G a + edgeMass G b - k*edgeForm G a b := by
have he : (fun v ↦ k*a v-b v) = (fun v ↦ k*a v)+(fun v ↦ (-1)*b v) := by
ext v; simp; ring
rw [he,edgeMass_add,edgeMass_smul,edgeMass_smul,edgeForm_smul_left,edgeForm_smul_right]
ring
lemma edgeForm_restrict (G : SimpleGraph V) (w : V → ℝ) (S D : Finset V) :
edgeForm G (restrict S w) (restrict D w) = crossMass G w S D := by
classical
unfold edgeForm crossMass restrict
calc
_ = ∑ u, if u ∈ S then ∑ v, if v ∈ D then (if G.Adj u v then w u*w v else 0) else 0 else 0 := by
apply sum_congr rfl
intro u _
by_cases hu : u ∈ S
· simp only [hu,ite_true]
apply sum_congr rfl
intro v _
by_cases hv : v ∈ D <;> simp [hv]
· simp [hu]
_ = _ := by
rw [← sum_filter]
simp only [filter_mem_eq_inter,univ_inter]
apply sum_congr rfl
intro u hu
rw [← sum_filter]
simp
lemma expected_weight (w : V → ℝ) (L : Law (V → ℝ)) (S : Finset V)
(hmean : ∀ v, expect L (fun m ↦ m v) = if v ∈ S then 1 else 0) :
expect L (fun m ↦ ∑ v, w v*m v) = mass w S := by
classical
rw [expect_sum]
simp_rw [Lottery.expect_mul,hmean,mul_ite,mul_one,mul_zero]
rw [← sum_filter]
simp [mass]
lemma expected_edgeForm (G : SimpleGraph V) (w : V → ℝ) (L : Law (V → ℝ)) (S D : Finset V)
(hmean : ∀ v, expect L (fun m ↦ m v) = if v ∈ S then 1 else 0) :
expect L (fun m ↦ edgeForm G (fun v ↦ w v*m v) (restrict D w)) = crossMass G w S D := by
classical
rw [← edgeForm_restrict]
simp only [edgeForm_neighbor]
rw [expect_sum]
apply sum_congr rfl
intro u _
have hf : (fun m : V → ℝ ↦ w u*m u*neighborMass G (restrict D w) u) =
(fun m ↦ (w u*neighborMass G (restrict D w) u)*m u) := by ext m; ring
rw [hf,Lottery.expect_mul,hmean]
by_cases hu : u ∈ S <;> simp [restrict,hu]
lemma vertex_divergence_upper {w y L : ℝ} (hw : 0 < w) (hy : 0 ≤ y) (hL : y ≤ L) :
(w*(1+y))*Real.log ((w*(1+y))/w) - w*(1+y) + w ≤ w*y*Real.log (1+L) := by
have hy1 : 0 < 1+y := by linarith
have hL1 : 0 < 1+L := hy1.trans_le (by linarith)
have hlog := Real.log_le_sub_one_of_pos hy1
have hmono := Real.log_le_log hy1 (by linarith : 1+y ≤ 1+L)
have hlo : w*y*Real.log (1+y) ≤ w*y*Real.log (1+L) :=
mul_le_mul_of_nonneg_left hmono (mul_nonneg hw.le hy)
have hcancel : w*(1+y)/w = 1+y := by field_simp
rw [hcancel]
nlinarith [mul_le_mul_of_nonneg_left hlog hw.le]
lemma variational_cross_lottery (G : SimpleGraph V) {w : V → ℝ} (hw : IsOptimizer G w)
(S D : Finset V) (hSD : Disjoint S D) (L : Law (V → ℝ)) (hp : IsProb L)
{b k ε : ℝ} (hk : 0 ≤ k) (hb : BoundedOn L S b)
(hm : ∀ v, expect L (fun m ↦ m v) = if v ∈ S then 1 else 0)
(he : expectedEdges G w L ≤ ε*(mass w S)^2) :
k*crossMass G w S D ≤ k^2*ε*(mass w S)^2 + (mass w D)^2/2 + mass w D +
k*Real.log (1+k*b)*mass w S := by
classical
have hwpos := fun v ↦ (optimizer_stationary hw v).1
have hw0 := fun v ↦ (hwpos v).le
let cost (m : V → ℝ) : ℝ :=
k*Real.log (1+k*b)*(∑ v, w v*m v) + mass w D +
(k^2*edgeMass G (fun v ↦ w v*m v) + edgeMass G (restrict D w) -
k*edgeForm G (fun v ↦ w v*m v) (restrict D w))
have hcost (z : ℝ × (V → ℝ)) (hz : z ∈ L) : 0 ≤ cost z.2 := by
let m := z.2
have hm0 := fun v ↦ (hb z hz).1 v |>.1
have hmb := fun v ↦ (hb z hz).1 v |>.2
have hmD (v : V) (hv : v ∈ D) : m v = 0 :=
(hb z hz).2 v (disjoint_left.1 hSD · hv)
let q : V → ℝ := fun v ↦ if v ∈ D then 0 else w v*(1+k*m v)
have hq (v : V) : 0 ≤ q v := by
dsimp [q]
split_ifs
· exact le_rfl
· exact mul_nonneg (hw0 v) (by nlinarith [mul_nonneg hk (hm0 v)])
obtain ⟨hdiv,heq⟩ := optimizer_divergence hw q hq
rw [heq] at hdiv
have hve (v : V) : q v*Real.log (q v/w v)-q v+w v ≤
k*Real.log (1+k*b)*(w v*m v) + if v ∈ D then w v else 0 := by
by_cases hv : v ∈ D
· simp [q,hv,hmD v hv]
· have hh := vertex_divergence_upper (hwpos v) (mul_nonneg hk (hm0 v))
(mul_le_mul_of_nonneg_left (hmb v) hk)
dsimp [q]
rw [ite_eq_right hv,ite_eq_right hv]
nlinarith only [hh]
have hD : (∑ v, if v ∈ D then w v else 0) = mass w D := by
rw [← sum_filter]; simp [mass]
have hvs : (∑ v, (q v*Real.log (q v/w v)-q v+w v)) ≤
k*Real.log (1+k*b)*(∑ v, w v*m v) + mass w D := by
calc
_ ≤ ∑ v, (k*Real.log (1+k*b)*(w v*m v) + if v ∈ D then w v else 0) :=
sum_le_sum fun v _ ↦ hve v
_ = _ := by rw [sum_add_distrib,← mul_sum,hD]
have hqsub : q-w = fun v ↦ k*(w v*m v)-restrict D w v := by
ext v
by_cases hv : v ∈ D <;> simp [q,restrict,hv,hmD v,Pi.sub_apply]
ring
rw [hqsub,edgeMass_lin_sub] at hdiv
dsimp [cost,m]
linarith only [hdiv,hvs]
have havg : 0 ≤ expect L cost := by
have hh := expect_mono hp.1 (f := fun _ ↦ 0) (g := cost) (fun z hz ↦ hcost z hz)
simpa [Lottery.expect_const] using hh
have hec : expect L cost =
k*Real.log (1+k*b)*mass w S + mass w D +
(k^2*expectedEdges G w L + edgeMass G (restrict D w) - k*crossMass G w S D) := by
have hsub (a b : (V → ℝ) → ℝ) : expect L (fun m ↦ a m-b m) = expect L a-expect L b := by
have hf : (fun m ↦ a m-b m) = (fun m ↦ a m+(-1)*b m) := by ext m; ring
rw [hf,expect_add,Lottery.expect_mul]; ring
dsimp [cost]
rw [expect_add,expect_add,hsub,expect_add,Lottery.expect_mul,expected_weight w L S hm,
Lottery.expect_const,hp.2,mul_one,Lottery.expect_mul,Lottery.expect_const,hp.2,mul_one,Lottery.expect_mul,
expected_edgeForm G w L S D hm]
rfl
rw [hec] at havg
have hDedge : edgeMass G (restrict D w) ≤ (mass w D)^2/2 := by
rw [edgeMass_restrict]
exact div_le_div_of_nonneg_right (by simpa [sq] using crossMass_le_product G hw0 D D) (by norm_num)
have hmult := mul_le_mul_of_nonneg_left he (sq_nonneg k)
nlinarith only [havg,hDedge,hmult]
end CliqueFreeIndependence.WeightedGraph
end
end OAI
|