import Mathlib

namespace OAI

namespace Fifths

/- pair on binary stacks. First component length `a.size`
costs exactly 2a.size+1 extra cells; does *not* double the second
component. Used also for encoding continuations. -/
namespace Bin

def val : List Bool → ℕ
  | [] => 0
  | b :: l => Nat.bit b (val l)

theorem val_bits (n : ℕ) : val n.bits = n := by
  induction n using Nat.binaryRec' with
  | zero => simp [val]
  | bit b n h ih => simp [Nat.bits_append_bit _ _ h, val, ih]

def esc (b : Bool) := [false, b]
def frame (l r : List Bool) : List Bool := l.flatMap esc ++ true :: r

@[simp] theorem frame_nil (r : List Bool) : frame [] r = true :: r := rfl
@[simp] theorem frame_cons (b : Bool) (l r : List Bool) :
    frame (b :: l) r = false :: b :: frame l r := by simp [frame,esc]

def pair (u v : ℕ) : ℕ := val (frame u.bits v.bits)

theorem frameLength (l r) : (frame l r).length = 2*l.length + 1 + r.length := by
  induction l with
  | nil => simp; omega
  | cons b l ih => simp [ih]; omega

private theorem bitTrue (n : ℕ) : Nat.bit true n ≠ 0 := by
  simp [Nat.bit]

theorem frameBits (l) (n : ℕ) :
    val (frame l n.bits) ≠ 0 ∧ (val (frame l n.bits)).bits = frame l n.bits := by
  induction l with
  | nil =>
    rw [frame_nil, val, val_bits]
    exact ⟨bitTrue _, Nat.bits_append_bit n true (fun _ => rfl)⟩
  | cons b l ih =>
    obtain ⟨a,c⟩ := ih
    rw [frame_cons,val,val]
    have h := Nat.bit_ne_zero b a
    refine ⟨Nat.bit_ne_zero _ h, ?_⟩
    rw [Nat.bits_append_bit _ _ (by tauto), Nat.bits_append_bit _ _ (by tauto), c]
@[simp] theorem pair_bits (a b) : (pair a b).bits = frame a.bits b.bits :=
  (frameBits a.bits b).2
theorem pair_ne_zero (a b) : pair a b ≠ 0 := (frameBits a.bits b).1
theorem pair_size (a b) : (pair a b).size = 2*a.size + 1 + b.size := by
  rw [← Nat.size_eq_bits_len, pair_bits, frameLength,Nat.size_eq_bits_len,
    Nat.size_eq_bits_len]

/-- Parse as a frame. Arbitrary result on malformed. -/
def unpack : List Bool → List Bool × List Bool
  | false :: b :: l =>
    let (a,c) := unpack l
    (b::a,c)
  | true :: l => ([],l)
  | _ => ([],[])

theorem unpack_frame (l r) : unpack (frame l r) = (l,r) := by
  induction l with
  | nil => rfl
  | cons b l ih => simp [ih,unpack]

def unpair (n : ℕ) : ℕ × ℕ :=
  let (l,r) := unpack n.bits
  (val l,val r)

@[simp] theorem unpair_pair (a b) : unpair (pair a b) = (a,b) := by
  simp [unpair,unpack_frame,val_bits]

@[simp] theorem pair_inj {a b a' b'} :
    pair a b = pair a' b' ↔ a = a' ∧ b = b' := by
  refine ⟨fun h => ?_, ?_⟩
  · simpa using congrArg unpair h
  · rintro ⟨rfl,rfl⟩; rfl

theorem mul_size (n m : ℕ) : (n*m).size ≤ n.size + m.size := by
  rw [Nat.size_le, pow_add]
  exact Nat.mul_lt_mul_of_lt_of_le (Nat.lt_size_self n)
    (Nat.le_of_lt (Nat.lt_size_self m)) (by positivity)
theorem add_size (n m : ℕ) : (n+m).size ≤ max n.size m.size + 1 := by
  have a : n < 2^(max n.size m.size) := Nat.size_le.mp (le_max_left n.size m.size)
  have b : m < 2^(max n.size m.size) := Nat.size_le.mp (le_max_right n.size m.size)
  rw [Nat.size_le, pow_add]
  omega
theorem succ_size (n : ℕ) : (n+1).size ≤ n.size + 1 := by
  by_cases h : n = 0
  · subst n; simp
  · have e : 1 ≤ n.size := Nat.size_pos.mpr (Nat.pos_of_ne_zero h)
    simpa [max_eq_left,e] using add_size n 1
theorem pow_size (n m : ℕ) : (n^m).size ≤ 1 + m*n.size := by
  induction m with
  | zero => simp
  | succ m ih =>
    rw [pow_succ]
    apply le_trans (mul_size _ _)
    simp [Nat.add_mul]
    omega
theorem size_le_self (n : ℕ) : n.size ≤ n := by
  induction n with
  | zero => rfl
  | succ n ih => have := succ_size n; omega

@[simp] theorem bits_nil (n : ℕ) : n.bits = [] ↔ n = 0 := by
  refine ⟨fun e => ?_, fun e => by simp [e]⟩
  rw [← val_bits n,e]; rfl
end Bin
end Fifths

end OAI