| import OAI.Computability.Superstring.Collections |
|
|
| namespace OAI |
|
|
| namespace Superstring.Hierarchical.LayerCollection |
|
|
| variable {α G : Type} {V : Set (List α)} (C : LayerCollection V G) |
|
|
|
|
| structure Child (d : C.Id) where |
| source : G |
| members : Finset (Fin (C.size source)) |
| nonempty : members.Nonempty |
| record : (C.layerAt d).Record (C.text source) |
| foreign : C.text source ≠ fun x => C.text d.1 (x + record.offset) |
| long : ∀ i ∈ members, record.start + C.period source < (C.layer source i).first record.start |
| margin : ∀ i ∈ members, (C.layer source i).last record.start < record.stop - C.period source |
|
|
| namespace Child |
|
|
| variable {C} {d : C.Id} (R : C.Child d) |
|
|
| def ids : Finset C.Id := C.groupIds R.source R.members |
|
|
| def budget : ℕ := R.members.card * C.period R.source |
|
|
| theorem later : C.period R.source < C.period d.1 := by |
| obtain ⟨i, hi⟩ := R.nonempty |
| have hl := R.long i hi |
| have hm := R.margin i hi |
| have hf := (C.layer R.source i).first_le_last R.record.start |
| have hb := R.record.length_lt (C.positive R.source) (C.positive d.1) |
| (C.periodic R.source) (C.periodic d.1) R.foreign |
| omega |
|
|
|
|
| def hosted : HostedGroup (C.layerAt d) where |
| text := fun x => C.text R.source (x - R.record.offset) |
| period := C.period R.source |
| positive := C.positive R.source |
| periodic := fun x => by |
| simpa only [add_sub_right_comm] using C.periodic R.source (x - R.record.offset) |
| start := R.record.start + R.record.offset |
| stop := R.record.stop + R.record.offset |
| first_le := R.record.first_le |
| le_last := R.record.le_last |
| agree := by |
| intro x hx hy |
| have hh := R.record.agree (x - R.record.offset) (by omega) (by omega) |
| simpa only [sub_add_cancel] using hh |
| foreign := by |
| intro he |
| apply R.foreign |
| funext x |
| simpa only [add_sub_cancel_right] using congrFun he (x + R.record.offset) |
|
|
| def request (i : {j // j ∈ R.members}) : R.hosted.Request where |
| layer := (C.layer R.source i.val).translate R.record.offset |
| stop := (C.layer R.source i.val).first R.record.start + R.record.offset |
| first_le := by simp [hosted] |
| le_last := by |
| simp only [hosted, Layer.translate_last, add_sub_cancel_right] |
| have hf := (C.layer R.source i.val).first_le_last R.record.start |
| omega |
| long := by |
| have hh := R.long i.val i.property |
| change R.record.start + R.record.offset + C.period R.source < _ |
| omega |
| margin := by |
| have hh := R.margin i.val i.property |
| have hf := (C.layer R.source i.val).first_le_last R.record.start |
| change _ ≤ R.record.stop + R.record.offset - C.period R.source |
| omega |
|
|
| theorem hosted_different (S : C.Child d) (hne : R.source ≠ S.source) (c : ℤ) : |
| R.hosted.text ≠ fun x => S.hosted.text (x + c) := by |
| intro he |
| apply C.different R.source S.source hne (R.record.offset + c - S.record.offset) |
| funext x |
| have hh := congrFun he (x + R.record.offset) |
| change C.text R.source (x + R.record.offset - R.record.offset) = |
| C.text S.source (x + R.record.offset + c - S.record.offset) at hh |
| have hx : x + R.record.offset + c - S.record.offset = |
| x + (R.record.offset + c - S.record.offset) := by omega |
| simpa only [add_sub_cancel_right, hx] using hh |
|
|
| end Child |
|
|
| /-- A nonempty collection of actual child groups can be fulfilled together. |
| The reserve includes the original turn of every requesting layer and of the |
| recipient. No other layer of the recipient group is charged or rooted here. -/ |
| theorem fulfill {ι : Type} [Fintype ι] [Nonempty ι] |
| (closed : SubstringClosed V) (d : C.Id) (R : ι → C.Child d) |
| (distinct : Function.Injective (fun i => (R i).source)) : |
| ∃ Q : Path V [] [], Q.cost ≤ 2 * C.period d.1 + 2 * ∑ i, (R i).budget ∧ |
| (∀ w ∈ (C.layerAt d).Content, Q.Visits w) ∧ |
| ∀ j i, i ∈ (R j).members → ∀ w ∈ (C.layer (R j).source i).Content, Q.Visits w := by |
| classical |
| let K := Σ j : ι, {i // i ∈ (R j).members} |
| let child : K → ι := fun k => k.1 |
| let req := fun k : K => (R k.1).request k.2 |
| have hK : (Finset.univ : Finset K).Nonempty := by |
| obtain ⟨j⟩ := ‹Nonempty ι› |
| obtain ⟨i, hi⟩ := (R j).nonempty |
| exact ⟨⟨j, i, hi⟩, Finset.mem_univ _⟩ |
| have budget_sum : (∑ k : K, C.period (R k.1).source) = ∑ j, (R j).budget := by |
| simp only [K, Fintype.sum_sigma, Finset.sum_const, Finset.card_univ, |
| Fintype.card_coe, smul_eq_mul, Child.budget] |
| obtain ⟨P, hcP, hdP, hrP⟩ := host_requests closed (C.layerAt d) (C.positive d.1) |
| (C.periodic d.1) (C.letters closed d.1) (fun j => (R j).hosted) child req |
| (fun j x => C.letters closed (R j).source (x - (R j).record.offset)) |
| (fun i j hij c => (R i).hosted_different (R j) (fun he => hij (distinct he)) c) |
| Finset.univ hK |
| obtain ⟨Q, hbQ, hcQ, hvQ, hdQ⟩ := fill_same_layers closed (fun _ : Unit => C.layerAt d) |
| (C.positive d.1) (C.periodic d.1) {()} ⟨[], P⟩ (fun _ _ => hdP) |
| obtain ⟨T, hbT, hcT, hvT, hrT⟩ := fill_layers closed (fun k : K => (req k).layer) |
| (fun k => C.positive (R k.1).source) (fun k => (R k.1).hosted.periodic) Finset.univ Q |
| (fun k hk => by |
| obtain ⟨x, e, hf, hl, hp⟩ := hrP k hk |
| exact ⟨x, e, hf, hl, hvQ _ hp⟩) |
| have hbase : T.base = [] := hbT.trans hbQ |
| refine ⟨T.path.copy hbase hbase, ?_, ?_, ?_⟩ |
| · simp only [Path.cost_copy] |
| change T.cost ≤ _ |
| simp only [Finset.card_singleton, one_mul] at hcQ |
| change Q.cost ≤ P.cost + C.period d.1 at hcQ |
| change P.cost ≤ C.period d.1 + ∑ k : K, C.period (R k.1).source at hcP |
| change T.cost ≤ Q.cost + ∑ k : K, C.period (R k.1).source at hcT |
| rw [budget_sum] at hcP hcT |
| omega |
| · intro w hw |
| exact (Path.visits_copy ..).mpr (hvT w (hdQ () (Finset.mem_singleton_self ()) w hw)) |
| · intro j i hi w hw |
| apply (Path.visits_copy ..).mpr |
| apply hrT ⟨j, i, hi⟩ (Finset.mem_univ _) w |
| change w ∈ ((C.layer (R j).source i).translate (R j).record.offset).Content |
| rwa [Layer.translate_content] |
|
|
| end Superstring.Hierarchical.LayerCollection |
|
|
| namespace Superstring.Hierarchical |
|
|
| /-- Concatenate a finite family of rooted closed walks, preserving every |
| visit and charging at most their sum. Abstracted only to avoid repeated splices. -/ |
| theorem combine_rooted {α ι : Type} {V : Set (List α)} (he : [] ∈ V) |
| (F : ι → Path V [] []) (I : Finset ι) : |
| ∃ Q : Path V [] [], Q.cost ≤ ∑ i ∈ I, (F i).cost ∧ |
| ∀ i ∈ I, ∀ w, (F i).Visits w → Q.Visits w := by |
| apply Loop.of_connected (fun i => ⟨[], F i⟩) I [] he |
| intro U hU hclosed i hi w hw |
| exact hclosed i hi ⟨[], hU, Path.visits_start (F i)⟩ w hw |
|
|
| namespace LayerCollection |
|
|
| variable {α G : Type} {V : Set (List α)} (C : LayerCollection V G) |
|
|
| include C in |
| theorem empty_mem (closed : SubstringClosed V) (g : G) : [] ∈ V := |
| closed (C.letters closed g 0) List.nil_infix |
|
|
| theorem root_short (closed : SubstringClosed V) (g : G) (i : Fin (C.size g)) |
| (hs : (C.layer g i).HasShort (C.period g)) : |
| ∃ Q : Path V [] [], Q.cost ≤ 2 * C.period g ∧ |
| ∀ w ∈ (C.layer g i).Content, Q.Visits w := by |
| obtain ⟨x, e, hf, hl, hc⟩ := hs |
| obtain ⟨P, hcP, hvP⟩ := Path.root_loop closed _ ((C.layer g i).actual x e hf hl) |
| obtain ⟨Q, hbQ, hcQ, _, hvQ⟩ := fill_same_layers closed (C.layer g) (C.positive g) |
| (C.periodic g) {i} ⟨[], P⟩ (by |
| intro j hj |
| have he : j = i := Finset.mem_singleton.mp hj |
| subst j |
| exact ⟨x, e, hf, hl, hvP⟩) |
| refine ⟨Q.path.copy hbQ hbQ, ?_, fun w hw => (Path.visits_copy ..).mpr |
| (hvQ i (Finset.mem_singleton_self i) w hw)⟩ |
| simp only [Path.cost_copy] |
| change Q.cost ≤ _ |
| simp only [Finset.card_singleton, one_mul] at hcQ |
| change Q.cost ≤ P.cost + C.period g at hcQ |
| omega |
|
|
| end LayerCollection |
| end Superstring.Hierarchical |
|
|
| namespace Superstring.Hierarchical.Processing |
|
|
| /-- Once the cardinality test stops, every layer strictly below the top k |
| has last end strictly below the tested threshold. -/ |
| theorem below_stopped {m : ℕ} (z : Fin m → ℤ) (hz : Monotone z) (H : ℤ) (p k : ℕ) |
| (hstop : (qualifying z H p k).card ≤ k) (i : Fin m) (hi : i.val < m - k) : |
| z i < H - (k * p : ℕ) := by |
| by_contra hh |
| have hsub : Finset.Ici i ⊆ qualifying z H p k := by |
| intro j hj |
| simp only [qualifying, Finset.mem_filter, Finset.mem_univ, true_and] |
| exact (le_of_not_gt hh).trans (hz (Finset.mem_Ici.mp hj)) |
| have hc := Finset.card_le_card hsub |
| rw [Fin.card_Ici] at hc |
| omega |
|
|
| end Superstring.Hierarchical.Processing |
|
|
| namespace Superstring.Hierarchical.LayerCollection |
|
|
| variable {α G : Type} [LinearOrder α] {V : Set (List α)} (C : LayerCollection V G) |
|
|
|
|
| theorem distribute_individuals (closed : SubstringClosed V) (g : G) |
| (d : C.Id) (R : (C.layerAt d).Record (C.text g)) |
| (foreign : C.text g ≠ fun x => C.text d.1 (x + R.offset)) |
| (I : Finset (Fin (C.size g))) |
| (hfirst : ∀ i ∈ I, (C.layer g i).first R.start ≤ R.stop) : |
| ∃ (Q : Path V [] []) (B : Finset C.PlannedBlock) (A : Finset (Fin (C.size g))), |
| Q.cost + (∑ b ∈ B, b.reserve) + 2 * (A.card * C.period g) ≤ 2 * (I.card * C.period g) ∧ |
| (∀ i ∈ I, (∀ w ∈ (C.layer g i).Content, Q.Visits w) ∨ |
| (∃ b ∈ B, (⟨g, i⟩ : C.Id) ∈ b.members) ∨ i ∈ A) ∧ |
| A ⊆ I ∧ |
| (∀ i ∈ A, R.start + C.period g < (C.layer g i).first R.start) ∧ |
| (∀ i ∈ A, (C.layer g i).last R.start < R.stop - C.period g) := by |
| classical |
| induction I using Finset.induction_on with |
| | empty => |
| exact ⟨.nil [] (C.empty_mem closed g), ∅, ∅, by simp [Path.cost], |
| by simp, by simp, by simp, by simp⟩ |
| | @insert i I hi ih => |
| obtain ⟨Q, B, A, hcQ, hvQ, hAI, hlong, hmargin⟩ := ih |
| (fun j hj => hfirst j (Finset.mem_insert_of_mem hj)) |
| have hcard : 2 * ((insert i I).card * C.period g) = |
| 2 * (I.card * C.period g) + 2 * C.period g := by |
| rw [Finset.card_insert_of_notMem hi, Nat.add_mul, Nat.one_mul, Nat.mul_add] |
| have lift_cover (T : Path V [] []) (B' : Finset C.PlannedBlock) |
| (A' : Finset (Fin (C.size g))) |
| (hP : ∀ w, Q.Visits w → T.Visits w) (hB : B ⊆ B') (hA : A ⊆ A') |
| (hv : (∀ w ∈ (C.layer g i).Content, T.Visits w) ∨ |
| (∃ b ∈ B', (⟨g, i⟩ : C.Id) ∈ b.members) ∨ i ∈ A') : |
| ∀ j ∈ insert i I, (∀ w ∈ (C.layer g j).Content, T.Visits w) ∨ |
| (∃ b ∈ B', (⟨g, j⟩ : C.Id) ∈ b.members) ∨ j ∈ A' := by |
| intro j hj |
| rcases Finset.mem_insert.mp hj with rfl | hj |
| · exact hv |
| · rcases hvQ j hj with hp | ⟨b, hb, hm⟩ | ha |
| · exact Or.inl (fun w hw => hP w (hp w hw)) |
| · exact Or.inr (Or.inl ⟨b, hB hb, hm⟩) |
| · exact Or.inr (Or.inr (hA ha)) |
| by_cases hs : (C.layer g i).HasShort (C.period g) |
| · obtain ⟨P, hcP, hvP⟩ := C.root_short closed g i hs |
| refine ⟨Q.trans P, B, A, ?_, lift_cover _ _ _ (fun _ h => Or.inl h) |
| (fun _ h => h) (fun _ h => h) (Or.inl (fun w hw => Or.inr (hvP w hw))), |
| hAI.trans (Finset.subset_insert i I), hlong, hmargin⟩ |
| rw [Path.cost_trans, hcard] |
| omega |
| · by_cases ht : R.stop ≤ (C.layer g i).last R.start + C.period g |
| · let b := C.individualPlan closed g i d R foreign |
| (hfirst i (Finset.mem_insert_self i I)) ht |
| have hbc : b.reserve = 2 * C.period g := by |
| simp [b, individualPlan, PlannedBlock.reserve] |
| have hsum : (∑ x ∈ insert b B, x.reserve) ≤ b.reserve + ∑ x ∈ B, x.reserve := by |
| by_cases hb : b ∈ B |
| · rw [Finset.insert_eq_of_mem hb] |
| omega |
| · rw [Finset.sum_insert hb] |
| have hmem : (⟨g, i⟩ : C.Id) ∈ b.members := by |
| exact Finset.mem_map.mpr ⟨i, Finset.mem_singleton_self i, rfl⟩ |
| refine ⟨Q, insert b B, A, ?_, lift_cover _ _ _ (fun _ h => h) |
| (Finset.subset_insert b B) (fun _ h => h) |
| (Or.inr (Or.inl ⟨b, Finset.mem_insert_self b B, hmem⟩)), |
| hAI.trans (Finset.subset_insert i I), hlong, hmargin⟩ |
| rw [hcard] |
| omega |
| · have hni : i ∉ A := fun hm => hi (hAI hm) |
| have hl := (C.layer g i).first_long_of_not_short (C.period g) hs R.start |
| refine ⟨Q, B, insert i A, ?_, lift_cover _ _ _ (fun _ h => h) |
| (fun _ h => h) (Finset.subset_insert i A) |
| (Or.inr (Or.inr (Finset.mem_insert_self i A))), |
| Finset.insert_subset_insert i hAI, ?_, ?_⟩ |
| · rw [Finset.card_insert_of_notMem hni, Nat.add_mul, Nat.one_mul, Nat.mul_add, hcard] |
| omega |
| · intro j hj |
| rcases Finset.mem_insert.mp hj with rfl | hj |
| · omega |
| · exact hlong j hj |
| · intro j hj |
| rcases Finset.mem_insert.mp hj with rfl | hj |
| · omega |
| · exact hmargin j hj |
|
|
| end Superstring.Hierarchical.LayerCollection |
|
|
| namespace Superstring.Hierarchical.LayerCollection |
|
|
| variable {α G : Type} [LinearOrder α] {V : Set (List α)} (C : LayerCollection V G) |
|
|
| /-- The hard-case distribution, using the ONE record already forced by the |
| count rule. Collective and uncollected individual budgets are disjoint. -/ |
| theorem distribute_record (closed : SubstringClosed V) (g : G) |
| (I : Finset (Fin (C.size g))) (k : ℕ) (hk : 0 < k) (hkm : k ≤ C.size g) |
| (hI : ∀ i : Fin (C.size g), C.size g - k ≤ i.val → i ∈ I) |
| (d : C.Id) (R : (C.layerAt d).Record (C.text g)) |
| (foreign : C.text g ≠ fun x => C.text d.1 (x + R.offset)) |
| (hat : R.start ≤ C.distinguished g) (htb : C.distinguished g < R.stop) |
| (hb : (C.layer g ⟨C.size g - 1, by have := C.nonempty g; omega⟩).first (C.distinguished g) |
| ≤ R.stop + (k * C.period g : ℕ)) |
| (hsharp : (C.layer g ⟨C.size g - 1, by have := C.nonempty g; omega⟩).first (C.distinguished g) - |
| (C.layer g ⟨C.size g - k, by omega⟩).last (C.distinguished g) ≤ ((k - 1) * C.period g : ℕ)) |
| (hstop : (Processing.qualifying (fun j => (C.layer g j).last (C.distinguished g)) |
| ((C.layer g ⟨C.size g - 1, by have := C.nonempty g; omega⟩).first (C.distinguished g)) |
| (C.period g) k).card ≤ k) : |
| ∃ (Q : Path V [] []) (B : Finset C.PlannedBlock) (A : Finset (Fin (C.size g))), |
| Q.cost + (∑ b ∈ B, b.reserve) + 2 * (A.card * C.period g) ≤ 2 * (I.card * C.period g) ∧ |
| (∀ i ∈ I, (∀ w ∈ (C.layer g i).Content, Q.Visits w) ∨ |
| (∃ b ∈ B, (⟨g, i⟩ : C.Id) ∈ b.members) ∨ i ∈ A) ∧ |
| A ⊆ I ∧ |
| (∀ i ∈ A, R.start + C.period g < (C.layer g i).first R.start) ∧ |
| (∀ i ∈ A, (C.layer g i).last R.start < R.stop - C.period g) := by |
| classical |
| let top : Fin (C.size g) := ⟨C.size g - 1, by have := C.nonempty g; omega⟩ |
| let lo : Fin (C.size g) := ⟨C.size g - k, by omega⟩ |
| let J := Finset.Ici lo |
| have hJcard : J.card = k := by simp only [J, Fin.card_Ici, lo]; omega |
| have hJI : J ⊆ I := by |
| intro i hi |
| have hh : lo ≤ i := Finset.mem_Ici.mp hi |
| exact hI i hh |
| have htop : ∀ i : Fin (C.size g), i ≤ top := by |
| intro i |
| change i.val ≤ C.size g - 1 |
| omega |
| have hlo : lo ∈ J := Finset.mem_Ici.mpr le_rfl |
| have hhi : top ∈ J := Finset.mem_Ici.mpr (htop lo) |
| have first_below : ∀ i : Fin (C.size g), i ∉ J → (C.layer g i).first R.start ≤ R.stop := by |
| intro i hi |
| have hil : i.val < C.size g - k := by |
| have hh : ¬ lo ≤ i := fun h => hi (Finset.mem_Ici.mpr h) |
| change ¬ C.size g - k ≤ i.val at hh |
| omega |
| have hh := Processing.below_stopped (fun j => (C.layer g j).last (C.distinguished g)) |
| (fun i j hij => C.ordered g i j hij _) ((C.layer g top).first (C.distinguished g)) |
| (C.period g) k hstop i hil |
| have hfa := (C.layer g i).first_mono hat |
| have hfl := (C.layer g i).first_le_last (C.distinguished g) |
| change (C.layer g top).first (C.distinguished g) ≤ _ at hb |
| omega |
| by_cases hcollect : R.stop ≤ (C.layer g lo).last R.start + (k * C.period g : ℕ) |
| · let b := C.collectivePlan closed g J lo top hlo hhi |
| (fun _ hj => Finset.mem_Ici.mp hj) (fun i _ => htop i) d R foreign hat htb |
| (by simpa only [hJcard] using hsharp) (by simpa only [hJcard] using hb) |
| (by simpa only [hJcard] using hcollect) |
| obtain ⟨Q, B, A, hcQ, hvQ, hA, hlong, hmargin⟩ := C.distribute_individuals closed g d R foreign |
| (I \ J) (fun i hi => first_below i (Finset.mem_sdiff.mp hi).2) |
| have hbc : b.reserve = 2 * (k * C.period g) := by |
| simp only [b, collectivePlan, PlannedBlock.reserve, card_groupIds, hJcard] |
| have hsum : (∑ x ∈ insert b B, x.reserve) ≤ b.reserve + ∑ x ∈ B, x.reserve := by |
| by_cases hb : b ∈ B |
| · rw [Finset.insert_eq_of_mem hb]; omega |
| · rw [Finset.sum_insert hb] |
| have hcard := Finset.card_sdiff_add_card_eq_card hJI |
| have hcost : 2 * ((I \ J).card * C.period g) + 2 * (k * C.period g) = |
| 2 * (I.card * C.period g) := by |
| rw [← Nat.mul_add, ← Nat.add_mul, ← hJcard, hcard] |
| refine ⟨Q, insert b B, A, by omega, ?_, hA.trans Finset.sdiff_subset, hlong, hmargin⟩ |
| intro i hi |
| by_cases hij : i ∈ J |
| · exact Or.inr (Or.inl ⟨b, Finset.mem_insert_self b B, |
| Finset.mem_map.mpr ⟨i, hij, rfl⟩⟩) |
| · rcases hvQ i (Finset.mem_sdiff.mpr ⟨hi, hij⟩) with hr | ⟨x, hx, hm⟩ | ha |
| · exact Or.inl hr |
| · exact Or.inr (Or.inl ⟨x, Finset.mem_insert_of_mem hx, hm⟩) |
| · exact Or.inr (Or.inr ha) |
| · apply C.distribute_individuals closed g d R foreign I |
| intro i _ |
| have hw := Processing.wide_band (C.layer g top) (C.layer g lo) |
| (C.positive g) hk (C.distinguished g) hsharp R.start |
| have hu := C.ordered g i top (htop i) (R.start - 1) |
| change (C.layer g i).first R.start ≤ (C.layer g top).first R.start at hu |
| omega |
|
|
| end Superstring.Hierarchical.LayerCollection |
|
|
| namespace Superstring.Hierarchical.Threading |
|
|
| variable {α ι : Type} [Fintype ι] {V : Set (List α)} |
|
|
| /-- The finite ordered collection is the actual sorted base decomposition, |
| not an arbitrary family substituted for its multiplicities. -/ |
| noncomputable def collection (T : Threading V ι) (closed : SubstringClosed V) : |
| LayerCollection V T.Groups where |
| text := T.groupText |
| period := T.groupPeriod |
| size := fun g => Fintype.card (T.Aligned (T.groupText g)) |
| positive := fun g => (T.primitive_group g).positive |
| nonempty := fun g => Fintype.card_pos_iff.mpr ⟨⟨Quotient.out g, rfl⟩⟩ |
| periodic := fun g => (T.primitive_group g).periodic |
| layer := fun g j => T.layerAt closed ⟨g, j⟩ |
| ordered := fun g i j hij x => T.layers_ordered (T.groupText g) i j hij x |
| different := by |
| intro g h hne c he |
| apply hne |
| exact (T.group_eq_of_alignment g h c 0 (fun x => by |
| simpa only [add_zero] using (congrFun he x).symm)).symm |
|
|
| end Superstring.Hierarchical.Threading |
|
|
| namespace Superstring.Hierarchical.LayerCollection |
|
|
| variable {α G : Type} {V : Set (List α)} (C : LayerCollection V G) |
|
|
|
|
| def RecordSupply : Prop := |
| ∀ (g : G) (j : Fin (C.size g)) (t : ℤ) (k : ℕ), 0 < k → |
| t + (k * C.period g : ℕ) < (C.layer g j).first t → |
| (Processing.qualifying (fun l => (C.layer g l).last t) |
| ((C.layer g j).first t) (C.period g) k).card ≤ k → |
| ∃ d : C.Id, ∃ R : (C.layerAt d).Record (C.text g), |
| R.start ≤ t ∧ (C.layer g j).first t - (k * C.period g : ℕ) ≤ R.stop ∧ |
| C.text g ≠ fun x => C.text d.1 (x + R.offset) |
|
|
| end Superstring.Hierarchical.LayerCollection |
|
|
| namespace Superstring.Counts.Data |
|
|
| variable {α : Type} [DecidableEq α] [Inhabited α] |
|
|
| theorem collection_records (D : Data α) (hD : D.WellFormed) : |
| ((D.threading hD).collection hD.closed).RecordSupply := by |
| intro g j t k hk hh hs |
| obtain ⟨d, R, ha, hb, hd, _⟩ := D.hard_case_record hD g j t k hk hh hs |
| exact ⟨d, R, ha, hb, hd⟩ |
|
|
| end Superstring.Counts.Data |
|
|
| end OAI |
|
|
