import OAI.Computability.FourierTransform.IntegerPrograms
import OAI.Computability.FourierTransform.TensorFibers

namespace OAI

/-! Transposed column address trick: a table of the addition of two f-bit digit
 vectors. We will be able to charge construction of the *whole* table. -/

namespace PowerSaving.RAM
open Binary Ty Finset
noncomputable section

def xorOrd (k : ℕ) : Layout (Bits k × Bits k) := (bits k).pair (bits k)

def xorTab (k : ℕ) : Tape ℕ := (xorOrd k).tape (fun i => (bits k).loc (i.1+i.2))

private lemma digit_prefix (z p : ℕ) (hp : p>0) :
    z % (p*2) = z%p + (z/p%2)*p := by
  have h : (z/p/2)*(p*2) + ((z/p%2)*p+z%p) = z := by
    calc
      _ = ((2*(z/p/2)+z/p%2)*p) + z%p := by ring
      _ = z := by rw [Nat.div_add_mod, mul_comm, Nat.div_add_mod]
  have hd : (z/p%2)*p+z%p < p*2 := by
    rw [mul_comm p]
    exact Layout.lt_join (Nat.mod_lt _ (by decide)) (Nat.mod_lt _ hp)
  exact (congr_arg (· % (p*2)) h).symm.trans ((Layout.mod_join hd).trans (add_comm ..))

private lemma digit_plus (k : ℕ) (x y : Bits k) (j : ℕ) (hj : j<k) :
    let b := (bits k).loc
    b (x+y) / 2^j % 2 =
      ((b x / 2^j) + (b y / 2^j))%2 := by
  intro b
  let i : Fin k := ⟨j,hj⟩
  have h (v : Bits k) : b v / 2^j % 2 = (v i).val := bits_div k v i
  rw [Nat.add_mod,h,h,h]
  exact ZMod.val_add _ _

namespace Can
universe U
variable {ι : Type U} {m : Bool} {s : Ty} {x : ι→T s} {B f : ι→ℕ}

/-- Assume the input environment supplies arguments to this subcalculation at O(1) cost. -/
private theorem xor_value (v : ∀ i, Bits (f i) × Bits (f i))
    (hf : Can m B s w x f (fun _ => 0))
    (ha : Can m B s w x (fun i => (bits (f i)).loc (v i).1) (fun _ => 0))
    (hb : Can m B s w x (fun i => (bits (f i)).loc (v i).2) (fun _ => 0))
    (hB : Small B f) (hd : Small B fun i => 2^f i) :
    Can m B s w x (fun i => (bits (f i)).loc ((v i).1+(v i).2)) f := by
  let X := fun i => (bits (f i)).loc ((v i).1+(v i).2)
  let a1 i := (bits (f i)).loc (v i).1
  let a2 i := (bits (f i)).loc (v i).2
  let g := fun (i : ι) (j : ℕ) => (2^j,X i % 2^j)
  let Y := p w w
  let T₀ := p s (p w Y)
  let env (d : During f) : T T₀ := (x d.i,d.j,g d.i d.j)
  let B' (d : During f) := B d.i
  let E (d : During f) := 2^d.j
  have hv (w : ∀ i, Bits (f i)) :
      Small B fun i => (bits (f i)).loc (w i) :=
    Small.loc (x:=w) (L:=fun i => bits (f i)) hd
  have sE : Small B' E :=
    (hd.reindex (During.i (n:=f))).mono (fun d => Nat.pow_le_pow_right (by omega) d.hj.le)
  have sr : Small B' (fun d : During f => (g d.i d.j).2) :=
    ((hv (fun i => (v i).1+(v i).2)).reindex (During.i (n:=f))).mod
  have step : Can m B' T₀ Y env (fun d => g d.i (d.j+1)) (fun _ => 0) := by
    have cg : Can m B' T₀ Y env (fun d => g d.i d.j) (fun _ => 0) := Can.snd Can.second
    have ce : Can m B' T₀ w env E (fun _ => 0) := cg.fst
    have cs2 : Can m B' T₀ w env (fun d => 2) (fun _ => 0) := Can.wc _
    have sa : Small B' fun d : During f => a1 d.i := (hv (fun i => (v i).1)).reindex During.i
    have sb : Small B' fun d : During f => a2 d.i := (hv (fun i => (v i).2)).reindex During.i
    have ca : Can m B' T₀ w env (fun d => a1 d.i) (fun _ => 0) :=
      Can.first.then_do (ha.reindex During.i)
    have cb : Can m B' T₀ w env (fun d => a2 d.i) (fun _ => 0) :=
      Can.first.then_do (hb.reindex During.i)
    have cp := (ca.dvdW ce sa).plus (cb.dvdW ce sb) sa.div sb.div
    have sx := (sa.div (Q:=E)).add (sb.div (Q:=E))
    have cy := (cp.modW cs2 sx).times ce sx.mod sE
    have cq := (cg.snd).plus cy sr ((sx.mod (Q:=fun _ => 2)).mul sE)
    refine ((ce.times cs2 sE (Small.const ..)).pair cq).cong (fun _ => rfl) ?_
    intro d
    apply Prod.ext
    · exact (pow_succ ..).symm
    · change X d.i % 2^d.j + _ = X d.i % 2^(d.j+1)
      rw [pow_succ,digit_prefix (X d.i) (2^d.j) (by positivity)]
      have h := digit_plus _ (v d.i).1 (v d.i).2 d.j d.hj
      congr 1
      exact congr_arg (· * 2^d.j) h.symm
  have c0 : Can m B s Y x (fun i => g i 0) (fun _ => 0) := by
    simp only [g,pow_zero,Nat.mod_one]
    exact (Can.wc _).pair (Can.wc _)
  have hh := Can.loop (t:=Y) (v:=g) (uB:=fun _ _ => 0) hf c0 step hB
  have he (i) : (g i (f i)).2=X i := Nat.mod_eq_of_lt ((bits (f i)).bd _)
  simpa [he,X] using hh.snd

