import OAI.Computability.WeisfeilerLeman.Predicates

namespace OAI

universe uJ

namespace WLTime.Digits

abbrev Word (d m : ℕ) := Fin d → Fin m
abbrev encode {d m : ℕ} : Word d m ≃ Fin (m^d) := finFunctionFinEquiv

def value {d m : ℕ} (a : Word d m) : ℕ := (encode a).val

@[simp] theorem value_zero {m : ℕ} (a : Word 0 m) : value a = 0 := by
  simp [value,encode]

theorem value_succ {d m : ℕ} (a : Word (d+1) m) :
    value a = (a 0).val + m * value (fun i : Fin d => a i.succ) := by
  simp only [value,encode,finFunctionFinEquiv_apply,Fin.sum_univ_succ,
    Fin.val_zero,pow_zero,Nat.mul_one,Fin.val_succ,pow_succ]
  rw [Finset.mul_sum]
  congr 1
  apply Finset.sum_congr rfl
  intro i _
  ring

def CarryDomain {d m : ℕ} (p : Fin (d+1)) (i : Fin d) : Finset (Fin m) :=
  Finset.univ.filter fun x => if i.val < p.val then x.val+1=m
    else if i.val=p.val then x.val + 1 < m else True

def Allowed {d m : ℕ} (p : Fin (d+1)) (a : Word d m) : Prop :=
  ∀ i, a i ∈ CarryDomain p i

theorem allowed_iff {d m : ℕ} (p : Fin (d+1)) (a : Word d m) :
    Allowed p a ↔ ∀ i, if i.val < p.val then (a i).val+1=m
      else if i.val=p.val then (a i).val + 1 < m else True := by
  simp only [Allowed,CarryDomain,Finset.mem_filter,Finset.mem_univ,true_and]

def inc (m : ℕ) : Equiv.Perm (Fin m) := finRotate m

def coordinate {d m : ℕ} (p : Fin (d+1)) (i : Fin d) : Equiv.Perm (Fin m) :=
  if i.val ≤ p.val then inc m else Equiv.refl _

def applyCarry {d m : ℕ} (p : Fin (d+1)) (a : Word d m) : Word d m :=
  fun i => coordinate p i (a i)

theorem inc_value {m : ℕ} (x : Fin m) :
    (inc m x).val = if x.val + 1 = m then 0 else x.val + 1 := by
  obtain ⟨m,rfl⟩ := Nat.exists_eq_succ_of_ne_zero (Nat.ne_of_gt x.pos)
  rw [inc,coe_finRotate]
  have he : x=Fin.last m ↔ x.val+1=m+1 := by
    simp only [Fin.ext_iff,Fin.val_last]
    omega
  simp only [he]

theorem allowed_zero {d m : ℕ} (a : Word (d+1) m) :
    Allowed (0 : Fin (d+2)) a ↔ (a 0).val + 1 < m := by
  simp [allowed_iff]

theorem allowed_succ {d m : ℕ} (p : Fin (d+1)) (a : Word (d+1) m) :
    Allowed p.succ a ↔ (a 0).val+1=m ∧ Allowed p (fun i => a i.succ) := by
  rw [allowed_iff,Fin.forall_fin_succ,allowed_iff]
  simp only [Fin.val_zero,Fin.val_succ,Nat.zero_lt_succ,ite_true,
    Nat.add_lt_add_iff_right,Nat.add_right_cancel_iff]

@[simp] theorem apply_zero_head {d m : ℕ} (a : Word (d+1) m) :
    applyCarry (0 : Fin (d+2)) a 0 = inc m (a 0) := by
  simp [applyCarry,coordinate]

@[simp] theorem apply_zero_tail {d m : ℕ} (a : Word (d+1) m) (i : Fin d) :
    applyCarry (0 : Fin (d+2)) a i.succ = a i.succ := by
  simp [applyCarry,coordinate]

@[simp] theorem apply_succ_head {d m : ℕ} (p : Fin (d+1)) (a : Word (d+1) m) :
    applyCarry p.succ a 0 = inc m (a 0) := by
  simp [applyCarry,coordinate]

