import OAI.Computability.WLIdentification.CircuitReduction

namespace OAI

namespace WLIdentification

namespace BinaryAddress

abbrev Bits (d : ℕ) := Fin d → Bool

def value : {d : ℕ} → Bits d → ℕ
  | 0, _ => 0
  | _ + 1, v => (if v 0 then 1 else 0) + 2 * value (fun i => v i.succ)

@[simp] theorem value_nil (v : Bits 0) : value v = 0 := rfl
@[simp] theorem value_cons {d : ℕ} (b : Bool) (v : Bits d) :
    value (Fin.cons b v) = (if b then 1 else 0) + 2 * value v := rfl

@[simp] theorem value_zero (d : ℕ) : value (fun _ : Fin d => false) = 0 := by
  induction d with
  | zero => rfl
  | succ d ih => simp [value, ih]

@[simp] theorem value_one (d : ℕ) : value (fun _ : Fin d => true) + 1 = 2 ^ d := by
  induction d with
  | zero => simp [value]
  | succ d ih => simp only [value, ↓reduceIte, pow_succ]; omega

theorem value_lt {d : ℕ} (v : Bits d) : value v < 2 ^ d := by
  induction d with
  | zero => simp [value]
  | succ d ih =>
    have h := ih (fun i => v i.succ)
    simp only [value, pow_succ]
    split <;> omega

theorem value_injective (d : ℕ) : Function.Injective (@value d) := by
  induction d with
  | zero => intro v w _; exact Subsingleton.elim _ _
  | succ d ih =>
    intro v w h
    have hh : v 0 = w 0 := by
      cases h1 : v 0 <;> cases h2 : w 0 <;> simp_all [value] <;> omega
    have ht : (fun i : Fin d => v i.succ) = (fun i : Fin d => w i.succ) := by
      apply ih
      simp only [value, hh] at h
      omega
    funext i
    exact Fin.cases hh (fun j => congrFun ht j) i

theorem value_surjective (d : ℕ) (n : ℕ) (hn : n < 2 ^ d) : ∃ v : Bits d, value v = n := by
  induction d generalizing n with
  | zero => refine ⟨Fin.elim0, ?_⟩; simp only [pow_zero] at hn; simp [value]; omega
  | succ d ih =>
    have hdiv : n / 2 < 2 ^ d := by rw [pow_succ] at hn; omega
    obtain ⟨v, hv⟩ := ih (n / 2) hdiv
    refine ⟨Fin.cons (decide (n % 2 = 1)) v, ?_⟩
    simp only [value_cons, hv, decide_eq_true_eq]
    split <;> omega

noncomputable def equiv (d : ℕ) : Bits d ≃ Fin (2 ^ d) :=
  Equiv.ofBijective (fun v => ⟨value v, value_lt v⟩)
    ⟨fun _ _ h => value_injective d (congrArg Fin.val h), fun ⟨n, hn⟩ => by
      obtain ⟨v, hv⟩ := value_surjective d n hn
      exact ⟨v, Fin.ext hv⟩⟩

def negate {d : ℕ} (v : Bits d) : Bits d := fun i => !(v i)

@[simp] theorem negate_negate {d : ℕ} (v : Bits d) : negate (negate v) = v := by
  funext i; exact Bool.not_not _

theorem value_negate {d : ℕ} (v : Bits d) : value (negate v) + value v + 1 = 2 ^ d := by
  induction d with
  | zero => simp [value]
  | succ d ih =>
    have h := ih (fun i => v i.succ)
    change (if !(v 0) then 1 else 0) + 2 * value (negate (fun i => v i.succ)) +
      ((if v 0 then 1 else 0) + 2 * value (fun i => v i.succ)) + 1 = 2 ^ (d + 1)
    rw [pow_succ]
    cases v 0 <;> simp only [Bool.not_false, Bool.not_true, Bool.false_eq_true, ↓reduceIte] <;> omega

/-- Little-endian carry without converting or enumerating the address space. -/
def advance : {d : ℕ} → Bits d → Bits d
  | 0, v => v
  | _ + 1, v => Fin.cons (!(v 0))
      (if v 0 then advance (fun i => v i.succ) else fun i => v i.succ)

theorem advance_one (d : ℕ) : advance (fun _ : Fin d => true) = fun _ => false := by
  induction d with
  | zero => exact Subsingleton.elim _ _
  | succ d ih =>
    funext i
    refine Fin.cases ?_ (fun j => ?_) i
    · simp [advance]
    · simp [advance, ih]

