import Mathlib
import OAI.Algebra.Finitistic.Encoding.DirectedBound
import OAI.Algebra.FinitisticAsymmetry.Model

namespace OAI

section
noncomputable section
open scoped BigOperators
namespace LittleFinitistic.DirectedBound
universe u

namespace DirectedSystem
variable {k A : Type u} [Field k] [Ring A] [Algebra k A] {n : ℕ}
variable (D : DirectedSystem k A n)
abbrev Vertices := {i : Fin n // D.e i ≠ 0}
def coefficient (a : A) (i : D.Vertices) : k := (D.diagonal i a).choose
lemma coefficient_spec (a : A) (i : D.Vertices) :
    D.e i * a * D.e i = D.coefficient a i • D.e i := (D.diagonal i a).choose_spec
lemma coefficient_eq_iff (a : A) (i : D.Vertices) (c : k) :
    D.coefficient a i = c ↔ D.e i * a * D.e i = c • D.e i := by
  rw [D.coefficient_spec]
  exact (smul_left_injective k i.property).eq_iff.symm

lemma corner_mul (a b : A) (i j : Fin n) :
    D.e i * (a * b) * D.e j = ∑ l, (D.e i * a * D.e l) * (D.e l * b * D.e j) := by
  conv_rhs => arg 2; ext l; rw [mul_assoc, ← mul_assoc (D.e l), ← mul_assoc (D.e l), D.idem]
  simp only [← mul_assoc]
  rw [← Finset.sum_mul, ← Finset.sum_mul, ← Finset.mul_sum, D.complete]
  simp [mul_assoc]

lemma diagonal_mul (a b : A) (i : Fin n) :
    D.e i * (a * b) * D.e i = (D.e i * a * D.e i) * (D.e i * b * D.e i) := by
  rw [D.corner_mul, Finset.sum_eq_single i]
  · intro j _ hji
    rcases lt_or_gt_of_ne hji with hji | hij
    · rw [D.directed i j hji b, mul_zero]
    · rw [D.directed j i hij a, zero_mul]
  · simp

def augmentation : A →ₐ[k] (D.Vertices → k) where
  toFun := D.coefficient
  map_zero' := by ext i; apply (D.coefficient_eq_iff _ _ _).mpr; simp
  map_one' := by ext i; apply (D.coefficient_eq_iff _ _ _).mpr; simp [D.idem]
  map_add' a b := by
    ext i
    apply (D.coefficient_eq_iff _ _ _).mpr
    simp [mul_add, add_mul, D.coefficient_spec, add_smul]
  map_mul' a b := by
    ext i
    apply (D.coefficient_eq_iff _ _ _).mpr
    rw [D.diagonal_mul, D.coefficient_spec, D.coefficient_spec, smul_mul_smul_comm, D.idem]
    rfl
  commutes' c := by
    ext i
    apply (D.coefficient_eq_iff _ _ _).mpr
    rw [← (Algebra.commutes c (D.e i)), ← Algebra.smul_def, smul_mul_assoc, D.idem]
    rfl

lemma coefficient_vertex (i j : D.Vertices) :
    D.coefficient (D.e i) j = if j = i then 1 else 0 := by
  classical
  apply (D.coefficient_eq_iff _ _ _).mpr
  split_ifs with h
  · subst j; simp [D.idem]
  · rw [D.orthogonal j i (fun hji => h (Subtype.ext hji))]
    simp

lemma augmentation_surjective : Function.Surjective D.augmentation := by
  classical
  intro s
  refine ⟨∑ i : D.Vertices, s i • D.e i, ?_⟩
  ext j
  simp [map_sum, map_smul, augmentation, coefficient_vertex]

lemma mem_augmentation_ker_iff (a : A) :
    a ∈ RingHom.ker D.augmentation.toRingHom ↔ ∀ i : Fin n, D.e i * a * D.e i = 0 := by
  constructor
  · intro ha i
    by_cases hi : D.e i = 0
    · simp [hi]
    · rw [D.coefficient_spec a ⟨i, hi⟩]
      have := congrFun ha ⟨i, hi⟩
      change D.coefficient a ⟨i, hi⟩ = 0 at this
      rw [this, zero_smul]
  · intro ha
    change D.augmentation a = 0
    ext i
    apply (D.coefficient_eq_iff _ _ _).mpr
    simpa using ha i

lemma ker_corner_vanish {a : A} (ha : a ∈ RingHom.ker D.augmentation.toRingHom)
    (i j : Fin n) (hij : i.val < j.val + 1) : D.e i * a * D.e j = 0 := by
  by_cases h : i = j
  · subst j; exact (D.mem_augmentation_ker_iff a).mp ha i
  · exact D.directed j i (by have hne : i.val ≠ j.val := fun hval => h (Fin.ext hval); omega) a

lemma pow_ker_corner_vanish (m : ℕ) {a : A}
    (ha : a ∈ (RingHom.ker D.augmentation.toRingHom) ^ m)
    (i j : Fin n) (hij : i.val < j.val + m) : D.e i * a * D.e j = 0 := by
  induction m generalizing a i j with
  | zero => exact D.directed j i (by simpa using hij) a
  | succ m ih =>
    rw [Submodule.pow_succ] at ha
    refine Submodule.mul_induction_on ha ?_ ?_
    · intro x hx y hy
      rw [D.corner_mul]
      apply Finset.sum_eq_zero
      intro l _
      by_cases hil : i.val < l.val + m
      · rw [ih hx i l hil, zero_mul]
      · rw [D.ker_corner_vanish hy l j (by omega), mul_zero]
    · intro x y hx hy
      simp [mul_add, add_mul, hx, hy]

lemma augmentation_ker_nilpotent :
    ∃ m : ℕ, (RingHom.ker D.augmentation.toRingHom) ^ m = ⊥ := by
  refine ⟨n, le_bot_iff.mp ?_⟩
  intro a ha
  change a = 0
  have he : (∑ i, D.e i) * a * (∑ j, D.e j) = 0 := by
    simp only [Finset.sum_mul, Finset.mul_sum]
    apply Finset.sum_eq_zero
    intro j _
    apply Finset.sum_eq_zero
    intro i _
    exact D.pow_ker_corner_vanish n ha i j (by omega)
  simpa [D.complete] using he
end DirectedSystem
end LittleFinitistic.DirectedBound

end
end

end OAI