import OAI.NumberTheory.TwoPoint.Circuits.CircuitBlockCode
import Mathlib.Data.List.OfFn

namespace OAI

/-! The finite alphabet for query positions and responses. Allowing one
separator per block at most doubles the length of a query code. -/

namespace TwoPointCorrelations

open Finset
open scoped Classical

abbrev BoundedRestrictionCode (w k : ℕ) :=
  Σ l : Fin (k + 1), Fin l.val → Option (Fin (w + 1) × Bool)

def readRestrictionCode {w k : ℕ} (c : BoundedRestrictionCode w k) :
    List (Option (ℕ × Bool)) :=
  List.ofFn (fun i => (c.2 i).map (fun z => (z.1.val, z.2)))

noncomputable def packRestrictionSymbol (w : ℕ) (z : Option (ℕ × Bool))
    (hz : ∀ a b, z = some (a, b) → a ≤ w) : Option (Fin (w + 1) × Bool) :=
  match z with
  | none => none
  | some (a, b) => some (⟨a, Nat.lt_succ_of_le (hz a b rfl)⟩, b)

lemma read_packRestrictionSymbol (w : ℕ) (z : Option (ℕ × Bool))
    (hz : ∀ a b, z = some (a, b) → a ≤ w) :
    (packRestrictionSymbol w z hz).map (fun v => (v.1.val, v.2)) = z := by
  cases z with
  | none => rfl
  | some z => cases z; rfl

noncomputable def packRestrictionCode (w k : ℕ) (l : List (Option (ℕ × Bool)))
    (hl : l.length ≤ k)
    (hw : ∀ z ∈ l, ∀ a b, z = some (a, b) → a ≤ w) : BoundedRestrictionCode w k :=
  ⟨⟨l.length, Nat.lt_succ_of_le hl⟩, fun i => packRestrictionSymbol w (l.get i)
    (hw (l.get i) (List.get_mem l i))⟩

lemma read_packRestrictionCode (w k : ℕ) (l : List (Option (ℕ × Bool)))
    (hl : l.length ≤ k)
    (hw : ∀ z ∈ l, ∀ a b, z = some (a, b) → a ≤ w) :
    readRestrictionCode (packRestrictionCode w k l hl hw) = l := by
  unfold readRestrictionCode packRestrictionCode
  simp only [read_packRestrictionSymbol]
  exact List.ofFn_get l

lemma boundedRestrictionCode_card (w k : ℕ) :
    Fintype.card (BoundedRestrictionCode w k) ≤ (k + 1) * (2 * w + 3) ^ k := by
  rw [Fintype.card_sigma]
  calc
    _ = ∑ l : Fin (k + 1), (2 * w + 3) ^ l.val := by
      apply sum_congr rfl
      intro l _
      simp [Nat.add_mul, Nat.mul_comm, Nat.add_assoc]
    _ ≤ ∑ _l : Fin (k + 1), (2 * w + 3) ^ k := by
      apply sum_le_sum
      intro l _
      exact Nat.pow_le_pow_right (by omega) (Nat.le_of_lt_succ l.isLt)
    _ = _ := by simp

lemma two_mul_add_one_le_three_pow (h : ℕ) : 2 * h + 1 ≤ 3 ^ h := by
  induction h with
  | zero => norm_num
  | succ h ih =>
    have hp : 1 ≤ 3 ^ h := Nat.one_le_pow h 3 (by omega)
    rw [pow_succ]
    omega

lemma boundedRestrictionCode_card_queries (w h : ℕ) :
    Fintype.card (BoundedRestrictionCode w (2 * h)) ≤
      (3 * (2 * w + 3) ^ 2) ^ h := by
  apply (boundedRestrictionCode_card w (2 * h)).trans
  calc
    (2 * h + 1) * (2 * w + 3) ^ (2 * h) ≤ 3 ^ h * (2 * w + 3) ^ (2 * h) :=
      Nat.mul_le_mul_right _ (two_mul_add_one_le_three_pow h)
    _ = _ := by rw [mul_pow, ← pow_mul]

end TwoPointCorrelations

end OAI