theorem value_advance {d : ℕ} (v : Bits d) (hv : value v + 1 < 2 ^ d) :
    value (advance v) = value v + 1 := by
  induction d with
  | zero => simp [value] at hv
  | succ d ih =>
    cases hb : v 0 with
    | false => simp [advance, value, hb, Nat.add_comm]
    | true =>
      have ht : value (fun i => v i.succ) + 1 < 2 ^ d := by
        simp only [value, hb, ↓reduceIte, pow_succ] at hv
        omega
      have hit := ih (fun i => v i.succ) ht
      simp only [advance, hb, Bool.not_true, ↓reduceIte, value_cons, Bool.false_eq_true, Nat.zero_add]
      rw [hit]
      simp only [value, hb, ↓reduceIte]
      omega

theorem value_eq_last {d : ℕ} (v : Bits d) : value v + 1 = 2 ^ d ↔ v = fun _ => true := by
  constructor
  · intro h
    apply value_injective d
    have h' := value_one d
    omega
  · rintro rfl; exact value_one d

theorem advance_mod {d : ℕ} (v : Bits d) :
    value (advance v) = (value v + 1) % (2 ^ d) := by
  have h := value_lt v
  by_cases h' : value v + 1 < 2 ^ d
  · rw [value_advance v h', Nat.mod_eq_of_lt h']
  · have he := (value_eq_last v).mp (by omega)
    subst v
    rw [advance_one, value_zero, value_one, Nat.mod_self]

/-- Each carry case fixes just the low prefix, including its first noncarry bit. -/
def Carry {d : ℕ} (h : Fin d) (b : Bool) (v : Bits d) : Prop :=
  (∀ i, i < h → v i = b) ∧ v h = !b

def flipPrefix {d : ℕ} (h : Fin d) (v : Bits d) : Bits d :=
  fun i => if i ≤ h then !(v i) else v i

theorem advance_carry {d : ℕ} (h : Fin d) (v : Bits d) (hv : Carry h true v) :
    advance v = flipPrefix h v := by
  induction d with
  | zero => exact Fin.elim0 h
  | succ d ih =>
    cases h using Fin.cases with
    | zero =>
      have h0 : v 0 = false := hv.2
      funext i
      refine Fin.cases ?_ (fun j => ?_) i
      · simp [advance, flipPrefix]
      · simp [advance, flipPrefix, h0]
    | succ j =>
      have h0 : v 0 = true := hv.1 0 (by simp)
      have ht : Carry j true (fun i => v i.succ) :=
        ⟨fun i hi => hv.1 i.succ (by simpa using hi), hv.2⟩
      funext i
      refine Fin.cases ?_ (fun l => ?_) i
      · simp [advance, flipPrefix]
      · simpa [advance, h0, flipPrefix] using congrFun (ih j _ ht) l

theorem carry_exists {d : ℕ} (v : Bits d) (h : v ≠ fun _ => true) :
    ∃ i, Carry i true v := by
  induction d with
  | zero => exact (h (Subsingleton.elim _ _)).elim
  | succ d ih =>
    cases hb : v 0 with
    | false => exact ⟨0, (by intro i hi; exact (Fin.not_lt_zero _ hi).elim), hb⟩
    | true =>
      have ht : (fun i : Fin d => v i.succ) ≠ fun _ => true := by
        intro he
        apply h
        funext i
        exact Fin.cases hb (fun j => congrFun he j) i
      obtain ⟨i, hi⟩ := ih (fun i => v i.succ) ht
      refine ⟨i.succ, ?_, hi.2⟩
      intro j hj
      cases j using Fin.cases with
      | zero => exact hb
      | succ l => exact hi.1 l (by simpa using hj)

theorem carry_not_last {d : ℕ} {h : Fin d} {v : Bits d} (hv : Carry h true v) :
    value v + 1 < 2 ^ d := by
  have hlt := value_lt v
  by_contra hn
  have he := (value_eq_last v).mp (by omega)
  have hh := hv.2
  rw [he] at hh
  contradiction

end BinaryAddress

namespace BinaryAddress

/-- The executable little-endian digit map; no search through 2^d addresses. -/
def ofNat : (d : ℕ) → ℕ → Bits d
  | 0, _ => Fin.elim0
  | d + 1, n => Fin.cons (decide (n % 2 = 1)) (ofNat d (n / 2))

theorem value_ofNat (d n : ℕ) (h : n < 2 ^ d) : value (ofNat d n) = n := by
  induction d generalizing n with
  | zero => simp only [pow_zero] at h; simp only [ofNat, value_nil]; omega
  | succ d ih =>
    have ht : n / 2 < 2 ^ d := by rw [pow_succ] at h; omega
    simp only [ofNat, value_cons, decide_eq_true_eq, ih _ ht]
    split <;> omega

theorem ofNat_value {d : ℕ} (x : Bits d) : ofNat d (value x) = x :=
  value_injective d (value_ofNat d _ (value_lt x))

@[simp] theorem ofNat_zero (d : ℕ) : ofNat d 0 = fun _ => false :=
  value_injective d (by rw [value_ofNat _ _ (by positivity), value_zero])

end BinaryAddress

