| import OAI.Computability.Superstring.Distribution |
|
|
| namespace OAI |
|
|
| namespace Superstring.Hierarchical.LayerCollection |
|
|
| variable {α G : Type} {V : Set (List α)} (C : LayerCollection V G) |
|
|
| /-- Complete one touched base layer and splice it into the rooted walk. |
| Only this layer's base turn and its one geometric connection are charged. -/ |
| theorem attach_layer (closed : SubstringClosed V) (g : G) (i : Fin (C.size g)) |
| (P : Path V [] []) (F : Loop V) (hcF : F.cost ≤ C.period g) |
| (ht : (C.layer g i).TouchedBy F.path) (hmeet : (Loop.mk [] P).Meets F) : |
| ∃ Q : Path V [] [], Q.cost ≤ P.cost + 2 * C.period g ∧ |
| (∀ w, P.Visits w → Q.Visits w) ∧ |
| ∀ w ∈ (C.layer g i).Content, Q.Visits w := by |
| obtain ⟨T, _, hcT, hvT, hlT⟩ := fill_same_layers closed (C.layer g) (C.positive g) |
| (C.periodic g) {i} F (by simpa using ht) |
| obtain ⟨w, hp, hf⟩ := hmeet |
| obtain ⟨Q, hcQ, hvQ⟩ := P.splice T.path w hp (hvT w hf) |
| refine ⟨Q, ?_, fun v hv => (hvQ v).mpr (Or.inl hv), fun v hv => ?_⟩ |
| · simp only [Finset.card_singleton, one_mul] at hcT |
| change Q.cost = P.cost + T.cost at hcQ |
| omega |
| · exact (hvQ v).mpr (Or.inr (hlT i (Finset.mem_singleton_self i) v hv)) |
|
|
| /-- Root each as-yet-unspent layer below the chosen recipient baseline. The |
| baseline itself is already fully retained by the incoming-request operation. -/ |
| theorem root_below (closed : SubstringClosed V) (g : G) (base : Fin (C.size g)) |
| (P : Path V [] []) (hp : ∀ w ∈ (C.layer g base).Content, P.Visits w) |
| (a b : ℤ) (hbf : (C.layer g base).first a ≤ b) |
| (hbl : b ≤ (C.layer g base).last a) (hlen : b - a < 2 * C.period g) |
| (I : Finset (Fin (C.size g))) (hbelow : ∀ i ∈ I, i ≤ base) : |
| ∃ Q : Path V [] [], Q.cost ≤ P.cost + 2 * (I.card * C.period g) ∧ |
| (∀ w, P.Visits w → Q.Visits w) ∧ |
| ∀ i ∈ I, ∀ w ∈ (C.layer g i).Content, Q.Visits w := by |
| classical |
| induction I using Finset.induction_on with |
| | empty => exact ⟨P, by simp, fun _ h => h, by simp⟩ |
| | @insert i I hi ih => |
| obtain ⟨Q, hcQ, hvQ, hlQ⟩ := ih (fun j hj => hbelow j (Finset.mem_insert_of_mem hj)) |
| have hqbase : Q.Visits (textWord (C.text g) a b) := |
| hvQ _ (hp _ ⟨a, b, hbf, hbl, rfl⟩) |
| obtain ⟨F, hcF, htF, hmeet⟩ : ∃ F : Loop V, |
| F.cost ≤ C.period g ∧ (C.layer g i).TouchedBy F.path ∧ (Loop.mk [] Q).Meets F := by |
| rcases (C.layer g i).below_baseline (C.layer g base) closed (C.letters closed g) |
| (C.periodic g) (C.ordered g i base (hbelow i (Finset.mem_insert_self i I))) |
| hbf hbl hlen with ⟨F, hcF, htF⟩ | ⟨F, hcF, htF⟩ |
| · exact ⟨⟨[], F⟩, hcF, htF, [], Path.visits_start Q, Path.visits_start F⟩ |
| · exact ⟨⟨_, F⟩, hcF, htF, _, hqbase, Path.visits_start F⟩ |
| obtain ⟨T, hcT, hvT, hlT⟩ := C.attach_layer closed g i Q F hcF htF hmeet |
| refine ⟨T, ?_, fun w hw => hvT w (hvQ w hw), ?_⟩ |
| · rw [Finset.card_insert_of_notMem hi, Nat.add_mul, Nat.one_mul, Nat.mul_add] |
| omega |
| · intro j hj w hw |
| rcases Finset.mem_insert.mp hj with rfl | hj |
| · exact hlT w hw |
| · exact hvT w (hlQ j hj w hw) |
|
|
| /-- Easy upper round-trip branch, including all upper base turns. -/ |
| theorem root_upper_budget (closed : SubstringClosed V) (g : G) |
| (I : Finset (Fin (C.size g))) (top : Fin (C.size g)) |
| (hupper : ∀ i ∈ I, i ≤ top) (t : ℤ) |
| (hcost : (C.layer g top).first t - t ≤ (I.card * C.period g : ℕ)) : |
| ∃ Q : Path V [] [], Q.cost ≤ 2 * (I.card * C.period g) ∧ |
| ∀ i ∈ I, ∀ w ∈ (C.layer g i).Content, Q.Visits w := by |
| let L := fun i : Fin (C.size g) => C.layer g i |
| have hall : ∀ j : {i // i ∈ insert top I}, ∀ x, (L j.val).z x ≤ (L top).z x := by |
| intro j x |
| rcases Finset.mem_insert.mp j.property with he | hj |
| · rw [he] |
| · exact C.ordered g j.val top (hupper j.val hj) x |
| obtain ⟨P, hcP, htP⟩ := root_upper closed (fun j : {i // i ∈ insert top I} => L j.val) |
| ⟨top, Finset.mem_insert_self top I⟩ hall t |
| obtain ⟨Q, hbQ, hcQ, _, hvQ⟩ := fill_same_layers closed (C.layer g) (C.positive g) |
| (C.periodic g) I ⟨[], P⟩ (fun i hi => htP ⟨i, Finset.mem_insert_of_mem hi⟩) |
| refine ⟨Q.path.copy hbQ hbQ, ?_, fun i hi w hw => (Path.visits_copy ..).mpr (hvQ i hi w hw)⟩ |
| simp only [Path.cost_copy] |
| change Q.cost ≤ _ |
| change Q.cost ≤ P.cost + I.card * C.period g at hcQ |
| simp only [length_textWord] at hcP |
| have ht := (C.layer g top).start_le_first t |
| change P.cost = Int.toNat ((C.layer g top).first t - t) at hcP |
| omega |
|
|
| /-- Easy upper band branch, paid only by upper layers, not by the already |
| rooted baseline's budget. -/ |
| theorem attach_upper_band (closed : SubstringClosed V) (g : G) |
| (I : Finset (Fin (C.size g))) (base top : Fin (C.size g)) |
| (horder : ∀ i ∈ I, base ≤ i ∧ i ≤ top) (hbt : base ≤ top) |
| (P : Path V [] []) (hp : ∀ w ∈ (C.layer g base).Content, P.Visits w) (t : ℤ) |
| (hband : (C.layer g top).first t - (C.layer g base).last t ≤ (I.card * C.period g : ℕ)) : |
| ∃ Q : Path V [] [], Q.cost ≤ P.cost + 2 * (I.card * C.period g) ∧ |
| (∀ w, P.Visits w → Q.Visits w) ∧ |
| ∀ i ∈ I, ∀ w ∈ (C.layer g i).Content, Q.Visits w := by |
| classical |
| let J := insert base (insert top I) |
| let L := fun j : {i // i ∈ J} => C.layer g j.val |
| let lo : {i // i ∈ J} := ⟨base, Finset.mem_insert_self _ _⟩ |
| let hi : {i // i ∈ J} := ⟨top, Finset.mem_insert_of_mem (Finset.mem_insert_self _ _)⟩ |
| have ho : ∀ j : {i // i ∈ J}, base ≤ j.val ∧ j.val ≤ top := by |
| intro j |
| rcases Finset.mem_insert.mp j.property with he | hm |
| · simpa only [he] using And.intro (le_refl base) hbt |
| · rcases Finset.mem_insert.mp hm with he | hm |
| · simpa only [he] using And.intro hbt (le_refl top) |
| · exact horder j.val hm |
| obtain ⟨F, hcF, htF⟩ := join_band closed (C.text g) (C.letters closed g) |
| (C.period g) I.card (C.periodic g) L lo hi |
| (fun j x => C.ordered g base j.val (ho j).1 x) |
| (fun j x => C.ordered g j.val top (ho j).2 x) t hband |
| obtain ⟨T, _, hcT, hvT, hlT⟩ := fill_same_layers closed (C.layer g) (C.positive g) |
| (C.periodic g) I ⟨_, F⟩ (fun i hi => htF ⟨i, Finset.mem_insert_of_mem (Finset.mem_insert_of_mem hi)⟩) |
| let w := textWord (C.text g) t ((C.layer g base).last t) |
| have hwP : P.Visits w := hp w ⟨t, _, (C.layer g base).first_le_last t, le_rfl, rfl⟩ |
| have hwT : T.Visits w := hvT _ (Path.visits_start F) |
| obtain ⟨Q, hcQ, hvQ⟩ := P.splice T.path w hwP hwT |
| refine ⟨Q, ?_, fun v hv => (hvQ v).mpr (Or.inl hv), fun i hi v hv => |
| (hvQ v).mpr (Or.inr (hlT i hi v hv))⟩ |
| change T.cost ≤ F.cost + I.card * C.period g at hcT |
| change Q.cost = P.cost + T.cost at hcQ |
| omega |
|
|
| end Superstring.Hierarchical.LayerCollection |
|
|
| namespace Superstring.Hierarchical.LayerCollection |
|
|
| variable {α G : Type} {V : Set (List α)} (C : LayerCollection V G) |
|
|
|
|
| abbrev Pending := Σ d : C.Id, C.Child d |
|
|
| namespace Pending |
| variable {C} (r : C.Pending) |
| def source : G := r.2.source |
| def ids : Finset C.Id := r.2.ids |
| def reserve : ℕ := 2 * r.2.budget |
|
|
| theorem later : C.period r.source < C.period r.1.1 := r.2.later |
|
|
| theorem same (i : C.Id) (hi : i ∈ r.ids) : i.1 = r.source := |
| C.groupIds_same r.source r.2.members hi |
| end Pending |
|
|
| def upper (g : G) (cut : ℕ) : Finset (Fin (C.size g)) := |
| Finset.univ.filter (fun i => cut ≤ i.val) |
|
|
| @[simp] theorem mem_upper (g : G) (cut : ℕ) (i : Fin (C.size g)) : |
| i ∈ C.upper g cut ↔ cut ≤ i.val := by simp [upper] |
|
|
| @[simp] theorem card_upper (g : G) (cut : ℕ) : |
| (C.upper g cut).card = C.size g - cut := by |
| by_cases hc : cut < C.size g |
| · have he : C.upper g cut = Finset.Ici (⟨cut, hc⟩ : Fin (C.size g)) := by |
| ext i |
| simp only [mem_upper, Finset.mem_Ici, Fin.le_def] |
| rw [he, Fin.card_Ici] |
| · have he : C.upper g cut = ∅ := by |
| ext i |
| simp only [mem_upper, Finset.notMem_empty, iff_false] |
| omega |
| rw [he, Finset.card_empty] |
| omega |
|
|
| variable [LinearOrder α] |
|
|
| def Covered (P : Path V [] []) (B : Finset C.PlannedBlock) (R : Finset C.Pending) |
| (i : C.Id) : Prop := |
| (∀ w ∈ (C.layerAt i).Content, P.Visits w) ∨ |
| (∃ b ∈ B, i ∈ b.members) ∨ ∃ r ∈ R, i ∈ r.ids |
|
|
| /-- Complete exactly the unspent upper interval. The failed count test is |
| resolved by the proved record supply, not taken as a plan oracle. -/ |
| theorem complete_upper (closed : SubstringClosed V) (supply : C.RecordSupply) |
| (g : G) (cut : ℕ) (hcut : cut ≤ C.size g) (P : Path V [] []) |
| (hp : ∀ i : Fin (C.size g), i.val < cut → |
| ∀ w ∈ (C.layer g i).Content, P.Visits w) : |
| ∃ (Q : Path V [] []) (B : Finset C.PlannedBlock) (R : Finset C.Pending), |
| Q.cost + (∑ b ∈ B, b.reserve) + (∑ r ∈ R, r.reserve) ≤ |
| P.cost + 2 * ((C.size g - cut) * C.period g) ∧ |
| (∀ w, P.Visits w → Q.Visits w) ∧ |
| (∀ i ∈ C.upper g cut, C.Covered Q B R ⟨g, i⟩) ∧ |
| (∀ r ∈ R, r.source = g) ∧ R.card ≤ 1 := by |
| classical |
| let n := C.size g - cut |
| let I := C.upper g cut |
| have hcard : I.card = n := C.card_upper g cut |
| by_cases hn : n = 0 |
| · refine ⟨P, ∅, ∅, by simp, fun _ h => h, ?_, by simp, by simp⟩ |
| intro i hi |
| have hh := (C.mem_upper g cut i).mp hi |
| have := i.isLt |
| dsimp only [n] at hn |
| omega |
| have hnpos : 0 < n := by omega |
| have hnm : n ≤ C.size g := Nat.sub_le _ _ |
| let top : Fin (C.size g) := ⟨C.size g - 1, by have := C.nonempty g; omega⟩ |
| let t := C.distinguished g |
| let H := (C.layer g top).first t |
| have htop : ∀ i ∈ I, i ≤ top := by |
| intro i _ |
| change i.val ≤ C.size g - 1 |
| omega |
| have easy (Q : Path V [] []) (hc : Q.cost ≤ P.cost + 2 * (n * C.period g)) |
| (hv : ∀ w, P.Visits w → Q.Visits w) |
| (hi : ∀ i ∈ I, ∀ w ∈ (C.layer g i).Content, Q.Visits w) : |
| ∃ (Q : Path V [] []) (B : Finset C.PlannedBlock) (R : Finset C.Pending), |
| Q.cost + (∑ b ∈ B, b.reserve) + (∑ r ∈ R, r.reserve) ≤ |
| P.cost + 2 * ((C.size g - cut) * C.period g) ∧ |
| (∀ w, P.Visits w → Q.Visits w) ∧ |
| (∀ i ∈ C.upper g cut, C.Covered Q B R ⟨g, i⟩) ∧ |
| (∀ r ∈ R, r.source = g) ∧ R.card ≤ 1 := by |
| exact ⟨Q, ∅, ∅, by simpa using hc, hv, fun i hm => Or.inl (hi i hm), |
| by simp, by simp⟩ |
| by_cases he : H - t ≤ (n * C.period g : ℕ) |
| · obtain ⟨Q, hcQ, hvQ⟩ := C.root_upper_budget closed g I top htop t (by simpa [hcard] using he) |
| apply easy (P.trans Q) |
| · rw [Path.cost_trans] |
| rw [hcard] at hcQ |
| omega |
| · exact fun _ h => Or.inl h |
| · exact fun i hi w hw => Or.inr (hvQ i hi w hw) |
| have hz : Monotone (fun i : Fin (C.size g) => (C.layer g i).last t) := by |
| intro i j hij |
| exact C.ordered g i j hij t |
| by_cases hb : ∃ base : Fin (C.size g), base.val + 1 = cut ∧ |
| H - (C.layer g base).last t ≤ (n * C.period g : ℕ) |
| · obtain ⟨base, hbase, hband⟩ := hb |
| obtain ⟨Q, hcQ, hvQ, hiQ⟩ := C.attach_upper_band closed g I base top |
| (by intro i hi; exact ⟨by have hh := (C.mem_upper g cut i).mp hi; change base.val ≤ i.val; omega, |
| htop i hi⟩) |
| (by change base.val ≤ C.size g - 1; omega) P |
| (hp base (by omega)) t (by simpa [hcard] using hband) |
| exact easy Q (by simpa only [hcard] using hcQ) hvQ hiQ |
| have hstopn : (Processing.qualifying (fun i => (C.layer g i).last t) |
| H (C.period g) n).card ≤ n := by |
| by_cases hzero : cut = 0 |
| · have hh := Finset.card_le_univ (Processing.qualifying |
| (fun i => (C.layer g i).last t) H (C.period g) n) |
| simpa only [Fintype.card_fin, n, hzero, Nat.sub_zero] using hh |
| · let base : Fin (C.size g) := ⟨cut - 1, by omega⟩ |
| have hfail : (C.layer g base).last t < H - (n * C.period g : ℕ) := by |
| by_contra hh |
| apply hb |
| exact ⟨base, by dsimp only [base]; omega, by omega⟩ |
| have hh := Processing.qualifying_bound _ hz H (C.period g) n base hfail |
| change _ ≤ C.size g - 1 - (cut - 1) at hh |
| dsimp only [n] at hh ⊢ |
| omega |
| obtain ⟨k, hk, hkn, hstop, hsharp⟩ := Processing.choose_k hnpos hnm _ hz H |
| (C.period g) ((C.layer g top).first_le_last t) hstopn |
| have hkm : k ≤ C.size g := hkn.trans hnm |
| have hmul : k * C.period g ≤ n * C.period g := Nat.mul_le_mul_right _ hkn |
| have hhard : t + (k * C.period g : ℕ) < (C.layer g top).first t := by omega |
| obtain ⟨d, R, ha, hh, hd⟩ := supply g top t k hk hhard hstop |
| have ht : t < R.stop := by omega |
| obtain ⟨Q, B, A, hcQ, hvQ, hAI, hlA, hmA⟩ := C.distribute_record closed g I k hk hkm |
| (by intro i hi; apply (C.mem_upper g cut i).mpr; dsimp only [n] at hkn; omega) |
| d R hd ha ht (by dsimp only [top, t, H] at hh ⊢; omega) |
| (by dsimp only [top, t, H] at hsharp ⊢; omega) hstop |
| have hhcost : (P.trans Q).cost + (∑ b ∈ B, b.reserve) + 2 * (A.card * C.period g) ≤ |
| P.cost + 2 * ((C.size g - cut) * C.period g) := by |
| rw [Path.cost_trans] |
| rw [hcard] at hcQ |
| dsimp only [n] at hcQ |
| omega |
| by_cases hA : A.Nonempty |
| · let r : C.Pending := ⟨d, { |
| source := g |
| members := A |
| nonempty := hA |
| record := R |
| foreign := hd |
| long := hlA |
| margin := hmA }⟩ |
| refine ⟨P.trans Q, B, {r}, ?_, fun _ h => Or.inl h, ?_, ?_, by simp⟩ |
| · simpa [r, Pending.reserve, Child.budget] using hhcost |
| · intro i hi |
| rcases hvQ i hi with hv | hB | hiA |
| · exact Or.inl (fun w hw => Or.inr (hv w hw)) |
| · exact Or.inr (Or.inl hB) |
| · exact Or.inr (Or.inr ⟨r, Finset.mem_singleton_self _, |
| Finset.mem_map.mpr ⟨i, hiA, rfl⟩⟩) |
| · intro s hs |
| have heq := Finset.mem_singleton.mp hs |
| subst s |
| rfl |
| · have heA : A = ∅ := Finset.not_nonempty_iff_eq_empty.mp hA |
| refine ⟨P.trans Q, B, ∅, ?_, fun _ h => Or.inl h, ?_, by simp, by simp⟩ |
| · simpa only [heA, Finset.card_empty, Nat.zero_mul, Nat.mul_zero, add_zero, |
| Finset.sum_empty] using hhcost |
| · intro i hi |
| rcases hvQ i hi with hv | hB | hiA |
| · exact Or.inl (fun w hw => Or.inr (hv w hw)) |
| · exact Or.inr (Or.inl hB) |
| · simp only [heA, Finset.notMem_empty] at hiA |
|
|
| end Superstring.Hierarchical.LayerCollection |
|
|
| namespace Superstring.Hierarchical.LayerCollection |
|
|
| variable {α G : Type} {V : Set (List α)} (C : LayerCollection V G) |
|
|
| namespace Pending |
| variable {C} (r : C.Pending) |
|
|
| def onTarget (d : C.Id) (h : r.1 = d) : C.Child d := h ▸ r.2 |
|
|
| @[simp] theorem at_source (d : C.Id) (h : r.1 = d) : (r.onTarget d h).source = r.source := by |
| cases h |
| rfl |
|
|
| @[simp] theorem at_budget (d : C.Id) (h : r.1 = d) : 2 * (r.onTarget d h).budget = r.reserve := by |
| cases h |
| rfl |
|
|
| @[simp] theorem at_ids (d : C.Id) (h : r.1 = d) : (r.onTarget d h).ids = r.ids := by |
| cases h |
| rfl |
|
|
| end Pending |
|
|
| /-- Fulfill precisely the pending requests on one fixed recipient. -/ |
| theorem fulfill_fibre (closed : SubstringClosed V) (d : C.Id) (R : Finset C.Pending) |
| (hne : R.Nonempty) (ht : ∀ r ∈ R, r.1 = d) |
| (distinct : Set.InjOn Pending.source (R : Set C.Pending)) : |
| ∃ Q : Path V [] [], Q.cost ≤ 2 * C.period d.1 + ∑ r ∈ R, r.reserve ∧ |
| (∀ w ∈ (C.layerAt d).Content, Q.Visits w) ∧ |
| ∀ r ∈ R, ∀ i ∈ r.ids, ∀ w ∈ (C.layerAt i).Content, Q.Visits w := by |
| classical |
| let ι := {r // r ∈ R} |
| let : Nonempty ι := ⟨⟨hne.choose, hne.choose_spec⟩⟩ |
| let F : ι → C.Child d := fun r => r.val.onTarget d (ht r.val r.property) |
| have hd : Function.Injective (fun r => (F r).source) := by |
| intro r s he |
| apply Subtype.ext |
| apply distinct r.property s.property |
| simpa only [F, Pending.at_source] using he |
| obtain ⟨Q, hc, hv, hr⟩ := C.fulfill closed d F hd |
| have hsum : 2 * ∑ r : ι, (F r).budget = ∑ r ∈ R, r.reserve := by |
| rw [Finset.mul_sum] |
| simp only [F, Pending.at_budget] |
| exact (Finset.sum_subtype R (fun _ => Iff.rfl) Pending.reserve).symm |
| refine ⟨Q, by simpa only [hsum] using hc, hv, ?_⟩ |
| intro r hrR i hi w hw |
| have hiF : i ∈ (F ⟨r, hrR⟩).ids := by simpa only [F, Pending.at_ids] using hi |
| obtain ⟨j, hj, he⟩ := Finset.mem_map.mp hiF |
| subst i |
| exact hr ⟨r, hrR⟩ j hj w hw |
|
|
|
|
| theorem fulfill_all (closed : SubstringClosed V) (g : G) (R : Finset C.Pending) |
| (targets : ∀ r ∈ R, r.1.1 = g) |
| (distinct : Set.InjOn Pending.source (R : Set C.Pending)) : |
| ∃ (Q : Path V [] []) (J : Finset (Fin (C.size g))), |
| Q.cost ≤ 2 * (J.card * C.period g) + ∑ r ∈ R, r.reserve ∧ |
| (∀ j ∈ J, ∀ w ∈ (C.layer g j).Content, Q.Visits w) ∧ |
| (∀ r ∈ R, ∀ i ∈ r.ids, ∀ w ∈ (C.layerAt i).Content, Q.Visits w) ∧ |
| (∀ j ∈ J, ∃ a b : ℤ, (C.layer g j).first a ≤ b ∧ |
| b ≤ (C.layer g j).last a ∧ b - a < 2 * C.period g) ∧ |
| (J = ∅ ↔ R = ∅) := by |
| classical |
| let J : Finset (Fin (C.size g)) := Finset.univ.filter |
| (fun j => ∃ r ∈ R, r.1 = ⟨g, j⟩) |
| let fibre := fun j => R.filter (fun r => r.1 = ⟨g, j⟩) |
| have hJ : ∀ j, j ∈ J ↔ ∃ r ∈ R, r.1 = ⟨g, j⟩ := by simp [J] |
| have recipient : ∀ r ∈ R, ∃ j : Fin (C.size g), r.1 = ⟨g, j⟩ := by |
| intro r hr |
| obtain ⟨⟨a, j⟩, c⟩ := r |
| have he := targets ⟨⟨a, j⟩, c⟩ hr |
| change a = g at he |
| subst a |
| exact ⟨j, rfl⟩ |
| have hex : ∀ j ∈ J, ∃ Q : Path V [] [], |
| Q.cost ≤ 2 * C.period g + ∑ r ∈ fibre j, r.reserve ∧ |
| (∀ w ∈ (C.layer g j).Content, Q.Visits w) ∧ |
| ∀ r ∈ fibre j, ∀ i ∈ r.ids, ∀ w ∈ (C.layerAt i).Content, Q.Visits w := by |
| intro j hj |
| obtain ⟨r, hr, ht⟩ := (hJ j).mp hj |
| exact C.fulfill_fibre closed ⟨g, j⟩ (fibre j) |
| ⟨r, Finset.mem_filter.mpr ⟨hr, ht⟩⟩ |
| (fun _ h => (Finset.mem_filter.mp h).2) |
| (distinct.mono (by intro r hr; exact (Finset.mem_filter.mp hr).1)) |
| let F : Fin (C.size g) → Path V [] [] := fun j => |
| if h : j ∈ J then (hex j h).choose else .nil [] (C.empty_mem closed g) |
| have hF : ∀ j ∈ J, |
| (F j).cost ≤ 2 * C.period g + ∑ r ∈ fibre j, r.reserve ∧ |
| (∀ w ∈ (C.layer g j).Content, (F j).Visits w) ∧ |
| ∀ r ∈ fibre j, ∀ i ∈ r.ids, ∀ w ∈ (C.layerAt i).Content, (F j).Visits w := by |
| intro j hj |
| simpa only [F, dite_eq_left hj] using (hex j hj).choose_spec |
| have hsum : ∑ j ∈ J, ∑ r ∈ fibre j, r.reserve = ∑ r ∈ R, r.reserve := by |
| simp only [fibre, Finset.sum_filter] |
| rw [Finset.sum_comm] |
| apply Finset.sum_congr rfl |
| intro r hr |
| obtain ⟨j, hj⟩ := recipient r hr |
| have hjJ : j ∈ J := (hJ j).mpr ⟨r, hr, hj⟩ |
| rw [Finset.sum_eq_single j] |
| · simp only [hj, ↓reduceIte] |
| · intro k _ hkj |
| have hne : r.1 ≠ ⟨g, k⟩ := by |
| intro he |
| have hh : j = k := by simpa only [Sigma.mk.inj_iff, heq_eq_eq, true_and] using hj.symm.trans he |
| exact hkj hh.symm |
| simp only [hne, ↓reduceIte] |
| · exact fun h => False.elim (h hjJ) |
| obtain ⟨Q, hcQ, hvQ⟩ := combine_rooted (C.empty_mem closed g) F J |
| refine ⟨Q, J, ?_, ?_, ?_, ?_, ?_⟩ |
| · have hh := Finset.sum_le_sum (fun j hj => (hF j hj).1) |
| have he : (∑ j ∈ J, (2 * C.period g + ∑ r ∈ fibre j, r.reserve)) = |
| 2 * (J.card * C.period g) + ∑ r ∈ R, r.reserve := by |
| rw [Finset.sum_add_distrib, hsum] |
| simp only [Finset.sum_const, nsmul_eq_mul, Nat.cast_id] |
| ring |
| rw [he] at hh |
| exact hcQ.trans hh |
| · intro j hj w hw |
| exact hvQ j hj w ((hF j hj).2.1 w hw) |
| · intro r hr i hi w hw |
| obtain ⟨j, hj⟩ := recipient r hr |
| have hjJ : j ∈ J := (hJ j).mpr ⟨r, hr, hj⟩ |
| exact hvQ j hjJ w ((hF j hjJ).2.2 r (Finset.mem_filter.mpr ⟨hr, hj⟩) i hi w hw) |
| · intro j hj |
| obtain ⟨r, hr, ht⟩ := (hJ j).mp hj |
| let c := r.onTarget ⟨g, j⟩ ht |
| refine ⟨c.record.start + c.record.offset, c.record.stop + c.record.offset, |
| c.record.first_le, c.record.le_last, ?_⟩ |
| have hl := c.record.length_lt (C.positive c.source) (C.positive g) |
| (C.periodic c.source) (C.periodic g) c.foreign |
| have hp := c.later |
| change c.record.stop - c.record.start < (C.period c.source : ℤ) + C.period g at hl |
| change C.period c.source < C.period g at hp |
| omega |
| · constructor |
| · intro he |
| apply Finset.eq_empty_iff_forall_notMem.mpr |
| intro r hr |
| obtain ⟨j, hj⟩ := recipient r hr |
| have hm := (hJ j).mpr ⟨r, hr, hj⟩ |
| simp only [he, Finset.notMem_empty] at hm |
| · intro he |
| apply Finset.eq_empty_iff_forall_notMem.mpr |
| intro j hj |
| obtain ⟨r, hr, _⟩ := (hJ j).mp hj |
| simp only [he, Finset.notMem_empty] at hr |
|
|
| end Superstring.Hierarchical.LayerCollection |
|
|
| end OAI |
|
|
