lean/OAI/Computability/Superstring/Records.lean

import OAI.Computability.Superstring.Counting

namespace OAI

namespace Superstring

namespace Hierarchical.Threading

variable {α ι : Type} [Fintype ι] {V : Set (List α)}

/-- Stable IDs for every sorted primitive layer of the exact base threading. -/
abbrev LayerId (C : Threading V ι) :=
  Σ g : C.Groups, Fin (Fintype.card (C.Aligned (C.groupText g)))

noncomputable def layerAt (C : Threading V ι) (closed : SubstringClosed V)
    (i : C.LayerId) : Layer V (C.groupText i.1) (C.groupPeriod i.1) :=
  C.layer closed (C.primitive_group i.1).periodic i.2

/-- Reordering a phase and a stable layer ID does not alter the recorded words. -/
noncomputable def occurrenceEquiv (C : Threading V ι) (closed : SubstringClosed V)
    (s : List α) : Family.Occurrence (C.layerAt closed) s ≃ C.Recorded s where
  toFun o := ⟨⟨o.1.1, o.2.val, o.1.2⟩,
    ((C.layerAt closed o.1).records_iff_prefix s o.2.val.val).mp o.2.property⟩
  invFun o := ⟨⟨o.val.1, o.val.2.2⟩, ⟨o.val.2.1,
    ((C.layerAt closed ⟨o.val.1, o.val.2.2⟩).records_iff_prefix s o.val.2.1.val).mpr
      o.property⟩⟩
  left_inv := by rintro ⟨⟨g, j⟩, ⟨r, hr⟩⟩; rfl
  right_inv := by rintro ⟨⟨g, r, j⟩, hr⟩; rfl

end Hierarchical.Threading

namespace Hierarchical.Layer

variable {α : Type} {V : Set (List α)} {A : ℤ → α} {p : ℕ}

/-- Moving a recorded occurrence to any identical full-text alignment preserves
its exact exit-end test. Primitivity, not just periodicity, is essential here. -/
theorem records_at_alignment (D : Layer V A p) (hp : Primitive A p)
    {s : List α} {r t : ℤ} (hr : D.Records s r)
    (halign : ∀ x, A (x + r) = A (x + t)) : D.Records s t := by
  have hper : Function.Periodic A (t - r) := by
    intro x
    have hh := (halign (x - r)).symm
    convert hh using 1 <;> congr 1 <;> omega
  obtain ⟨m, hm⟩ := (hp.period_iff_dvd (t - r)).mp hper
  have he : r + m * p = t := by rw [mul_comm]; omega
  exact he ▸ D.records_shift hp.periodic hr m

end Hierarchical.Layer

namespace Hierarchical.Threading

variable {α ι : Type} [Fintype ι] {V : Set (List α)}

omit [Fintype ι] in
/-- Identical aligned infinite texts necessarily belong to the same primitive
text group; no finite-word coincidence is substituted for this condition. -/
theorem group_eq_of_alignment (C : Threading V ι) (g h : C.Groups) (r t : ℤ)
    (halign : ∀ x, C.groupText h (x + r) = C.groupText g (x + t)) : h = g := by
  have he : C.group (Quotient.out h) = C.group (Quotient.out g) := by
    apply Quotient.sound
    refine ⟨r - t, ?_⟩
    intro x
    have hh := halign (x - t)
    convert hh using 1 <;> congr 1 <;> omega
  exact (Quotient.out_eq h).symm.trans (he.trans (Quotient.out_eq g))

abbrev AlignedOccurrence (C : Threading V ι) (closed : SubstringClosed V)
    (g : C.Groups) (t : ℤ) (s : List α) :=
  {o : Family.Occurrence (C.layerAt closed) s //
    ∀ x : ℤ, C.groupText o.1.1 (x + o.2.val.val) = C.groupText g (x + t)}

noncomputable instance (C : Threading V ι) (closed : SubstringClosed V)
    (g : C.Groups) (t : ℤ) (s : List α) : Fintype (C.AlignedOccurrence closed g t s) := by
  classical
  exact inferInstanceAs (Fintype {o : Family.Occurrence (C.layerAt closed) s //
    ∀ x : ℤ, C.groupText o.1.1 (x + o.2.val.val) = C.groupText g (x + t)})

