import OAI.Combinatorics.LowSpaceSubsetSum.Streams.MergedReader
import Mathlib.Algebra.BigOperators.Fin

namespace OAI

/-!
# Binary indexing and empty padding for the row tournament

Binary paths index a power-of-two set of leaves. Array indices occupy the
initial segment and all other leaves are empty. The reindexing proof counts
exact occurrences; its finite sums and lists are analysis views only.
-/

namespace LowSpaceSubsetSum
namespace PaddedRows

variable {α σ : Type*}

def index (d : ℕ) : RowMerge.Path d ≃ Fin (2 ^ d) :=
  (Equiv.piCongrRight (fun _ : Fin d => finTwoEquiv.symm)).trans finFunctionFinEquiv

def next (read : σ → Option (α × σ)) : Option σ → Option (α × Option σ)
  | none => none
  | some s => (read s).map (fun z => (z.1, some z.2))

def view (output : σ → List α) : Option σ → List α
  | none => []
  | some s => output s

theorem reader (read : σ → Option (α × σ)) (output : σ → List α)
    (hread : RowMerge.IsReader read output) : RowMerge.IsReader (next read) (view output) := by
  intro s
  cases s with
  | none => rfl
  | some s =>
    have h := hread s
    cases hr : read s with
    | none => simpa only [next, hr, Option.map_none, view] using h
    | some z => simpa only [next, hr, Option.map_some, view] using h

def rows (xs : Array σ) (d : ℕ) (p : RowMerge.Path d) : Option σ :=
  if h : (index d p).val < xs.size then some xs[(index d p).val] else none

theorem rows_sorted (xs : Array σ) (d : ℕ) (output : σ → List α) (key : α → ℤ)
    (hs : ∀ s ∈ xs.toList, (output s).Pairwise (fun x y => key x ≤ key y))
    (p : RowMerge.Path d) :
    (view output (rows xs d p)).Pairwise (fun x y => key x ≤ key y) := by
  unfold rows
  split_ifs with h
  · apply hs
    exact List.mem_iff_getElem.mpr ⟨(index d p).val,
      by simpa only [Array.length_toList] using h, by simp⟩
  · simp [view]

theorem sum_padding {M : Type*} [AddCommMonoid M] (n m : ℕ) (hnm : n ≤ m)
    (f : Fin n → M) :
    (∑ i : Fin m, if h : i.val < n then f ⟨i.val, h⟩ else 0) = ∑ i : Fin n, f i := by
  induction m with
  | zero =>
    have hn : n = 0 := by omega
    subst n
    simp
  | succ m ih =>
    by_cases hn : n ≤ m
    · rw [Fin.sum_univ_castSucc]
      have hlast : ¬ m < n := by omega
      simp only [Fin.val_castSucc, Fin.val_last, dite_eq_right hlast, add_zero]
      exact ih hn
    · have hn : n = m + 1 := by omega
      subst n
      apply Finset.sum_congr rfl
      intro i _
      exact dite_eq_left i.isLt

theorem sum_rows {M : Type*} [AddCommMonoid M] (xs : Array σ) (d : ℕ)
    (hd : xs.size ≤ 2 ^ d) (f : σ → M) :
    (∑ p : RowMerge.Path d, match rows xs d p with | none => 0 | some s => f s) =
      ∑ i : Fin xs.size, f xs[i.val] := by
  calc
    _ = ∑ i : Fin (2 ^ d), if h : i.val < xs.size then f xs[i.val] else 0 := by
      apply Fintype.sum_equiv (index d)
      intro p
      dsimp only [rows]
      split_ifs <;> rfl
    _ = _ := sum_padding xs.size (2 ^ d) hd (fun i => f xs[i.val])

theorem row_bag (xs : Array σ) (d : ℕ) (hd : xs.size ≤ 2 ^ d) (output : σ → List α) :
    (∑ p : RowMerge.Path d, (view output (rows xs d p) : Multiset α)) =
      ∑ i : Fin xs.size, (output xs[i.val] : Multiset α) := by
  calc
    _ = ∑ p : RowMerge.Path d,
        match rows xs d p with | none => 0 | some s => (output s : Multiset α) := by
      apply Finset.sum_congr rfl
      intro p _
      cases rows xs d p <;> rfl
    _ = _ := sum_rows xs d hd (fun s => (output s : Multiset α))

end PaddedRows
end LowSpaceSubsetSum

end OAI