import OAI.Computability.WeisfeilerLeman.Colors

namespace OAI

universe uV uE uF

namespace WLTime.Compression

abbrev F₂ := ZMod 2

variable {V : Type uV} {G : SimpleGraph V}

def walkWeight (mark : V → V → F₂) : {u v : V} → G.Walk u v → F₂
  | _, _, .nil => 0
  | _, _, @SimpleGraph.Walk.cons _ _ u v _ _ p => mark u v + walkWeight mark p

@[simp] theorem walkWeight_nil (mark : V → V → F₂) (v : V) :
    walkWeight mark (G := G) (.nil : G.Walk v v) = 0 := rfl

@[simp] theorem walkWeight_cons (mark : V → V → F₂) {u v w : V}
    (h : G.Adj u v) (p : G.Walk v w) :
    walkWeight mark (.cons h p) = mark u v + walkWeight mark p := rfl

@[simp] theorem walkWeight_append (mark : V → V → F₂) {u v w : V}
    (p : G.Walk u v) (q : G.Walk v w) :
    walkWeight mark (p.append q) = walkWeight mark p + walkWeight mark q := by
  induction p with
  | nil => simp [walkWeight]
  | @cons u v w h p ih => simp [walkWeight, ih, add_assoc]

@[simp] theorem walkWeight_reverse (mark : V → V → F₂)
    (hsymm : ∀ u v, G.Adj u v → mark u v = mark v u)
    {u v : V} (p : G.Walk u v) :
    walkWeight mark p.reverse = walkWeight mark p := by
  induction p with
  | nil => rfl
  | @cons u v w h p ih =>
    simp [SimpleGraph.Walk.reverse_cons, ih, hsymm u v h, add_comm]

theorem walkWeight_independent (mark : V → V → F₂)
    (hsymm : ∀ u v, G.Adj u v → mark u v = mark v u)
    (hclosed : ∀ v (p : G.Walk v v), walkWeight mark p = 0)
    {u v : V} (p q : G.Walk u v) : walkWeight mark p = walkWeight mark q := by
  have h := hclosed u (p.append q.reverse)
  simp only [walkWeight_append, walkWeight_reverse mark hsymm] at h
  have hz := CharTwo.add_self_eq_zero (walkWeight mark q)
  exact add_right_cancel (h.trans hz.symm)