/-- Forgetting the unique aligned residue retains a qualifying sorted layer. -/
noncomputable def qualifyingLayer (C : Threading V ι) (closed : SubstringClosed V)
    (g : C.Groups) (t : ℤ) (s : List α) (o : C.AlignedOccurrence closed g t s) :
    {j : Fin (Fintype.card (C.Aligned (C.groupText g))) //
      t + s.length ≤ C.sortedExit (C.groupText g) j t} := by
  rcases o with ⟨⟨⟨h, j⟩, r⟩, halign⟩
  have hg := C.group_eq_of_alignment g h r.val.val t halign
  subst h
  exact ⟨j, ((C.layerAt closed ⟨g, j⟩).records_at_alignment (C.primitive_group g)
    r.property halign).2⟩

theorem qualifyingLayer_injective (C : Threading V ι) (closed : SubstringClosed V)
    (g : C.Groups) (t : ℤ) (s : List α) :
    Function.Injective (C.qualifyingLayer closed g t s) := by
  rintro ⟨⟨⟨h, j⟩, r⟩, hr⟩ ⟨⟨⟨h', j'⟩, r'⟩, hr'⟩ he
  have hh := C.group_eq_of_alignment g h r.val.val t hr
  have hh' := C.group_eq_of_alignment g h' r'.val.val t hr'
  subst h
  subst h'
  have hj : j = j' := congrArg Subtype.val he
  subst j'
  have hphase : r.val = r'.val := by
    apply Fin.ext
    have hh := (C.primitive_group g).alignment_unique
      (by omega : 0 ≤ (r.val.val : ℤ)) (by exact_mod_cast r.val.isLt)
      (by omega : 0 ≤ (r'.val.val : ℤ)) (by exact_mod_cast r'.val.isLt)
      (fun x => (hr x).trans (hr' x).symm)
    omega
  have hre : r = r' := Subtype.ext hphase
  subst r'
  rfl


theorem aligned_card_le_qualifying (C : Threading V ι) (closed : SubstringClosed V)
    (g : C.Groups) (t : ℤ) (s : List α) :
    Nat.card (C.AlignedOccurrence closed g t s) ≤
      Nat.card {j : Fin (Fintype.card (C.Aligned (C.groupText g))) //
        t + s.length ≤ C.sortedExit (C.groupText g) j t} := by
  classical
  simpa only [Nat.card_eq_fintype_card] using
    Fintype.card_le_of_injective (C.qualifyingLayer closed g t s)
      (C.qualifyingLayer_injective closed g t s)

end Hierarchical.Threading

namespace Hierarchical.Processing

/-- The occurrence count tested when choosing a layer. -/
def qualifying {m : ℕ} (z : Fin m → ℤ) (H : ℤ) (p k : ℕ) : Finset (Fin m) :=
  Finset.univ.filter (fun j => H - (k * p : ℕ) ≤ z j)

theorem qualifying_bound {m : ℕ} (z : Fin m → ℤ) (hz : Monotone z)
    (H : ℤ) (p k : ℕ) (j : Fin m) (hj : z j < H - (k * p : ℕ)) :
    (qualifying z H p k).card ≤ m - 1 - j.val := by
  have hsub : qualifying z H p k ⊆ Finset.Ioi j := by
    intro i hi
    simp only [qualifying, Finset.mem_filter, Finset.mem_univ, true_and] at hi
    apply Finset.mem_Ioi.mpr
    by_contra h
    have hh := hz (le_of_not_gt h)
    omega
  exact (Finset.card_le_card hsub).trans_eq (Fin.card_Ioi j)

/-- The first failed test exists by the number of still available upper layers;
the sharp-band bound comes from the previous, successful, integer test. -/
theorem choose_k {m n : ℕ} (hn : 0 < n) (hnm : n ≤ m)
    (z : Fin m → ℤ) (hz : Monotone z) (H : ℤ) (p : ℕ)
    (hH : H ≤ z ⟨m - 1, by omega⟩)
    (hstop : (qualifying z H p n).card ≤ n) :
    ∃ (k : ℕ) (hk : 0 < k) (hkn : k ≤ n),
      (qualifying z H p k).card ≤ k ∧
      H - ((k - 1) * p : ℕ) ≤ z ⟨m - k, by omega⟩ := by
  classical
  have hex : ∃ k : ℕ, 0 < k ∧ (qualifying z H p k).card ≤ k := ⟨n, hn, hstop⟩
  let k := Nat.find hex
  have hspec : 0 < k ∧ (qualifying z H p k).card ≤ k := Nat.find_spec hex
  have hkn : k ≤ n := Nat.find_min' hex ⟨hn, hstop⟩
  refine ⟨k, hspec.1, hkn, hspec.2, ?_⟩
  by_cases hk1 : k = 1
  · simp only [hk1, Nat.sub_self, Nat.zero_mul, Nat.cast_zero, sub_zero]
    exact hH
  · have hprev : k - 1 < (qualifying z H p (k - 1)).card := by
      have hh := Nat.find_min hex (show k - 1 < k by omega)
      have hkprev : 0 < k - 1 := by omega
      exact lt_of_not_ge (fun he => hh ⟨hkprev, he⟩)
    by_contra hsharp
    have hh := qualifying_bound z hz H p (k - 1) ⟨m - k, by omega⟩
      (lt_of_not_ge hsharp)
    change (qualifying z H p (k - 1)).card ≤ m - 1 - (m - k) at hh
    omega


theorem wide_band {α : Type} {V : Set (List α)} {A : ℤ → α} {p k : ℕ}
    (H L : Layer V A p) (hp : 0 < p) (hk : 0 < k) (t : ℤ)
    (hsharp : H.first t - L.last t ≤ ((k - 1) * p : ℕ)) :
    ∀ x : ℤ, H.first x - L.last x ≤ (k * p : ℕ) := by
  intro x
  let r := (t - x) % (p : ℤ)
  let q := (t - x) / (p : ℤ)
  let y := t - r
  have hr0 : 0 ≤ r := Int.emod_nonneg _ (by omega)
  have hrp : r < p := Int.emod_lt_of_pos _ (by omega)
  have hyt : y ≤ t := by dsimp only [y]; omega
  have hty : t ≤ y + p := by dsimp only [y]; omega
  have he : x + q * p = y := by
    have hdiv := Int.emod_add_ediv_mul (t - x) (p : ℤ)
    dsimp only [r, q, y]
    omega
  have hH := H.first_mono hyt
  have hL := L.last_mono hty
  have hLshift : L.last (y + p) = L.last y + p := L.shift y
  rw [hLshift] at hL
  have hHx := H.first_shift_int q x
  have hLx := L.shift_int q x
  rw [he] at hHx hLx
  change L.last y = L.last x + q * p at hLx
  have hprod : ((k - 1) * p : ℕ) + p = k * p := by
    calc
      (k - 1) * p + p = (k - 1) * p + 1 * p := by rw [one_mul]
      _ = (k - 1 + 1) * p := (Nat.add_mul _ _ _).symm
      _ = k * p := by rw [Nat.sub_add_cancel hk]
  have hprod' : (((k - 1) * p : ℕ) : ℤ) + p = (k * p : ℕ) := by exact_mod_cast hprod
  omega

end Hierarchical.Processing

namespace Hierarchical.Layer

variable {α : Type} {V : Set (List α)} {A : ℤ → α} {p : ℕ}

theorem normalize_alignment (D : Layer V A p) (hp : 0 < p)
    (per : Function.Periodic A (p : ℤ)) {s : List α} {t : ℤ}
    (h : D.Records s t) :
    ∀ x, A (x + (D.normalize hp per h).val.val) = A (x + t) := by
  intro x
  rw [D.normalize_val hp per h]
  have hh := per.int_mul (t / (p : ℤ)) (x + t % (p : ℤ))
  have he := Int.emod_add_ediv_mul t (p : ℤ)
  simp only [Int.cast_id] at hh
  have he' : x + t % (p : ℤ) + t / (p : ℤ) * p = x + t := by omega
  rw [he'] at hh
  exact hh.symm

end Hierarchical.Layer

namespace Counts.Data

open Hierarchical
variable {α : Type} [DecidableEq α] [Inhabited α]

theorem family_occurrence_count (D : Data α) (hD : D.WellFormed) {s : List α}
    (hs : s ≠ []) :
    Fintype.card (Family.Occurrence ((D.threading hD).layerAt hD.closed) s) =
      D.count s := by
  rw [Fintype.card_congr ((D.threading hD).occurrenceEquiv hD.closed s)]
  exact D.recorded_count hD hs

/-- Empty recorded words do not disturb this identity: every positive blocking
coefficient has a strictly longer, hence nonempty, bracketing word. -/
theorem blocking_layer_count (D : Data α) (hD : D.WellFormed)
    (A : ℤ → α) (s : List α) :
    blocking D.vertices A s
      (fun r => Fintype.card (Family.Occurrence ((D.threading hD).layerAt hD.closed) r)) =
      blocking D.vertices A s D.count := by
  apply blocking_congr
  intro r _hr hlen
  apply D.family_occurrence_count hD
  intro he
  simp only [he, List.length_nil] at hlen
  omega

/-- The exact period rule plus the exact base-layer histogram forces a genuine
matching record with a different aligned bi-infinite text. -/
theorem period_forces_matching (D : Data α) (hD : D.WellFormed)
    {A : ℤ → α} {w v : List α} {p k : ℕ}
    (hp : 0 < p) (hk : 0 < k) (hper : Function.Periodic A (p : ℤ))
    (hw : w ∈ D.vertices) (hwne : w ≠ []) (hv : v ∈ D.vertices)
    (hmv : Matches A v) (hmw : Matches A w)
    (hlen : w.length + k * p = v.length)
    (ov : Family.Occurrence ((D.threading hD).layerAt hD.closed) v)
    (halign : ∀ x : ℤ, (D.threading hD).groupText ov.1.1 (x + ov.2.val.val) = A x)
    (hfew : Nat.card {o : Family.Occurrence ((D.threading hD).layerAt hD.closed) w //
      ∀ x : ℤ, (D.threading hD).groupText o.1.1 (x + o.2.val.val) = A x} ≤ k) :
    ∃ o : Family.Occurrence ((D.threading hD).layerAt hD.closed) w,
      (¬ ∀ x : ℤ, (D.threading hD).groupText o.1.1 (x + o.2.val.val) = A x) ∧
      ∃ a b : ℤ, a ≤ o.2.val.val ∧ (o.2.val.val : ℤ) + w.length ≤ b ∧
        ((D.threading hD).layerAt hD.closed o.1).first a ≤ b ∧
        b ≤ ((D.threading hD).layerAt hD.closed o.1).last a ∧
        AgreeOn ((D.threading hD).groupText o.1.1) (fun x => A (x - o.2.val.val)) a b := by
  have hvne : v ≠ [] := by
    intro he
    have hwpos := List.length_pos_iff.mpr hwne
    simp only [he, List.length_nil] at hlen
    omega
  have pos := fun i : (D.threading hD).LayerId =>
    ((D.threading hD).primitive_group i.1).positive
  have per := fun i : (D.threading hD).LayerId =>
    ((D.threading hD).primitive_group i.1).periodic
  have ht := Family.blocking_lt_of_aligned ((D.threading hD).layerAt hD.closed)
    pos per D.vertices ov halign
  rw [D.blocking_layer_count hD, D.family_occurrence_count hD hvne] at ht
  have hexcess := D.period_rule hp hk hper hw hwne hv hmv hmw hlen ht
  apply Family.matching_different ((D.threading hD).layerAt hD.closed)
    pos per D.vertices rfl hD.closed hmw k _ hfew
  rw [D.blocking_layer_count hD, D.family_occurrence_count hD hwne]
  omega

end Counts.Data

namespace Hierarchical

variable {α : Type}

/-- Reindexing a text changes coordinates, never the represented graph word. -/
theorem textWord_reindex (A : ℤ → α) (c a b : ℤ) :
    textWord (fun x => A (x + c)) a b = textWord A (a + c) (b + c) := by
  apply List.ext_getElem
  · simp only [length_textWord]
    congr 1
    omega
  · intro i hi hj
    simp only [textWord, List.getElem_ofFn]
    congr 1
    omega

namespace Layer

variable {V : Set (List α)} {A B : ℤ → α} {p q : ℕ}


structure Record (D : Layer V B q) (A : ℤ → α) where
  offset : ℤ
  start : ℤ
  stop : ℤ
  first_le : D.first (start + offset) ≤ stop + offset
  le_last : stop + offset ≤ D.last (start + offset)
  agree : AgreeOn A (fun x => B (x + offset)) start stop

namespace Record

variable {D : Layer V B q} (R : D.Record A)

theorem start_le_stop : R.start ≤ R.stop := by
  have hh := D.start_le_first (R.start + R.offset)
  have hh' := R.first_le
  omega

theorem word_eq : textWord A R.start R.stop =
    textWord B (R.start + R.offset) (R.stop + R.offset) :=
  (textWord_eq_of_agree R.agree).trans (textWord_reindex B R.offset R.start R.stop)

theorem word_mem : textWord A R.start R.stop ∈ V :=
  R.word_eq ▸ D.actual (R.start + R.offset) (R.stop + R.offset) R.first_le R.le_last

theorem touched {s t : List α} (P : Path V s t)
    (hv : P.Visits (textWord A R.start R.stop)) : D.TouchedBy P := by
  refine ⟨R.start + R.offset, R.stop + R.offset, R.first_le, R.le_last, ?_⟩
  rwa [R.word_eq] at hv

theorem length_lt (hp : 0 < p) (hq : 0 < q)
    (hA : Function.Periodic A (p : ℤ)) (hB : Function.Periodic B (q : ℤ))
    (hdiff : A ≠ fun x => B (x + R.offset)) : R.stop - R.start < p + q := by
  apply agreement_bound A (fun x => B (x + R.offset)) p q hp hq hA _ hdiff
    R.start R.stop R.agree
  intro x
  simpa only [add_right_comm] using hB (x + R.offset)

theorem same_period_length_lt (hp : 0 < p)
    (hA : Function.Periodic A (p : ℤ)) (hB : Function.Periodic B (p : ℤ))
    (hdiff : A ≠ fun x => B (x + R.offset)) : R.stop - R.start < p := by
  apply same_period_agreement_bound A (fun x => B (x + R.offset)) p hp hA _ hdiff
    R.start R.stop R.agree
  intro x
  simpa only [add_right_comm] using hB (x + R.offset)

end Record
end Layer
end Hierarchical

namespace Counts.Data

open Hierarchical
variable {α : Type} [DecidableEq α] [Inhabited α]


theorem hard_case_record (D : Data α) (hD : D.WellFormed)
    (g : (D.threading hD).Groups)
    (j : Fin (Fintype.card ((D.threading hD).Aligned ((D.threading hD).groupText g))))
    (t : ℤ) (k : ℕ) (hk : 0 < k)
    (hhard : t + (k * (D.threading hD).groupPeriod g : ℕ) <
      ((D.threading hD).layerAt hD.closed ⟨g, j⟩).first t)
    (hfew : (Processing.qualifying
      (fun l => (D.threading hD).sortedExit ((D.threading hD).groupText g) l t)
      (((D.threading hD).layerAt hD.closed ⟨g, j⟩).first t)
      ((D.threading hD).groupPeriod g) k).card ≤ k) :
    ∃ i : (D.threading hD).LayerId,
      ∃ R : ((D.threading hD).layerAt hD.closed i).Record ((D.threading hD).groupText g),
        R.start ≤ t ∧
        ((D.threading hD).layerAt hD.closed ⟨g, j⟩).first t -
          (k * (D.threading hD).groupPeriod g : ℕ) ≤ R.stop ∧
        ((D.threading hD).groupText g ≠
          fun x => (D.threading hD).groupText i.1 (x + R.offset)) ∧
        R.stop - R.start < (D.threading hD).groupPeriod g + (D.threading hD).groupPeriod i.1 ∧
        (i.1 = g → R.stop - R.start < (D.threading hD).groupPeriod g) := by
  classical
  let C := D.threading hD
  let A := C.groupText g
  let p := C.groupPeriod g
  let L := C.layerAt hD.closed ⟨g, j⟩
  let H := L.first t
  let v := textWord A t H
  let w := textWord A t (H - (k * p : ℕ))
  have hp : 0 < p := (C.primitive_group g).positive
  have per : Function.Periodic A (p : ℤ) := (C.primitive_group g).periodic
  change t + (k * p : ℕ) < H at hhard
  have hv : v ∈ D.vertices := L.first_actual t
  have hw : w ∈ D.vertices := hD.closed hv (textWord_infix A le_rfl
    (by omega : t ≤ H - (k * p : ℕ)) (by omega))
  have hwlen : t + (w.length : ℤ) = H - (k * p : ℕ) := by
    dsimp only [w]
    rw [length_textWord]
    omega
  have hvlen : t + (v.length : ℤ) = H := by
    dsimp only [v]
    rw [length_textWord]
    omega
  have hwne : w ≠ [] := by
    intro he
    simp only [he, List.length_nil, Nat.cast_zero, add_zero] at hwlen
    omega
  have hlen : w.length + k * p = v.length := by omega
  have hvrec : L.Records v t := ⟨TextOccurs.word A t H, by
    rw [hvlen]
    exact L.first_le_last t⟩
  let ov : Family.Occurrence (C.layerAt hD.closed) v :=
    ⟨⟨g, j⟩, L.normalize hp per hvrec⟩
  have halign : ∀ x, C.groupText ov.1.1 (x + ov.2.val.val) = A (x + t) :=
    L.normalize_alignment hp per hvrec
  have hmv : Matches (fun x => A (x + t)) v := by
    intro i
    simpa only [add_comm] using (TextOccurs.word A t H i)
  have hmw : Matches (fun x => A (x + t)) w := by
    intro i
    simpa only [add_comm] using (TextOccurs.word A t (H - (k * p : ℕ)) i)
  have hper : Function.Periodic (fun x => A (x + t)) (p : ℤ) := by
    intro x
    simpa only [add_right_comm] using per (x + t)
  have hcard : Nat.card {l : Fin (Fintype.card (C.Aligned A)) //
      t + w.length ≤ C.sortedExit A l t} ≤ k := by
    rw [Nat.card_eq_fintype_card, Fintype.card_subtype]
    simpa only [hwlen, Processing.qualifying] using hfew
  have hAligned : Nat.card (C.AlignedOccurrence hD.closed g t w) ≤ k :=
    (C.aligned_card_le_qualifying hD.closed g t w).trans hcard
  obtain ⟨o, hdiff, a, b, har, hrb, hfa, hbl, hagree⟩ :=
    D.period_forces_matching hD hp hk hper hw hwne hv hmv hmw hlen ov halign hAligned
  let c : ℤ := o.2.val.val - t
  let R : (C.layerAt hD.closed o.1).Record A := {
    offset := c
    start := a - c
    stop := b - c
    first_le := by simpa only [sub_add_cancel] using hfa
    le_last := by simpa only [sub_add_cancel] using hbl
    agree := by
      intro x hax hxb
      have hh := hagree (x + c) (by omega) (by omega)
      change C.groupText o.1.1 (x + c) = A (x + c - o.2.val.val + t) at hh
      have he : x + c - (o.2.val.val : ℤ) + t = x := by dsimp only [c]; omega
      rw [he] at hh
      exact hh.symm }
  have hd : A ≠ fun x => C.groupText o.1.1 (x + R.offset) := by
    intro he
    apply hdiff
    intro x
    have hh := congrFun he (x + t)
    change A (x + t) = C.groupText o.1.1 (x + t + c) at hh
    have hc : x + t + c = x + (o.2.val.val : ℤ) := by dsimp only [c]; omega
    rw [hc] at hh
    exact hh.symm
  refine ⟨o.1, R, ?_, ?_, hd,
    R.length_lt hp (C.primitive_group o.1.1).positive per
      (C.primitive_group o.1.1).periodic hd, ?_⟩
  · change a - c ≤ t
    dsimp only [c]
    omega
  · change H - (k * p : ℕ) ≤ b - c
    dsimp only [c]
    omega
  · intro he
    apply R.same_period_length_lt hp per _ hd
    simpa only [he] using (C.primitive_group o.1.1).periodic

end Counts.Data

end Superstring

end OAI