| import OAI.Computability.Superstring.Periods |
|
|
| namespace OAI |
|
|
| namespace Superstring |
|
|
| namespace Counts.Data |
|
|
| variable {α : Type} [DecidableEq α] [Inhabited α] |
| |
| /-- Prefix-subtree telescoping, stronger than the total-cost identity. -/ |
| theorem down_descendants (D : Data α) (hD : D.WellFormed) {s : List α} (hs : s ≠ []) : |
| (∑ r ∈ D.vertices with s <+: r, D.down r) = D.count s := by |
| classical |
| by_cases hsm : s ∈ D.vertices |
| · let T := D.vertices.filter (fun r => s <+: r) |
| have hsT : s ∈ T := Finset.mem_filter.mpr ⟨hsm, List.prefix_refl s⟩ |
| have hext : (∑ r ∈ T, ∑ c ∈ D.alphabet, D.count (r ++ [c])) = |
| ∑ r ∈ T.erase s, D.count r := by |
| rw [← Finset.sum_product T D.alphabet (fun a => D.count (a.1 ++ [a.2]))] |
| apply Finset.sum_bij_ne_zero (fun a _ _ => a.1 ++ [a.2]) |
| · intro a ha hz |
| obtain ⟨haT, _⟩ := Finset.mem_product.mp ha |
| have hpre := (Finset.mem_filter.mp haT).2 |
| have hlen := hpre.length_le |
| refine Finset.mem_erase.mpr ⟨?_, Finset.mem_filter.mpr |
| ⟨D.mem_of_count_ne_zero hz, hpre.trans (List.prefix_append _ _)⟩⟩ |
| intro he |
| have := congrArg List.length he |
| simp only [List.length_append, List.length_singleton] at this |
| omega |
| · intro a _ _ b _ _ hab |
| have he := congrArg List.dropLast hab |
| simp only [List.dropLast_concat] at he |
| have hc : a.2 = b.2 := by |
| rw [he] at hab |
| simpa only [List.append_cancel_left_eq, List.cons.injEq, and_true] using hab |
| exact Prod.ext he hc |
| · intro r hr hz |
| obtain ⟨hrs, hrT⟩ := Finset.mem_erase.mp hr |
| obtain ⟨hrV, hpre⟩ := Finset.mem_filter.mp hrT |
| have hrne : r ≠ [] := by |
| intro he |
| have := hpre.length_le |
| have hslen : 0 < s.length := List.length_pos_iff.mpr hs |
| simp only [he, List.length_nil] at this |
| omega |
| have hsl : s.length < r.length := by |
| have := hpre.length_le |
| by_contra hn |
| exact hrs (hpre.eq_of_length (by omega)).symm |
| have hpl : s <+: r.dropLast := |
| List.prefix_of_prefix_length_le hpre (List.dropLast_prefix r) |
| (by simp only [List.length_dropLast]; omega) |
| have heq := List.dropLast_append_getLast hrne |
| have hpT : r.dropLast ∈ T := Finset.mem_filter.mpr |
| ⟨hD.closed hrV (List.dropLast_prefix r).isInfix, hpl⟩ |
| have hc : r.getLast hrne ∈ D.alphabet := hD.letters r hrV _ |
| (List.getLast_mem hrne) |
| refine ⟨(r.dropLast, r.getLast hrne), Finset.mem_product.mpr ⟨hpT, hc⟩, ?_, heq⟩ |
| simpa only [heq] using hz |
| · intros |
| rfl |
| have hadd := Finset.sum_congr rfl (fun r (hr : r ∈ T) => |
| D.down_add hD (s := r) (by |
| intro he |
| have hh := (Finset.mem_filter.mp hr).2.length_le |
| have hslen : 0 < s.length := List.length_pos_iff.mpr hs |
| simp only [he, List.length_nil] at hh |
| omega)) |
| rw [Finset.sum_add_distrib, hext] at hadd |
| have hsum := Finset.sum_erase_add T D.count hsT |
| change (∑ r ∈ T, D.down r) = D.count s |
| rw [← hsum] at hadd |
| exact Nat.add_right_cancel (hadd.trans (Nat.add_comm _ _)) |
| · have he : D.vertices.filter (fun r => s <+: r) = ∅ := by |
| apply Finset.eq_empty_iff_forall_notMem.mpr |
| intro r hr |
| obtain ⟨hr, hp⟩ := Finset.mem_filter.mp hr |
| exact hsm (hD.closed hr hp.isInfix) |
| rw [he, Finset.sum_empty, D.count_zero s (Or.inl hsm)] |
|
|
| /-- Each copy of an actual base down edge is a distinct token. -/ |
| abbrev DownToken (D : Data α) := Σ s : D.vertices, Fin (D.down s.val) |
|
|
| namespace DownToken |
|
|
| variable (D : Data α) |
|
|
| def word (i : D.DownToken) : List α := i.1.val |
|
|
| theorem mem (i : D.DownToken) : word D i ∈ D.vertices := i.1.property |
|
|
| theorem nonempty (i : D.DownToken) : word D i ≠ [] := by |
| intro he |
| have hi := i.2.isLt |
| change i.2.val < D.down (word D i) at hi |
| rw [he] at hi |
| have hz := D.count_zero [] (Or.inr rfl) |
| simp only [down, hz, Nat.zero_sub, Nat.not_lt_zero] at hi |
|
|
| theorem histogram (P : List α → Prop) [DecidablePred P] : |
| (Finset.univ.filter (fun i : D.DownToken => P (word D i))).card = |
| ∑ s ∈ D.vertices, if P s then D.down s else 0 := by |
| classical |
| rw [Finset.card_filter, Fintype.sum_sigma] |
| change (∑ x : D.vertices, ∑ _ : Fin (D.down x.val), if P x.val then 1 else 0) = _ |
| simp only [Finset.sum_const, Finset.card_univ, Fintype.card_fin, |
| nsmul_eq_mul, mul_ite, mul_one, mul_zero] |
| exact Finset.sum_coe_sort D.vertices (fun s => if P s then D.down s else 0) |
|
|
| theorem card (hD : D.WellFormed) : Fintype.card D.DownToken = D.weight := by |
| have hh := histogram D (fun _ => True) |
| simpa only [Finset.filter_true, Finset.card_univ, ite_true, D.total_down hD] using hh |
|
|
| theorem prefix_count (hD : D.WellFormed) {s : List α} (hs : s ≠ []) : |
| (Finset.univ.filter (fun i : D.DownToken => s <+: word D i)).card = D.count s := by |
| rw [histogram, ← Finset.sum_filter] |
| exact D.down_descendants hD hs |
|
|
| /-- The capacity condition needed to thread the down tokens into passages. -/ |
| theorem capacity (hD : D.WellFormed) (s : List α) : |
| (Finset.univ.filter (fun i : D.DownToken => s <+: (word D i).tail)).card ≤ |
| (Finset.univ.filter (fun i : D.DownToken => s <+: word D i)).card := by |
| classical |
| by_cases hs : s = [] |
| · subst s |
| simp only [List.nil_prefix, Finset.filter_true, le_refl] |
| · let U := Finset.univ.filter (fun i : D.DownToken => s <+: (word D i).tail) |
| have hf := Finset.sum_card_fiberwise_eq_card_filter U D.alphabet |
| (fun i => (word D i).head (nonempty D i)) |
| have he : U.filter (fun i => (word D i).head (nonempty D i) ∈ D.alphabet) = U := by |
| apply Finset.filter_eq_self.mpr |
| intro i _ |
| exact hD.letters _ (mem D i) _ (List.head_mem (nonempty D i)) |
| rw [he] at hf |
| have hterm (c : α) : U.filter (fun i => (word D i).head (nonempty D i) = c) = |
| Finset.univ.filter (fun i : D.DownToken => c :: s <+: word D i) := by |
| ext i |
| simp only [U, Finset.mem_filter, Finset.mem_univ, true_and] |
| have hpref (w : List α) (hn : w ≠ []) : |
| (s <+: w.tail ∧ w.head hn = c) ↔ c :: s <+: w := by |
| cases w with |
| | nil => exact (hn rfl).elim |
| | cons a w => simp only [List.tail_cons, List.head_cons, List.cons_prefix_cons] |
| tauto |
| exact hpref _ (nonempty D i) |
| simp_rw [hterm, prefix_count D hD (List.cons_ne_nil _ _)] at hf |
| rw [prefix_count D hD hs] |
| exact hf ▸ D.left_bound hD hs |
|
|
| end DownToken |
|
|
|
|
| theorem down_permutation (D : Data α) (hD : D.WellFormed) : |
| ∃ f : Equiv.Perm D.DownToken, |
| ∀ i, (DownToken.word D i).tail <+: DownToken.word D (f i) := |
| PrefixMatching.permutation _ _ (DownToken.capacity D hD) |
|
|
| end Counts.Data |
|
|
| namespace Hierarchical |
|
|
| variable {α ι : Type} |
|
|
| /-- Down-edge tokens threaded through the acyclic up-edge runs. -/ |
| structure Threading (V : Set (List α)) (ι : Type) where |
| word : ι → List α |
| nonempty : ∀ i, word i ≠ [] |
| mem : ∀ i, word i ∈ V |
| next : Equiv.Perm ι |
| follows : ∀ i, (word i).tail <+: word (next i) |
|
|
| namespace Threading |
|
|
| variable {V : Set (List α)} (C : Threading V ι) |
|
|
| /-- The letter removed by the down step at each integer start coordinate. -/ |
| def text (i : ι) (x : ℤ) : α := |
| (C.word ((C.next ^ x) i)).head (C.nonempty _) |
|
|
| theorem text_zpow (i : ι) (d x : ℤ) : |
| C.text ((C.next ^ d) i) x = C.text i (x + d) := by |
| simp only [text, zpow_add, Equiv.Perm.mul_apply] |
|
|
| theorem text_next (i : ι) (x : ℤ) : C.text (C.next i) x = C.text i (x + 1) := by |
| simpa only [zpow_one] using C.text_zpow i 1 x |
|
|
| theorem text_period [Fintype ι] (i : ι) : |
| Function.Periodic (C.text i) (orderOf C.next : ℤ) := by |
| intro x |
| rw [← C.text_zpow, zpow_natCast, pow_orderOf_eq_one] |
| rfl |
|
|
| theorem exists_primitive_text [Fintype ι] (i : ι) : |
| ∃ p, Primitive (C.text i) p := |
| exists_primitive (orderOf_pos C.next) (C.text_period i) |
|
|
| /-- Following tails proves that every old vertex is spelled by the infinite |
| text, even if it is longer than an entire turn of the threaded circulation. -/ |
| theorem word_spelled (i : ι) : |
| C.word i = textWord (C.text i) 0 (C.word i).length := by |
| have hget : ∀ k (j : ι) (hk : k < (C.word j).length), |
| (C.word j)[k] = C.text j (k : ℤ) := by |
| intro k |
| induction k with |
| | zero => |
| intro j hk |
| simp only [text, Nat.cast_zero, zpow_zero, Equiv.Perm.one_apply] |
| exact (List.head_eq_getElem (C.nonempty j)).symm |
| | succ k ih => |
| intro j hk |
| have hkt : k < (C.word j).tail.length := by |
| rw [List.length_tail] |
| omega |
| have hkn : k < (C.word (C.next j)).length := |
| lt_of_lt_of_le hkt (C.follows j).length_le |
| calc |
| (C.word j)[k + 1] = (C.word j).tail[k] := (List.getElem_tail hkt).symm |
| _ = (C.word (C.next j))[k] := (C.follows j).getElem hkt |
| _ = C.text (C.next j) (k : ℤ) := ih _ hkn |
| _ = C.text j ((k + 1 : ℕ) : ℤ) := by |
| simpa only [Nat.cast_add, Nat.cast_one] using C.text_next j (k : ℤ) |
| apply List.ext_getElem |
| · simp only [length_textWord, sub_zero, Int.toNat_natCast] |
| · intro k hk hk' |
| simp only [textWord, List.getElem_ofFn, zero_add] |
| exact hget k i hk |
|
|
| /-- The actual exit vertex seen at any translated token. -/ |
| theorem translated_word (i : ι) (x : ℤ) : |
| C.word ((C.next ^ x) i) = |
| textWord (C.text i) x (x + (C.word ((C.next ^ x) i)).length) := by |
| calc |
| C.word ((C.next ^ x) i) = |
| textWord (C.text ((C.next ^ x) i)) 0 (C.word ((C.next ^ x) i)).length := |
| C.word_spelled _ |
| _ = textWord (C.text i) x (x + (C.word ((C.next ^ x) i)).length) := by |
| apply List.ext_getElem |
| · simp only [length_textWord, sub_zero, add_sub_cancel_left] |
| · intro k hk hk' |
| simp only [textWord, List.getElem_ofFn, zero_add, C.text_zpow] |
| congr 1 |
| omega |
|
|
| /-- Entry-exit monotonicity before sorting; all entry windows are nonnegative. -/ |
| theorem exit_mono_one (i : ι) : |
| (C.word i).length ≤ 1 + (C.word (C.next i)).length := by |
| have hh := (C.follows i).length_le |
| rw [List.length_tail] at hh |
| omega |
|
|
| end Threading |
|
|
| end Hierarchical |
|
|
| namespace Counts.Data |
|
|
| variable {α : Type} [DecidableEq α] [Inhabited α] |
|
|
| /-- Realize the base down multiset as a periodic circulation on actual vertices. -/ |
| noncomputable def threading (D : Data α) (hD : D.WellFormed) : |
| Hierarchical.Threading (D.vertices : Set (List α)) D.DownToken where |
| word := DownToken.word D |
| nonempty := DownToken.nonempty D |
| mem := DownToken.mem D |
| next := Classical.choose (D.down_permutation hD) |
| follows := Classical.choose_spec (D.down_permutation hD) |
|
|
| end Counts.Data |
|
|
| namespace OrderStats |
|
|
| variable {β : Type} [LinearOrder β] {n : ℕ} |
|
|
| omit [LinearOrder β] in |
| theorem card_filter_perm (f : Fin n → β) (e : Equiv.Perm (Fin n)) |
| (P : β → Prop) [DecidablePred P] : |
| (Finset.univ.filter (fun i => P (f (e i)))).card = |
| (Finset.univ.filter (fun i => P (f i))).card := by |
| rw [Finset.card_filter, Finset.card_filter] |
| exact Equiv.sum_comp e (fun i => if P (f i) then 1 else 0) |
|
|
| theorem order_perm (f : Fin n → β) (e : Equiv.Perm (Fin n)) (i : Fin n) : |
| order (fun j => f (e j)) i = order f i := |
| order_eq_of_counts (fun t => card_filter_perm f e (fun v => v ≤ t)) i |
|
|
| end OrderStats |
|
|
| namespace Hierarchical.Threading |
|
|
| variable {α ι : Type} {V : Set (List α)} [Fintype ι] |
|
|
| /-- Tokens with a specified full-text alignment, not just a matching finite word. -/ |
| def Aligned (C : Threading V ι) (A : ℤ → α) := {i : ι // C.text i = A} |
|
|
| noncomputable instance (C : Threading V ι) (A : ℤ → α) : Fintype (C.Aligned A) := by |
| classical |
| exact inferInstanceAs (Fintype {i : ι // C.text i = A}) |
|
|
| noncomputable def enumerate (C : Threading V ι) (A : ℤ → α) : |
| Fin (Fintype.card (C.Aligned A)) ≃ C.Aligned A := (Fintype.equivFin _).symm |
|
|
| /-- A text period permutes, rather than fixes, the multiple aligned passages. -/ |
| def periodPerm (C : Threading V ι) {A : ℤ → α} {p : ℕ} |
| (hp : Function.Periodic A (p : ℤ)) : Equiv.Perm (C.Aligned A) := |
| (C.next ^ (p : ℤ)).subtypeEquiv (by |
| intro i |
| constructor |
| · intro hi |
| funext x |
| rw [C.text_zpow, hi] |
| exact hp x |
| · intro hi |
| funext x |
| have hh := congrFun hi (x - p) |
| rw [C.text_zpow, sub_add_cancel] at hh |
| exact hh.trans (by simpa only [sub_eq_add_neg] using hp.neg x)) |
|
|
| /-- Exit ends of the unsorted primitive passages. -/ |
| noncomputable def exits (C : Threading V ι) (A : ℤ → α) (x : ℤ) |
| (j : Fin (Fintype.card (C.Aligned A))) : ℤ := |
| x + (C.word ((C.next ^ x) (C.enumerate A j).val)).length |
|
|
| theorem exits_step (C : Threading V ι) (A : ℤ → α) (x : ℤ) |
| (j : Fin (Fintype.card (C.Aligned A))) : C.exits A x j ≤ C.exits A (x + 1) j := by |
| have he : (C.next ^ (x + 1)) (C.enumerate A j).val = |
| C.next ((C.next ^ x) (C.enumerate A j).val) := by |
| rw [show x + 1 = 1 + x by omega, zpow_add, zpow_one, Equiv.Perm.mul_apply] |
| have hh := C.exit_mono_one ((C.next ^ x) (C.enumerate A j).val) |
| simp only [exits, he] |
| omega |
|
|
| theorem exits_lower (C : Threading V ι) (A : ℤ → α) (x : ℤ) |
| (j : Fin (Fintype.card (C.Aligned A))) : x + 1 ≤ C.exits A x j := by |
| have hh := List.length_pos_iff.mpr (C.nonempty ((C.next ^ x) (C.enumerate A j).val)) |
| simp only [exits] |
| omega |
|
|
| /-- Sorting independently at every coordinate gives the monotone layer function. -/ |
| noncomputable def sortedExit (C : Threading V ι) (A : ℤ → α) |
| (j : Fin (Fintype.card (C.Aligned A))) (x : ℤ) : ℤ := OrderStats.order (C.exits A x) j |
|
|
| theorem sortedExit_mono (C : Threading V ι) (A : ℤ → α) |
| (j : Fin (Fintype.card (C.Aligned A))) : Monotone (C.sortedExit A j) := by |
| apply monotone_int_of_le_succ |
| intro x |
| exact OrderStats.order_le_order (C.exits_step A x) j |
|
|
| theorem sortedExit_lower (C : Threading V ι) (A : ℤ → α) |
| (j : Fin (Fintype.card (C.Aligned A))) (x : ℤ) : x ≤ C.sortedExit A j (x - 1) := by |
| obtain ⟨k, hk⟩ := OrderStats.order_mem (C.exits A (x - 1)) j |
| change x ≤ OrderStats.order (C.exits A (x - 1)) j |
| rw [← hk] |
| have := C.exits_lower A (x - 1) k |
| omega |
|
|
| theorem exits_period (C : Threading V ι) {A : ℤ → α} {p : ℕ} |
| (hp : Function.Periodic A (p : ℤ)) (x : ℤ) |
| (j : Fin (Fintype.card (C.Aligned A))) : |
| C.exits A (x + p) j = |
| C.exits A x ((C.enumerate A).symm (C.periodPerm hp (C.enumerate A j))) + p := by |
| have he : (C.periodPerm hp (C.enumerate A j)).val = |
| (C.next ^ (p : ℤ)) (C.enumerate A j).val := rfl |
| simp only [exits, Equiv.apply_symm_apply, he, zpow_add, Equiv.Perm.mul_apply] |
| omega |
|
|
| theorem sortedExit_shift (C : Threading V ι) {A : ℤ → α} {p : ℕ} |
| (hp : Function.Periodic A (p : ℤ)) |
| (j : Fin (Fintype.card (C.Aligned A))) (x : ℤ) : |
| C.sortedExit A j (x + p) = C.sortedExit A j x + p := by |
| let e : Equiv.Perm (Fin (Fintype.card (C.Aligned A))) := |
| (C.enumerate A).trans ((C.periodPerm hp).trans (C.enumerate A).symm) |
| have he : C.exits A (x + p) = fun k => C.exits A x (e k) + p := by |
| funext k |
| exact C.exits_period hp x k |
| change OrderStats.order (C.exits A (x + p)) j = |
| OrderStats.order (C.exits A x) j + (p : ℤ) |
| rw [he, OrderStats.order_add, OrderStats.order_perm] |
|
|
| theorem exits_actual (C : Threading V ι) (A : ℤ → α) (x : ℤ) |
| (j : Fin (Fintype.card (C.Aligned A))) : textWord A x (C.exits A x j) ∈ V := by |
| have he := C.translated_word (C.enumerate A j).val x |
| rw [(C.enumerate A j).property] at he |
| exact he ▸ C.mem ((C.next ^ x) (C.enumerate A j).val) |
|
|
| /-- The sorted windows are genuine substring vertices. No abstract completion of |
| V or artificial layer windows are introduced. -/ |
| theorem sortedExit_actual (C : Threading V ι) (closed : SubstringClosed V) |
| (A : ℤ → α) (j : Fin (Fintype.card (C.Aligned A))) (x e : ℤ) |
| (hlo : C.sortedExit A j (x - 1) ≤ e) (hhi : e ≤ C.sortedExit A j x) : |
| textWord A x e ∈ V := by |
| obtain ⟨k, hk⟩ := OrderStats.order_mem (C.exits A x) j |
| have hh : e ≤ C.exits A x k := by |
| change e ≤ OrderStats.order (C.exits A x) j at hhi |
| rwa [hk] |
| exact closed (C.exits_actual A x k) |
| (textWord_infix A le_rfl ((C.sortedExit_lower A j x).trans hlo) hh) |
|
|
| /-- The ordered-layer construction for a specified primitive-text group. -/ |
| noncomputable def layer (C : Threading V ι) (closed : SubstringClosed V) |
| {A : ℤ → α} {p : ℕ} (hp : Function.Periodic A (p : ℤ)) |
| (j : Fin (Fintype.card (C.Aligned A))) : Layer V A p where |
| z := C.sortedExit A j |
| mono := C.sortedExit_mono A j |
| lower := C.sortedExit_lower A j |
| shift := C.sortedExit_shift hp j |
| actual := C.sortedExit_actual closed A j |
|
|
| theorem layers_ordered (C : Threading V ι) (A : ℤ → α) |
| (i j : Fin (Fintype.card (C.Aligned A))) (hij : i ≤ j) (x : ℤ) : |
| C.sortedExit A i x ≤ C.sortedExit A j x := OrderStats.monotone_order _ hij |
|
|
| /-- Exact conservation of vertical unit edges under the sorting operation. -/ |
| theorem sorted_edges (C : Threading V ι) (A : ℤ → α) (x e : ℤ) : |
| (Finset.univ.filter (fun j => C.sortedExit A j (x - 1) ≤ e ∧ |
| e < C.sortedExit A j x)).card = |
| (Finset.univ.filter (fun j => C.exits A (x - 1) j ≤ e ∧ |
| e < C.exits A x j)).card := by |
| apply OrderStats.sorted_edge_count |
| intro j |
| have hh := C.exits_step A (x - 1) j |
| simpa only [sub_add_cancel] using hh |
|
|
| end Hierarchical.Threading |
|
|
| end Superstring |
|
|
| end OAI |
|
|