theorem walkWeight_congr (mark mark' : V → V → F₂)
    (h : ∀ u v, G.Adj u v → mark u v = mark' u v)
    {u v : V} (p : G.Walk u v) : walkWeight mark p = walkWeight mark' p := by
  induction p with
  | nil => rfl
  | cons e p ih => simp only [walkWeight_cons, h _ _ e, ih]

@[simp] theorem walkWeight_zero {u v : V} (p : G.Walk u v) :
    walkWeight (fun _ _ => 0) p = 0 := by
  induction p with
  | nil => rfl
  | cons e p ih => simp only [walkWeight_cons, zero_add, ih]

@[simp] theorem walkWeight_add (a b : V → V → F₂) {u v : V} (p : G.Walk u v) :
    walkWeight (fun u v => a u v + b u v) p = walkWeight a p + walkWeight b p := by
  induction p with
  | nil => simp
  | cons e p ih => simp only [walkWeight_cons, ih]; abel

@[simp] theorem walkWeight_mul (a : V → V → F₂) (c : F₂)
    {u v : V} (p : G.Walk u v) :
    walkWeight (fun u v => c * a u v) p = c * walkWeight a p := by
  induction p with
  | nil => simp
  | cons e p ih => simp only [walkWeight_cons, ih, mul_add]

@[simp] theorem walkWeight_coboundary (s : V → F₂) {u v : V} (p : G.Walk u v) :
    walkWeight (fun u v => s u + s v) p = s u + s v := by
  induction p with
  | nil => simp [CharTwo.add_self_eq_zero]
  | @cons a b c e p ih =>
    simp only [walkWeight_cons, ih]
    calc
      _ = s a + (s b + s b) + s c := by abel
      _ = _ := by rw [CharTwo.add_self_eq_zero, add_zero]

noncomputable def potentialFrom (mark : V → V → F₂) (root v : V) : F₂ := by
  classical
  exact if h : G.Reachable root v then walkWeight mark h.some else 0

theorem potentialFrom_edge (mark : V → V → F₂)
    (hsymm : ∀ u v, G.Adj u v → mark u v = mark v u)
    (hclosed : ∀ v (p : G.Walk v v), walkWeight mark p = 0)
    {root u v : V} (hu : G.Reachable root u) (h : G.Adj u v) :
    potentialFrom (G := G) mark root u + potentialFrom (G := G) mark root v = mark u v := by
  classical
  have hv := hu.trans h.reachable
  simp only [potentialFrom, dite_eq_left hu, dite_eq_left hv]
  have hp := walkWeight_independent mark hsymm hclosed
    (hu.some.append (.cons h .nil)) hv.some
  simp only [walkWeight_append, walkWeight_cons, walkWeight_nil, add_zero] at hp
  rw [← hp, ← add_assoc, CharTwo.add_self_eq_zero, zero_add]

theorem exists_seam_potential (mark : V → V → F₂)
    (hsymm : ∀ u v, G.Adj u v → mark u v = mark v u)
    (hclosed : ∀ v (p : G.Walk v v), walkWeight mark p = 0) :
    ∃ s : V → F₂, ∀ u v, G.Adj u v → s u + s v = mark u v := by
  classical
  let root (v : V) : V := (G.connectedComponentMk v).out
  have hroot (v : V) : G.Reachable (root v) v :=
    SimpleGraph.ConnectedComponent.eq.mp (Quot.out_eq (G.connectedComponentMk v))
  refine ⟨fun v => potentialFrom (G := G) mark (root v) v, ?_⟩
  intro u v huv
  have heq : root u = root v :=
    congrArg Quot.out (SimpleGraph.ConnectedComponent.eq.mpr huv.reachable)
  change potentialFrom mark (root u) u + potentialFrom mark (root v) v = mark u v
  rw [← heq]
  exact potentialFrom_edge mark hsymm hclosed (hroot u) huv

section ReadoutAlgebra

variable {E : Type uE} {F : Type uF} [AddCommGroup E] [Module F₂ E]
  [AddCommGroup F] [Module F₂ F]

def horizontalReadout (left right shift : E) (seam : F₂) : E :=
  left + right + seam • shift

def verticalReadout (L : E →ₗ[F₂] F₂) (R : F →ₗ[F₂] F₂)
    (left : E) (right : F) : F₂ := L left + R right

theorem horizontal_adjustment (left right oldShift newShift : E)
    (s t seam : F₂) (hst : s + t = seam) :
    horizontalReadout (left + s • (oldShift - newShift))
      (right + t • (oldShift - newShift)) newShift seam =
        horizontalReadout left right oldShift seam := by
  unfold horizontalReadout
  calc
    _ = left + right + (s + t) • (oldShift - newShift) + seam • newShift := by
      module
    _ = _ := by rw [hst, smul_sub]; abel

theorem homogeneous_shift_difference (L : E →ₗ[F₂] F₂) (R : F →ₗ[F₂] F₂)
    (oldLeft newLeft : E) (oldRight newRight : F) (b : F₂)
    (ho : L oldLeft + R oldRight = b) (hn : L newLeft + R newRight = b) :
    L (oldLeft - newLeft) + R (oldRight - newRight) = 0 := by
  simp only [map_sub]
  linear_combination ho - hn

theorem vertical_adjustment (L : E →ₗ[F₂] F₂) (R : F →ₗ[F₂] F₂)
    (left gLeft : E) (right gRight : F) (s : F₂)
    (hg : L gLeft + R gRight = 0) :
    verticalReadout L R (left + s • gLeft) (right + s • gRight) =
      verticalReadout L R left right := by
  simp only [verticalReadout, map_add, map_smul, smul_eq_mul]
  linear_combination s * hg

theorem square_readouts_legal (L : E →ₗ[F₂] F₂) (R : F →ₗ[F₂] F₂)
    (left₀ left₁ shiftLeft : E) (right₀ right₁ shiftRight : F) (seam b : F₂)
    (hlink : L shiftLeft + R shiftRight = b) :
    L (horizontalReadout left₀ left₁ shiftLeft seam) +
      R (horizontalReadout right₀ right₁ shiftRight seam) +
      verticalReadout L R left₀ right₀ + verticalReadout L R left₁ right₁ =
        seam * b := by
  simp only [horizontalReadout, verticalReadout, map_add, map_smul, smul_eq_mul]
  linear_combination (norm := (ring_nf; simp [CharTwo.two_eq_zero])) seam * hlink

end ReadoutAlgebra

end WLTime.Compression

end OAI