import OAI.Combinatorics.EditApproximation.Queries.QueryOrderBounds

namespace OAI

/-! Key encoding uses only a fixed number of natural-word operations.
Its word sizes and Boolean work are polynomial in the coordinate widths. -/

namespace EditApproximation

theorem queryNaturalAdd_size (a b : ℕ) : Nat.size (a + b) ≤ Nat.size a + Nat.size b + 1 := by
  have h := bitAddWithWork_length a.bits b.bits false
  have hs := Nat.size_le.mpr (bitWordValue_lt_pow_length (binaryNaturalAddWithWork a b).1)
  rw [binaryNaturalAddWithWork_value] at hs
  simp only [binaryNaturalAddWithWork] at hs
  simp only [Nat.size_eq_bits_len] at h
  omega

theorem queryNaturalMul_size (a b : ℕ) : Nat.size (a * b) ≤ 2 * Nat.size a + Nat.size b + 1 := by
  have h := bitMulWithWork_length a.bits b.bits
  have hs := Nat.size_le.mpr (bitWordValue_lt_pow_length (binaryNaturalMulWithWork a b).1)
  rw [binaryNaturalMulWithWork_value] at hs
  simp only [binaryNaturalMulWithWork] at hs
  simp only [Nat.size_eq_bits_len] at h
  omega

theorem queryNaturalAdd_cost (a b K : ℕ) (ha : Nat.size a ≤ K) (hb : Nat.size b ≤ K) :
    (binaryNaturalAddWithWork a b).2 ≤ 18 * K + 1 := by
  have h := binaryNaturalAddWithWork_cost a b
  omega

theorem queryNaturalMul_cost (a b K : ℕ) (ha : Nat.size a ≤ K) (hb : Nat.size b ≤ K) :
    (binaryNaturalMulWithWork a b).2 ≤ 20 * (K + 1) * (2 * K + 1) := by
  apply (binaryNaturalMulWithWork_cost a b).trans
  gcongr
  omega

theorem queryChildCodeWithWork_bounds {M n : ℕ} (input : Fin M × TargetInterval n)
    (B : ℕ) (hM : Nat.size M ≤ B) (hn : Nat.size n ≤ B) :
    Nat.size (queryChildCodeWithWork input).1 ≤ 8 * (B + 1) ∧
      (queryChildCodeWithWork input).2 ≤ 100000 * (B + 1) ^ 2 := by
  have hi : Nat.size input.1.val ≤ B := (Nat.size_le_size input.1.isLt.le).trans hM
  have hl : Nat.size input.2.lo ≤ B :=
    (Nat.size_le_size (input.2.ordered.trans input.2.valid)).trans hn
  have hh : Nat.size input.2.hi ≤ B := (Nat.size_le_size input.2.valid).trans hn
  have hw : Nat.size (n + 1) ≤ B + 2 := by
    have h := queryNaturalAdd_size n 1
    norm_num only [Nat.size_one] at h
    omega
  have hhigh : Nat.size ((n + 1) * input.2.hi) ≤ 3 * B + 5 := by
    have h := queryNaturalMul_size (n + 1) input.2.hi
    omega
  have hcoord : Nat.size (input.2.lo + (n + 1) * input.2.hi) ≤ 4 * B + 6 := by
    have h := queryNaturalAdd_size input.2.lo ((n + 1) * input.2.hi)
    omega
  have hscaled : Nat.size (M * (input.2.lo + (n + 1) * input.2.hi)) ≤ 6 * B + 7 := by
    have h := queryNaturalMul_size M (input.2.lo + (n + 1) * input.2.hi)
    omega
  have hout : Nat.size (input.1.val + M * (input.2.lo + (n + 1) * input.2.hi)) ≤ 7 * B + 8 := by
    have h := queryNaturalAdd_size input.1.val (M * (input.2.lo + (n + 1) * input.2.hi))
    omega
  constructor
  · rw [queryChildCodeWithWork_value]
    exact hout.trans (by omega)
  · let K := 8 * (B + 1)
    have h1 : Nat.size 1 ≤ K := by norm_num only [Nat.size_one]; dsimp [K]; omega
    have hN : Nat.size n ≤ K := by dsimp [K]; omega
    have hW : Nat.size (n + 1) ≤ K := by dsimp [K]; omega
    have hI : Nat.size input.1.val ≤ K := by dsimp [K]; omega
    have hL : Nat.size input.2.lo ≤ K := by dsimp [K]; omega
    have hH : Nat.size input.2.hi ≤ K := by dsimp [K]; omega
    have hM' : Nat.size M ≤ K := by dsimp [K]; omega
    have hHigh : Nat.size ((n + 1) * input.2.hi) ≤ K := by dsimp [K]; omega
    have hCoord : Nat.size (input.2.lo + (n + 1) * input.2.hi) ≤ K := by dsimp [K]; omega
    have hScaled : Nat.size (M * (input.2.lo + (n + 1) * input.2.hi)) ≤ K := by dsimp [K]; omega
    have c1 := queryNaturalAdd_cost n 1 K hN h1
    have c2 := queryNaturalMul_cost (n + 1) input.2.hi K hW hH
    have c3 := queryNaturalAdd_cost input.2.lo ((n + 1) * input.2.hi) K hL hHigh
    have c4 := queryNaturalMul_cost M (input.2.lo + (n + 1) * input.2.hi) K hM' hCoord
    have c5 := queryNaturalAdd_cost input.1.val (M * (input.2.lo + (n + 1) * input.2.hi)) K hI hScaled
    simp only [queryChildCodeWithWork, binaryNaturalAddWithWork_value, binaryNaturalMulWithWork_value]
    dsimp only [K] at c1 c2 c3 c4 c5
    nlinarith only [c1, c2, c3, c4, c5, Nat.zero_le B]

theorem queryChildOrderWithWork_cost {M n : ℕ} (a b : Fin M × TargetInterval n)
    (B : ℕ) (hM : Nat.size M ≤ B) (hn : Nat.size n ≤ B) :
    (queryEncodedLEWithWork queryChildCodeWithWork a b).2 ≤ 201000 * (B + 1) ^ 2 := by
  have ha := queryChildCodeWithWork_bounds a B hM hn
  have hb := queryChildCodeWithWork_bounds b B hM hn
  have h := queryEncodedLEWithWork_cost queryChildCodeWithWork a b
    (100000 * (B + 1) ^ 2) (8 * (B + 1)) ha.2 hb.2 ha.1 hb.1
  nlinarith only [h, Nat.zero_le B]

theorem queryOrderedChildInputsWithWork_cost {M n : ℕ} (inputs : List (Fin M × TargetInterval n))
    (B : ℕ) (hM : Nat.size M ≤ B) (hn : Nat.size n ≤ B) :
    (queryOrderedChildInputsWithWork inputs).2 ≤
      (inputs.length + 1) ^ 2 * (202000 * (B + 1) ^ 2) := by
  have h := queryOrderedInputsWithWork_cost childInputCode coordinateEqualWithWork
    (queryEncodedLEWithWork queryChildCodeWithWork)
    (fun a b => by simp only [queryEncodedLEWithWork_value, queryChildCodeWithWork_value])
    (24 * B + 8) (201000 * (B + 1) ^ 2)
    (fun a b => coordinateEqualWithWork_cost a b B hM hn)
    (fun a b => queryChildOrderWithWork_cost a b B hM hn) inputs
  apply h.trans
  gcongr
  nlinarith only [Nat.zero_le B]

end EditApproximation

end OAI