lean/OAI/Computability/Superstring/Schedule.lean

import OAI.Computability.Superstring.Attachments

namespace OAI

namespace Superstring.Hierarchical.LayerCollection

variable {α G : Type} [LinearOrder α] {V : Set (List α)} (C : LayerCollection V G)

/-- A whole group is processed, reserving at most one outgoing request record.
Incoming reserves are spent once; every new block and request is included in
this exact numerical budget. -/
theorem process_group (closed : SubstringClosed V) (supply : C.RecordSupply)
    (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 [] []) (B : Finset C.PlannedBlock) (O : Finset C.Pending),
      Q.cost + (∑ b ∈ B, b.reserve) + (∑ r ∈ O, r.reserve) ≤
        2 * (C.size g * C.period g) + ∑ r ∈ R, r.reserve ∧
      (∀ i : Fin (C.size g), C.Covered Q B O ⟨g, i⟩) ∧
      (∀ r ∈ R, ∀ i ∈ r.ids, ∀ w ∈ (C.layerAt i).Content, Q.Visits w) ∧
      (∀ r ∈ O, r.source = g) ∧ O.card ≤ 1 := by
  classical
  obtain ⟨P, J, hcP, hjP, hrP, hshort, _⟩ := C.fulfill_all closed g R targets distinct
  have finish (cut : ℕ) (hcut : cut ≤ C.size g) (P' : Path V [] [])
      (hcP' : P'.cost ≤ 2 * (cut * C.period g) + ∑ r ∈ R, r.reserve)
      (hp : ∀ i : Fin (C.size g), i.val < cut → ∀ w ∈ (C.layer g i).Content, P'.Visits w)
      (hpres : ∀ w, P.Visits w → P'.Visits w) :
      ∃ (Q : Path V [] []) (B : Finset C.PlannedBlock) (O : Finset C.Pending),
        Q.cost + (∑ b ∈ B, b.reserve) + (∑ r ∈ O, r.reserve) ≤
          2 * (C.size g * C.period g) + ∑ r ∈ R, r.reserve ∧
        (∀ i : Fin (C.size g), C.Covered Q B O ⟨g, i⟩) ∧
        (∀ r ∈ R, ∀ i ∈ r.ids, ∀ w ∈ (C.layerAt i).Content, Q.Visits w) ∧
        (∀ r ∈ O, r.source = g) ∧ O.card ≤ 1 := by
    obtain ⟨Q, B, O, hcQ, hvQ, hiQ, hsQ, hcardQ⟩ := C.complete_upper closed supply g cut hcut P' hp
    refine ⟨Q, B, O, ?_, ?_, ?_, hsQ, hcardQ⟩
    · have hmul := Nat.add_mul cut (C.size g - cut) (C.period g)
      rw [Nat.add_sub_of_le hcut] at hmul
      omega
    · intro i
      by_cases hi : i.val < cut
      · exact Or.inl (fun w hw => hvQ w (hp i hi w hw))
      · exact hiQ i ((C.mem_upper g cut i).mpr (by omega))
    · exact fun r hr i hi w hw => hvQ w (hpres w (hrP r hr i hi w hw))
  by_cases hJ : J.Nonempty
  · let base := J.max' hJ
    have hbJ : base ∈ J := Finset.max'_mem J hJ
    have hjbase : ∀ j ∈ J, j ≤ base := fun j hj => Finset.le_max' J j hj
    let I := Finset.Iic base \ J
    have hJsub : J ⊆ Finset.Iic base := fun j hj => Finset.mem_Iic.mpr (hjbase j hj)
    have hcard : I.card + J.card = base.val + 1 := by
      have hh := Finset.card_sdiff_add_card_eq_card hJsub
      rw [Fin.card_Iic] at hh
      exact hh
    obtain ⟨a, b, hf, hl, hlen⟩ := hshort base hbJ
    obtain ⟨Q, hcQ, hvQ, hiQ⟩ := C.root_below closed g base P (hjP base hbJ)
      a b hf hl hlen I (fun i hi => Finset.mem_Iic.mp (Finset.mem_sdiff.mp hi).1)
    apply finish (base.val + 1) (by omega) Q
    · have hmul := Nat.add_mul I.card J.card (C.period g)
      rw [hcard] at hmul
      omega
    · intro i hi w hw
      by_cases hj : i ∈ J
      · exact hvQ w (hjP i hj w hw)
      · exact hiQ i (Finset.mem_sdiff.mpr ⟨Finset.mem_Iic.mpr (by change i.val ≤ base.val; omega), hj⟩) w hw
    · exact hvQ
  · have heJ : J = ∅ := Finset.not_nonempty_iff_eq_empty.mp hJ
    apply finish 0 (Nat.zero_le _) P
    · simpa only [heJ, Finset.card_empty, Nat.zero_mul, Nat.mul_zero] using hcP
    · intro i hi
      omega
    · exact fun _ h => h

end Superstring.Hierarchical.LayerCollection

namespace Superstring.Hierarchical.LayerCollection

variable {α G : Type} [LinearOrder α] {V : Set (List α)} (C : LayerCollection V G)

namespace Covered
variable {C} {P Q : Path V [] []} {B D : Finset C.PlannedBlock} {R O : Finset C.Pending}

 theorem mono {i : C.Id} (h : C.Covered P B R i)
    (hp : ∀ w, P.Visits w → Q.Visits w) (hb : B ⊆ D) (hr : R ⊆ O) :
    C.Covered Q D O i := by
  rcases h with hv | ⟨b, hm, hi⟩ | ⟨r, hm, hi⟩
  · exact Or.inl (fun w hw => hp w (hv w hw))
  · exact Or.inr (Or.inl ⟨b, hb hm, hi⟩)
  · exact Or.inr (Or.inr ⟨r, hr hm, hi⟩)
end Covered

/-- Finite period-order scheduling, with all previously spent and reserved
budgets retained. Strict increase of outgoing requests is proved by their
actual record, and prevents both backward requests and duplicate sources. -/
theorem schedule (closed : SubstringClosed V) (supply : C.RecordSupply)
    (I : Finset G) (P : Path V [] []) (B : Finset C.PlannedBlock) (R : Finset C.Pending)
    (upward : ∀ g ∈ I, ∀ h, C.period g < C.period h → h ∈ I)
    (targets : ∀ r ∈ R, r.1.1 ∈ I) (sources : ∀ r ∈ R, r.source ∉ I)
    (distinct : Set.InjOn Pending.source (R : Set C.Pending))
    (ready : ∀ i : C.Id, i.1 ∈ I ∨ C.Covered P B R i) :
    ∃ Q : Path V [] [],
      Q.cost ≤ P.cost + (∑ b ∈ B, b.reserve) + (∑ r ∈ R, r.reserve) +
        ∑ g ∈ I, 2 * (C.size g * C.period g) ∧
      (∀ w, P.Visits w → Q.Visits w) ∧
      ∀ i : C.Id, ∀ w ∈ (C.layerAt i).Content, Q.Visits w := by
  classical
  induction I using Finset.strongInductionOn generalizing P B R with
  | _ I ih =>
    by_cases hI : I.Nonempty
    · obtain ⟨g, hg, hmin⟩ := Finset.exists_min_image I C.period hI
      let In := R.filter (fun r => r.1.1 = g)
      let Rest := R.filter (fun r => r.1.1 ≠ g)
      have hIn : ∀ r ∈ In, r.1.1 = g := fun _ h => (Finset.mem_filter.mp h).2
      have hdIn : Set.InjOn Pending.source (In : Set C.Pending) :=
        distinct.mono (by intro r hr; exact (Finset.mem_filter.mp hr).1)
      obtain ⟨F, D, O, hcF, hvF, hiF, hsO, hcardO⟩ := C.process_group closed supply g In hIn hdIn
      let P' := P.trans F
      let B' := B ∪ D
      let R' := Rest ∪ O
      have hup : ∀ a ∈ I.erase g, ∀ b, C.period a < C.period b → b ∈ I.erase g := by
        intro a ha b hb
        have haI := (Finset.mem_erase.mp ha).2
        apply Finset.mem_erase.mpr
        refine ⟨?_, upward a haI b hb⟩
        intro he
        subst b
        have := hmin a haI
        omega
      have htarget : ∀ r ∈ R', r.1.1 ∈ I.erase g := by
        intro r hr
        rcases Finset.mem_union.mp hr with hr | hr
        · exact Finset.mem_erase.mpr ⟨(Finset.mem_filter.mp hr).2,
            targets r (Finset.mem_filter.mp hr).1⟩
        · have hl := r.later
          rw [hsO r hr] at hl
          exact Finset.mem_erase.mpr ⟨by intro he; rw [he] at hl; omega,
            upward g hg _ hl⟩
      have hsource : ∀ r ∈ R', r.source ∉ I.erase g := by
        intro r hr
        rcases Finset.mem_union.mp hr with hr | hr
        · exact fun hh => sources r (Finset.mem_filter.mp hr).1 (Finset.mem_of_mem_erase hh)
        · rw [hsO r hr]
          exact Finset.notMem_erase g I
      have hd : Set.InjOn Pending.source (R' : Set C.Pending) := by
        intro r hr s hs he
        rcases Finset.mem_union.mp hr with hr | hr <;>
          rcases Finset.mem_union.mp hs with hs | hs
        · exact distinct (Finset.mem_filter.mp hr).1 (Finset.mem_filter.mp hs).1 he
        · have hh : r.source = g := he.trans (hsO s hs)
          exact False.elim (sources r (Finset.mem_filter.mp hr).1 (hh ▸ hg))
        · have hh : s.source = g := he.symm.trans (hsO r hr)
          exact False.elim (sources s (Finset.mem_filter.mp hs).1 (hh ▸ hg))
        · exact Finset.card_le_one.mp hcardO r hr s hs
      have hready : ∀ i : C.Id, i.1 ∈ I.erase g ∨ C.Covered P' B' R' i := by
        intro i
        by_cases hi : i.1 ∈ I.erase g
        · exact Or.inl hi
        apply Or.inr
        by_cases hig : i.1 = g
        · obtain ⟨a, j⟩ := i
          change a = g at hig
          subst a
          exact (hvF j).mono (fun _ h => Or.inr h)
            Finset.subset_union_right Finset.subset_union_right
        · have hnot : i.1 ∉ I := fun hm => hi (Finset.mem_erase.mpr ⟨hig, hm⟩)
          have hcov := (ready i).resolve_left hnot
          rcases hcov with hv | ⟨b, hb, hbi⟩ | ⟨r, hr, hri⟩
          · exact Or.inl (fun w hw => Or.inl (hv w hw))
          · exact Or.inr (Or.inl ⟨b, Finset.mem_union_left _ hb, hbi⟩)
          · by_cases hrg : r.1.1 = g
            · exact Or.inl (fun w hw => Or.inr (hiF r (Finset.mem_filter.mpr ⟨hr, hrg⟩) i hri w hw))
            · exact Or.inr (Or.inr ⟨r, Finset.mem_union_left _ (Finset.mem_filter.mpr ⟨hr, hrg⟩), hri⟩)
      obtain ⟨Q, hcQ, hvQ, hlQ⟩ := ih (I.erase g) (Finset.erase_ssubset hg)
        P' B' R' hup htarget hsource hd hready
      refine ⟨Q, ?_, fun w hw => hvQ w (Or.inl hw), hlQ⟩
      have hBsum : (∑ b ∈ B', b.reserve) ≤ (∑ b ∈ B, b.reserve) + ∑ b ∈ D, b.reserve := by
        have hh := Finset.sum_union_inter (s₁ := B) (s₂ := D) (f := PlannedBlock.reserve)
        change _ ≤ _
        dsimp only [B']
        omega
      have hRsum : (∑ r ∈ R', r.reserve) ≤ (∑ r ∈ Rest, r.reserve) + ∑ r ∈ O, r.reserve := by
        have hh := Finset.sum_union_inter (s₁ := Rest) (s₂ := O) (f := Pending.reserve)
        dsimp only [R']
        omega
      have hpartition : (∑ r ∈ In, r.reserve) + (∑ r ∈ Rest, r.reserve) = ∑ r ∈ R, r.reserve :=
        Finset.sum_filter_add_sum_filter_not R (fun r => r.1.1 = g) Pending.reserve
      have hbudget := Finset.sum_erase_add I (fun g => 2 * (C.size g * C.period g)) hg
      have hPcost : P'.cost = P.cost + F.cost := Path.cost_trans _ _
      omega
    · have heI : I = ∅ := Finset.not_nonempty_iff_eq_empty.mp hI
      have heR : R = ∅ := by
        apply Finset.eq_empty_iff_forall_notMem.mpr
        intro r hr
        have hh := targets r hr
        simp only [heI, Finset.notMem_empty] at hh
      obtain ⟨Q, hcQ, hvQ, hlQ⟩ := PlannedBlock.execute closed B P (by
        intro i
        have hh := ready i
        simp only [heI, Finset.notMem_empty, false_or] at hh
        rcases hh with hv | hb | ⟨r, hr, _⟩
        · exact Or.inl hv
        · exact Or.inr hb
        · simp only [heR, Finset.notMem_empty] at hr)
      exact ⟨Q, by simpa only [heI, heR, Finset.sum_empty, add_zero] using hcQ, hvQ, hlQ⟩

/-- The geometric main bound for any actual finite layer collection supplied
by the count rule. All local plans, requests, and functional cycles are paid. -/
theorem connect [Fintype G] (closed : SubstringClosed V) (he : [] ∈ V)
    (supply : C.RecordSupply) :
    ∃ Q : Path V [] [], Q.cost ≤ 2 * ∑ g, C.size g * C.period g ∧
      ∀ i : C.Id, ∀ w ∈ (C.layerAt i).Content, Q.Visits w := by
  classical
  obtain ⟨Q, hcQ, _, hvQ⟩ := C.schedule closed supply Finset.univ (.nil [] he) ∅ ∅
    (by simp) (by simp) (by simp) (by simp [Set.InjOn]) (by simp)
  refine ⟨Q, ?_, hvQ⟩
  simpa only [Path.cost, Finset.sum_empty, zero_add, Finset.mul_sum] using hcQ

end Superstring.Hierarchical.LayerCollection

namespace Superstring.Counts.Data

variable {α : Type} [LinearOrder α] [DecidableEq α] [Inhabited α]

/-- Reading the fully connected actual layer graph gives a constructive
numerical bound, without treating recorded prefixes as vertices. -/
theorem superstring_of_counts (D : Data α) (hD : D.WellFormed)
    (required_valid : ∀ s ∈ D.required, s ∈ D.vertices ∧ s ≠ []) :
    ∃ T : List α, T.length ≤ 2 * D.weight ∧ ∀ s ∈ D.required, s <:+: T := by
  classical
  let C := (D.threading hD).collection hD.closed
  obtain ⟨Q, hcQ, hvQ⟩ := C.connect hD.closed hD.empty_mem (D.collection_records hD)
  have hbudget : (∑ g, C.size g * C.period g) = D.weight := by
    simpa only [C, Hierarchical.Threading.collection, Nat.mul_comm] using D.layer_budget hD
  refine ⟨Q.written, ?_, ?_⟩
  · rw [Hierarchical.Path.length_written]
    simpa only [hbudget] using hcQ
  · intro s hs
    obtain ⟨hsV, hsne⟩ := required_valid s hs
    have hn := D.required_le_count hsV hsne hs
    have hpos : 0 < Fintype.card ((D.threading hD).Recorded s) := by
      rw [D.recorded_count hD hsne]
      omega
    obtain ⟨o⟩ := Fintype.card_pos_iff.mp hpos
    let e := ((D.threading hD).occurrenceEquiv hD.closed s).symm o
    let L := C.layerAt e.1
    have hprefix : s <+: Hierarchical.textWord (C.text e.1.1) e.2.val.val (L.last e.2.val.val) :=
      (L.records_iff_prefix s e.2.val.val).mp e.2.property
    have hv := hvQ e.1 _ ⟨e.2.val.val, L.last e.2.val.val,
      L.first_le_last e.2.val.val, le_rfl, rfl⟩
    have hinfix := Q.visited_infix_written hv
    simpa only [List.nil_append] using hprefix.isInfix.trans hinfix

end Superstring.Counts.Data

namespace Superstring

/-- The approximation inequality, separated from computational implementation.
This lemma is NOT the main theorem: a polynomial bit implementation is required. -/
theorem exists_two_approximation (S : Instance) :
    ∃ T : Word, IsCommonSuperstring S T ∧ T.length ≤ 2 * opt S := by
  obtain ⟨T, hcT, hvT⟩ := (Input.data S).superstring_of_counts
    (Counts.Data.input_wellFormed S) (fun s hs =>
      ⟨Input.required_mem hs, (Input.mem_core.mp hs).2.1⟩)
  exact ⟨T, (Input.core_superstring_iff S T).mp hvT,
    hcT.trans (Nat.mul_le_mul_left 2 (weight_le_opt S))⟩

end Superstring

end OAI