| import OAI.Combinatorics.CliqueFree.Deletion |
| import OAI.Combinatorics.CliqueFree.CrossBound |
| import OAI.Combinatorics.CliqueFree.TriangleBound |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| open scoped BigOperators |
| open Finset |
|
|
| attribute [local instance] Classical.propDecidable |
|
|
| namespace CliqueFreeIndependence.WeightedGraph |
|
|
| universe u v |
|
|
| variable {V : Type u} [Fintype V] |
|
|
| lemma exists_optimizer_triangle_bound (k : ℕ) : |
| ∃ B : ℝ, 0 < B ∧ ∀ {V : Type u} [Fintype V] (G : SimpleGraph V) (w : V → ℝ), |
| IsOptimizer G w → G.CliqueFree (k+2) → triangleMass G w ≤ B * edgeMass G w := by |
| have hC : 1 ≤ 16*((k : ℝ)+2)^2 := by nlinarith [Nat.cast_nonneg (α := ℝ) k] |
| obtain ⟨B,hB,hbound⟩ := weighted_triangles.{u} hC |
| exact ⟨B,hB,fun G w hw hf ↦ hbound G w (fun v ↦ (optimizer_stationary hw v).1) |
| (optimizer_cross_bound k G hw hf)⟩ |
|
|
| lemma exists_cheap_vertex {G : SimpleGraph V} {w : V → ℝ} (hw : IsOptimizer G w) |
| [Nonempty V] {Δ B : ℝ} (hΔ : 3 ≤ Δ) (hB : 0 ≤ B) |
| (hdeg : ∀ v, (G.degree v : ℝ) ≤ Δ) (htri : triangleMass G w ≤ B * edgeMass G w) : |
| ∃ v, mass w (closedNeighbors G v) + edgeMass G (restrict (closedNeighbors G v) w) ≤ |
| (3+3*B/2) * Real.log Δ := by |
| have hwpos (v : V) : 0 < w v := (optimizer_stationary hw v).1 |
| have hp (v : V) : |
| w v * (mass w (closedNeighbors G v) + edgeMass G (restrict (closedNeighbors G v) w)) ≤ |
| w v + 2 * (w v * neighborMass G w v) + w v * triangleAt G w v / 2 := by |
| rw [mass_closedNeighbors,edgeMass_closedNeighbors] |
| have hv := (optimizer_stationary hw v).2.2 |
| have hN := neighborMass_nonneg G hw.1 v |
| have hsq : w v * w v ≤ w v := by nlinarith [hw.1 v] |
| have hmul := mul_le_mul_of_nonneg_right hsq hN |
| nlinarith |
| have hsum := sum_le_sum (s := univ) fun v _ ↦ hp v |
| simp only [sum_add_distrib, ← mul_sum, ← sum_div] at hsum |
| have he := edgeForm_self G w |
| rw [edgeForm_neighbor] at he |
| have ht : (∑ v, w v * triangleAt G w v) / 2 = 3*triangleMass G w := by |
| unfold triangleMass |
| ring |
| rw [he,ht] at hsum |
| have hedge := optimizer_edge_bound hw hΔ hdeg |
| have hlog : 1 ≤ Real.log Δ := le_of_lt <| (Real.lt_log_iff_exp_lt (by linarith)).2 |
| (Real.exp_one_lt_three.trans_le hΔ) |
| have hW : 0 ≤ ∑ v, w v := sum_nonneg (fun v _ ↦ hw.1 v) |
| have htot : (∑ v, w v * (mass w (closedNeighbors G v) + |
| edgeMass G (restrict (closedNeighbors G v) w))) ≤ |
| ((3+3*B/2)*Real.log Δ) * (∑ v, w v) := by |
| have h1 := mul_le_mul_of_nonneg_right hlog hW |
| have h2 := mul_le_mul_of_nonneg_left hedge (show 0 ≤ 2+3*B/2 by positivity) |
| nlinarith |
| by_contra h |
| push Not at h |
| have hlt (v : V) := mul_lt_mul_of_pos_left (h v) (hwpos v) |
| have hh := sum_lt_sum (s := univ) (fun v _ ↦ (hlt v).le) |
| ⟨Classical.arbitrary V, mem_univ _, hlt _⟩ |
| rw [← sum_mul] at hh |
| linarith |
|
|
| lemma degree_induce_le (G : SimpleGraph V) (A : Finset V) (v : (A : Set V)) : |
| (G.induce (A : Set V)).degree v ≤ G.degree v := by |
| classical |
| rw [← SimpleGraph.card_neighborSet_eq_degree, ← SimpleGraph.card_neighborSet_eq_degree] |
| exact Fintype.card_le_of_injective |
| (fun u : (G.induce (A : Set V)).neighborSet v ↦ |
| (⟨u.val.val, u.property⟩ : G.neighborSet v)) |
| (fun u z h ↦ by |
| apply Subtype.ext |
| apply Subtype.ext |
| exact congrArg (fun x : G.neighborSet v ↦ (x : V)) h) |
|
|
| omit [Fintype V] in |
| lemma indepSet_image_induce (G : SimpleGraph V) (A : Finset V) (I : Finset (A : Set V)) |
| (hI : (G.induce (A : Set V)).IsIndepSet (I : Set (A : Set V))) : |
| G.IsIndepSet (I.map ⟨Subtype.val, Subtype.val_injective⟩ : Set V) := by |
| classical |
| intro a ha b hb hab |
| obtain ⟨a',ha',rfl⟩ := mem_map.1 ha |
| obtain ⟨b',hb',rfl⟩ := mem_map.1 hb |
| exact hI ha' hb' (fun h ↦ hab (congrArg Subtype.val h)) |
|
|
| omit [Fintype V] in |
| lemma indepSet_insert_induce (G : SimpleGraph V) (A : Finset V) (v : V) |
| (hA : ∀ b ∈ A, b ≠ v ∧ ¬G.Adj v b) |
| (I : Finset (A : Set V)) |
| (hI : (G.induce (A : Set V)).IsIndepSet (I : Set _)) : |
| G.IsIndepSet (↑(insert v (I.map ⟨Subtype.val, Subtype.val_injective⟩) : Finset V) : Set V) ∧ |
| (insert v (I.map ⟨Subtype.val, Subtype.val_injective⟩)).card = I.card + 1 := by |
| classical |
| have hnot (b : V) (hb : b ∈ I.map ⟨Subtype.val, Subtype.val_injective⟩) : |
| b ≠ v ∧ ¬G.Adj v b := by |
| obtain ⟨b',_,rfl⟩ := mem_map.1 hb |
| exact hA b' b'.property |
| have hi := indepSet_image_induce G A I hI |
| constructor |
| · intro a ha b hb hab |
| change a ∈ insert v (I.map _) at ha |
| change b ∈ insert v (I.map _) at hb |
| rw [mem_insert] at ha hb |
| rcases ha with rfl | ha |
| · rcases hb with rfl | hb |
| · exact fun _ ↦ hab rfl |
| · exact (hnot b hb).2 |
| · rcases hb with rfl | hb |
| · exact fun h ↦ (hnot a ha).2 h.symm |
| · exact hi ha hb hab |
| · rw [card_insert_of_notMem (fun h ↦ (hnot v h).1 rfl), card_map] |
|
|
| / |
| not a surrogate objective or a conditional independence bound. -/ |
| lemma maximum_degree_potential_bound (k : ℕ) {B Δ : ℝ} (hB : 0 ≤ B) (hΔ : 3 ≤ Δ) |
| (htri : ∀ {U : Type u} [Fintype U] (H : SimpleGraph U) (w : U → ℝ), |
| IsOptimizer H w → H.CliqueFree (k+2) → triangleMass H w ≤ B * edgeMass H w) |
| (G : SimpleGraph V) (hf : G.CliqueFree (k+2)) (hdeg : ∀ v, (G.degree v : ℝ) ≤ Δ) : |
| ∃ I : Finset V, G.IsIndepSet (I : Set V) ∧ |
| ∀ q : V → ℝ, (∀ v, 0 ≤ q v) → |
| potential G q ≤ ((3+3*B/2)*Real.log Δ) * (I.card : ℝ) := by |
| classical |
| have aux : ∀ n : ℕ, ∀ (U : Type u) [Fintype U], Fintype.card U = n → |
| ∀ H : SimpleGraph U, H.CliqueFree (k+2) → (∀ v, (H.degree v : ℝ) ≤ Δ) → |
| ∃ I : Finset U, H.IsIndepSet (I : Set U) ∧ |
| ∀ q : U → ℝ, (∀ v, 0 ≤ q v) → |
| potential H q ≤ ((3+3*B/2)*Real.log Δ) * (I.card : ℝ) := by |
| intro n |
| induction n using Nat.strong_induction_on with |
| | h n ih => |
| intro U _ hn H hfree hdegree |
| rcases isEmpty_or_nonempty U with hU | hU |
| · let _ := hU |
| refine ⟨∅,by simp,?_⟩ |
| intro q _ |
| simp [potential,edgeMass,crossMass] |
| · let _ := hU |
| obtain ⟨w,hw⟩ := exists_optimizer H |
| obtain ⟨v,hv⟩ := exists_cheap_vertex hw hΔ hB hdegree (htri H w hw hfree) |
| let A : Finset U := (closedNeighbors H v)ᶜ |
| have hA : ∀ b ∈ A, b ≠ v ∧ ¬H.Adj v b := by |
| intro b hb |
| simpa [A] using hb |
| have hcard : Fintype.card (A : Set U) < n := by |
| rw [← hn] |
| exact Fintype.card_subtype_lt (x := v) (by simp [A]) |
| have hfreeA : (H.induce (A : Set U)).CliqueFree (k+2) := |
| (H.cliqueFree_induce_iff _ _).2 hfree.cliqueFreeOn |
| have hdegA (a : (A : Set U)) : ((H.induce (A : Set U)).degree a : ℝ) ≤ Δ := |
| (Nat.cast_le.2 (degree_induce_le H A a)).trans (hdegree a) |
| obtain ⟨I,hI,hIp⟩ := ih _ hcard (A : Set U) rfl (H.induce (A : Set U)) hfreeA hdegA |
| obtain ⟨hJ,hJcard⟩ := indepSet_insert_induce H A v hA I hI |
| refine ⟨insert v (I.map ⟨Subtype.val,Subtype.val_injective⟩),hJ,?_⟩ |
| intro q hq |
| have hres := hIp (fun a ↦ w a) (fun a ↦ hw.1 a) |
| rw [potential_induce] at hres |
| have hcost := optimizer_deletion_cost hw (closedNeighbors H v) |
| change potential H w - potential H (restrict A w) = _ at hcost |
| rw [hJcard,Nat.cast_add,Nat.cast_one] |
| have hmax := hw.2 q hq |
| nlinarith |
| exact aux _ V rfl G hf hdeg |
|
|
| end CliqueFreeIndependence.WeightedGraph |
|
|
| end |
|
|
| end OAI |
|
|
