lean/OAI/Combinatorics/LowSpaceSubsetSum/Streams/MeasuredRow.lean

import OAI.Combinatorics.LowSpaceSubsetSum.Streams.MeasuredPivot
import OAI.Combinatorics.LowSpaceSubsetSum.Representation.RepresentationKeys

namespace OAI

/-! # Modular row initialization with measured weight evaluation

Every binary-search predicate executes the stored-record weight routine.
The left weight is computed once, and all searches address the shared right
array directly. The resulting cursor is the original filtered row cursor.
-/

namespace LowSpaceSubsetSum
namespace BinarySlice

variable {α : Type*}

def measuredRange (xs : Array α) (key : α → ℤ × ℕ) (r : ℤ) (k : ℕ)
    (hs : Monotone (fun i : Fin xs.size => (key xs[i.val]).1))
    (hk : xs.size < 2 ^ k) : SliceCursor.Range xs.size × ℕ :=
  let lo := BinaryPivot.measuredSearch (fun i : Fin xs.size =>
    let q := key xs[i.val]; (decide (q.1 < r), q.2 + 2)) k
  let hi := BinaryPivot.measuredSearch (fun i : Fin xs.size =>
    let q := key xs[i.val]; (decide (q.1 ≤ r), q.2 + 2)) k
  have hlo : lo.1.lo = lower xs (fun x => (key x).1) r k :=
    congrArg BinaryPivot.Cut.lo (BinaryPivot.measuredSearch_value _ _)
  have hhi : hi.1.lo = upper xs (fun x => (key x).1) r k :=
    congrArg BinaryPivot.Cut.lo (BinaryPivot.measuredSearch_value _ _)
  (⟨lo.1.lo, hi.1.lo - lo.1.lo, by
    rw [hlo, hhi]
    exact (range xs (fun x => (key x).1) r k hs hk).bounded⟩,
    lo.2 + hi.2 + 4)

theorem measuredRange_value (xs : Array α) (key : α → ℤ × ℕ) (r : ℤ) (k : ℕ)
    (hs : Monotone (fun i : Fin xs.size => (key xs[i.val]).1))
    (hk : xs.size < 2 ^ k) :
    (measuredRange xs key r k hs hk).1 = range xs (fun x => (key x).1) r k hs hk := by
  simp only [measuredRange, BinaryPivot.measuredSearch_value, range, lower, upper]

theorem measuredRange_work (xs : Array α) (key : α → ℤ × ℕ) (r : ℤ) (k K : ℕ)
    (hkey : ∀ x, (key x).2 ≤ K)
    (hs : Monotone (fun i : Fin xs.size => (key xs[i.val]).1))
    (hk : xs.size < 2 ^ k) :
    (measuredRange xs key r k hs hk).2 ≤ 2 * (K + 10) * k + 4 := by
  have hl := BinaryPivot.measuredSearch_work
    (fun i : Fin xs.size => let q := key xs[i.val]; (decide (q.1 < r), q.2 + 2))
    (K + 2) (fun i => Nat.add_le_add_right (hkey xs[i.val]) 2) k
  have hh := BinaryPivot.measuredSearch_work
    (fun i : Fin xs.size => let q := key xs[i.val]; (decide (q.1 ≤ r), q.2 + 2))
    (K + 2) (fun i => Nat.add_le_add_right (hkey xs[i.val]) 2) k
  change _ + _ + 4 ≤ _
  simp only [Nat.add_assoc, Nat.mul_assoc, Nat.reduceAdd] at hl hh ⊢
  omega

end BinarySlice
namespace ModularCursor

open scoped Fin.NatCast

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

def measuredForward (a : Fin n → α) (key : α → ℤ × ℕ) (P r : ℤ) (k : ℕ) :
    CyclicCursor.State n × ℕ :=
  let q := BinaryPivot.measuredSearch (fun i =>
    let w := key (a i); (decide (w.1 < P - r), w.2 + 2)) k
  (⟨Fin.ofNat n q.1.lo, n, false⟩, q.2 + 6)

def measuredReverse (a : Fin n → α) (key : α → ℤ × ℕ) (r : ℤ) (k : ℕ) :
    CyclicCursor.State n × ℕ :=
  let q := BinaryPivot.measuredSearch (fun i =>
    let w := key (a i); (decide (w.1 ≤ r), w.2 + 2)) k
  (⟨Fin.ofNat n q.1.lo - 1, n, true⟩, q.2 + 6)

