import OAI.Combinatorics.LowSpaceSubsetSum.Streams.MergeCorrectness

namespace OAI

/-!
# Sortedness of complete and stopped row merges

Only each row's individual order is required. The tournament minimum is
no larger than every remaining occurrence; replacing its front by its
successor preserves this invariant. Every finite trace is therefore sorted,
including traces stopped by the operation cap.
-/

namespace LowSpaceSubsetSum
namespace RowMerge

universe u v

variable {α : Type u} {σ : Type v} {d : ℕ}

def RowsSorted (key : α → ℤ) (view : σ → List α)
    (t : Tournament.Tree (Front d α σ) d) : Prop :=
  ∀ p, (remaining view t p).Pairwise (fun x y => key x ≤ key y)

theorem replacement_remaining_subset (key : α → ℤ) (read : σ → Option (α × σ))
    (view : σ → List α) (hread : IsReader read view)
    (t : Tournament.Tree (Front d α σ) d)
    (ht : Tournament.Valid (fun y => key y.value) t) (halign : Aligned t)
    {x : Front d α σ} (hx : Tournament.winner t = some x) (p : Path d) :
    remaining view (Tournament.replace (fun y => key y.value) t x.row
      (front read x.row x.after)) p ⊆ remaining view t p := by
  have hnew := replace_remaining key read view hread t x p
  have hrow := winner_at_own_row key t ht halign hx
  rw [hnew]
  by_cases hp : x.row = p
  · subst p
    rw [ite_eq_left rfl]
    simp only [remaining, hrow]
    intro y hy
    exact List.mem_cons_of_mem _ hy
  · rw [ite_eq_right hp]

theorem replacement_rowsSorted (key : α → ℤ) (read : σ → Option (α × σ))
    (view : σ → List α) (hread : IsReader read view)
    (t : Tournament.Tree (Front d α σ) d)
    (ht : Tournament.Valid (fun y => key y.value) t) (halign : Aligned t)
    (hsort : RowsSorted key view t) {x : Front d α σ}
    (hx : Tournament.winner t = some x) :
    RowsSorted key view (Tournament.replace (fun y => key y.value) t x.row
      (front read x.row x.after)) := by
  intro p
  rw [replace_remaining key read view hread t x p]
  by_cases hp : x.row = p
  · subst p
    rw [ite_eq_left rfl]
    have hs := hsort x.row
    have hrow := winner_at_own_row key t ht halign hx
    simp only [remaining, hrow] at hs
    exact (List.pairwise_cons.mp hs).2
  · rw [ite_eq_right hp]
    exact hsort p

theorem winner_le_remaining (key : α → ℤ) (view : σ → List α)
    (t : Tournament.Tree (Front d α σ) d)
    (ht : Tournament.Valid (fun y => key y.value) t) (hsort : RowsSorted key view t)
    {x : Front d α σ} (hx : Tournament.winner t = some x)
    (p : Path d) {y : α} (hy : y ∈ remaining view t p) : key x.value ≤ key y := by
  cases hp : Tournament.lookup t p with
  | none => simp [remaining, hp] at hy
  | some z =>
    have hmin := winner_is_minimum key t ht hx p hp
    have hs := hsort p
    simp only [remaining, hp] at hy hs
    rcases List.mem_cons.mp hy with hy | hy
    · simpa [hy] using hmin
    · exact hmin.trans ((List.pairwise_cons.mp hs).1 y hy)

theorem trace_lower_bound (key : α → ℤ) (read : σ → Option (α × σ))
    (view : σ → List α) (hread : IsReader read view) (k : ℕ)
    (t : Tournament.Tree (Front d α σ) d)
    (ht : Tournament.Valid (fun y => key y.value) t) (halign : Aligned t)
    (c : ℤ) (hc : ∀ p, ∀ y ∈ remaining view t p, c ≤ key y) :
    ∀ y ∈ trace key read k t, c ≤ key y := by
  induction k generalizing t with
  | zero => simp [trace]
  | succ k ih =>
    cases hw : Tournament.winner t with
    | none => simp [trace, advance, hw]
    | some x =>
      let t' := Tournament.replace (fun y => key y.value) t x.row (front read x.row x.after)
      have ha : advance key read t = some (x.value, t') := by simp [advance, hw, t']
      have ht' := advance_valid key read t ht ha
      have halign' := advance_aligned key read t halign ha
      have hrow := winner_at_own_row key t ht halign hw
      have hfront : c ≤ key x.value := hc x.row x.value (by simp [remaining, hrow])
      have hc' : ∀ p, ∀ y ∈ remaining view t' p, c ≤ key y := by
        intro p y hy
        exact hc p y (replacement_remaining_subset key read view hread t ht halign hw p hy)
      rw [trace, ha]
      intro y hy
      rcases List.mem_cons.mp hy with hy | hy
      · simpa [hy] using hfront
      · exact ih t' ht' halign' hc' y hy

theorem trace_sorted (key : α → ℤ) (read : σ → Option (α × σ))
    (view : σ → List α) (hread : IsReader read view) (k : ℕ)
    (t : Tournament.Tree (Front d α σ) d)
    (ht : Tournament.Valid (fun y => key y.value) t) (halign : Aligned t)
    (hsort : RowsSorted key view t) :
    (trace key read k t).Pairwise (fun x y => key x ≤ key y) := by
  induction k generalizing t with
  | zero => simp [trace]
  | succ k ih =>
    cases hw : Tournament.winner t with
    | none => simp [trace, advance, hw]
    | some x =>
      let t' := Tournament.replace (fun y => key y.value) t x.row (front read x.row x.after)
      have ha : advance key read t = some (x.value, t') := by simp [advance, hw, t']
      have ht' := advance_valid key read t ht ha
      have halign' := advance_aligned key read t halign ha
      have hsort' := replacement_rowsSorted key read view hread t ht halign hsort hw
      rw [trace, ha]
      apply List.pairwise_cons.mpr
      refine ⟨?_, ih t' ht' halign' hsort'⟩
      apply trace_lower_bound key read view hread k t' ht' halign' (key x.value)
      intro p y hy
      exact winner_le_remaining key view t ht hsort hw p
        (replacement_remaining_subset key read view hread t ht halign hw p hy)

end RowMerge
end LowSpaceSubsetSum

end OAI