| import OAI.Combinatorics.ListHadwiger.BagContraction |
|
|
| namespace OAI |
|
|
| namespace LinearListHadwiger |
| open SimpleGraph PathPacking |
| open scoped Classical |
|
|
| namespace BagRouting |
| variable {V I J : Type} {G : SimpleGraph V} {s : I → V} {B : J → Set V} |
|
|
| def used (D : BagRouting G s B) : Set V := |
| {v | ∃ i, v ∈ (D.paths i).2.val.support} |
|
|
| def Minimal [Fintype I] (D : BagRouting G s B) : Prop := |
| ∀ E : BagRouting G s B, D.totalLength ≤ E.totalLength |
|
|
| lemma exists_minimal [Fintype I] (h : Nonempty (BagRouting G s B)) : |
| ∃ D : BagRouting G s B, D.Minimal := by |
| classical |
| have hex : ∃ n : ℕ, ∃ D : BagRouting G s B, D.totalLength = n := by |
| obtain ⟨D⟩ := h |
| exact ⟨D.totalLength, D, rfl⟩ |
| obtain ⟨D, hd⟩ := Nat.find_spec hex |
| refine ⟨D, fun E => ?_⟩ |
| rw [hd] |
| exact Nat.find_min' hex ⟨E, rfl⟩ |
|
|
| noncomputable def replace [DecidableEq I] (D : BagRouting G s B) (i : I) |
| (p : G.Path (s i) (D.paths i).1) |
| (hp : ∀ j, i ≠ j → ∀ v ∈ p.val.support, |
| v ∈ (D.paths j).2.val.support → v = s i ∧ v = s j) : BagRouting G s B := by |
| let paths : ∀ a, Σ w, G.Path (s a) w := |
| fun a => if h : a = i then h.symm ▸ (⟨(D.paths i).1, p⟩ : Σ w, G.Path (s i) w) else D.paths a |
| refine ⟨paths, D.bag, D.bag_injective, ?_, ?_⟩ |
| · intro a |
| by_cases ha : a = i |
| · subst a |
| have he : paths i = ⟨(D.paths i).1, p⟩ := dite_eq_left rfl |
| rw [he] |
| exact D.endpoint_mem i |
| · have he : paths a = D.paths a := dite_eq_right ha |
| rw [he] |
| exact D.endpoint_mem a |
| · intro a b hab v hva hvb |
| by_cases ha : a = i |
| · subst a |
| have he : paths i = ⟨(D.paths i).1, p⟩ := dite_eq_left rfl |
| have he' : paths b = D.paths b := dite_eq_right (Ne.symm hab) |
| rw [he] at hva |
| rw [he'] at hvb |
| exact hp b hab v hva hvb |
| · have he : paths a = D.paths a := dite_eq_right ha |
| rw [he] at hva |
| by_cases hb : b = i |
| · subst b |
| have he' : paths i = ⟨(D.paths i).1, p⟩ := dite_eq_left rfl |
| rw [he'] at hvb |
| exact (hp a (Ne.symm ha) v hvb hva).symm |
| · have he' : paths b = D.paths b := dite_eq_right hb |
| rw [he'] at hvb |
| exact D.overlap a b hab v hva hvb |
|
|
| lemma replace_shorter [Fintype I] [DecidableEq I] (D : BagRouting G s B) (i : I) |
| (p : G.Path (s i) (D.paths i).1) |
| (hp : ∀ j, i ≠ j → ∀ v ∈ p.val.support, |
| v ∈ (D.paths j).2.val.support → v = s i ∧ v = s j) |
| (hlt : p.val.length < (D.paths i).2.val.length) : |
| (D.replace i p hp).totalLength < D.totalLength := by |
| have hi : (D.replace i p hp).paths i = ⟨(D.paths i).1, p⟩ := dite_eq_left rfl |
| have ha : ∀ a, a ≠ i → (D.replace i p hp).paths a = D.paths a := fun a h => dite_eq_right h |
| apply Finset.sum_lt_sum |
| · intro a _ |
| by_cases h : a = i |
| · subst a |
| rw [hi] |
| exact hlt.le |
| · rw [ha a h] |
| · refine ⟨i, Finset.mem_univ _, ?_⟩ |
| rw [hi] |
| exact hlt |
|
|
| lemma Minimal.walk_length_le [Fintype I] [DecidableEq V] [DecidableEq I] |
| {D : BagRouting G s B} (hD : D.Minimal) (i : I) |
| (p : G.Walk (s i) (D.paths i).1) |
| (hp : ∀ j, i ≠ j → ∀ v ∈ p.support, |
| v ∈ (D.paths j).2.val.support → v = s i ∧ v = s j) : |
| (D.paths i).2.val.length ≤ p.length := by |
| have hp' : ∀ j, i ≠ j → ∀ v ∈ p.toPath.val.support, |
| v ∈ (D.paths j).2.val.support → v = s i ∧ v = s j := by |
| intro j hij v hv hvj |
| exact hp j hij v (p.support_toPath_subset_support hv) hvj |
| have hle : (D.paths i).2.val.length ≤ p.toPath.val.length := by |
| by_contra hn |
| exact (not_lt_of_ge (hD (D.replace i p.toPath hp'))) |
| (D.replace_shorter i p.toPath hp' (Nat.lt_of_not_ge hn)) |
| exact hle.trans p.length_bypass_le_length |
|
|
| lemma Minimal.no_long_shortcut [Fintype I] [DecidableEq V] [DecidableEq I] |
| {D : BagRouting G s B} (hD : D.Minimal) (i : I) (v : V) (hv : v ∉ D.used) |
| (a b : ℕ) (ha : a ≤ (D.paths i).2.val.length) (hb : b ≤ (D.paths i).2.val.length) |
| (hva : G.Adj ((D.paths i).2.val.getVert a) v) |
| (hvb : G.Adj v ((D.paths i).2.val.getVert b)) : b ≤ a + 2 := by |
| let p := (D.paths i).2.val |
| let q : G.Walk (s i) (D.paths i).1 := ((p.take a).concat hva).append (Walk.cons hvb (p.drop b)) |
| change a ≤ p.length at ha |
| change b ≤ p.length at hb |
| have hq := hD.walk_length_le i q (by |
| intro j hij w hw hwj |
| have hw' : w ∈ p.support ∨ w = v := by |
| simp only [q, Walk.mem_support_append_iff, Walk.support_concat, Walk.support_cons, |
| List.mem_append, List.mem_cons, List.not_mem_nil, or_false] at hw |
| rcases hw with (hw | hw) | (hw | hw) |
| · left |
| rw [Walk.support_take] at hw |
| exact List.mem_of_mem_take hw |
| · exact Or.inr hw |
| · exact Or.inr hw |
| · left |
| rw [Walk.drop_support_eq_support_drop_min] at hw |
| exact List.mem_of_mem_drop hw |
| rcases hw' with hw | rfl |
| · exact D.overlap i j hij w hw hwj |
| · exact (hv ⟨j, hwj⟩).elim) |
| have hlen : q.length = a + 2 + (p.length - b) := by |
| simp [q, Walk.take_length, Nat.min_eq_left ha, Walk.drop_length] |
| omega |
| change p.length ≤ q.length at hq |
| rw [hlen] at hq |
| omega |
|
|
| lemma Minimal.path_neighbors_le_three [Fintype I] [DecidableEq V] [DecidableEq I] |
| [DecidableRel G.Adj] |
| {D : BagRouting G s B} (hD : D.Minimal) (i : I) (v : V) (hv : v ∉ D.used) : |
| ((D.paths i).2.val.support.toFinset.filter fun w => G.Adj v w).card ≤ 3 := by |
| classical |
| let p := (D.paths i).2.val |
| let R := (Finset.range (p.length + 1)).filter fun a => G.Adj v (p.getVert a) |
| have hR : R.card ≤ 3 := by |
| obtain he | hn := R.eq_empty_or_nonempty |
| · simp [he] |
| let a := R.min' hn |
| have haR : a ∈ R := R.min'_mem hn |
| have ha : a ≤ p.length := by |
| have hh := (Finset.mem_filter.mp haR).1 |
| simp only [Finset.mem_range] at hh |
| omega |
| have hsub : R ⊆ Finset.Icc a (a + 2) := by |
| intro b hbR |
| have hb : b ≤ p.length := by |
| have hh := (Finset.mem_filter.mp hbR).1 |
| simp only [Finset.mem_range] at hh |
| omega |
| have hab := hD.no_long_shortcut i v hv a b ha hb |
| (Finset.mem_filter.mp haR).2.symm (Finset.mem_filter.mp hbR).2 |
| exact Finset.mem_Icc.mpr ⟨R.min'_le b hbR, hab⟩ |
| exact (Finset.card_le_card hsub).trans (by simp; omega) |
| have hsub : (p.support.toFinset.filter fun w => G.Adj v w) ⊆ R.image p.getVert := by |
| intro w hw |
| obtain ⟨hwp, hvw⟩ := Finset.mem_filter.mp hw |
| obtain ⟨a, ha, hlen⟩ := Walk.mem_support_iff_exists_getVert.mp (List.mem_toFinset.mp hwp) |
| refine Finset.mem_image.mpr ⟨a, Finset.mem_filter.mpr ⟨?_, ?_⟩, ha⟩ |
| · exact Finset.mem_range.mpr (by omega) |
| · rwa [ha] |
| exact (Finset.card_le_card hsub).trans ((Finset.card_image_le).trans hR) |
|
|
| noncomputable def usedFinset [Fintype I] [DecidableEq V] (D : BagRouting G s B) : Finset V := |
| Finset.univ.biUnion fun i => (D.paths i).2.val.support.toFinset |
|
|
| lemma mem_usedFinset [Fintype I] [DecidableEq V] (D : BagRouting G s B) (v : V) : |
| v ∈ D.usedFinset ↔ v ∈ D.used := by |
| simp [usedFinset, used] |
|
|
| lemma Minimal.used_neighbors_le [Fintype I] [DecidableEq V] [DecidableEq I] |
| [DecidableRel G.Adj] |
| {D : BagRouting G s B} (hD : D.Minimal) (v : V) (hv : v ∉ D.used) : |
| (D.usedFinset.filter fun w => G.Adj v w).card ≤ 3 * Fintype.card I := by |
| classical |
| have he : D.usedFinset.filter (fun w => G.Adj v w) = |
| Finset.univ.biUnion (fun i => (D.paths i).2.val.support.toFinset.filter fun w => G.Adj v w) := by |
| ext w |
| simp only [Finset.mem_filter, usedFinset, Finset.mem_biUnion, Finset.mem_univ, true_and] |
| constructor |
| · rintro ⟨⟨i, hi⟩, hw⟩ |
| exact ⟨i, hi, hw⟩ |
| · rintro ⟨i, hi, hw⟩ |
| exact ⟨⟨i, hi⟩, hw⟩ |
| rw [he] |
| calc |
| _ ≤ ∑ i : I, ((D.paths i).2.val.support.toFinset.filter fun w => G.Adj v w).card := Finset.card_biUnion_le |
| _ ≤ ∑ _i : I, 3 := Finset.sum_le_sum (fun i _ => hD.path_neighbors_le_three i v hv) |
| _ = 3 * Fintype.card I := by simp [Nat.mul_comm] |
|
|
| lemma mem_take_indices {u w : V} (p : G.Walk u w) (a : ℕ) {v : V} |
| (hv : v ∈ (p.take a).support) : |
| ∃ n, n ≤ a ∧ n ≤ p.length ∧ p.getVert n = v := by |
| obtain ⟨n, hn, hlen⟩ := Walk.mem_support_iff_exists_getVert.mp hv |
| rw [Walk.take_length] at hlen |
| have hna := (Nat.le_min.mp hlen).1 |
| have hnl := (Nat.le_min.mp hlen).2 |
| rw [Walk.take_getVert, Nat.min_eq_right hna] at hn |
| exact ⟨n, hna, hnl, hn⟩ |
|
|
| lemma mem_drop_indices {u w : V} (p : G.Walk u w) (b : ℕ) (hb : b ≤ p.length) |
| {v : V} (hv : v ∈ (p.drop b).support) : |
| ∃ n, b ≤ n ∧ n ≤ p.length ∧ p.getVert n = v := by |
| obtain ⟨n, hn, hlen⟩ := Walk.mem_support_iff_exists_getVert.mp hv |
| rw [Walk.drop_length] at hlen |
| rw [Walk.drop_getVert] at hn |
| exact ⟨b + n, by omega, by omega, hn⟩ |
|
|
| lemma take_drop_disjoint {u w : V} (p : G.Path u w) (a b : ℕ) |
| (hab : a < b) (hb : b ≤ p.val.length) : |
| Disjoint {v | v ∈ (p.val.take a).support} {v | v ∈ (p.val.drop b).support} := by |
| rw [Set.disjoint_left] |
| intro v hv ht |
| obtain ⟨c, hca, hcl, hc⟩ := mem_take_indices p.val a hv |
| obtain ⟨d, hbd, hdl, hd⟩ := mem_drop_indices p.val b hb ht |
| have he := p.property.getVert_injOn hcl hdl (hc.trans hd.symm) |
| omega |
|
|
| lemma source_not_mem_drop {u w : V} (p : G.Path u w) (b : ℕ) |
| (hpos : 0 < b) (hb : b ≤ p.val.length) : u ∉ (p.val.drop b).support := by |
| intro hu |
| obtain ⟨n, hbn, hnl, hn⟩ := mem_drop_indices p.val b hb hu |
| have h0 : p.val.getVert 0 = u := p.val.getVert_zero |
| have he := p.property.getVert_injOn (show 0 ≤ p.val.length by omega) hnl (h0.trans hn.symm) |
| omega |
|
|
| structure Exchange (D : BagRouting G s B) where |
| active : Finset I |
| e : Equiv.Perm I |
| fixed : ∀ i, i ∉ active → e i = i |
| stable : ∀ i, i ∈ active ↔ e i ∈ active |
| a : I → ℕ |
| b : I → ℕ |
| bounds : ∀ i ∈ active, a i + 2 ≤ b i ∧ b i ≤ (D.paths i).2.val.length |
| edge : ∀ i ∈ active, |
| G.Adj ((D.paths i).2.val.getVert (a i)) ((D.paths (e i)).2.val.getVert (b (e i))) |
|
|
| namespace Exchange |
| variable [DecidableEq V] [DecidableEq I] {D : BagRouting G s B} |
|
|
| noncomputable def front (E : D.Exchange) (i : I) : Set V := |
| if i ∈ E.active then {v | v ∈ ((D.paths i).2.val.take (E.a i)).support} |
| else {v | v ∈ (D.paths i).2.val.support} |
|
|
| noncomputable def tail (E : D.Exchange) (i : I) : Set V := |
| if i ∈ E.active then {v | v ∈ ((D.paths i).2.val.drop (E.b i)).support} else ∅ |
|
|
| lemma front_subset {V I J : Type} {G : SimpleGraph V} {s : I → V} {B : J → Set V} |
| [DecidableEq V] [DecidableEq I] {D : BagRouting G s B} |
| (E : D.Exchange) (i : I) : E.front i ⊆ {v | v ∈ (D.paths i).2.val.support} := by |
| intro v hv |
| by_cases hi : i ∈ E.active |
| · rw [front, ite_eq_left hi] at hv |
| rw [Walk.support_take] at hv |
| exact List.mem_of_mem_take hv |
| · simpa [front, hi] using hv |
|
|
| lemma tail_subset {V I J : Type} {G : SimpleGraph V} {s : I → V} {B : J → Set V} |
| [DecidableEq V] [DecidableEq I] {D : BagRouting G s B} |
| (E : D.Exchange) (i : I) : E.tail i ⊆ {v | v ∈ (D.paths i).2.val.support} := by |
| intro v hv |
| by_cases hi : i ∈ E.active |
| · rw [tail, ite_eq_left hi] at hv |
| rw [Walk.drop_support_eq_support_drop_min] at hv |
| exact List.mem_of_mem_drop hv |
| · simp [tail, hi] at hv |
|
|
| lemma not_source_tail {V I J : Type} {G : SimpleGraph V} {s : I → V} {B : J → Set V} |
| [DecidableEq V] [DecidableEq I] {D : BagRouting G s B} |
| (E : D.Exchange) (i : I) : s i ∉ E.tail i := by |
| by_cases hi : i ∈ E.active |
| · rw [tail, ite_eq_left hi] |
| exact source_not_mem_drop _ _ (by have := (E.bounds i hi).1; omega) (E.bounds i hi).2 |
| · simp [tail, hi] |
|
|
| lemma front_tail_disjoint {V I J : Type} {G : SimpleGraph V} {s : I → V} {B : J → Set V} |
| [DecidableEq V] [DecidableEq I] {D : BagRouting G s B} |
| (E : D.Exchange) (i : I) : Disjoint (E.front i) (E.tail i) := by |
| by_cases hi : i ∈ E.active |
| · rw [front, tail, ite_eq_left hi, ite_eq_left hi] |
| exact take_drop_disjoint _ _ _ (by have := (E.bounds i hi).1; omega) (E.bounds i hi).2 |
| · simp [tail, hi] |
|
|
| noncomputable def walk (E : D.Exchange) (i : I) (hi : i ∈ E.active) : |
| G.Walk (s i) (D.paths (E.e i)).1 := |
| (((D.paths i).2.val.take (E.a i)).concat (E.edge i hi)).append |
| ((D.paths (E.e i)).2.val.drop (E.b (E.e i))) |
|
|
| lemma walk_support {V I J : Type} {G : SimpleGraph V} {s : I → V} {B : J → Set V} |
| [DecidableEq V] [DecidableEq I] {D : BagRouting G s B} |
| (E : D.Exchange) (i : I) (hi : i ∈ E.active) {v : V} |
| (hv : v ∈ (E.walk i hi).support) : v ∈ E.front i ∪ E.tail (E.e i) := by |
| have hei := (E.stable i).mp hi |
| rw [front, tail, ite_eq_left hi, ite_eq_left hei] |
| simp only [walk, Walk.mem_support_append_iff, Walk.support_concat, List.mem_append, |
| List.mem_cons, List.not_mem_nil, or_false] at hv |
| rcases hv with (hv | hv) | hv |
| · exact Or.inl hv |
| · subst v |
| exact Or.inr (Walk.start_mem_support _) |
| · exact Or.inr hv |
|
|
| lemma support_overlap (E : D.Exchange) (i j : I) (hij : i ≠ j) (v : V) |
| (hi : v ∈ E.front i ∪ E.tail (E.e i)) |
| (hj : v ∈ E.front j ∪ E.tail (E.e j)) : v = s i ∧ v = s j := by |
| rcases hi with hi | hi <;> rcases hj with hj | hj |
| · exact D.overlap i j hij v (E.front_subset i hi) (E.front_subset j hj) |
| · by_cases he : i = E.e j |
| · subst i |
| exact (Set.disjoint_left.mp (E.front_tail_disjoint _) hi hj).elim |
| · have h := D.overlap i (E.e j) he v (E.front_subset i hi) (E.tail_subset _ hj) |
| exact (E.not_source_tail _ (h.2 ▸ hj)).elim |
| · by_cases he : j = E.e i |
| · subst j |
| exact (Set.disjoint_left.mp (E.front_tail_disjoint _) hj hi).elim |
| · have h := D.overlap j (E.e i) he v (E.front_subset j hj) (E.tail_subset _ hi) |
| exact (E.not_source_tail _ (h.2 ▸ hi)).elim |
| · have he : E.e i ≠ E.e j := fun h => hij (E.e.injective h) |
| have h := D.overlap _ _ he v (E.tail_subset _ hi) (E.tail_subset _ hj) |
| exact (E.not_source_tail _ (h.1 ▸ hi)).elim |
|
|
| noncomputable def routing (E : D.Exchange) : BagRouting G s B := by |
| let paths : ∀ i, Σ v, G.Path (s i) v := fun i => |
| if hi : i ∈ E.active then ⟨(D.paths (E.e i)).1, (E.walk i hi).toPath⟩ else D.paths i |
| refine ⟨paths, D.bag ∘ E.e, D.bag_injective.comp E.e.injective, ?_, ?_⟩ |
| · intro i |
| by_cases hi : i ∈ E.active |
| · have he : paths i = ⟨(D.paths (E.e i)).1, (E.walk i hi).toPath⟩ := dite_eq_left hi |
| rw [he] |
| exact D.endpoint_mem _ |
| · have he : paths i = D.paths i := dite_eq_right hi |
| rw [he] |
| simpa [E.fixed i hi] using D.endpoint_mem i |
| · intro i j hij v hvi hvj |
| apply E.support_overlap i j hij v |
| · by_cases hi : i ∈ E.active |
| · have he : paths i = ⟨(D.paths (E.e i)).1, (E.walk i hi).toPath⟩ := dite_eq_left hi |
| rw [he] at hvi |
| exact E.walk_support i hi ((E.walk i hi).support_toPath_subset_support hvi) |
| · have he : paths i = D.paths i := dite_eq_right hi |
| rw [he] at hvi |
| exact Or.inl (by simpa [front, hi] using hvi) |
| · by_cases hj : j ∈ E.active |
| · have he : paths j = ⟨(D.paths (E.e j)).1, (E.walk j hj).toPath⟩ := dite_eq_left hj |
| rw [he] at hvj |
| exact E.walk_support j hj ((E.walk j hj).support_toPath_subset_support hvj) |
| · have he : paths j = D.paths j := dite_eq_right hj |
| rw [he] at hvj |
| exact Or.inl (by simpa [front, hj] using hvj) |
|
|
| lemma length_inequality (E : D.Exchange) (i : I) : |
| (E.routing.paths i).2.val.length + (if E.e i ∈ E.active then E.b (E.e i) else 0) ≤ |
| (D.paths (E.e i)).2.val.length + (if i ∈ E.active then E.a i + 1 else 0) := by |
| by_cases hi : i ∈ E.active |
| · have he : E.routing.paths i = ⟨(D.paths (E.e i)).1, (E.walk i hi).toPath⟩ := dite_eq_left hi |
| rw [he, ite_eq_left hi, ite_eq_left ((E.stable i).mp hi)] |
| have hlen : (E.walk i hi).toPath.val.length ≤ (E.walk i hi).length := |
| (E.walk i hi).length_bypass_le_length |
| have ha := (E.bounds i hi).1 |
| have hb := E.bounds (E.e i) ((E.stable i).mp hi) |
| have hia := E.bounds i hi |
| have hleni : E.a i ≤ (D.paths i).2.val.length := by omega |
| have hwlen : (E.walk i hi).length = E.a i + 1 + |
| ((D.paths (E.e i)).2.val.length - E.b (E.e i)) := by |
| simp only [walk, Walk.length_append, Walk.length_concat, Walk.take_length, |
| Nat.min_eq_left hleni, Walk.drop_length] |
| rw [hwlen] at hlen |
| change (E.walk i hi).toPath.val.length + E.b (E.e i) ≤ _ |
| omega |
| · have he : E.routing.paths i = D.paths i := dite_eq_right hi |
| rw [he, E.fixed i hi] |
| simp only [ite_eq_right hi, le_refl] |
|
|
| lemma shorter [Fintype I] (E : D.Exchange) (hE : E.active.Nonempty) : |
| E.routing.totalLength < D.totalLength := by |
| let a : I → ℕ := fun i => if i ∈ E.active then E.a i + 1 else 0 |
| let b : I → ℕ := fun i => if i ∈ E.active then E.b i else 0 |
| have hlt : (∑ i, a i) < ∑ i, b i := by |
| apply Finset.sum_lt_sum |
| · intro i _ |
| by_cases hi : i ∈ E.active |
| · have := (E.bounds i hi).1 |
| simp only [a, b, ite_eq_left hi] |
| omega |
| · simp [a, b, hi] |
| · obtain ⟨i, hi⟩ := hE |
| refine ⟨i, Finset.mem_univ _, ?_⟩ |
| have := (E.bounds i hi).1 |
| simp only [a, b, ite_eq_left hi] |
| omega |
| have hs := Finset.sum_le_sum (s := Finset.univ) (fun i _ => E.length_inequality i) |
| change (∑ i, ((E.routing.paths i).2.val.length + b (E.e i))) ≤ |
| ∑ i, ((D.paths (E.e i)).2.val.length + a i) at hs |
| rw [Finset.sum_add_distrib, Finset.sum_add_distrib, Equiv.sum_comp E.e b, |
| Equiv.sum_comp E.e (fun i => (D.paths i).2.val.length)] at hs |
| change E.routing.totalLength + (∑ i, b i) ≤ D.totalLength + (∑ i, a i) at hs |
| omega |
|
|
| end Exchange |
|
|
| lemma Minimal.no_exchange [Fintype I] [DecidableEq V] [DecidableEq I] |
| {D : BagRouting G s B} (hD : D.Minimal) (E : D.Exchange) : ¬ E.active.Nonempty := by |
| intro hE |
| exact (not_lt_of_ge (hD E.routing)) (E.shorter hE) |
|
|
| lemma cycle_permutation [Fintype I] [DecidableEq I] (Q : Finset I) (hQ : Q.Nonempty) |
| (f : I → I) (hf : ∀ i ∈ Q, f i ∈ Q) : |
| ∃ T : Finset I, T ⊆ Q ∧ T.Nonempty ∧ ∃ e : Equiv.Perm I, |
| (∀ i, i ∉ T → e i = i) ∧ (∀ i, i ∈ T ↔ e i ∈ T) ∧ |
| (∀ i ∈ T, e i = f i) := by |
| classical |
| let C := Q.powerset.filter fun T => T.Nonempty ∧ ∀ i ∈ T, f i ∈ T |
| have hQC : Q ∈ C := Finset.mem_filter.mpr ⟨Finset.mem_powerset.mpr (by rfl), hQ, hf⟩ |
| obtain ⟨T, hTC, hmin⟩ := C.exists_min_image Finset.card ⟨Q, hQC⟩ |
| obtain ⟨hTQ, hn, hclosed⟩ := Finset.mem_filter.mp hTC |
| have hsub : T.image f ⊆ T := by |
| intro i hi |
| obtain ⟨j, hj, rfl⟩ := Finset.mem_image.mp hi |
| exact hclosed j hj |
| have hIC : T.image f ∈ C := by |
| refine Finset.mem_filter.mpr ⟨Finset.mem_powerset.mpr (hsub.trans (Finset.mem_powerset.mp hTQ)), |
| hn.image f, ?_⟩ |
| intro i hi |
| exact Finset.mem_image.mpr ⟨i, hsub hi, rfl⟩ |
| have heq : T.image f = T := Finset.eq_of_subset_of_card_le hsub (hmin _ hIC) |
| let g : ↥T → ↥T := fun i => ⟨f i, hclosed i i.property⟩ |
| have hsurj : Function.Surjective g := by |
| intro i |
| have hi : i.val ∈ T.image f := heq.symm ▸ i.property |
| obtain ⟨j, hj, he⟩ := Finset.mem_image.mp hi |
| exact ⟨⟨j, hj⟩, Subtype.ext he⟩ |
| let e0 : Equiv.Perm ↥T := Equiv.ofBijective g (Finite.surjective_iff_bijective.mp hsurj) |
| let e := Equiv.Perm.ofSubtype e0 |
| refine ⟨T, Finset.mem_powerset.mp hTQ, hn, e, ?_, ?_, ?_⟩ |
| · intro i hi |
| exact Equiv.Perm.ofSubtype_apply_of_not_mem e0 hi |
| · intro i |
| exact (Equiv.Perm.ofSubtype_apply_mem_iff_mem e0 i).symm |
| · intro i hi |
| exact Equiv.Perm.ofSubtype_apply_of_mem e0 hi |
|
|
| lemma Minimal.low_degree [Fintype I] [DecidableEq V] [DecidableEq I] |
| [DecidableRel G.Adj] {D : BagRouting G s B} (hD : D.Minimal) |
| (S : Finset V) (hS : S ⊆ D.usedFinset) (hne : S.Nonempty) : |
| ∃ v ∈ S, (S.filter (G.Adj v)).card ≤ 2 * Fintype.card I := by |
| classical |
| by_contra hno |
| have hdeg : ∀ v ∈ S, 2 * Fintype.card I < (S.filter (G.Adj v)).card := by |
| intro v hv |
| exact Nat.lt_of_not_ge (fun hh => hno ⟨v, hv, hh⟩) |
| let R : I → Finset ℕ := fun i => (Finset.range ((D.paths i).2.val.length + 1)).filter |
| fun a => (D.paths i).2.val.getVert a ∈ S |
| let Q : Finset I := Finset.univ.filter fun i => (R i).Nonempty |
| let a : I → ℕ := fun i => if hi : (R i).Nonempty then (R i).min' hi else 0 |
| have hQiff : ∀ i, i ∈ Q ↔ (R i).Nonempty := by simp [Q] |
| have hamin : ∀ i ∈ Q, a i ∈ R i := by |
| intro i hi |
| have hn := (hQiff i).mp hi |
| dsimp [a] |
| rw [dite_eq_left hn] |
| exact Finset.min'_mem _ _ |
| have haS : ∀ i ∈ Q, (D.paths i).2.val.getVert (a i) ∈ S := by |
| intro i hi |
| exact (Finset.mem_filter.mp (hamin i hi)).2 |
| have hfind : ∀ v ∈ S, ∃ i ∈ Q, ∃ b, b ∈ R i ∧ (D.paths i).2.val.getVert b = v := by |
| intro v hv |
| obtain ⟨i, hi⟩ := (D.mem_usedFinset v).mp (hS hv) |
| obtain ⟨b, hb, hblen⟩ := Walk.mem_support_iff_exists_getVert.mp hi |
| have hbR : b ∈ R i := Finset.mem_filter.mpr ⟨Finset.mem_range.mpr (by omega), hb ▸ hv⟩ |
| exact ⟨i, (hQiff i).mpr ⟨b, hbR⟩, b, hbR, hb⟩ |
| have hQ : Q.Nonempty := by |
| obtain ⟨v, hv⟩ := hne |
| obtain ⟨i, hi, _⟩ := hfind v hv |
| exact ⟨i, hi⟩ |
| let M := Finset.univ.biUnion fun i : I => |
| {(D.paths i).2.val.getVert (a i), (D.paths i).2.val.getVert (a i + 1)} |
| have hM : M.card ≤ 2 * Fintype.card I := by |
| calc |
| _ ≤ ∑ i : I, ({(D.paths i).2.val.getVert (a i), |
| (D.paths i).2.val.getVert (a i + 1)} : Finset V).card := Finset.card_biUnion_le |
| _ ≤ ∑ i : I, 2 := Finset.sum_le_sum fun _ _ => Finset.card_le_two |
| _ = _ := by simp [Nat.mul_comm] |
| have hm0 : ∀ i, (D.paths i).2.val.getVert (a i) ∈ M := by |
| intro i |
| exact Finset.mem_biUnion.mpr ⟨i, Finset.mem_univ _, by simp⟩ |
| have hm1 : ∀ i, (D.paths i).2.val.getVert (a i + 1) ∈ M := by |
| intro i |
| exact Finset.mem_biUnion.mpr ⟨i, Finset.mem_univ _, by simp⟩ |
| have hout : ∀ i, ∃ j b, i ∈ Q → j ∈ Q ∧ a j + 2 ≤ b ∧ |
| b ≤ (D.paths j).2.val.length ∧ |
| G.Adj ((D.paths i).2.val.getVert (a i)) ((D.paths j).2.val.getVert b) := by |
| intro i |
| by_cases hi : i ∈ Q |
| · have hlarge := hdeg _ (haS i hi) |
| have hex : ∃ v ∈ S.filter (G.Adj ((D.paths i).2.val.getVert (a i))), v ∉ M := by |
| by_contra hh |
| have hsub : S.filter (G.Adj ((D.paths i).2.val.getVert (a i))) ⊆ M := by |
| intro v hv |
| by_contra hvm |
| exact hh ⟨v, hv, hvm⟩ |
| have hle := (Finset.card_le_card hsub).trans hM |
| omega |
| obtain ⟨v, hv, hvm⟩ := hex |
| obtain ⟨hvS, hvadj⟩ := Finset.mem_filter.mp hv |
| obtain ⟨j, hj, b, hbR, hb⟩ := hfind v hvS |
| have hbj : a j ≤ b := by |
| have hn := (hQiff j).mp hj |
| dsimp [a] |
| rw [dite_eq_left hn] |
| exact Finset.min'_le _ _ hbR |
| have hb0 : b ≠ a j := by |
| intro he |
| apply hvm |
| rw [he] at hb |
| exact hb ▸ hm0 j |
| have hb1 : b ≠ a j + 1 := by |
| intro he |
| apply hvm |
| rw [he] at hb |
| exact hb ▸ hm1 j |
| have hblen : b ≤ (D.paths j).2.val.length := by |
| have hh := (Finset.mem_filter.mp hbR).1 |
| simp only [Finset.mem_range] at hh |
| omega |
| refine ⟨j, b, fun _ => ⟨hj, by omega, hblen, ?_⟩⟩ |
| rwa [hb] |
| · exact ⟨i, 0, fun hh => (hi hh).elim⟩ |
| choose f c hfc using hout |
| obtain ⟨T, hTQ, hT, e, hfix, hstable, heq⟩ := |
| cycle_permutation Q hQ f (fun i hi => (hfc i hi).1) |
| let E : D.Exchange := { |
| active := T |
| e := e |
| fixed := hfix |
| stable := hstable |
| a := a |
| b := fun i => c (e.symm i) |
| bounds := by |
| intro i hi |
| have hpre : e.symm i ∈ T := (hstable _).mpr (by simpa using hi) |
| have he : f (e.symm i) = i := (heq _ hpre).symm.trans (e.apply_symm_apply i) |
| have hc := (hfc _ (hTQ hpre)).2 |
| rw [he] at hc |
| exact ⟨hc.1, hc.2.1⟩ |
| edge := by |
| intro i hi |
| have hc := (hfc i (hTQ hi)).2.2.2 |
| rw [← heq i hi] at hc |
| simpa only [Equiv.symm_apply_apply] using hc |
| } |
| exact hD.no_exchange E hT |
|
|
| end BagRouting |
|
|
| end LinearListHadwiger |
|
|
| end OAI |
|
|