namespace ProductMap
variable {r : ℕ}

/-- The relation described by a table, without enumerating its product points. -/
def Rel (D : ProductMap r) (x y : Fin r → Bool) : Prop :=
  (∀ i, x i ∈ D.domain i) ∧ ∀ i, D.mapping i (x i) = y i

theorem rel_point (D : ProductMap r) (a : D.Point) : D.Rel (D.source a) (D.target a) :=
  ⟨fun i => (a i).property, fun _ => rfl⟩

theorem rel_iff (D : ProductMap r) (x y : Fin r → Bool) :
    D.Rel x y ↔ ∃ a : D.Point, D.source a = x ∧ D.target a = y := by
  constructor
  · rintro ⟨hx, hy⟩
    exact ⟨fun i => ⟨x i, hx i⟩, rfl, funext hy⟩
  · rintro ⟨a, rfl, rfl⟩; exact rel_point D a

def singleton (x y : Fin r → Bool) : ProductMap r where
  domain i := {x i}
  nonempty i := ⟨x i, by simp⟩
  mapping i _ := y i
  injective i _ hx _ hy _ := (Finset.mem_singleton.mp hx).trans (Finset.mem_singleton.mp hy).symm

@[simp] theorem singleton_rel (x y u v : Fin r → Bool) :
    (singleton x y).Rel u v ↔ u = x ∧ v = y := by
  simp only [Rel, singleton, Finset.mem_singleton]
  rw [← funext_iff, ← funext_iff, eq_comm (a := y)]

@[simp] theorem identity_rel (x y : Fin r → Bool) : (identity r).Rel x y ↔ x = y := by
  simp [Rel, identity, funext_iff]

def concat {a b : ℕ} (D : ProductMap a) (E : ProductMap b) : ProductMap (a + b) where
  domain := Fin.append D.domain E.domain
  nonempty i := by
    refine Fin.addCases (fun j => ?_) (fun j => ?_) i
    · simpa only [Fin.append_left] using D.nonempty j
    · simpa only [Fin.append_right] using E.nonempty j
  mapping := Fin.append D.mapping E.mapping
  injective i := by
    refine Fin.addCases (fun j => ?_) (fun j => ?_) i
    · simpa only [Fin.append_left] using D.injective j
    · simpa only [Fin.append_right] using E.injective j

@[simp] theorem concat_rel {a b : ℕ} (D : ProductMap a) (E : ProductMap b)
    (x y : Fin (a + b) → Bool) :
    (D.concat E).Rel x y ↔
      D.Rel (fun i => x (Fin.castAdd b i)) (fun i => y (Fin.castAdd b i)) ∧
      E.Rel (fun i => x (Fin.natAdd a i)) (fun i => y (Fin.natAdd a i)) := by
  simp only [Rel, concat, Fin.forall_fin_add, Fin.append_left, Fin.append_right]
  tauto

def inverse (D : ProductMap r) : ProductMap r where
  domain i := (D.domain i).image (D.mapping i)
  nonempty i := (D.nonempty i).image _
  mapping i b := if false ∈ D.domain i ∧ D.mapping i false = b then false else true
  injective := by
    intro i x hx y hy h
    obtain ⟨a, ha, rfl⟩ := Finset.mem_image.mp hx
    obtain ⟨b, hb, rfl⟩ := Finset.mem_image.mp hy
    by_cases he : a = b
    · rw [he]
    · cases a <;> cases b <;> simp_all [D.injective i ha hb]

@[simp] theorem inverse_rel (D : ProductMap r) (x y : Fin r → Bool) :
    D.inverse.Rel x y ↔ D.Rel y x := by
  have h (i : Fin r) (b : Bool) (hb : b ∈ D.domain i) :
      D.inverse.mapping i (D.mapping i b) = b := by
    cases b with
    | false => simp [inverse, hb]
    | true =>
      have hh : ¬ (false ∈ D.domain i ∧ D.mapping i false = D.mapping i true) := by
        rintro ⟨hfalse, he⟩
        have := D.injective i hfalse hb he
        contradiction
      dsimp only [inverse]
      rw [ite_eq_right hh]
  constructor
  · rintro ⟨hx, hy⟩
    have hy' (i : Fin r) : y i ∈ D.domain i ∧ D.mapping i (y i) = x i := by
      obtain ⟨a, ha, he⟩ := Finset.mem_image.mp (hx i)
      have hh := hy i
      rw [← he, h i a ha] at hh
      exact hh ▸ ⟨ha, he⟩
    exact ⟨fun i => (hy' i).1, fun i => (hy' i).2⟩
  · rintro ⟨hy, hx⟩
    exact ⟨fun i => Finset.mem_image.mpr ⟨y i, hy i, hx i⟩,
      fun i => by rw [← hx i, h i (y i) (hy i)]⟩

end ProductMap

end WLIdentification

end OAI