theorem measuredForward_value (a : Fin n → α) (key : α → ℤ × ℕ) (P r : ℤ) (k : ℕ) :
    (measuredForward a key P r k).1 = forwardStart a (fun x => (key x).1) P r k := by
  simp only [measuredForward, BinaryPivot.measuredSearch_value, forwardStart]

theorem measuredReverse_value (a : Fin n → α) (key : α → ℤ × ℕ) (r : ℤ) (k : ℕ) :
    (measuredReverse a key r k).1 = reverseStart a (fun x => (key x).1) r k := by
  simp only [measuredReverse, BinaryPivot.measuredSearch_value, reverseStart]

theorem measuredForward_work (a : Fin n → α) (key : α → ℤ × ℕ) (P r : ℤ) (k K : ℕ)
    (hkey : ∀ x, (key x).2 ≤ K) :
    (measuredForward a key P r k).2 ≤ (K + 10) * k + 6 := by
  exact Nat.add_le_add_right (BinaryPivot.measuredSearch_work _ (K + 2)
    (fun i => Nat.add_le_add_right (hkey (a i)) 2) k) 6

theorem measuredReverse_work (a : Fin n → α) (key : α → ℤ × ℕ) (r : ℤ) (k K : ℕ)
    (hkey : ∀ x, (key x).2 ≤ K) :
    (measuredReverse a key r k).2 ≤ (K + 10) * k + 6 := by
  exact Nat.add_le_add_right (BinaryPivot.measuredSearch_work _ (K + 2)
    (fun i => Nat.add_le_add_right (hkey (a i)) 2) k) 6

end ModularCursor
namespace SliceModular

variable {α : Type*}

def measuredForward (xs : Array α) (rr : SliceCursor.Range xs.size)
    (key : α → ℤ × ℕ) (P r : ℤ) (k : ℕ) : SliceCursor.State xs.size × ℕ :=
  if h : 0 < rr.length then
    haveI : NeZero rr.length := ⟨by omega⟩
    let q := ModularCursor.measuredForward (SliceCursor.values xs rr) key P r k
    (⟨rr, some q.1⟩, q.2 + 2)
  else (⟨rr, none⟩, 1)

def measuredReverse (xs : Array α) (rr : SliceCursor.Range xs.size)
    (key : α → ℤ × ℕ) (r : ℤ) (k : ℕ) : SliceCursor.State xs.size × ℕ :=
  if h : 0 < rr.length then
    haveI : NeZero rr.length := ⟨by omega⟩
    let q := ModularCursor.measuredReverse (SliceCursor.values xs rr) key r k
    (⟨rr, some q.1⟩, q.2 + 2)
  else (⟨rr, none⟩, 1)

theorem measuredForward_value (xs : Array α) (rr : SliceCursor.Range xs.size)
    (key : α → ℤ × ℕ) (P r : ℤ) (k : ℕ) :
    (measuredForward xs rr key P r k).1 = forward xs rr (fun x => (key x).1) P r k := by
  unfold measuredForward forward
  split <;> simp only [ModularCursor.measuredForward_value]

theorem measuredReverse_value (xs : Array α) (rr : SliceCursor.Range xs.size)
    (key : α → ℤ × ℕ) (r : ℤ) (k : ℕ) :
    (measuredReverse xs rr key r k).1 = reverse xs rr (fun x => (key x).1) r k := by
  unfold measuredReverse reverse
  split <;> simp only [ModularCursor.measuredReverse_value]

theorem measuredForward_work (xs : Array α) (rr : SliceCursor.Range xs.size)
    (key : α → ℤ × ℕ) (P r : ℤ) (k K : ℕ) (hkey : ∀ x, (key x).2 ≤ K) :
    (measuredForward xs rr key P r k).2 ≤ (K + 10) * k + 8 := by
  unfold measuredForward
  split
  · rename_i h
    have : NeZero rr.length := ⟨by omega⟩
    exact Nat.add_le_add_right (ModularCursor.measuredForward_work _ key P r k K hkey) 2
  · omega

theorem measuredReverse_work (xs : Array α) (rr : SliceCursor.Range xs.size)
    (key : α → ℤ × ℕ) (r : ℤ) (k K : ℕ) (hkey : ∀ x, (key x).2 ≤ K) :
    (measuredReverse xs rr key r k).2 ≤ (K + 10) * k + 8 := by
  unfold measuredReverse
  split
  · rename_i h
    have : NeZero rr.length := ⟨by omega⟩
    exact Nat.add_le_add_right (ModularCursor.measuredReverse_work _ key r k K hkey) 2
  · omega