@[simp] theorem apply_succ_tail {d m : ℕ} (p : Fin (d+1)) (a : Word (d+1) m) (i : Fin d) :
    applyCarry p.succ a i.succ = applyCarry p (fun i => a i.succ) i := by
  simp [applyCarry,coordinate]

theorem exists_allowed {d m : ℕ} (a : Word d m) : ∃ p : Fin (d+1), Allowed p a := by
  induction d with
  | zero => exact ⟨0,fun i => Fin.elim0 i⟩
  | succ d ih =>
    by_cases hm : (a 0).val+1=m
    · obtain ⟨p,hp⟩ := ih (fun i => a i.succ)
      exact ⟨p.succ,(allowed_succ p a).mpr ⟨hm,hp⟩⟩
    · exact ⟨0,(allowed_zero a).mpr (by have := (a 0).isLt; omega)⟩

theorem carry_value {d m : ℕ} (p : Fin (d+1)) (a : Word d m) (ha : Allowed p a) :
    value (applyCarry p a) = if p.val=d then 0 else value a+1 := by
  induction d with
  | zero => simp
  | succ d ih =>
    revert ha
    refine Fin.cases ?_ (fun p => ?_) p
    · intro ha
      have ha0 : (a 0).val+1< m := (allowed_zero a).mp ha
      simp only [Fin.val_zero,Ne.symm (Nat.succ_ne_zero d),ite_false]
      rw [value_succ,value_succ,apply_zero_head,inc_value]
      simp only [apply_zero_tail,ite_eq_right (Nat.ne_of_lt ha0)]
      omega
    · intro ha
      obtain ⟨ha0,hat⟩ := (allowed_succ p a).mp ha
      have ht := ih p (fun i => a i.succ) hat
      rw [value_succ,value_succ,apply_succ_head,inc_value,ite_eq_left ha0]
      simp only [apply_succ_tail,Fin.val_succ,Nat.add_right_cancel_iff]
      rw [ht]
      split_ifs with hp
      · simp
      · nlinarith

theorem wrap_value {d m : ℕ} (a : Word d m) (ha : Allowed (Fin.last d) a) :
    value a+1=m^d := by
  induction d with
  | zero => simp
  | succ d ih =>
    have hh : Fin.last (d+1) = (Fin.last d).succ := rfl
    rw [hh,allowed_succ] at ha
    obtain ⟨ha0,hat⟩ := ha
    have ht := ih (fun i => a i.succ) hat
    rw [value_succ,pow_succ]
    nlinarith

theorem carry_rotation {d m : ℕ} (p : Fin (d+1)) (a : Word d m) (ha : Allowed p a) :
    encode (applyCarry p a) = inc (m^d) (encode a) := by
  apply Fin.ext
  change value (applyCarry p a) = _
  rw [inc_value]
  change value (applyCarry p a) = if value a+1=m^d then 0 else value a+1
  rw [carry_value p a ha]
  by_cases hp : p.val=d
  · have he : p=Fin.last d := Fin.ext hp
    have hv := wrap_value a (he ▸ ha)
    simp only [hp,hv,ite_true]
  · have hv : value a+1 < m^d := by
      have hb := (encode (applyCarry p a)).isLt
      change value (applyCarry p a) < m^d at hb
      simpa only [carry_value p a ha,ite_eq_right hp] using hb
    simp only [ite_eq_right hp,ite_eq_right (Nat.ne_of_lt hv)]

theorem carry_relation {d m : ℕ} (a b : Word d m) :
    (∃ p : Fin (d+1), Allowed p a ∧ applyCarry p a=b) ↔
      encode b=inc (m^d) (encode a) := by
  constructor
  · rintro ⟨p,ha,rfl⟩
    exact carry_rotation p a ha
  · intro hab
    obtain ⟨p,ha⟩ := exists_allowed a
    refine ⟨p,ha,encode.injective ?_⟩
    exact (carry_rotation p a ha).trans hab.symm