theorem xor_prepare (hf : Can m B s w x f (fun _ => 0))
    (hg : Can m B s w x (fun i => 2^f i) (fun _ => 0))
    (hB : Small B f) (hd : Small B fun i => 2^f i) :
    Can m B s (a w) x (fun i => xorTab (f i)) (fun i => (2^f i)^3) := by
  let V i := (bits (f i)).n
  let D i := xorOrd (f i)
  have sn : Small B fun i => (D i).n := hd.mul hd
  have hn : Can m B s w x (fun i => (D i).n) (fun _ => 0) := hg.times hg hd hd
  let I i := Bits (f i) × Bits (f i)
  let BB (d : Σ i, I i) := B d.1
  let VV (d : Σ i, I i) : T (p s w) := (x d.1,(D d.1).loc d.2)
  have hh : Can m BB (p s w) w VV (fun d : Σ i, I i =>
      (bits (f d.1)).loc (d.2.1+d.2.2)) (fun d => f d.1) := by
    have hv : Can m BB (p s w) w VV
      (fun d => V d.1) (fun _ => 0) :=
      Can.first.then_do (hg.reindex (Sigma.fst (β:=I)))
    have hBB := sn.reindex (Sigma.fst (β:=I))
    let X (d : Σ i, I i) := bits (f d.1)
    apply xor_value (f:=fun d : Σ i, I i => f d.1) _
        (Can.first.then_do (hf.reindex (Sigma.fst (β:=I)))) _ _
        (hB.reindex Sigma.fst) (hd.reindex Sigma.fst)
    · exact Can.addr_high (u:=fun d : Σ i, I i => d.2) (L:=X) (R:=X)
        Can.second hv hBB
    · exact Can.addr_low (u:=fun d : Σ i, I i => d.2) (L:=X) (R:=X)
        Can.second hv hBB
  have ht := Can.layout (t:=w) (P:=f) (L:=D) (α:=I)
    (v:=fun (i : ι) j => (bits (f i)).loc (j.1+j.2)) hn hh sn
  refine ht.mono (fun i => ?_)
  change 0+2^f i * 2^f i + _* f i ≤ _
  have he : f i < 2^f i := Nat.lt_two_pow_self
  change 0+2^f i * 2^f i + 2^f i * 2^f i * f i ≤ _
  have h := Nat.mul_le_mul_left (2^f i * 2^f i) he
  simpa [pow_succ,Nat.mul_add,add_comm] using h

theorem xor_lookup {W : ι → ℕ}
    (v : ∀ i, Bits (f i) × Bits (f i))
    (ht : Can m B s (a w) x (fun i => xorTab (f i)) W)
    (ha : Can m B s w x (fun i => (bits (f i)).loc (v i).1) W)
    (hb : Can m B s w x (fun i => (bits (f i)).loc (v i).2) W)
    (hn : Can m B s w x (fun i => 2^f i) W)
    (hd : Small B fun i => 2^f i) :
    Can m B s w x (fun i => (bits (f i)).loc ((v i).1+(v i).2)) W :=
  Can.fetch (t:=w) (L:=fun i => xorOrd (f i)) (i:=v)
    (v:=fun i j => (bits (f i)).loc (j.1+j.2)) ht
    (Can.addr_join (u:=v) (L:=fun i => bits (f i)) (R:=fun i => bits (f i))
    ha hb hn hd hd)

end Can
end
end PowerSaving.RAM

end OAI