import OAI.Computability.LoopMatching.BitAddRoutine
import OAI.Computability.LoopMatching.BitLength

namespace OAI

/-! Polynomial-time approximation of weighted matchings with singleton loops. -/

namespace LoopMatching.BitNormalize
open BinaryMatching.StackCode
open BitAdd (value)

def step (z : List Bool × Bool) : List Bool :=
  if z.2 then true :: z.1 else if z.1.isEmpty then [] else false :: z.1

def normalize (l : List Bool) : List Bool :=
  l.foldr (fun b acc => step (acc,b)) []

lemma normalize_cons (b : Bool) (l : List Bool) :
    normalize (b::l) = step (normalize l,b) := rfl

lemma step_length (l : List Bool) (b : Bool) :
    (step (l,b)).length ≤ l.length+1 := by
  cases b <;> cases l <;> simp [step]

theorem length_normalize (l : List Bool) : (normalize l).length ≤ l.length := by
  induction l with
  | nil => simp [normalize]
  | cons b l ih =>
    rw [normalize_cons]
    have h := step_length (normalize l) b
    simp only [List.length_cons]
    omega

lemma value_step (l : List Bool) (b : Bool) :
    value (step (l,b)) = b.toNat + 2*value l := by
  cases b <;> cases l <;> simp [step, value]

theorem value_normalize (l : List Bool) : value (normalize l) = value l := by
  induction l with
  | nil => rfl
  | cons b l ih => rw [normalize_cons, value_step, ih]; rfl

theorem normalize_eq_bits (l : List Bool) : normalize l = (value l).bits := by
  induction l with
  | nil => simp [normalize, value]
  | cons b l ih =>
    rw [normalize_cons, ih]
    by_cases hz : value l = 0
    · cases b <;> simp [step, value, hz]
    · have hb : value l = 0 → b = true := fun h => (hz h).elim
      have hn : (value l).bits ≠ [] := by
        intro h
        have hv := BitAdd.value_bits (value l)
        rw [h] at hv
        exact hz hv.symm
      have he : ((value l).bits).isEmpty = false := by
        cases h : (value l).bits with
        | nil => exact (hn h).elim
        | cons a as => rfl
      have hv : value (b::l) = Nat.bit b (value l) := by
        cases b <;> simp [value, Nat.bit]; omega
      rw [hv, Nat.bits_append_bit _ _ hb]
      cases b <;> simp [step, he]

theorem normalize_bits (n : ℕ) : normalize n.bits = n.bits := by
  rw [normalize_eq_bits, BitAdd.value_bits]

theorem normalize_idempotent (l : List Bool) : normalize (normalize l) = normalize l := by
  rw [normalize_eq_bits l, normalize_bits]

@[fun_prop] theorem step_poly : Poly step := by
  unfold step
  fun_prop

lemma step_growth (z : List Bool × Bool) :
    (encode (step z)).length ≤ (encode z.1).length + 1*(2*(encode z.2).length+1) := by
  rw [BitAdd.boolList_code_length, BitAdd.boolList_code_length]
  simp only [encode_bool, List.length_singleton]
  have h := step_length z.1 z.2
  change (step z).length ≤ z.1.length + 1 at h
  omega

@[fun_prop] theorem normalize_poly : Poly normalize := by
  have hf := Poly.listFoldAdd step step_poly 1 step_growth
  have hh := Poly.comp _ (fun l : List Bool => (l.reverse, ([] : List Bool))) hf (by fun_prop)
  exact hh.congr (fun l => by simp [normalize, List.foldl_reverse])

def add (z : List Bool × List Bool) : List Bool := normalize (BitAdd.add z)

@[fun_prop] theorem add_poly : Poly add := by unfold add; fun_prop

theorem add_eq_bits (z : List Bool × List Bool) :
    add z = (value z.1 + value z.2).bits := by
  rw [add, normalize_eq_bits, BitAdd.value_add]

theorem value_add (z : List Bool × List Bool) : value (add z) = value z.1 + value z.2 := by
  rw [add, value_normalize, BitAdd.value_add]

theorem add_bits (m n : ℕ) : add (m.bits,n.bits) = (m+n).bits := by
  rw [add_eq_bits, BitAdd.value_bits, BitAdd.value_bits]

theorem length_add (z : List Bool × List Bool) :
    (add z).length ≤ max z.1.length z.2.length + 1 := by
  rw [add_eq_bits]
  exact BitAdd.length_bits_value_add z.1 z.2

end LoopMatching.BitNormalize

end OAI