lean/OAI/Computability/LoopMatching/BitAdd.lean

import OAI.Computability.MatchingCount.BinarySolve

namespace OAI

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

namespace LoopMatching.BitAdd

def value : List Bool → ℕ
  | [] => 0
  | b :: bs => b.toNat + 2 * value bs

def xor (a b : Bool) : Bool := if a then !b else b
def digit (a b c : Bool) : Bool := xor (xor a b) c
def carry (a b c : Bool) : Bool := (a && b) || (c && (a || b))

lemma fullAdder (a b c : Bool) :
    a.toNat + b.toNat + c.toNat = (digit a b c).toNat + 2 * (carry a b c).toNat := by
  cases a <;> cases b <;> cases c <;> decide

lemma value_append (xs ys : List Bool) :
    value (xs ++ ys) = value xs + 2 ^ xs.length * value ys := by
  induction xs with
  | nil => simp [value]
  | cons b xs ih => simp only [List.cons_append, value, List.length_cons, pow_succ, ih]; ring

lemma value_head_tail (xs : List Bool) :
    value xs = (xs.headD false).toNat + 2 * value xs.tail := by
  cases xs <;> rfl

abbrev State := (List Bool × List Bool) × (Bool × List Bool)

def step (z : State × Bool) : State :=
  ((z.1.1.1.tail, z.1.1.2.tail),
    (carry (z.1.1.1.headD false) (z.1.1.2.headD false) z.1.2.1,
     z.1.2.2 ++ [digit (z.1.1.1.headD false) (z.1.1.2.headD false) z.1.2.1]))

def initial (z : List Bool × List Bool) : State := (z, (false, []))
def finish (s : State) : List Bool := s.2.2 ++ if s.2.1 then [true] else []

def run (l : List Bool) (s : State) : State := l.foldl (fun s b => step (s,b)) s

def add (z : List Bool × List Bool) : List Bool :=
  finish (run (z.1 ++ z.2) (initial z))

def potential (s : State) : ℕ :=
  value s.2.2 + 2 ^ s.2.2.length * (value s.1.1 + value s.1.2 + s.2.1.toNat)

lemma potential_step (s : State) (b : Bool) : potential (step (s,b)) = potential s := by
  rcases s with ⟨⟨xs,ys⟩,c,os⟩
  have h := fullAdder (xs.headD false) (ys.headD false) c
  have hx := value_head_tail xs
  have hy := value_head_tail ys
  simp only [potential, step, value_append, List.length_append, List.length_singleton,
    value, mul_zero, add_zero, pow_succ]
  rw [hx, hy]
  calc
    _ = value os + 2 ^ os.length *
        ((xs.headD false).toNat + (ys.headD false).toNat + c.toNat +
          2 * (value xs.tail + value ys.tail)) := by
      rw [h]
      ring
    _ = _ := by ring

lemma potential_run (l : List Bool) (s : State) : potential (run l s) = potential s := by
  induction l generalizing s with
  | nil => rfl
  | cons b l ih =>
    change potential (run l (step (s,b))) = potential s
    rw [ih, potential_step]

lemma run_inputs (l : List Bool) (s : State) :
    (run l s).1 = (s.1.1.drop l.length, s.1.2.drop l.length) := by
  induction l generalizing s with
  | nil => simp [run]
  | cons b l ih =>
    change (run l (step (s,b))).1 = _
    rw [ih]
    simp only [step, List.length_cons]
    congr 1 <;> simp [List.drop_tail]

lemma run_length (l : List Bool) (s : State) :
    (run l s).2.2.length = s.2.2.length + l.length := by
  induction l generalizing s with
  | nil => simp [run]
  | cons b l ih =>
    change (run l (step (s,b))).2.2.length = _
    rw [ih]
    simp [step, Nat.add_comm, Nat.add_left_comm]

lemma value_finish (s : State) (h : s.1 = ([], [])) : value (finish s) = potential s := by
  rcases s with ⟨⟨xs,ys⟩,c,os⟩
  cases h
  cases c <;> simp [finish, potential, value_append, value]

theorem value_add (z : List Bool × List Bool) : value (add z) = value z.1 + value z.2 := by
  have hi : (run (z.1 ++ z.2) (initial z)).1 = ([], []) := by
    rw [run_inputs]
    simp only [initial, List.length_append]
    rw [List.drop_eq_nil_of_le (by omega), List.drop_eq_nil_of_le (by omega)]
  rw [add, value_finish _ hi, potential_run]
  simp [potential, initial, value]

theorem length_add (z : List Bool × List Bool) :
    (add z).length ≤ z.1.length + z.2.length + 1 := by
  have h := run_length (z.1 ++ z.2) (initial z)
  simp only [initial, List.length_nil, zero_add, List.length_append] at h
  unfold add finish
  split <;> simp_all [initial]

lemma value_bits (n : ℕ) : value n.bits = n := by
  induction n using Nat.binaryRec' with
  | zero => simp [value]
  | bit b n h ih =>
    rw [Nat.bits_append_bit n b h]
    cases b <;> simp [value, ih, Nat.bit, Nat.add_comm]

theorem value_add_bits (m n : ℕ) : value (add (m.bits,n.bits)) = m+n := by
  rw [value_add, value_bits, value_bits]

end LoopMatching.BitAdd

end OAI