import OAI.NumberTheory.SingleFold.Power

namespace OAI

namespace SingleFold.Binary

def Bits (x y : ℕ) : Prop := ∀ i, x/2^i%2 ≤ y/2^i%2

lemma split (x y : ℕ) : Bits x y ↔ x%2 ≤ y%2 ∧ Bits (x/2) (y/2) := by
  constructor
  · intro h
    refine ⟨by simpa using h 0, ?_⟩
    intro i
    simpa [Nat.div_div_eq_div_mul, pow_succ', mul_comm] using h (i+1)
  · rintro ⟨h,h'⟩ (_|i)
    · simpa using h
    · simpa [Nat.div_div_eq_div_mul, pow_succ', mul_comm] using h' i

lemma zero_right (x : ℕ) : Bits x 0 ↔ x=0 := by
  constructor
  · induction x using Nat.strong_induction_on with
    | h x ih =>
      intro hx
      by_cases h : x=0
      · exact h
      have he := (split x 0).mp hx
      have hh := ih (x/2) (Nat.div_lt_self (by omega) (by omega)) (by simpa using he.2)
      simp only [Nat.zero_mod] at he
      omega
  · rintro rfl; intro i; simp

lemma choose_odd_iff (x y : ℕ) : y.choose x % 2=1 ↔ Bits x y := by
  induction y using Nat.strong_induction_on generalizing x with
  | h y ih =>
    by_cases hy : y=0
    · subst y
      rw [zero_right]
      cases x <;> simp
    have hl := Choose.choose_modEq_choose_mod_mul_choose_div_nat (n:=y) (k:=x) (p:=2)
    change y.choose x%2 = (y%2).choose (x%2)*(y/2).choose (x/2)%2 at hl
    rw [hl,Nat.mul_mod,split, ← ih (y/2) (Nat.div_lt_self (by omega) (by omega))]
    have hx := Nat.mod_lt x (by omega : 0<2)
    have hy' := Nat.mod_lt y (by omega : 0<2)
    have hz := Nat.mod_lt ((y/2).choose (x/2)) (by omega : 0<2)
    interval_cases hxm : x%2 <;> interval_cases hym : y%2 <;> simp_all

lemma le {x y : ℕ} (h : Bits x y) : x≤y := by
  have hh := (choose_odd_iff x y).mpr h
  by_contra hl
  rw [Nat.choose_eq_zero_of_lt (by omega)] at hh
  omega

lemma ofDigits_digit {B : ℕ} (hB : 0<B) (l : List ℕ) (hl : ∀ a∈l, a<B) (i : ℕ) :
    Nat.ofDigits B l/B^i%B=l[i]?.getD 0 := by
  rw [Nat.ofDigits_div_pow_eq_ofDigits_drop i hB l hl]
  have hd : ∀ a∈l.drop i,a<B := fun a ha => hl a (List.mem_of_mem_drop ha)
  have he : l[i]?=(l.drop i)[0]? := by simp
  rw [he]
  generalize l.drop i = v at *
  cases v with
  | nil => simp
  | cons a v =>
    simp only [Nat.ofDigits_cons, Nat.add_mul_mod_self_left, List.getElem?_cons_zero, Option.getD_some]
    exact Nat.mod_eq_of_lt (hd a List.mem_cons_self)

lemma ofDigits_map_range (B n : ℕ) (f : ℕ → ℕ) :
    Nat.ofDigits B ((List.range n).map f) = ∑ i∈Finset.range n, f i*B^i := by
  induction n with
  | zero => simp
  | succ n ih =>
    rw [List.range_succ,List.map_append,Nat.ofDigits_append]
    simp [ih,Finset.sum_range_succ, mul_comm]

lemma choose_digit {x y B : ℕ} (hxy : x≤y) (hB : 2^y<B) :
    (B+1)^y/B^x%B=y.choose x := by
  have hpos : 0<B := lt_of_lt_of_le (by positivity : 0<2^y) (Nat.le_of_lt hB)
  have hl : ∀ a∈(List.range (y+1)).map (Nat.choose y),a<B := by
    intro a ha
    obtain ⟨i,hi,rfl⟩ := List.mem_map.mp ha
    exact lt_of_le_of_lt (Nat.choose_le_two_pow y i) hB
  have he : (B+1)^y=Nat.ofDigits B ((List.range (y+1)).map (Nat.choose y)) := by
    rw [ofDigits_map_range,add_pow]
    apply Finset.sum_congr rfl
    intro i hi
    simp [mul_comm]
  rw [he,ofDigits_digit hpos _ hl]
  simp [show x<y+1 by omega]

def System (x y : ℕ) (w : Fin 7 → ℕ) : Prop :=
  let B:=w 0; let H:=w 1; let N:=w 2; let s:=w 3; let d:=w 4; let r:=w 5; let t:=w 6
  x≤y ∧ B=2^(y+1) ∧ H=B^x ∧ N=(B+1)^y ∧
    N=s*B*H+d*H+r ∧ d<B ∧ r<H ∧ d=2*t+1

lemma extract_unique {B H N s d r : ℕ} (h : N=s*B*H+d*H+r) (hd : d<B) (hr : r<H) :
    r=N%H ∧ d=N/H%B ∧ s=N/H/B := by
  have hH : 0<H := by omega
  have hB : 0<B := by omega
  have he : N=(s*B+d)*H+r := by nlinarith only [h]
  have hq : N/H=s*B+d := by rw [he, Nat.add_comm, Nat.add_mul_div_right _ _ hH, Nat.div_eq_of_lt hr, zero_add]
  have hm : N%H=r := by rw [he,Nat.add_mod]; simp [Nat.mod_eq_of_lt hr]
  rw [hq]
  constructor
  · exact hm.symm
  constructor
  · simp [Nat.mod_eq_of_lt hd]
  · rw [Nat.add_comm,Nat.add_mul_div_right _ _ hB,Nat.div_eq_of_lt hd,zero_add]

lemma sound {x y : ℕ} {w : Fin 7 → ℕ} (hw : System x y w) : Bits x y := by
  rcases hw with ⟨hxy,hB,hH,hN,he,hd,hr,ht⟩
  have hh := (extract_unique he hd hr).2.1
  have hpow : 2^y<2^(y+1) := by simp [pow_succ]
  rw [hN,hH,hB,choose_digit hxy hpow] at hh
  apply (choose_odd_iff x y).mp
  rw [← hh,ht]
  omega

lemma unique {x y : ℕ} {w v : Fin 7 → ℕ} (hw : System x y w) (hv : System x y v) : w=v := by
  rcases hw with ⟨_,hB,hH,hN,he,hd,hr,ht⟩
  rcases hv with ⟨_,hB',hH',hN',he',hd',hr',ht'⟩
  have h0 : w 0=v 0 := hB.trans hB'.symm
  have h1 : w 1=v 1 := by rw [hH,hH',h0]
  have h2 : w 2=v 2 := by rw [hN,hN',h0]
  have hh := extract_unique he hd hr
  have hh' := extract_unique he' hd' hr'
  rw [h0,h1,h2] at hh
  have h3 := hh.2.2.trans hh'.2.2.symm
  have h4 := hh.2.1.trans hh'.2.1.symm
  have h5 := hh.1.trans hh'.1.symm
  have h6 : w 6=v 6 := by omega
  funext i; fin_cases i <;> assumption

lemma complete {x y : ℕ} (h : Bits x y) : ∃ w, System x y w := by
  let B:=2^(y+1)
  let H:=B^x
  let N:=(B+1)^y
  let d:=N/H%B
  have hB : 0<B := by positivity
  have hH : 0<H := by positivity
  have hpow : 2^y<B := by dsimp [B]; simp [pow_succ]
  have hd : d=y.choose x := choose_digit (le h) hpow
  have ho : d%2=1 := by rw [hd]; exact (choose_odd_iff x y).mpr h
  refine ⟨![B,H,N,N/H/B,d,N%H,d/2],le h,rfl,rfl,rfl,?_,Nat.mod_lt _ hB,Nat.mod_lt _ hH,?_⟩
  · change N=N/H/B*B*H+(N/H%B)*H+N%H
    have hq := Nat.mod_add_div (N/H) B
    have hn := Nat.mod_add_div N H
    nlinarith only [hq,hn]
  · change d=2*(d/2)+1
    omega
end SingleFold.Binary

namespace SingleFold.Compiler.MapSF
lemma vector {α ι : Type} [Finite ι] {f : ι → (α → ℕ) → ℕ}
    (h : ∀ i, ScalarSF (f i)) : MapSF (fun z i => f i z) := by
  exact ((MapSF.proj (fun i => (i,()))).comp (MapSF.all h)).congr (by intros; rfl)
end SingleFold.Compiler.MapSF

namespace SingleFold.Compiler.ScalarSF
variable {α : Type} {f g h : (α → ℕ) → ℕ}
lemma powerRel (hf : ScalarSF f) (hg : ScalarSF g) (hh : ScalarSF h) :
    SF (fun z => 2≤f z ∧ h z=f z^g z) := by
  have hv : MapSF (fun z => ![f z,g z,h z]) := MapSF.vector (by intro i; fin_cases i <;> assumption)
  exact hv.pullback PowerCompilation.power
end SingleFold.Compiler.ScalarSF

namespace SingleFold.Binary
open Compiler
lemma system_sf : SF (fun z : Fin 2⊕Fin 7 → ℕ => System (z (.inl 0)) (z (.inl 1)) (z ∘ Sum.inr)) := by
  let α:=Fin 2⊕Fin 7
  let a (i : α) : ScalarSF (fun z : α → ℕ => z i) := ScalarSF.proj i
  let x:=a (.inl 0); let y:=a (.inl 1)
  let B:=a (.inr 0); let H:=a (.inr 1); let N:=a (.inr 2)
  let s:=a (.inr 3); let d:=a (.inr 4); let r:=a (.inr 5); let t:=a (.inr 6)
  let k (j : ℕ) : ScalarSF (fun _ : α → ℕ => j) := ScalarSF.const j
  have h := (x.le y).and (((k 2).powerRel (y.add (k 1)) B).and
    ((B.powerRel x H).and (((B.add (k 1)).powerRel y N).and
      ((N.eq ((((s.mul B).mul H).add (d.mul H)).add r)).and
        ((d.lt B).and ((r.lt H).and (d.eq (((k 2).mul t).add (k 1)))))))))
  refine h.congr ?_
  intro z

  constructor
  · rintro ⟨hxy,⟨_,hB⟩,⟨_,hH⟩,⟨_,hN⟩,he⟩
    exact ⟨hxy,hB,hH,hN,he⟩
  · rintro ⟨hxy,hB,hH,hN,he⟩
    have hb : 2≤z (.inr 0) := by
      change 2≤(z ∘ Sum.inr) 0
      rw [hB,pow_succ]
      have := Nat.two_pow_pos (z (.inl 1))
      omega
    exact ⟨hxy,⟨by omega,hB⟩,⟨hb,hH⟩,⟨by omega,hN⟩,he⟩

theorem bits : SF (fun z : Fin 2 → ℕ => Bits (z 0) (z 1)) := by
  have h := system_sf.ex (by intro z w w' hw hw'; exact unique hw hw')
  refine h.congr ?_
  intro z
  exact ⟨fun ⟨w,hw⟩ => sound hw,complete⟩
end SingleFold.Binary

end OAI