end SliceModular
end LowSpaceSubsetSum
namespace LowSpaceSubsetSum.FilteredStream

variable {α β : Type*}

def measuredRow (right : Array β) (wl : α → ℤ × ℕ) (wr : β → ℤ × ℕ)
    (p P c : ℤ) (hs : FilteredRow.PrimarySorted right (fun y => (wr y).1) p)
    (mode : Mode) (x : α) : PairCursor.State α right.size × ℕ :=
  let wx := wl x
  let k := steps right.size
  let low := fun y => let w := wr y; (w.1 % p, w.2 + 2)
  let high := fun y => let w := wr y; (w.1 % P, w.2 + 2)
  let rr := BinarySlice.measuredRange right low ((c - wx.1) % p) k
    hs (steps_sufficient right.size)
  let q := match mode with
    | .direct => SliceModular.measuredForward right rr.1 high P (wx.1 % P) k
    | .complementary v => SliceModular.measuredReverse right rr.1 high ((v - wx.1) % P) k
  (⟨x, q.1⟩, wx.2 + rr.2 + q.2 + 4)

theorem measuredRow_value (right : Array β) (wl : α → ℤ × ℕ) (wr : β → ℤ × ℕ)
    (p P c : ℤ) (hs : FilteredRow.PrimarySorted right (fun y => (wr y).1) p)
    (mode : Mode) (x : α) :
    (measuredRow right wl wr p P c hs mode x).1 =
      row right (fun x => (wl x).1) (fun y => (wr y).1) p P c hs mode x := by
  cases mode <;> simp only [measuredRow, row, FilteredRow.forward, FilteredRow.reverse,
    BinarySlice.measuredRange_value, SliceModular.measuredForward_value,
    SliceModular.measuredReverse_value, FilteredRow.range]

theorem measuredRow_work (right : Array β) (wl : α → ℤ × ℕ) (wr : β → ℤ × ℕ)
    (p P c : ℤ) (hs : FilteredRow.PrimarySorted right (fun y => (wr y).1) p)
    (mode : Mode) (x : α) (K : ℕ)
    (hl : ∀ x, (wl x).2 ≤ K) (hr : ∀ y, (wr y).2 ≤ K) :
    (measuredRow right wl wr p P c hs mode x).2 ≤
      3 * (K + 12) * steps right.size + K + 16 := by
  let low := fun y => let w := wr y; (w.1 % p, w.2 + 2)
  let high := fun y => let w := wr y; (w.1 % P, w.2 + 2)
  let k := steps right.size
  let rr := BinarySlice.measuredRange right low ((c - (wl x).1) % p) k
    hs (steps_sufficient right.size)
  have hrr := BinarySlice.measuredRange_work right low ((c - (wl x).1) % p) k (K + 2)
    (fun y => Nat.add_le_add_right (hr y) 2) hs (steps_sufficient right.size)
  have hx := hl x
  cases mode with
  | direct =>
    have hq := SliceModular.measuredForward_work right rr.1 high P ((wl x).1 % P) k
      (K + 2) (fun y => Nat.add_le_add_right (hr y) 2)
    change (wl x).2 + rr.2 +
      (SliceModular.measuredForward right rr.1 high P ((wl x).1 % P) k).2 + 4 ≤ _
    change rr.2 ≤ 2 * (K + 2 + 10) * k + 4 at hrr
    change _ ≤ 3 * (K + 12) * k + K + 16
    simp only [Nat.add_assoc, Nat.mul_assoc, Nat.reduceAdd] at hrr hq ⊢
    omega
  | complementary v =>
    have hq := SliceModular.measuredReverse_work right rr.1 high ((v - (wl x).1) % P) k
      (K + 2) (fun y => Nat.add_le_add_right (hr y) 2)
    change (wl x).2 + rr.2 +
      (SliceModular.measuredReverse right rr.1 high ((v - (wl x).1) % P) k).2 + 4 ≤ _
    change rr.2 ≤ 2 * (K + 2 + 10) * k + 4 at hrr
    change _ ≤ 3 * (K + 12) * k + K + 16
    simp only [Nat.add_assoc, Nat.mul_assoc, Nat.reduceAdd] at hrr hq ⊢
    omega

end LowSpaceSubsetSum.FilteredStream

end OAI