import OAI.Combinatorics.LowSpaceSubsetSum.Streams.WeightEncoding

namespace OAI

/-! # Indexed membership, signed sums and fixed-width key generation

The runtime mask is an indexed list; its finite set is only a proof view.
The operation tally counts index comparisons, addition, testBit and list
construction. Numerical values occupy the word widths proved separately.
Every finite indexed mask is permitted, including repeated input values.
-/

namespace LowSpaceSubsetSum.CountedWeights

variable {n : ℕ}

def member (i : Fin n) : List (Fin n) → Bool × ℕ
  | [] => (false, 1)
  | j :: xs =>
    if i = j then (true, 1) else
      let rest := member i xs
      (rest.1, rest.2 + 1)

theorem member_value (i : Fin n) (xs : List (Fin n)) :
    (member i xs).1 = decide (i ∈ xs) := by
  induction xs with
  | nil => simp [member]
  | cons j xs ih => by_cases h : i = j <;> simp [member, h, ih]

theorem member_work (i : Fin n) (xs : List (Fin n)) :
    (member i xs).2 ≤ xs.length + 1 := by
  induction xs with
  | nil => simp [member]
  | cons j xs ih => simp only [member, List.length_cons]; split <;> dsimp only <;> omega

def sumIndices (a : Fin n → ℤ) (mask : List (Fin n)) : List (Fin n) → ℤ × ℕ
  | [] => (0, 1)
  | i :: xs =>
    let hit := member i mask
    let rest := sumIndices a mask xs
    ((if hit.1 then a i else 0) + rest.1, hit.2 + rest.2 + 3)

theorem sumIndices_value (a : Fin n → ℤ) (mask : List (Fin n)) (xs : List (Fin n)) :
    (sumIndices a mask xs).1 = (xs.map (fun i => if i ∈ mask then a i else 0)).sum := by
  induction xs with
  | nil => rfl
  | cons i xs ih => simp only [sumIndices, member_value, decide_eq_true_eq,
      List.map_cons, List.sum_cons, ih]

theorem sumIndices_work (a : Fin n → ℤ) (mask : List (Fin n)) (xs : List (Fin n)) :
    (sumIndices a mask xs).2 ≤ (mask.length + 4) * xs.length + 1 := by
  induction xs with
  | nil => simp [sumIndices]
  | cons i xs ih =>
    have hm := member_work i mask
    simp only [sumIndices, List.length_cons, Nat.mul_add, Nat.mul_one]
    omega

def weight (a : Fin n → ℤ) (mask : List (Fin n)) : ℤ × ℕ :=
  sumIndices a mask (List.ofFn id)

theorem weight_value (a : Fin n → ℤ) (mask : List (Fin n)) :
    (weight a mask).1 = LowSpaceSubsetSum.weight a mask.toFinset := by
  rw [weight, sumIndices_value]
  simp only [List.map_ofFn, Function.comp_id, List.sum_ofFn, LowSpaceSubsetSum.weight, List.mem_toFinset]

theorem weight_work (a : Fin n → ℤ) (mask : List (Fin n)) :
    (weight a mask).2 ≤ (mask.length + 4) * n + 1 := by
  have h := sumIndices_work a mask (List.ofFn id)
  simp only [List.length_ofFn] at h
  exact h

def maskIndices (mask : List (Fin n)) : List (Fin n) → List Bool × ℕ
  | [] => ([], 1)
  | i :: xs =>
    let hit := member i mask
    let rest := maskIndices mask xs
    (hit.1 :: rest.1, hit.2 + rest.2 + 2)

theorem maskIndices_value (mask : List (Fin n)) (xs : List (Fin n)) :
    (maskIndices mask xs).1 = xs.map (fun i => decide (i ∈ mask)) := by
  induction xs with
  | nil => rfl
  | cons i xs ih => simp only [maskIndices, member_value, ih, List.map_cons]

theorem maskIndices_work (mask : List (Fin n)) (xs : List (Fin n)) :
    (maskIndices mask xs).2 ≤ (mask.length + 3) * xs.length + 1 := by
  induction xs with
  | nil => simp [maskIndices]
  | cons i xs ih =>
    have hm := member_work i mask
    simp only [maskIndices, List.length_cons, Nat.mul_add, Nat.mul_one]
    omega

def maskBits (mask : List (Fin n)) : List Bool × ℕ := maskIndices mask (List.ofFn id)

theorem maskBits_value (mask : List (Fin n)) :
    (maskBits mask).1 = WeightEncoding.maskBits mask.toFinset := by
  rw [maskBits, maskIndices_value]
  simp only [List.map_ofFn, Function.comp_id, WeightEncoding.maskBits, List.mem_toFinset]

theorem maskBits_work (mask : List (Fin n)) :
    (maskBits mask).2 ≤ (mask.length + 3) * n + 1 := by
  have h := maskIndices_work mask (List.ofFn id)
  simp only [List.length_ofFn] at h
  exact h

/-- Each output bit uses one testBit operation and one list record. -/
def bits (value : ℕ) : ℕ → ℕ → List Bool × ℕ
  | 0, _ => ([], 1)
  | k + 1, start =>
    let rest := bits value k (start + 1)
    (value.testBit start :: rest.1, rest.2 + 3)

theorem bits_value (value k start : ℕ) :
    (bits value k start).1 = List.ofFn (fun i : Fin k => value.testBit (start + i.val)) := by
  induction k generalizing start with
  | zero => rfl
  | succ k ih =>
    simp only [bits, ih, List.ofFn_succ, Fin.val_zero, Nat.add_zero, Fin.val_succ]
    congr 1
    congr 1
    funext i
    congr 1
    omega

theorem bits_work (value k start : ℕ) : (bits value k start).2 = 3 * k + 1 := by
  induction k generalizing start with
  | zero => rfl
  | succ k ih => simp only [bits, ih]; omega

def natBits (width value : ℕ) : List Bool × ℕ := bits value width 0

theorem natBits_value (width value : ℕ) :
    (natBits width value).1 = WeightEncoding.natBits width value := by
  simp only [natBits, bits_value, Nat.zero_add, WeightEncoding.natBits]

def entryKey (I : Instance n) (value : ℤ) (mask : List (Fin n)) : List Bool × ℕ :=
  let mag := natBits (2 * inputScale I) value.natAbs
  let bits := maskBits mask
  (decide (value < 0) :: (mag.1 ++ bits.1), mag.2 + bits.2 + 2 * inputScale I + 3)

theorem entryKey_value (I : Instance n) (value : ℤ) (mask : List (Fin n)) :
    (entryKey I value mask).1 = WeightEncoding.entryKey I ⟨value, mask.toFinset⟩ := by
  simp only [entryKey, natBits_value, maskBits_value,
    WeightEncoding.entryKey, WeightEncoding.weightKey, WeightEncoding.signedBits, List.cons_append]

theorem entryKey_work (I : Instance n) (value : ℤ) (mask : List (Fin n)) (hmask : mask.length ≤ n) :
    (entryKey I value mask).2 ≤ 12 * inputScale I ^ 2 := by
  have hm := maskBits_work mask
  have hn : n ≤ inputScale I := by unfold inputScale; omega
  have hu : 2 ≤ inputScale I := by unfold inputScale; omega
  have hs : n ^ 2 ≤ inputScale I ^ 2 := Nat.pow_le_pow_left hn 2
  have hp := Nat.mul_le_mul_right n (Nat.add_le_add_right hmask 3)
  simp only [entryKey, natBits, bits_work]
  nlinarith only [hm, hn, hu, hs, hp]

end LowSpaceSubsetSum.CountedWeights

end OAI