| import OAI.Combinatorics.CliqueFree.TriangleState |
|
|
| 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] |
|
|
| attribute [local instance 10000] edgeStateDecEq |
|
|
| variable {U : Type v} [Fintype U] |
|
|
| lemma sum_injective_le {I : Type u} {J : Type v} [Fintype I] [Fintype J] |
| (f : I → J) (hf : Function.Injective f) (g : J → ℝ) (hg : ∀ j, 0 ≤ g j) : |
| (∑ i, g (f i)) ≤ ∑ j, g j := by |
| classical |
| calc |
| _ = ∑ j ∈ univ.image f, g j := (sum_image (fun _ _ _ _ h ↦ hf h)).symm |
| _ ≤ _ := sum_le_univ_sum_of_nonneg hg |
|
|
| / |
| structure EdgeProjection (H : SimpleGraph U) (G : SimpleGraph V) (π : U → V) : Prop where |
| map_adj : ∀ a b, H.Adj a b → G.Adj (π a) (π b) |
| inj : ∀ a b c d, H.Adj a b → H.Adj c d → π a = π c → π b = π d → a = c ∧ b = d |
|
|
| namespace EdgeProjection |
| variable {H : SimpleGraph U} {G : SimpleGraph V} {π : U → V} |
|
|
| def edgeMap (h : EdgeProjection H G π) (e : EdgeState H) : EdgeState G := |
| ⟨(π e.src, π e.dst), h.map_adj _ _ e.adj⟩ |
|
|
| omit [Fintype V] [Fintype U] in |
| lemma edgeMap_injective (h : EdgeProjection H G π) : Function.Injective h.edgeMap := by |
| intro e f hef |
| have heq := congrArg Subtype.val hef |
| have hpair := h.inj e.src e.dst f.src f.dst e.adj f.adj |
| (congrArg Prod.fst heq) (congrArg Prod.snd heq) |
| exact Subtype.ext (Prod.ext hpair.1 hpair.2) |
|
|
| omit [Fintype V] [Fintype U] in |
| lemma mass_image_le {w : V → ℝ} (hw : ∀ v, 0 ≤ w v) (A : Finset U) : |
| mass w (A.image π) ≤ mass (w ∘ π) A := by |
| classical |
| exact sum_image_le_of_nonneg (fun _ _ ↦ hw _) |
|
|
| lemma crossMass_edge_sum (H : SimpleGraph U) (w : U → ℝ) (A B : Finset U) : |
| crossMass H w A B = |
| ∑ e : EdgeState H, if e.src ∈ A ∧ e.dst ∈ B then w e.src * w e.dst else 0 := by |
| classical |
| rw [EdgeState.sum_eq (fun a b ↦ if a ∈ A ∧ b ∈ B then w a * w b else 0)] |
| have heq : (∑ a, ∑ b ∈ neighbors H a, if a ∈ A ∧ b ∈ B then w a * w b else 0) = |
| ∑ a, if a ∈ A then (∑ b, if b ∈ B then if H.Adj a b then w a * w b else 0 else 0) else 0 := by |
| apply sum_congr rfl |
| intro a _ |
| by_cases ha : a ∈ A |
| · simp only [ha, true_and, ↓reduceIte, neighbors, sum_filter] |
| apply sum_congr rfl |
| intro b _ |
| by_cases hb : b ∈ B <;> simp [hb] |
| · simp [ha] |
| rw [heq] |
| simp [crossMass] |
|
|
| lemma crossMass_le (h : EdgeProjection H G π) {w : V → ℝ} (hw : ∀ v, 0 ≤ w v) |
| (A B : Finset U) : |
| crossMass H (w ∘ π) A B ≤ crossMass G w (A.image π) (B.image π) := by |
| classical |
| rw [crossMass_edge_sum, crossMass_edge_sum] |
| calc |
| _ ≤ ∑ e : EdgeState H, |
| if (h.edgeMap e).src ∈ A.image π ∧ (h.edgeMap e).dst ∈ B.image π |
| then w (h.edgeMap e).src * w (h.edgeMap e).dst else 0 := by |
| apply sum_le_sum |
| intro e _ |
| by_cases he : e.src ∈ A ∧ e.dst ∈ B |
| · have hi : (h.edgeMap e).src ∈ A.image π ∧ (h.edgeMap e).dst ∈ B.image π := |
| ⟨mem_image.2 ⟨e.src, he.1, rfl⟩, mem_image.2 ⟨e.dst, he.2, rfl⟩⟩ |
| simp only [he, hi] |
| exact le_rfl |
| · simp only [he, ↓reduceIte] |
| split_ifs |
| · exact mul_nonneg (hw _) (hw _) |
| · exact le_rfl |
| _ ≤ _ := sum_injective_le h.edgeMap h.edgeMap_injective |
| (fun e ↦ if e.src ∈ A.image π ∧ e.dst ∈ B.image π then w e.src * w e.dst else 0) |
| (fun e ↦ by split_ifs; exact mul_nonneg (hw _) (hw _); exact le_rfl) |
|
|
| lemma crossBound (h : EdgeProjection H G π) {w : V → ℝ} (hw : ∀ v, 0 ≤ w v) |
| {C : ℝ} (hC : 0 ≤ C) (hc : CrossBound G w C) : CrossBound H (w ∘ π) C := by |
| classical |
| intro x hx A B hA hB |
| have hAi := mass_image_le (π := π) hw A |
| have hBi := mass_image_le (π := π) hw B |
| exact (h.crossMass_le hw A B).trans ((hc x hx _ _ (hAi.trans hA) (hBi.trans hB)).trans |
| (mul_le_mul_of_nonneg_left (growth_mono hx (mass_nonneg hw _) (mass_nonneg (fun u ↦ hw (π u)) _) hAi) hC)) |
|
|
| lemma edgeMass_le (h : EdgeProjection H G π) {w : V → ℝ} (hw : ∀ v, 0 ≤ w v) : |
| edgeMass H (w ∘ π) ≤ edgeMass G w := by |
| classical |
| have hsum : (∑ e : EdgeState H, w (π e.src) * w (π e.dst)) ≤ |
| ∑ e : EdgeState G, w e.src * w e.dst := |
| sum_injective_le h.edgeMap h.edgeMap_injective (fun e ↦ w e.src * w e.dst) |
| (fun e ↦ mul_nonneg (hw _) (hw _)) |
| unfold edgeMass |
| rw [crossMass_edge_sum, crossMass_edge_sum] |
| simpa only [mem_univ, true_and, ↓reduceIte, Function.comp_apply] using |
| div_le_div_of_nonneg_right hsum (by norm_num : (0 : ℝ) ≤ 2) |
|
|
| omit [Fintype V] in |
| lemma neighbor_injective (h : EdgeProjection H G π) (a : U) : |
| Set.InjOn π (neighbors H a) := by |
| intro b hb c hc heq |
| exact (h.inj a b a c ((mem_neighbors _ _ _).1 hb) ((mem_neighbors _ _ _).1 hc) rfl heq).2 |
|
|
| lemma neighborhood_image (h : EdgeProjection H G π) (a : U) : |
| (neighbors H a).image π ⊆ neighbors G (π a) := by |
| intro b hb |
| obtain ⟨c, hc, rfl⟩ := mem_image.1 hb |
| exact (mem_neighbors _ _ _).2 (h.map_adj _ _ ((mem_neighbors _ _ _).1 hc)) |
|
|
| lemma neighborMass_le (h : EdgeProjection H G π) {w : V → ℝ} (hw : ∀ v, 0 ≤ w v) (a : U) : |
| neighborMass H (w ∘ π) a ≤ neighborMass G w (π a) := by |
| classical |
| calc |
| _ = mass w ((neighbors H a).image π) := (sum_image (h.neighbor_injective a)).symm |
| _ ≤ _ := mass_mono hw (h.neighborhood_image a) |
|
|
| end EdgeProjection |
|
|
| end CliqueFreeIndependence.WeightedGraph |
|
|
| end |
|
|
| end OAI |
|
|
