import OAI.Combinatorics.LowSpaceSubsetSum.Streams.CyclicCursor
import OAI.Combinatorics.LowSpaceSubsetSum.Streams.BinaryPivot

namespace OAI

/-!
# Executable modular row initialization

Binary search finds the first direct pivot and the position after the last
complementary pivot. The resulting constant-state cyclic cursor produces
the corresponding sorted modular row exactly. The cutoff search uses a
supplied number of steps; the theorem requires only that the array length
be smaller than `2^k`. Equal residues stay separate array occurrences.
-/

namespace LowSpaceSubsetSum
namespace ModularCursor

open scoped Fin.NatCast

variable {n : ℕ} [NeZero n] {α : Type*}

def forwardStart (a : Fin n → α) (residue : α → ℤ) (P r : ℤ) (k : ℕ) :
    CyclicCursor.State n :=
  ⟨Fin.ofNat n (BinaryPivot.search (fun i => decide (residue (a i) < P - r)) k).lo,
    n, false⟩

def reverseStart (a : Fin n → α) (residue : α → ℤ) (K : ℤ) (k : ℕ) :
    CyclicCursor.State n :=
  ⟨Fin.ofNat n (BinaryPivot.search (fun i => decide (residue (a i) ≤ K)) k).lo - 1,
    n, true⟩

theorem forward_trace (a : Fin n → α) (residue : α → ℤ) (P r : ℤ) (k : ℕ)
    (hk : n < 2 ^ k) (hsort : Monotone (fun i => residue (a i))) :
    CyclicCursor.trace a n (forwardStart a residue P r k) =
      ModularRows.direct P r residue (List.ofFn a) := by
  have hprefix : BinaryPivot.PrefixPredicate
      (fun i : Fin n => decide (residue (a i) < P - r)) := by
    intro i j hij hj
    apply decide_eq_true
    exact lt_of_le_of_lt (hsort hij) (of_decide_eq_true hj)
  have hsplit := BinaryPivot.search_split a
    (fun x => decide (residue x < P - r)) hprefix k hk
  let c := BinaryPivot.search (fun i : Fin n => decide (residue (a i) < P - r)) k
  let lo := (List.ofFn a).take c.lo
  let hi := (List.ofFn a).drop c.lo
  have hc : c.lo ≤ n := c.ordered.trans c.bounded
  have hlist : List.ofFn a = lo ++ hi := (List.take_append_drop c.lo _).symm
  apply CyclicCursor.forward_trace_eq_direct a P r residue lo hi hlist
    (Fin.ofNat n c.lo)
  · simp [lo, hc]
  · simpa only [decide_eq_true_eq] using hsplit.1
  · simpa only [decide_eq_false_iff_not, not_lt] using hsplit.2

theorem reverse_trace (a : Fin n → α) (residue : α → ℤ) (K : ℤ) (k : ℕ)
    (hk : n < 2 ^ k) (hsort : Monotone (fun i => residue (a i))) :
    CyclicCursor.trace a n (reverseStart a residue K k) =
      ModularRows.complementary K residue (List.ofFn a) := by
  have hprefix : BinaryPivot.PrefixPredicate
      (fun i : Fin n => decide (residue (a i) ≤ K)) := by
    intro i j hij hj
    apply decide_eq_true
    exact (hsort hij).trans (of_decide_eq_true hj)
  have hsplit := BinaryPivot.search_split a
    (fun x => decide (residue x ≤ K)) hprefix k hk
  let c := BinaryPivot.search (fun i : Fin n => decide (residue (a i) ≤ K)) k
  let lo := (List.ofFn a).take c.lo
  let hi := (List.ofFn a).drop c.lo
  have hc : c.lo ≤ n := c.ordered.trans c.bounded
  have hlist : List.ofFn a = lo ++ hi := (List.take_append_drop c.lo _).symm
  apply CyclicCursor.reverse_trace_eq_complementary a K residue lo hi hlist
    (Fin.ofNat n c.lo)
  · simp [lo, hc]
  · simpa only [decide_eq_true_eq] using hsplit.1
  · simpa only [decide_eq_false_iff_not, not_le] using hsplit.2

theorem forward_sorted (a : Fin n → α) (residue : α → ℤ) (P r : ℤ) (k : ℕ)
    (hk : n < 2 ^ k) (hsort : Monotone (fun i => residue (a i)))
    (hr : 0 ≤ r) (hrP : r < P) (hbound : ∀ i, 0 ≤ residue (a i) ∧ residue (a i) < P) :
    (CyclicCursor.trace a n (forwardStart a residue P r k)).Pairwise
      (fun x y => (r + residue x) % P ≤ (r + residue y) % P) := by
  rw [forward_trace a residue P r k hk hsort]
  apply ModularRows.direct_sorted hr hrP
  · intro x hx
    obtain ⟨i, rfl⟩ := List.mem_ofFn.mp hx
    exact hbound i
  · exact List.pairwise_ofFn.mpr (fun _ _ h => hsort h.le)

theorem reverse_sorted (a : Fin n → α) (residue : α → ℤ) (P K : ℤ) (k : ℕ)
    (hk : n < 2 ^ k) (hsort : Monotone (fun i => residue (a i)))
    (hK : 0 ≤ K) (hKP : K < P) (hbound : ∀ i, 0 ≤ residue (a i) ∧ residue (a i) < P) :
    (CyclicCursor.trace a n (reverseStart a residue K k)).Pairwise
      (fun x y => (K - residue x) % P ≤ (K - residue y) % P) := by
  rw [reverse_trace a residue K k hk hsort]
  apply ModularRows.complementary_sorted hK hKP
  · intro x hx
    obtain ⟨i, rfl⟩ := List.mem_ofFn.mp hx
    exact hbound i
  · exact List.pairwise_ofFn.mpr (fun _ _ h => hsort h.le)

end ModularCursor
end LowSpaceSubsetSum

end OAI