import Mathlib
import OAI.Combinatorics.IndependentSets.Machines.ExprTables
import OAI.Combinatorics.IndependentSets.Encoding.GeometryExpr

namespace OAI

namespace LargeIndependentSets.GeometryNames
open IndependentSetsCut.CounterMachine UniformLC ShortestPaths
open scoped Classical BigOperators
noncomputable section

variable (L R : Type) [Fintype L] [Fintype R] (n D : ℕ) [NeZero D]

def pointCost (a b : StaticPoint L R n D) : ℕ :=
  (Capped.clip D (copyCost (decode (fun _ => ()) (fun _ => ()) a)
    (decode (fun _ => ()) (fun _ => ()) b))).val

omit [NeZero D] in
lemma copyCost_same {U V : Type} [DecidableEq U] [DecidableEq V]
    (u u' : Fin n → U) (v v' : Fin n → V) (a b : StaticPoint L R n D) :
    (Capped.clip D (copyCost (decode u v a) (decode u' v' b))).val =
      if sameQuestion L R n D u u' v v' a b then pointCost L R n D a b else D+1 := by
  by_cases hq : sameQuestion L R n D u u' v v' a b
  · rw [ite_eq_left hq]
    have hh := (sameQuestion_iff L R n D u u' v v' a b).mp hq
    rcases a with ⟨i,a⟩
    rcases b with ⟨j,b⟩
    have hij : i=j := congrArg (fun w => w.1) hh
    subst j
    have hq' : mixed u v i.val=mixed u' v' i.val :=
      eq_of_heq (Sigma.mk.inj_iff.mp hh).2
    have hcopy (q q' : MixedTuple U V n i.val) (he : q=q') :
        copyCost (M:=LayerAnswer L R) (⟨⟨i,q⟩,a⟩ : GridLocation _ D) ⟨⟨i,q'⟩,b⟩ =
          (Finset.univ.sup (fun k => circleCost (a k) (b k)) : ℕ) := by
      subst q'
      simp [copyCost]
    rw [show copyCost (decode u v ⟨i,a⟩) (decode u' v' ⟨i,b⟩)=
      (Finset.univ.sup (fun k => circleCost (a k) (b k)) : ℕ) from hcopy _ _ hq']
    simp [pointCost,copyCost,decode]
    rfl
  · have hh := (sameQuestion_iff L R n D u u' v v' a b).not.mp hq
    simp [hq,copyCost,hh]

def questionExpr (x y c : Expr) (h : Fin n) : Expr :=
  .mul (Expr.equal (uExpr L R n D x h) (fieldExpr c 0))
    (.mul (Expr.equal (vExpr L R n D y h) (fieldExpr c 1))
      (Expr.listAll (List.finRange n) (fun k => if k=h then .const 1 else
        if k.val<h.val then Expr.equal (vExpr L R n D x k) (vExpr L R n D y k)
        else Expr.equal (uExpr L R n D x k) (uExpr L R n D y k))))

lemma questionExpr_nonzero (t : Table L R) (x y c : Expr) (a : ℕ → ℕ)
    (i j : Fin (size L R n D t)) (e : Fin t.ne)
    (hi : x.eval t.bits a=i.val) (hj : y.eval t.bits a=j.val) (he : c.eval t.bits a=e.val) (h : Fin n) :
    (questionExpr L R n D x y c h).eval t.bits a≠0 ↔
      QuestionStep t.lc h e ((nodeEquiv L R n D t.nu t.nv).symm i).1.1
        ((nodeEquiv L R n D t.nu t.nv).symm j).1.1
        ((nodeEquiv L R n D t.nu t.nv).symm i).1.2
        ((nodeEquiv L R n D t.nu t.nv).symm j).1.2 := by
  simp only [questionExpr,Expr.eval,Expr.equal_eval,Expr.listAll_eval,
    uExpr_eval L R n D t x a i hi,vExpr_eval L R n D t y a j hj,
    fieldExpr_eval t a c e he ⟨0,by omega⟩,fieldExpr_eval t a c e he ⟨1,by omega⟩]
  have indicator (P : Prop) [Decidable P] : (if P then (1:ℕ) else 0)≠0 ↔ P := by
    split_ifs <;> simp_all
  simp only [↓reduceIte,Nat.one_ne_zero,mul_ne_zero_iff,indicator,Fin.val_inj]
  unfold QuestionStep Table.lc
  apply and_congr_right
  intro _
  apply and_congr_right
  intro _
  simp only [List.mem_finRange,forall_true_left]
  apply forall_congr'
  intro k
  by_cases hk : k=h
  · simp [hk,Expr.eval]
  · by_cases hl : k.val<h.val <;> simp [hk,hl,Expr.equal_eval,
      uExpr_eval L R n D t x a i hi,uExpr_eval L R n D t y a j hj,
      vExpr_eval L R n D t x a i hi,vExpr_eval L R n D t y a j hj,Fin.val_inj]

def pointStepExpr (x y c : Expr) (h : Fin n) : Expr :=
  Expr.static3 (fun (a b : StaticPoint L R n D) (f : L → R) => if PointStep h f a b then 1 else 0)
    (pointExpr L R n D x) (pointExpr L R n D y) (fieldExpr c 2)

lemma pointStepExpr_eval (t : Table L R) (x y c : Expr) (a : ℕ → ℕ)
    (i j : Fin (size L R n D t)) (e : Fin t.ne)
    (hi : x.eval t.bits a=i.val) (hj : y.eval t.bits a=j.val) (he : c.eval t.bits a=e.val) (h : Fin n) :
    (pointStepExpr L R n D x y c h).eval t.bits a =
      if PointStep h (t.project e) ((nodeEquiv L R n D t.nu t.nv).symm i).2
        ((nodeEquiv L R n D t.nu t.nv).symm j).2 then 1 else 0 := by
  apply Expr.static3_eval
  · exact pointExpr_eval L R n D t x a i hi
  · exact pointExpr_eval L R n D t y a j hj
  · exact fieldExpr_eval t a c e he ⟨2,by omega⟩

def forwardExpr (x y : Expr) : Expr :=
  .sum neExpr (Expr.listSum (List.finRange n) (fun h =>
    .mul (pointStepExpr L R n D (x.rename Nat.succ) (y.rename Nat.succ) (.arg 0) h)
      (questionExpr L R n D (x.rename Nat.succ) (y.rename Nat.succ) (.arg 0) h)))

lemma forwardExpr_nonzero (t : Table L R) (x y : Expr) (a : ℕ → ℕ)
    (i j : Fin (size L R n D t)) (hi : x.eval t.bits a=i.val) (hj : y.eval t.bits a=j.val) :
    (forwardExpr L R n D x y).eval t.bits a≠0 ↔
      (layeredSystem t.lc n).ForwardZero D (names L R n D t.nu t.nv i) (names L R n D t.nu t.nv j) := by
  dsimp only [names,nodeDecode]
  rw [forward_iff]
  change _ ↔ ∃ h e, PointStep h (t.project e) ((nodeEquiv L R n D t.nu t.nv).symm i).2
    ((nodeEquiv L R n D t.nu t.nv).symm j).2 ∧ QuestionStep t.lc h e _ _ _ _
  simp only [forwardExpr,Expr.sum_ne_zero,neExpr_eval,Expr.listSum_ne_zero,List.mem_finRange,true_and]
  have each (c : ℕ) (hc : c<t.ne) (h : Fin n) :
      (Expr.mul (pointStepExpr L R n D (x.rename Nat.succ) (y.rename Nat.succ) (.arg 0) h)
        (questionExpr L R n D (x.rename Nat.succ) (y.rename Nat.succ) (.arg 0) h)).eval
        t.bits (Expr.bind a c)≠0 ↔
      PointStep h (t.project ⟨c,hc⟩) ((nodeEquiv L R n D t.nu t.nv).symm i).2
        ((nodeEquiv L R n D t.nu t.nv).symm j).2 ∧ QuestionStep t.lc h ⟨c,hc⟩
          ((nodeEquiv L R n D t.nu t.nv).symm i).1.1
          ((nodeEquiv L R n D t.nu t.nv).symm j).1.1
          ((nodeEquiv L R n D t.nu t.nv).symm i).1.2
          ((nodeEquiv L R n D t.nu t.nv).symm j).1.2 := by
    have hx : (x.rename Nat.succ).eval t.bits (Expr.bind a c)=i.val := by simpa [Expr.bind] using hi
    have hy : (y.rename Nat.succ).eval t.bits (Expr.bind a c)=j.val := by simpa [Expr.bind] using hj
    rw [Expr.eval,mul_ne_zero_iff,pointStepExpr_eval L R n D t _ _ _ _ i j ⟨c,hc⟩ hx hy rfl h,
      questionExpr_nonzero L R n D t _ _ _ _ i j ⟨c,hc⟩ hx hy rfl h]
    split_ifs <;> simp_all
  constructor
  · rintro ⟨c,hc,h,hh⟩; exact ⟨h,⟨c,hc⟩,(each c hc h).mp hh⟩
  · rintro ⟨h,e,hh⟩; exact ⟨e.val,e.isLt,h,(each e.val e.isLt h).mpr hh⟩

def levelExpr (x : Expr) : Expr :=
  Expr.staticLookup (fun a : StaticPoint L R n D => a.1.val) (pointExpr L R n D x)

lemma levelExpr_eval (t : Table L R) (x : Expr) (a : ℕ → ℕ) (i : Fin (size L R n D t))
    (hi : x.eval t.bits a=i.val) :
    (levelExpr L R n D x).eval t.bits a=((nodeEquiv L R n D t.nu t.nv).symm i).2.1.val := by
  exact Expr.staticLookup_eval _ _ _ _ _ (pointExpr_eval L R n D t x a i hi)

def sameQuestionExpr (x y : Expr) : Expr :=
  .mul (Expr.equal (levelExpr L R n D x) (levelExpr L R n D y))
    (Expr.listAll (List.finRange n) (fun k =>
      Expr.cond (Expr.lt (.const k.val) (levelExpr L R n D x))
        (Expr.equal (vExpr L R n D x k) (vExpr L R n D y k))
        (Expr.equal (uExpr L R n D x k) (uExpr L R n D y k))))

lemma sameQuestionExpr_nonzero (t : Table L R) (x y : Expr) (a : ℕ → ℕ)
    (i j : Fin (size L R n D t)) (hi : x.eval t.bits a=i.val) (hj : y.eval t.bits a=j.val) :
    (sameQuestionExpr L R n D x y).eval t.bits a≠0 ↔
      sameQuestion L R n D ((nodeEquiv L R n D t.nu t.nv).symm i).1.1
        ((nodeEquiv L R n D t.nu t.nv).symm j).1.1
        ((nodeEquiv L R n D t.nu t.nv).symm i).1.2
        ((nodeEquiv L R n D t.nu t.nv).symm j).1.2
        ((nodeEquiv L R n D t.nu t.nv).symm i).2
        ((nodeEquiv L R n D t.nu t.nv).symm j).2 := by
  have indicator (P : Prop) [Decidable P] : (if P then (1:ℕ) else 0)≠0 ↔ P := by
    split_ifs <;> simp_all
  simp only [sameQuestionExpr,Expr.eval,mul_ne_zero_iff,Expr.equal_eval,Expr.listAll_eval,
    levelExpr_eval L R n D t x a i hi,levelExpr_eval L R n D t y a j hj,
    indicator,Fin.val_inj,List.mem_finRange,forall_true_left,sameQuestion]
  apply and_congr_right
  intro _
  apply forall_congr'
  intro k
  simp only [Expr.cond_eval,Expr.lt_eval,Expr.eval,levelExpr_eval L R n D t x a i hi,
    indicator,Expr.equal_eval,vExpr_eval L R n D t x a i hi,vExpr_eval L R n D t y a j hj,
    uExpr_eval L R n D t x a i hi,uExpr_eval L R n D t y a j hj]
  split_ifs <;> simp_all [Fin.val_inj]

def copyCostExpr (x y : Expr) : Expr :=
  Expr.cond (sameQuestionExpr L R n D x y)
    (Expr.static2 (pointCost L R n D) (pointExpr L R n D x) (pointExpr L R n D y))
    (.const (D+1))

lemma copyCostExpr_eval (t : Table L R) (x y : Expr) (a : ℕ → ℕ)
    (i j : Fin (size L R n D t)) (hi : x.eval t.bits a=i.val) (hj : y.eval t.bits a=j.val) :
    (copyCostExpr L R n D x y).eval t.bits a=
      (Capped.clip D (copyCost (names L R n D t.nu t.nv i) (names L R n D t.nu t.nv j))).val := by
  dsimp only [names,nodeDecode]
  rw [copyCost_same]
  simp only [copyCostExpr,Expr.cond_eval,sameQuestionExpr_nonzero L R n D t x y a i j hi hj,
    Expr.static2_eval _ _ _ _ _ _ _ (pointExpr_eval L R n D t x a i hi)
      (pointExpr_eval L R n D t y a j hj),Expr.eval]

def costExpr (x y : Expr) : Expr :=
  Expr.cond (.add (forwardExpr L R n D x y) (forwardExpr L R n D y x))
    (.const 0) (copyCostExpr L R n D x y)

lemma costExpr_eval (t : Table L R) (x y : Expr) (a : ℕ → ℕ)
    (i j : Fin (size L R n D t)) (hi : x.eval t.bits a=i.val) (hj : y.eval t.bits a=j.val) :
    (costExpr L R n D x y).eval t.bits a=
      (Capped.clip D (linkCost (layeredSystem t.lc n)
        (names L R n D t.nu t.nv i) (names L R n D t.nu t.nv j))).val := by
  have add_ne (a b : ℕ) : a+b≠0 ↔ a≠0 ∨ b≠0 := by omega
  simp only [costExpr,Expr.cond_eval,Expr.eval,add_ne,
    forwardExpr_nonzero L R n D t x y a i j hi hj,
    forwardExpr_nonzero L R n D t y x a j i hj hi,
    copyCostExpr_eval L R n D t x y a i j hi hj,linkCost,ProjectionSystem.ZeroLink]
  split_ifs <;> simp_all [Capped.clip]

end
end LargeIndependentSets.GeometryNames

end OAI