| import OAI.Combinatorics.ListHadwiger.SamplingBounds |
|
|
| namespace OAI |
|
|
| namespace LinearListHadwiger.Fractional |
| open scoped BigOperators |
| variable {V : Type} [Fintype V] [DecidableEq V] |
|
|
| def cliqueBlowup (G : SimpleGraph V) (m : ℕ) : SimpleGraph (V × Fin m) where |
| Adj u v := G.Adj u.1 v.1 ∨ (u.1 = v.1 ∧ u.2 ≠ v.2) |
| symm := ⟨by |
| intro u v h |
| rcases h with h | ⟨h₁,h₂⟩ |
| · exact Or.inl h.symm |
| · exact Or.inr ⟨h₁.symm,h₂.symm⟩⟩ |
| loopless := ⟨by intro u; simp⟩ |
|
|
| lemma stable_blowup_projection {V : Type} [Fintype V] [DecidableEq V] {G : SimpleGraph V} {m : ℕ} {S : Finset (V × Fin m)} |
| (hS : Stable (cliqueBlowup G m) S) : Stable G (S.image Prod.fst) := by |
| classical |
| intro v hv w hw hadj |
| obtain ⟨u,hu,rfl⟩ := Finset.mem_image.mp hv |
| obtain ⟨z,hz,rfl⟩ := Finset.mem_image.mp hw |
| exact hS u hu z hz (Or.inl hadj) |
|
|
| lemma stable_blowup_injOn {V : Type} [Fintype V] [DecidableEq V] {G : SimpleGraph V} {m : ℕ} {S : Finset (V × Fin m)} |
| (hS : Stable (cliqueBlowup G m) S) : Set.InjOn Prod.fst (S : Set (V × Fin m)) := by |
| intro u hu v hv huv |
| apply Prod.ext huv |
| by_contra hn |
| exact hS u hu v hv (Or.inr ⟨huv,hn⟩) |
|
|
| lemma Dual.blowup {G : SimpleGraph V} {w : V → ℝ} (hw : Dual G w) (m : ℕ) : |
| Dual (cliqueBlowup G m) (fun v => w v.1) := by |
| classical |
| refine ⟨fun v => hw.1 v.1,?_⟩ |
| intro S hS |
| have hh := hw.2 (S.image Prod.fst) (stable_blowup_projection hS) |
| rw [Finset.sum_image (stable_blowup_injOn hS)] at hh |
| exact hh |
|
|
| lemma dual_sum_le_colors {V : Type} [Fintype V] [DecidableEq V] {G : SimpleGraph V} {w : V → ℝ} (hw : Dual G w) |
| {Color : Type} [Fintype Color] (c : G.Coloring Color) : |
| (∑ v, w v) ≤ Fintype.card Color := by |
| classical |
| rw [← Finset.sum_fiberwise Finset.univ c w] |
| calc |
| _ ≤ ∑ _ : Color, (1 : ℝ) := by |
| apply Finset.sum_le_sum |
| intro a _ |
| apply hw.2 |
| intro v hv u hu hadj |
| exact c.valid hadj ((Finset.mem_filter.mp hv).2.trans (Finset.mem_filter.mp hu).2.symm) |
| _ = _ := by simp |
|
|
| lemma number_le_colorable {G : SimpleGraph V} {k : ℕ} (hc : G.Colorable k) : |
| number G ≤ k := by |
| classical |
| obtain ⟨w,hw,heq⟩ := duality G |
| rw [← heq] |
| simpa only [Fintype.card_fin] using dual_sum_le_colors hw hc.some |
|
|
| theorem cliqueBlowup_chromatic_lower (G : SimpleGraph V) (m : ℕ) : |
| (m : ℝ) * number G ≤ (cliqueBlowup G m).chromaticNumber.toNat := by |
| classical |
| obtain ⟨w,hw,heq⟩ := duality G |
| have hh := dual_sum_le_colors (hw.blowup m) |
| (cliqueBlowup G m).colorable_chromaticNumber_of_fintype.some |
| rw [← heq] |
| simpa only [Fintype.card_fin,Fintype.sum_prod_type,Finset.sum_const, |
| Finset.card_univ,Fintype.card_fin,nsmul_eq_mul,← Finset.mul_sum] using hh |
|
|
| lemma cliqueBlowup_colorable_rounded {G : SimpleGraph V} {μ : Finset V → ℝ} |
| (hμ : Cover G μ) (m : ℕ) : |
| (cliqueBlowup G m).Colorable (∑ I, ⌈(m : ℝ)*μ I⌉₊) := by |
| classical |
| let counts : Finset V → ℕ := fun I => ⌈(m : ℝ)*μ I⌉₊ |
| let Slots := Σ I : Finset V, Fin (counts I) |
| let good (v : V) : Finset Slots := Finset.univ.filter (fun s => v ∈ s.1) |
| have hcard (v : V) : (good v).card = ∑ I, if v ∈ I then counts I else 0 := by |
| simp only [good,Finset.card_filter] |
| change (∑ s : (Σ I : Finset V, Fin (counts I)), if v ∈ s.1 then 1 else 0) = _ |
| rw [Fintype.sum_sigma] |
|
|
| apply Finset.sum_congr rfl |
| intro I _ |
| by_cases hv : v ∈ I <;> simp [hv] |
| have hlarge (v : V) : m ≤ (good v).card := by |
| have hm : (m : ℝ) ≤ ∑ I, if v ∈ I then ((counts I : ℕ) : ℝ) else 0 := by |
| calc |
| (m : ℝ) ≤ (m : ℝ)*(∑ I, if v ∈ I then μ I else 0) := by |
| simpa only [mul_one] using mul_le_mul_of_nonneg_left (hμ.2.2 v) (Nat.cast_nonneg m) |
| _ = ∑ I, if v ∈ I then (m : ℝ)*μ I else 0 := by |
| rw [Finset.mul_sum] |
| apply Finset.sum_congr rfl |
| intro I _ |
| split_ifs <;> simp |
| _ ≤ _ := by |
| apply Finset.sum_le_sum |
| intro I _ |
| split_ifs |
| · exact Nat.le_ceil _ |
| · exact le_rfl |
| rw [hcard] |
| exact_mod_cast hm |
| have hinj (v : V) : Nonempty (Fin m ↪ good v) := |
| Function.Embedding.nonempty_of_card_le (by simpa using hlarge v) |
| let e : (v : V) → Fin m ↪ good v := fun v => (hinj v).some |
| let c : V × Fin m → Slots := fun v => (e v.1 v.2).val |
| have hc : ∀ {v w : V × Fin m}, (cliqueBlowup G m).Adj v w → c v ≠ c w := by |
| intro v w hadj heq |
| have hv : v.1 ∈ (c v).1 := (Finset.mem_filter.mp (e v.1 v.2).property).2 |
| have hw : w.1 ∈ (c v).1 := by |
| rw [heq] |
| exact (Finset.mem_filter.mp (e w.1 w.2).property).2 |
| have stable : Stable G (c v).1 := by |
| by_contra hn |
| have hzero : counts (c v).1 = 0 := by simp [counts,hμ.2.1 _ hn] |
| have hslot := (c v).2.isLt |
| exact Nat.not_lt_zero _ (by simpa only [hzero] using hslot) |
| rcases hadj with hadj | ⟨hfst,hsnd⟩ |
| · exact stable _ hv _ hw hadj |
| · have hwv : w = (v.1,w.2) := Prod.ext hfst.symm rfl |
| have he : e v.1 v.2 = e v.1 w.2 := by |
| apply Subtype.ext |
| change c v = c (v.1,w.2) |
| rw [← hwv] |
| exact heq |
| exact hsnd ((e v.1).injective he) |
| have hchoose := (SimpleGraph.Coloring.mk c hc).colorable |
| simpa only [Slots,Fintype.card_sigma,Fintype.card_fin,counts] using hchoose |
|
|
| theorem cliqueBlowup_chromatic_upper (G : SimpleGraph V) (m : ℕ) : |
| ((cliqueBlowup G m).chromaticNumber.toNat : ℝ) ≤ |
| (m : ℝ)*number G + Fintype.card (Finset V) := by |
| classical |
| obtain ⟨μ,hμ,heq⟩ := optimum_exists G |
| have hcolor := cliqueBlowup_colorable_rounded hμ m |
| have hn := ENat.toNat_le_of_le_natCast hcolor.chromaticNumber_le |
| have hnr : ((cliqueBlowup G m).chromaticNumber.toNat : ℝ) ≤ |
| ∑ I, (⌈(m : ℝ)*μ I⌉₊ : ℝ) := by exact_mod_cast hn |
| apply hnr.trans |
| calc |
| _ ≤ ∑ I, ((m : ℝ)*μ I + 1) := by |
| apply Finset.sum_le_sum |
| intro I _ |
| exact (Nat.ceil_lt_add_one (mul_nonneg (Nat.cast_nonneg m) (hμ.1 I))).le |
| _ = _ := by |
| rw [Finset.sum_add_distrib,← Finset.mul_sum] |
| change (m : ℝ) * cost μ + _ = _ |
| rw [heq] |
| simp |
|
|
| end LinearListHadwiger.Fractional |
|
|
| namespace LinearListHadwiger |
| namespace FixedDecomposition |
| variable {V : Type} [DecidableEq V] {G : SimpleGraph V} {k : ℕ} |
|
|
| inductive Tree (G : SimpleGraph V) (k : ℕ) : Finset V → Type |
| | leaf {S} (stop : S.card ≤ 2*k ∨ KConnectedOn G S k) : Tree G k S |
| | branch {S A Z B} (split : SeparatorSplit G S A Z B) (small : Z.card < k) |
| (left : Tree G k (A ∪ Z)) (right : Tree G k (B ∪ Z)) : Tree G k S |
|
|
| theorem exists_tree (S : Finset V) : Nonempty (Tree G k S) := by |
| classical |
| induction S using Finset.strongInductionOn with | _ S ih => |
| by_cases hs : S.card ≤ 2*k |
| · exact ⟨Tree.leaf (Or.inl hs)⟩ |
| by_cases hc : KConnectedOn G S k |
| · exact ⟨Tree.leaf (Or.inr hc)⟩ |
| obtain ⟨A,Z,B,hZ,hsplit⟩ := exists_separator G S (by omega : k < S.card) hc |
| exact ⟨Tree.branch hsplit hZ (ih _ hsplit.left_union_ssubset).some |
| (ih _ hsplit.swap.left_union_ssubset).some⟩ |
|
|
| def Tree.leaves {S : Finset V} : Tree G k S → List (Finset V) |
| | .leaf _ => [S] |
| | .branch _ _ l r => l.leaves ++ r.leaves |
|
|
| def Tree.separators {S : Finset V} : Tree G k S → List (Finset V) |
| | .leaf _ => [] |
| | @Tree.branch _ _ _ _ _ _ Z _ _ _ l r => Z :: (l.separators ++ r.separators) |
|
|
| def budget (k u : ℕ) : ℕ := if u ≤ 2*k then 1 else (u-k)^2 |
|
|
| lemma budget_branch {u a b z : ℕ} (hu : 2*k < u) (hz : z < k) |
| (ha : a < u) (hb : b < u) (hsum : a+b = u+z) : |
| budget k a + budget k b + 1 ≤ budget k u := by |
| unfold budget |
| rw [ite_eq_right (by omega : ¬u ≤ 2*k)] |
| split_ifs with hka hkb hkb |
| · have hp : 2 ≤ u-k := by omega |
| nlinarith |
| · have hp : 2 ≤ u-k := by omega |
| have hbp : b-k < u-k := by omega |
| nlinarith |
| · have hp : 2 ≤ u-k := by omega |
| have hap : a-k < u-k := by omega |
| nlinarith |
| · have hsum' : (a-k)+(b-k) < u-k := by omega |
| have ha0 : 0 < a-k := by omega |
| have hb0 : 0 < b-k := by omega |
| nlinarith [sq_nonneg ((a-k : ℕ) : ℤ),sq_nonneg ((b-k : ℕ) : ℤ)] |
|
|
| lemma Tree.leaf_subset {S U : Finset V} (d : Tree G k S) (hU : U ∈ d.leaves) : |
| U ⊆ S := by |
| induction d with |
| | leaf _ => |
| have he : U = _ := List.mem_singleton.mp hU |
| exact he ▸ Finset.Subset.refl _ |
| | branch hs hz l r ihl ihr => |
| rcases List.mem_append.mp hU with hl | hr |
| · exact (ihl hl).trans hs.left_union_subset |
| · exact (ihr hr).trans hs.swap.left_union_subset |
|
|
| lemma Tree.separator_subset {S Z : Finset V} (d : Tree G k S) |
| (hZ : Z ∈ d.separators) : Z ⊆ S := by |
| induction d with |
| | leaf _ => simp [Tree.separators] at hZ |
| | @branch S A T B hs hz l r ihl ihr => |
| rcases List.mem_cons.mp hZ with rfl | hZ |
| · exact Finset.subset_union_right.trans hs.left_union_subset |
| · rcases List.mem_append.mp hZ with hl | hr |
| · exact (ihl hl).trans hs.left_union_subset |
| · exact (ihr hr).trans hs.swap.left_union_subset |
|
|
| lemma Tree.leaf_stop {S U : Finset V} (d : Tree G k S) (hU : U ∈ d.leaves) : |
| U.card ≤ 2*k ∨ KConnectedOn G U k := by |
| induction d with |
| | leaf h => |
| have he : U = _ := List.mem_singleton.mp hU |
| exact he ▸ h |
| | branch hs hz l r ihl ihr => |
| rcases List.mem_append.mp hU with hl | hr |
| · exact ihl hl |
| · exact ihr hr |
|
|
| lemma Tree.separator_small {S Z : Finset V} (d : Tree G k S) |
| (hZ : Z ∈ d.separators) : Z.card < k := by |
| induction d with |
| | leaf _ => simp [Tree.separators] at hZ |
| | branch hs hz l r ihl ihr => |
| rcases List.mem_cons.mp hZ with rfl | hZ |
| · exact hz |
| · rcases List.mem_append.mp hZ with hl | hr |
| · exact ihl hl |
| · exact ihr hr |
|
|
| theorem exists_bounded_tree (S : Finset V) : |
| ∃ d : Tree G k S, d.leaves.length + d.separators.length ≤ budget k S.card := by |
| classical |
| induction S using Finset.strongInductionOn with | _ S ih => |
| by_cases hs : S.card ≤ 2*k |
| · refine ⟨Tree.leaf (Or.inl hs),?_⟩ |
| simp [Tree.leaves,Tree.separators,budget,hs] |
| by_cases hc : KConnectedOn G S k |
| · refine ⟨Tree.leaf (Or.inr hc),?_⟩ |
| simp only [Tree.leaves,Tree.separators,List.length_singleton,List.length_nil,Nat.add_zero] |
| unfold budget |
| rw [ite_eq_right hs] |
| have hp : 1 ≤ S.card-k := by omega |
| nlinarith |
| obtain ⟨A,Z,B,hZ,hsp⟩ := exists_separator G S (by omega : k < S.card) hc |
| obtain ⟨l,hl⟩ := ih _ hsp.left_union_ssubset |
| obtain ⟨r,hr⟩ := ih _ hsp.swap.left_union_ssubset |
| refine ⟨Tree.branch hsp hZ l r,?_⟩ |
| have hcard : (A ∪ Z).card + (B ∪ Z).card = S.card + Z.card := by |
| rw [Finset.card_union_of_disjoint hsp.left_sep, |
| Finset.card_union_of_disjoint hsp.sep_right.symm, |
| ← hsp.union_eq,Finset.card_union_of_disjoint hsp.left_union_disjoint, |
| Finset.card_union_of_disjoint hsp.left_sep] |
| omega |
| have hb := budget_branch (by omega : 2*k < S.card) hZ |
| (Finset.card_lt_card hsp.left_union_ssubset) |
| (Finset.card_lt_card hsp.swap.left_union_ssubset) hcard |
| simp only [Tree.leaves,Tree.separators,List.length_append,List.length_cons] |
| omega |
|
|
| lemma budget_le_square (k u : ℕ) : budget k u ≤ (u+1)^2 := by |
| unfold budget |
| split_ifs |
| · nlinarith |
| · have : u-k ≤ u := Nat.sub_le _ _ |
| nlinarith |
|
|
| lemma reachable_preserves {W : Type} {H : SimpleGraph W} {P : W → Prop} |
| (hstep : ∀ u v, H.Adj u v → P u → P v) {u v : W} |
| (hr : H.Reachable u v) (hu : P u) : P v := by |
| obtain ⟨p⟩ := hr |
| induction p with |
| | nil => exact hu |
| | cons h p ih => exact ih (hstep _ _ h hu) |
|
|
| lemma confine_split {W : Type} [DecidableEq W] {H : SimpleGraph W} |
| (π : W → V) (hπ : ∀ u v, H.Adj u v → G.Adj (π u) (π v) ∨ π u = π v) |
| {S A Z B : Finset V} (hs : SeparatorSplit G S A Z B) |
| {T : Finset W} {j : ℕ} (hT : KConnectedOn H T j) |
| (hTS : ∀ u ∈ T, π u ∈ S) |
| (hZ : (T.filter (fun u => π u ∈ Z)).card < j) : |
| (∀ u ∈ T, π u ∈ A ∪ Z) ∨ (∀ u ∈ T, π u ∈ B ∪ Z) := by |
| classical |
| by_contra hn |
| push Not at hn |
| obtain ⟨⟨u,hu,huAZ⟩,v,hv,hvBZ⟩ := hn |
| have hmem (w : W) (hw : w ∈ T) : π w ∈ A ∨ π w ∈ Z ∨ π w ∈ B := by |
| have hh := hTS w hw |
| rw [← hs.union_eq] at hh |
| simpa only [Finset.mem_union,or_assoc] using hh |
| have huB : π u ∈ B := by have := hmem u hu; simp only [Finset.mem_union] at huAZ; tauto |
| have hvA : π v ∈ A := by have := hmem v hv; simp only [Finset.mem_union] at hvBZ; tauto |
| let R := T.filter (fun w => π w ∈ Z) |
| have huR : u ∈ T \ R := by |
| refine Finset.mem_sdiff.mpr ⟨hu,?_⟩ |
| simpa only [R,Finset.mem_filter,hu,true_and] using |
| (show π u ∉ Z from fun hz => huAZ (Finset.mem_union_right _ hz)) |
| have hvR : v ∈ T \ R := by |
| refine Finset.mem_sdiff.mpr ⟨hv,?_⟩ |
| simpa only [R,Finset.mem_filter,hv,true_and] using |
| (show π v ∉ Z from fun hz => hvBZ (Finset.mem_union_right _ hz)) |
| have hc := hT.2 R (Finset.filter_subset _ _) hZ |
| have hstep : ∀ a b : (↑(T \ R) : Set W), |
| (H.induce (↑(T \ R) : Set W)).Adj a b → π a.val ∈ A → π b.val ∈ A := by |
| intro a b hab ha |
| have hbT := (Finset.mem_sdiff.mp b.property).1 |
| have hbZ : π b.val ∉ Z := by |
| intro hz |
| exact (Finset.mem_sdiff.mp b.property).2 (Finset.mem_filter.mpr ⟨hbT,hz⟩) |
| rcases hmem b hbT with hb | hb | hb |
| · exact hb |
| · exact (hbZ hb).elim |
| · rcases hπ a b hab with hedge | heq |
| · exact (hs.anticomplete _ ha _ hb hedge).elim |
| · exact heq ▸ ha |
| have huA := reachable_preserves hstep (hc.preconnected ⟨v,hvR⟩ ⟨u,huR⟩) hvA |
| exact Finset.disjoint_left.mp hs.left_right huA huB |
|
|
| lemma Tree.confine {W : Type} [DecidableEq W] {H : SimpleGraph W} |
| {S : Finset V} (d : Tree G k S) |
| (π : W → V) (hπ : ∀ u v, H.Adj u v → G.Adj (π u) (π v) ∨ π u = π v) |
| {T : Finset W} {j : ℕ} (hT : KConnectedOn H T j) |
| (hTS : ∀ u ∈ T, π u ∈ S) |
| (hZ : ∀ Z ∈ d.separators, (T.filter (fun u => π u ∈ Z)).card < j) : |
| ∃ L ∈ d.leaves, ∀ u ∈ T, π u ∈ L := by |
| induction d with |
| | leaf _ => exact ⟨_,by simp [Tree.leaves],hTS⟩ |
| | @branch S A Z B hs hz l r ihl ihr => |
| rcases confine_split π hπ hs hT hTS (hZ Z (by simp [Tree.separators])) with hl | hr |
| · obtain ⟨L,hL,hTL⟩ := ihl hl (fun Z hZ' => hZ Z (by simp [Tree.separators,hZ'])) |
| exact ⟨L,List.mem_append_left _ hL,hTL⟩ |
| · obtain ⟨L,hL,hTL⟩ := ihr hr (fun Z hZ' => hZ Z (by simp [Tree.separators,hZ'])) |
| exact ⟨L,List.mem_append_right _ hL,hTL⟩ |
|
|
| end FixedDecomposition |
| end LinearListHadwiger |
|
|
| namespace LinearListHadwiger.FixedDecomposition |
| open Fractional |
| variable {V : Type} [Fintype V] [DecidableEq V] {G : SimpleGraph V} {k : ℕ} |
|
|
| lemma card_finset_subtype_le {V : Type} [Fintype V] [DecidableEq V] (A : Finset V) : |
| Fintype.card (Finset (↑A : Set V)) ≤ Fintype.card (Finset V) := by |
| exact Fintype.card_le_of_injective |
| (fun s : Finset (↑A : Set V) => s.map (⟨Subtype.val,Subtype.val_injective⟩ : (↑A : Set V) ↪ V)) |
| (by intro s t h; exact Finset.map_injective _ h) |
|
|
| lemma lifted_separator_card {V : Type} [Fintype V] [DecidableEq V] {A Z : Finset V} {m : ℕ} |
| (T : Finset ((↑A : Set V) × Fin m)) : |
| (T.filter (fun u => u.1.val ∈ Z)).card ≤ (A ∩ Z).card*m := by |
| classical |
| let f : (↑A : Set V) × Fin m → V × Fin m := fun u => (u.1.val,u.2) |
| have hf : Function.Injective f := by |
| intro u v h |
| apply Prod.ext |
| · exact Subtype.ext (congrArg Prod.fst h) |
| · exact congrArg (fun z : V × Fin m => z.2) h |
| calc |
| _ ≤ ((A ∩ Z).product (Finset.univ : Finset (Fin m))).card := by |
| apply Finset.card_le_card_of_injOn f |
| · intro u hu |
| exact Finset.mem_product.mpr ⟨Finset.mem_inter.mpr |
| ⟨u.1.property,(Finset.mem_filter.mp hu).2⟩,Finset.mem_univ _⟩ |
| · exact hf.injOn |
| _ = _ := by simp |
|
|
| lemma cliqueBlowup_leaf_hom {V : Type} [Fintype V] [DecidableEq V] {G : SimpleGraph V} {A L : Finset V} {m : ℕ} |
| (T : Finset ((↑A : Set V) × Fin m)) |
| (hTL : ∀ u ∈ T, u.1.val ∈ L) : |
| Nonempty (((cliqueBlowup (G.induce (↑A : Set V)) m).induce (↑T : Set _)) →g |
| cliqueBlowup (G.induce (↑(A ∩ L) : Set V)) m) := by |
| let f : (↑T : Set ((↑A : Set V) × Fin m)) → (↑(A ∩ L) : Set V) × Fin m := |
| fun u => (⟨u.val.1.val,Finset.mem_inter.mpr ⟨u.val.1.property,hTL _ u.property⟩⟩,u.val.2) |
| refine ⟨⟨f,?_⟩⟩ |
| intro u v huv |
| change G.Adj u.val.1.val v.val.1.val ∨ |
| (u.val.1 = v.val.1 ∧ u.val.2 ≠ v.val.2) at huv |
| change G.Adj u.val.1.val v.val.1.val ∨ |
| ((f u).1 = (f v).1 ∧ u.val.2 ≠ v.val.2) |
| rcases huv with h | ⟨h,h'⟩ |
| · exact Or.inl h |
| · refine Or.inr ⟨?_,h'⟩ |
| apply Subtype.ext |
| exact congrArg (fun x : (↑A : Set V) => x.val) h |
|
|
| theorem fractional_le_leaves_add_separator {S A : Finset V} (d : Tree G k S) |
| (hAS : A ⊆ S) {a b : ℝ} (ha : 0 ≤ a) (hb : 0 ≤ b) |
| (hleaf : ∀ L ∈ d.leaves, number (G.induce (↑(A ∩ L) : Set V)) ≤ a) |
| (hsep : ∀ Z ∈ d.separators, ((A ∩ Z).card : ℝ) ≤ b) : |
| number (G.induce (↑A : Set V)) ≤ a+6*b := by |
| classical |
| by_contra hn |
| have hgap : 0 < number (G.induce (↑A : Set V))-(a+6*b) := by linarith |
| obtain ⟨m,hm⟩ := exists_nat_gt ((12+(Fintype.card (Finset V) : ℝ))/ |
| (number (G.induce (↑A : Set V))-(a+6*b))) |
| have hmbig : 12+(Fintype.card (Finset V) : ℝ) < |
| (m : ℝ)*(number (G.induce (↑A : Set V))-(a+6*b)) := |
| (div_lt_iff₀ hgap).mp hm |
| let F := cliqueBlowup (G.induce (↑A : Set V)) m |
| let j := ⌈(m : ℝ)*b⌉₊ + 1 |
| have hj : 1 ≤ j := by simp [j] |
| have hjlow : (m : ℝ)*b < j := by |
| have := Nat.le_ceil ((m : ℝ)*b) |
| dsimp [j] |
| push_cast |
| linarith |
| have hjup : (j : ℝ) < (m : ℝ)*b+2 := by |
| have := Nat.ceil_lt_add_one (mul_nonneg (Nat.cast_nonneg m) hb) |
| dsimp [j] |
| push_cast |
| linarith |
|
|
| have hlower := cliqueBlowup_chromatic_lower (G.induce (↑A : Set V)) m |
| have hlargeR : (6*j : ℕ) < F.chromaticNumber.toNat := by |
| have : (6 : ℝ)*j < (F.chromaticNumber.toNat : ℝ) := by |
| dsimp [F] |
| nlinarith [mul_nonneg (Nat.cast_nonneg m : (0:ℝ) ≤ m) ha, (show (0:ℝ) ≤ Fintype.card (Finset V) from Nat.cast_nonneg _)] |
| exact_mod_cast this |
| obtain ⟨T,hT,hχ⟩ := ordinary_connectivity_extraction F hj hlargeR |
| let π : (↑A : Set V) × Fin m → V := fun u => u.1.val |
| have hπ : ∀ u v, F.Adj u v → G.Adj (π u) (π v) ∨ π u = π v := by |
| intro u v h |
| rcases h with h | ⟨h,h'⟩ |
| · exact Or.inl h |
| · exact Or.inr (congrArg Subtype.val h) |
| have htests : ∀ Z ∈ d.separators, (T.filter (fun u => π u ∈ Z)).card < j := by |
| intro Z hZ |
| have hc := lifted_separator_card (Z := Z) T |
| have hcr : ((T.filter (fun u => π u ∈ Z)).card : ℝ) ≤ |
| ((A ∩ Z).card : ℝ)*m := by exact_mod_cast hc |
| have hrr : ((T.filter (fun u => π u ∈ Z)).card : ℝ) < j := by |
| nlinarith [mul_le_mul_of_nonneg_right (hsep Z hZ) (Nat.cast_nonneg m)] |
| exact_mod_cast hrr |
| obtain ⟨L,hL,hTL⟩ := d.confine π hπ hT (fun u _ => hAS u.1.property) htests |
| obtain ⟨hom⟩ := cliqueBlowup_leaf_hom (G := G) T hTL |
| have hcolor := (cliqueBlowup (G.induce (↑(A ∩ L) : Set V)) m).colorable_chromaticNumber_of_fintype.of_hom hom |
| have hχup := (ordinary_chromatic_le_iff (F.induce (↑T : Set _)) _).mpr hcolor |
| have hχupR : ((F.induce (↑T : Set _)).chromaticNumber.toNat : ℝ) ≤ |
| ((cliqueBlowup (G.induce (↑(A ∩ L) : Set V)) m).chromaticNumber.toNat : ℝ) := by |
| exact_mod_cast hχup |
| have hu := cliqueBlowup_chromatic_upper (G.induce (↑(A ∩ L) : Set V)) m |
| have hcost := card_finset_subtype_le (A ∩ L) |
| have hcostR : (Fintype.card (Finset (↑(A ∩ L) : Set V)) : ℝ) ≤ |
| Fintype.card (Finset V) := by exact_mod_cast hcost |
| have hχR : (F.chromaticNumber.toNat : ℝ)-6*j ≤ |
| ((F.induce (↑T : Set _)).chromaticNumber.toNat : ℝ) := by |
| have he : (F.chromaticNumber.toNat-6*j : ℕ) + 6*j = F.chromaticNumber.toNat := |
| Nat.sub_add_cancel hlargeR.le |
| have heR : ((F.chromaticNumber.toNat-6*j : ℕ) : ℝ) + 6*j = F.chromaticNumber.toNat := by |
| exact_mod_cast he |
| have hh : ((F.chromaticNumber.toNat-6*j : ℕ) : ℝ) ≤ |
| ((F.induce (↑T : Set _)).chromaticNumber.toNat : ℝ) := by exact_mod_cast hχ |
| linarith |
| have hla := mul_le_mul_of_nonneg_left (hleaf L hL) (Nat.cast_nonneg m) |
| dsimp [F] at hχR hχupR |
| have hh : (m : ℝ)*number (G.induce (↑A : Set V)) ≤ |
| (m : ℝ)*a + Fintype.card (Finset V) + 6*j := by |
| linarith only [hlower,hχR,hχupR,hu,hcostR,hla] |
| nlinarith only [hh,hmbig,hjup] |
|
|
| end LinearListHadwiger.FixedDecomposition |
|
|
| end OAI |
|
|