theorem nonwrap_relation {d m : ℕ} (a b : Word d m) :
    (∃ p : Fin d, Allowed p.castSucc a ∧ applyCarry p.castSucc a=b) ↔
      value b=value a+1 := by
  constructor
  · rintro ⟨p,ha,rfl⟩
    rw [carry_value p.castSucc a ha]; simp only [Fin.val_castSucc,ite_eq_right (Nat.ne_of_lt p.isLt)]
  · intro hab
    obtain ⟨p,ha⟩ := exists_allowed a
    have hp : p.val<d := by
      have hv : value b< m^d := (encode b).isLt
      have hlt := p.isLt
      by_contra hn
      have he : p=Fin.last d := Fin.ext (by simp only [Fin.val_last]; omega)
      have hw := wrap_value a (he ▸ ha)
      omega
    let p' : Fin d := ⟨p.val,hp⟩
    have he : p'.castSucc=p := rfl
    refine ⟨p',he.symm ▸ ha,encode.injective ?_⟩
    apply Fin.ext
    change value (applyCarry p'.castSucc a)=value b
    rw [he,carry_value p a ha,ite_eq_right (Nat.ne_of_lt hp),hab]

theorem value_eq_zero_iff {d m : ℕ} (hm : 0< m) (a : Word d m) :
    value a=0 ↔ ∀ i,(a i).val=0 := by
  induction d with
  | zero => simp
  | succ d ih =>
    rw [value_succ,Fin.forall_fin_succ]
    constructor
    · intro h
      have hz : value (fun i : Fin d => a i.succ)=0 := by nlinarith
      exact ⟨by omega,(ih _).mp hz⟩
    · rintro ⟨h0,ht⟩
      rw [h0,(ih _).mpr ht]
      omega

theorem allowed_last_iff {d m : ℕ} (a : Word d m) :
    Allowed (Fin.last d) a ↔ ∀ i,(a i).val+1=m := by
  simp only [allowed_iff,Fin.val_last,Fin.isLt,ite_true]

theorem value_last_iff {d m : ℕ} (a : Word d m) :
    value a+1=m^d ↔ ∀ i,(a i).val+1=m := by
  constructor
  · intro h
    obtain ⟨p,hp⟩ := exists_allowed a
    have he : p.val=d := by
      by_contra hn
      have hb := (encode (applyCarry p a)).isLt
      change value (applyCarry p a)< m^d at hb
      rw [carry_value p a hp,ite_eq_right hn,h] at hb
      omega
    have he' : p=Fin.last d := Fin.ext he
    exact allowed_last_iff a |>.mp (he' ▸ hp)
  · intro h
    exact wrap_value a ((allowed_last_iff a).mpr h)

end WLTime.Digits

namespace WLTime.ProductBox
abbrev Address (r m : ℕ) := Fin r → Fin m

structure Box (r m : ℕ) where
  domain : Fin r → Finset (Fin m)
  coord : Fin r → Equiv.Perm (Fin m)

namespace Box
variable {r m : ℕ} (B : Box r m)

def Allowed (a : Address r m) : Prop := ∀ i, a i ∈ B.domain i

def apply (a : Address r m) : Address r m := fun i => B.coord i (a i)

def Rel (a b : Address r m) : Prop := B.Allowed a ∧ B.apply a=b

def reverse : Box r m where
  domain i := (B.domain i).image (B.coord i)
  coord i := (B.coord i).symm

@[simp] theorem reverse_apply_apply (a : Address r m) : B.reverse.apply (B.apply a)=a := by
  funext i
  exact (B.coord i).symm_apply_apply (a i)

@[simp] theorem apply_reverse_apply (a : Address r m) : B.apply (B.reverse.apply a)=a := by
  funext i
  exact (B.coord i).apply_symm_apply (a i)

theorem reverse_allowed (a : Address r m) : B.reverse.Allowed a ↔ B.Allowed (B.reverse.apply a) := by
  unfold Allowed reverse apply
  apply forall_congr'
  intro i
  constructor
  · intro h
    obtain ⟨b,hb,he⟩ := Finset.mem_image.mp h
    simpa only [← he,Equiv.symm_apply_apply] using hb
  · intro h
    exact Finset.mem_image.mpr ⟨(B.coord i).symm (a i),h,(B.coord i).apply_symm_apply (a i)⟩

theorem reverse_relation (a b : Address r m) : B.reverse.Rel a b ↔ B.Rel b a := by
  rw [Rel,reverse_allowed,Rel]
  constructor
  · rintro ⟨ha,hab⟩
    exact ⟨hab ▸ ha,by rw [← hab,B.apply_reverse_apply]⟩
  · rintro ⟨hb,hba⟩
    rw [← hba,B.reverse_apply_apply]
    exact ⟨hb,rfl⟩

def identity (r m : ℕ) : Box r m where
  domain _ := Finset.univ
  coord _ := Equiv.refl _

@[simp] theorem identity_rel (a b : Address r m) : (identity r m).Rel a b ↔ a=b := by
  change ((∀ i, a i ∈ (Finset.univ : Finset (Fin m))) ∧ a=b) ↔ a=b
  simp

def product {d q : ℕ} (B : Box d m) (C : Box q m) : Box (d+q) m where
  domain := Fin.addCases B.domain C.domain
  coord := Fin.addCases B.coord C.coord

@[simp] theorem product_allowed {d q : ℕ} (B : Box d m) (C : Box q m)
    (a : Address d m) (b : Address q m) :
    (B.product C).Allowed (Fin.append a b) ↔ B.Allowed a ∧ C.Allowed b := by
  simp [Allowed,product,Fin.forall_fin_add]

@[simp] theorem product_apply {d q : ℕ} (B : Box d m) (C : Box q m)
    (a : Address d m) (b : Address q m) :
    (B.product C).apply (Fin.append a b)=Fin.append (B.apply a) (C.apply b) := by
  funext i
  refine Fin.addCases (fun i => ?_) (fun i => ?_) i <;> simp [apply,product]

def carry {d m : ℕ} (p : Fin (d+1)) : Box d m where
  domain := Digits.CarryDomain p
  coord := Digits.coordinate p

theorem carry_rel {d m : ℕ} (a b : Address d m) :
    (∃ p : Fin (d+1), (carry p).Rel a b) ↔
      Digits.encode b=Digits.inc (m^d) (Digits.encode a) :=
  Digits.carry_relation a b

theorem borrow_rel {d m : ℕ} (a b : Address d m) :
    (∃ p : Fin (d+1), (carry p).reverse.Rel a b) ↔
      Digits.encode b=(Digits.inc (m^d)).symm (Digits.encode a) := by
  simp_rw [reverse_relation]
  rw [carry_rel]
  constructor
  · intro h
    have he := congrArg (Digits.inc (m^d)).symm h
    simpa only [Equiv.symm_apply_apply] using he.symm
  · intro h
    have he := congrArg (Digits.inc (m^d)) h
    simpa only [Equiv.apply_symm_apply] using he.symm

end Box
end WLTime.ProductBox

namespace WLTime.ProductBox
abbrev time {d q m : ℕ} (a : Address (d+q) m) : Address d m := fun i => a (i.castAdd q)
abbrev space {d q m : ℕ} (a : Address (d+q) m) : Address q m := fun i => a (i.natAdd d)

@[simp] theorem append_time_space {d q m : ℕ} (a : Address (d+q) m) :
    Fin.append (time a) (space a)=a := Fin.append_castAdd_natAdd

@[simp] theorem time_append {d q m : ℕ} (a : Address d m) (b : Address q m) :
    time (Fin.append a b)=a := by funext i; exact Fin.append_left _ _ _
@[simp] theorem space_append {d q m : ℕ} (a : Address d m) (b : Address q m) :
    space (Fin.append a b)=b := by funext i; exact Fin.append_right _ _ _

def addressEquiv {d q m : ℕ} : Address (d+q) m ≃ Fin (m^d) × Fin (m^q) where
  toFun a := (Digits.encode (time a),Digits.encode (space a))
  invFun b := Fin.append (Digits.encode.symm b.1) (Digits.encode.symm b.2)
  left_inv a := by simp
  right_inv b := by simp

namespace Box
variable {d q m : ℕ}
theorem product_relation (B : Box d m) (C : Box q m) (a b : Address (d+q) m) :
    (B.product C).Rel a b ↔ B.Rel (time a) (time b) ∧ C.Rel (space a) (space b) := by
  rw [← append_time_space a,← append_time_space b]
  simp only [Rel,product_allowed,product_apply,time_append,space_append]
  have he {a a' : Address d m} {b b' : Address q m} :
      Fin.append a b=Fin.append a' b' ↔ a=a' ∧ b=b' := by
    constructor
    · intro h
      exact ⟨by simpa using congrArg time h,by simpa using congrArg space h⟩
    · rintro ⟨rfl,rfl⟩; rfl
  rw [he]
  tauto
end Box
end WLTime.ProductBox

namespace WLTime.NatCode
namespace Expr
variable {J : Type uJ}
def choose (p : Predicate J) (a b : Expr J) : Expr J :=
  .binary .add (.binary .mul p.code a) (.binary .mul (.binary .sub (.const 1) p.code) b)

 theorem choose_eval (p : Predicate J) (a b : Expr J) (σ : J → ℕ) (w : List Bool) :
    (choose p a b).eval σ w=if p.Holds σ w then a.eval σ w else b.eval σ w := by
  simp only [choose,eval,Binary.eval,Predicate.code_eval]
  split_ifs <;> simp

 theorem choose_bounded (p : Predicate J) (a b : Expr J) (σ : J → ℕ) (w : List Bool)
    (B : ℕ) (hp : p.Bounded σ w B) (ha : a.Bounded σ w B) (hb : b.Bounded σ w B) :
    (choose p a b).Bounded σ w (2*B+1) := by
  have hp' := p.code_bounded σ w B hp
  have ha' := a.bounded_mono σ w ha (by omega : B≤2*B+1)
  have hb' := b.bounded_mono σ w hb (by omega : B≤2*B+1)
  have hva := a.eval_le σ w B ha
  have hvb := b.eval_le σ w B hb
  refine ⟨⟨hp',ha',?_⟩,⟨⟨by change 1≤2*B+1; omega,hp',?_⟩,hb',?_⟩,?_⟩
  · simp only [Binary.eval,Predicate.code_eval]; split_ifs <;> simp_all; omega
  · change 1-p.code.eval σ w≤2*B+1; omega
  · simp only [Binary.eval,eval,Predicate.code_eval]; split_ifs <;> simp_all; omega
  · change (choose p a b).eval σ w≤2*B+1
    rw [choose_eval]; split_ifs <;> omega

def incCode (M a : Expr J) : Expr J :=
  choose (.eq (.binary .add a (.const 1)) M) (.const 0) (.binary .add a (.const 1))
def decCode (M a : Expr J) : Expr J :=
  choose (.eq a (.const 0)) (.binary .sub M (.const 1)) (.binary .sub a (.const 1))

 theorem incCode_eval {m : ℕ} (x : Fin m) (M a : Expr J) (σ : J → ℕ) (w : List Bool)
    (hM : M.eval σ w=m) (ha : a.eval σ w=x.val) :
    (incCode M a).eval σ w=(Digits.inc m x).val := by
  rw [incCode,choose_eval,Digits.inc_value]
  simp only [Predicate.Holds,eval,Binary.eval,hM,ha]

 theorem decCode_eval {m : ℕ} (x : Fin m) (M a : Expr J) (σ : J → ℕ) (w : List Bool)
    (hM : M.eval σ w=m) (ha : a.eval σ w=x.val) :
    (decCode M a).eval σ w=((Digits.inc m).symm x).val := by
  have h := Digits.inc_value ((Digits.inc m).symm x)
  rw [Equiv.apply_symm_apply] at h
  rw [decCode,choose_eval]
  simp only [Predicate.Holds,eval,Binary.eval,hM,ha]
  have hh := ((Digits.inc m).symm x).isLt
  split_ifs at h ⊢ <;> omega
end Expr
end WLTime.NatCode

namespace WLTime.ProductBox
open NatCode
namespace Formula
variable {d q m : ℕ} {J : Type uJ}

def carryDomain (p : Fin (d+1)) (i : Fin d) (M a : Expr J) : Predicate J :=
  if i.val<p.val then .eq (.binary .add a (.const 1)) M
  else if i.val=p.val then .lt (.binary .add a (.const 1)) M else .truth true

def carryCoord (p : Fin (d+1)) (i : Fin d) (M a : Expr J) : Expr J :=
  if i.val≤p.val then Expr.incCode M a else a

def borrowCoord (p : Fin (d+1)) (i : Fin d) (M a : Expr J) : Expr J :=
  if i.val≤p.val then Expr.decCode M a else a

def borrowDomain (p : Fin (d+1)) (i : Fin d) (M a : Expr J) : Predicate J :=
  carryDomain p i M (borrowCoord p i M a)

 theorem carryDomain_correct (p : Fin (d+1)) (i : Fin d) (M a : Expr J)
    (σ : J → ℕ) (w : List Bool) (x : Fin m) (hM : M.eval σ w=m) (ha : a.eval σ w=x.val) :
    (carryDomain p i M a).Holds σ w ↔ x∈(Box.carry p).domain i := by
  simp only [Box.carry,Digits.CarryDomain,Finset.mem_filter,Finset.mem_univ,true_and,carryDomain]
  split_ifs <;> simp only [Predicate.Holds,Expr.eval,Binary.eval,ha,hM]

 theorem carryCoord_correct (p : Fin (d+1)) (i : Fin d) (M a : Expr J)
    (σ : J → ℕ) (w : List Bool) (x : Fin m) (hM : M.eval σ w=m) (ha : a.eval σ w=x.val) :
    (carryCoord p i M a).eval σ w=((Box.carry p).coord i x).val := by
  simp only [carryCoord,Box.carry,Digits.coordinate]
  split_ifs
  · exact Expr.incCode_eval x M a σ w hM ha
  · exact ha

 theorem borrowCoord_correct (p : Fin (d+1)) (i : Fin d) (M a : Expr J)
    (σ : J → ℕ) (w : List Bool) (x : Fin m) (hM : M.eval σ w=m) (ha : a.eval σ w=x.val) :
    (borrowCoord p i M a).eval σ w=((Box.carry p).reverse.coord i x).val := by
  simp only [borrowCoord,Box.reverse,Box.carry,Digits.coordinate]
  split_ifs
  · exact Expr.decCode_eval x M a σ w hM ha
  · exact ha

 theorem borrowDomain_correct (p : Fin (d+1)) (i : Fin d) (M a : Expr J)
    (σ : J → ℕ) (w : List Bool) (x : Fin m) (hM : M.eval σ w=m) (ha : a.eval σ w=x.val) :
    (borrowDomain p i M a).Holds σ w ↔ x∈(Box.carry p).reverse.domain i := by
  rw [borrowDomain,carryDomain_correct p i M _ σ w _ hM (borrowCoord_correct p i M a σ w x hM ha)]
  change (Digits.coordinate p i).symm x∈(Box.carry p).domain i ↔ _
  simp only [Box.reverse,Finset.mem_image]
  constructor
  · intro h; exact ⟨(Digits.coordinate p i).symm x,h,Equiv.apply_symm_apply _ _⟩
  · rintro ⟨y,hy,he⟩
    change Digits.coordinate p i y=x at he
    rw [← he,Equiv.symm_apply_apply]
    exact hy
end Formula
end WLTime.ProductBox

end OAI