lean/OAI/Algebra/Finitistic/Encoding/DirectedBound.lean

import Mathlib.Algebra.Category.ModuleCat.ProjectiveDimension
import Mathlib.LinearAlgebra.TensorProduct.Tower
import Mathlib.LinearAlgebra.Basis.VectorSpace
import Mathlib.Algebra.Algebra.Opposite
import Mathlib.Data.Fin.Rev
import Mathlib.LinearAlgebra.FiniteDimensional.Defs

namespace OAI
noncomputable section
open scoped TensorProduct
open TensorProduct
namespace LittleFinitistic.DirectedBound
universe u v
variable {k A : Type u} [Field k] [Ring A] [Algebra k A] {n : ℕ}

/-- The displayed algebraic hypotheses of Section 3, Lemma directed-bound.
The field and algebra are unital; zero idempotents are allowed by the source. -/
structure DirectedSystem (k A : Type u) [Field k] [Ring A] [Algebra k A] (n : ℕ) where
  e : Fin n → A
  idem : ∀ i, e i * e i = e i
  orthogonal : ∀ i j, i ≠ j → e i * e j = 0
  complete : ∑ i, e i = 1
  diagonal : ∀ i a, ∃ c : k, e i * a * e i = c • e i
  directed : ∀ i j, j < i → ∀ a, e j * a * e i = 0

namespace DirectedSystem
variable (D : DirectedSystem k A n)
variable (M : Type v) [AddCommGroup M] [Module A M] [Module k M]
  [IsScalarTower k A M]

/-- Vanishing of vertex components below p, for arbitrary modules. -/
def Supported (p : ℕ) : Prop := ∀ j : Fin n, j.val < p → ∀ m : M, D.e j • m = 0

/-- Evaluation of the free induced module. -/
def evaluation (_D : DirectedSystem k A n) : A ⊗[k] M →ₗ[A] M := AlgebraTensorModule.lift
  { toFun := fun a =>
      { toFun := fun m => a • m
        map_add' := smul_add a
        map_smul' := fun c m => smul_comm a c m }
    map_add' := fun a b => by ext m; exact add_smul a b m
    map_smul' := fun a b => by ext m; exact mul_smul a b m }

@[simp] theorem evaluation_tmul (a : A) (m : M) :
    evaluation M D (a ⊗ₜ[k] m) = a • m := rfl

/-- One summand of the separable diagonal projection. -/
def vertexProjection (i : Fin n) : A ⊗[k] M →ₗ[A] A ⊗[k] M :=
  AlgebraTensorModule.lift
    { toFun := fun a =>
        { toFun := fun m => (a * D.e i) ⊗ₜ[k] (D.e i • m)
          map_add' := fun x y => by simp [smul_add, tmul_add]
          map_smul' := fun c m => by
            simp only [RingHom.id_apply, smul_comm (D.e i) c, tmul_smul] }
      map_add' := fun a b => by ext m; simp [add_mul, add_tmul]
      map_smul' := fun a b => by
        ext m
        change ((a * b) * D.e i) ⊗ₜ[k] (D.e i • m) =
          a • ((b * D.e i) ⊗ₜ[k] (D.e i • m))
        rw [smul_tmul', smul_eq_mul, mul_assoc] }

@[simp] theorem vertexProjection_tmul (i : Fin n) (a : A) (m : M) :
    D.vertexProjection M i (a ⊗ₜ[k] m) = (a * D.e i) ⊗ₜ[k] (D.e i • m) := rfl

def projection : A ⊗[k] M →ₗ[A] A ⊗[k] M := ∑ i, D.vertexProjection M i

@[simp] theorem projection_tmul (a : A) (m : M) :
    D.projection M (a ⊗ₜ[k] m) = ∑ i, (a * D.e i) ⊗ₜ[k] (D.e i • m) := by
  simp [projection]


lemma projection_vertexTensor (i : Fin n) (a : A) (m : M) :
    D.projection M ((a * D.e i) ⊗ₜ[k] (D.e i • m)) =
      (a * D.e i) ⊗ₜ[k] (D.e i • m) := by
  rw [projection_tmul, Finset.sum_eq_single i]
  · simp only [mul_assoc, D.idem, ← mul_smul]
  · intro j _ hji
    rw [mul_assoc, D.orthogonal i j hji.symm, mul_zero, zero_tmul]
  · simp

lemma projection_idempotent (x : A ⊗[k] M) :
    D.projection M (D.projection M x) = D.projection M x := by
  induction x using TensorProduct.inductionOn with
  | tmul a m =>
    rw [projection_tmul, map_sum]
    simp only [projection_vertexTensor]
  | add x y hx hy => simp only [map_add, hx, hy]

lemma evaluation_projection (x : A ⊗[k] M) :
    evaluation M D (D.projection M x) = evaluation M D x := by
  induction x using TensorProduct.inductionOn with
  | tmul a m =>
    simp only [projection_tmul, map_sum, evaluation_tmul, ← mul_smul, mul_assoc, D.idem]
    rw [← Finset.sum_smul, ← Finset.mul_sum, D.complete, mul_one]
  | add x y hx hy => simp only [map_add, hx, hy]

/-- The manuscript's projective cover, realized as an actual direct summand. -/
abbrev Cover := LinearMap.range (D.projection M)

instance cover_addCommGroup : AddCommGroup (D.Cover M) :=
  Submodule.addCommGroup _

instance cover_projective : Module.Projective A (D.Cover M) := by
  apply Module.Projective.of_split (D.projection M).range.subtype
    (D.projection M).rangeRestrict
  ext x
  obtain ⟨t, ht⟩ := x.property
  change D.projection M x.val = x.val
  rw [← ht, projection_idempotent]

/-- Evaluation restricted to the projective summand. -/
abbrev coverMap : D.Cover M →ₗ[A] M :=
  (evaluation M D).comp (D.projection M).range.subtype

lemma coverMap_surjective : Function.Surjective (D.coverMap M) := by
  intro m
  refine ⟨(D.projection M).rangeRestrict (1 ⊗ₜ[k] m), ?_⟩
  change evaluation M D (D.projection M (1 ⊗ₜ[k] m)) = m
  rw [evaluation_projection, evaluation_tmul, one_smul]

lemma low_tensor {p : ℕ} (hM : D.Supported M p) (j : Fin n) (hj : j.val ≤ p)
    (i : Fin n) (a : A) (m : M) :
    (D.e j * a * D.e i) ⊗ₜ[k] (D.e i • m) =
      D.e j ⊗ₜ[k] ((D.e j * a * D.e i) • (D.e i • m)) := by
  by_cases hij : i = j
  · subst i
    obtain ⟨c, hc⟩ := D.diagonal j a
    rw [hc, smul_tmul, smul_assoc, ← mul_smul, D.idem, tmul_smul]
  · rcases lt_or_gt_of_ne hij with hij | hij
    · have hz := hM i (by omega) m
      simp [hz]
    · rw [D.directed i j hij a]
      simp

lemma low_projection {p : ℕ} (hM : D.Supported M p) (j : Fin n) (hj : j.val ≤ p)
    (x : A ⊗[k] M) :
    D.e j • D.projection M x =
      D.e j ⊗ₜ[k] evaluation M D (D.e j • D.projection M x) := by
  induction x using TensorProduct.inductionOn with
  | tmul a m =>
    simp only [projection_tmul, Finset.smul_sum, smul_tmul', smul_eq_mul, map_sum,
      evaluation_tmul, tmul_sum]
    apply Finset.sum_congr rfl
    intro i _
    simpa only [← mul_assoc] using D.low_tensor M hM j hj i a m
  | add x y hx hy =>
    simp only [map_add, smul_add, tmul_add]
    exact congrArg₂ (· + ·) hx hy

/-- One syzygy raises the lower bound on the support by one. -/
lemma kernel_supported {p : ℕ} (hM : D.Supported M p) :
    D.Supported (LinearMap.ker (D.coverMap M)) (p + 1) := by
  intro j hj x
  apply Subtype.ext
  apply Subtype.ext
  change D.e j • x.val.val = 0
  obtain ⟨t, ht⟩ := x.val.property
  have h := D.low_projection M hM j (by omega) t
  rw [ht] at h
  rw [h, map_smul]
  have hz : evaluation M D x.val.val = 0 := x.property
  rw [hz, smul_zero, tmul_zero]

open CategoryTheory

omit [Module k M] [IsScalarTower k A M] in
lemma supported_subsingleton (hM : D.Supported M n) : Subsingleton M := by
  have hz (m : M) : m = 0 := by
    calc
      m = (1 : A) • m := (one_smul A m).symm
      _ = (∑ i, D.e i) • m := by rw [D.complete]
      _ = ∑ i, D.e i • m := Finset.sum_smul
      _ = 0 := Finset.sum_eq_zero (fun i _ => hM i i.isLt m)
  exact ⟨fun x y => (hz x).trans (hz y).symm⟩

/-- The support induction uses genuine projective dimensions (vanishing Ext),
via mathlib's short exact sequence dimension-shifting theorem. -/
theorem supported_projectiveDimensionLT (r : ℕ) :
    ∀ (p : ℕ), p + r = n → ∀ (N : Type (max u v))
      [AddCommGroup N] [Module A N] [Module k N] [IsScalarTower k A N],
      D.Supported N p → HasProjectiveDimensionLT (ModuleCat.of A N) r := by
  induction r with
  | zero =>
    intro p hp N _ _ _ _ hN
    have hp' : p = n := by omega
    subst p
    have := D.supported_subsingleton N hN
    exact (ModuleCat.isZero_iff_subsingleton.mpr inferInstance).hasProjectiveDimensionLT_zero
  | succ r ih =>
    intro p hp N _ _ _ _ hN
    have hK := ih (p + 1) (by omega) (LinearMap.ker (D.coverMap N))
      (D.kernel_supported N hN)
    have hP : HasProjectiveDimensionLT (ModuleCat.of A (D.Cover N)) (r + 1) :=
      hasProjectiveDimensionLT_of_ge _ 1 (r + 1) (by omega)
    exact (LinearMap.shortExact_shortComplexKer (D.coverMap_surjective N)).hasProjectiveDimensionLT_X₃ r hK hP

include D

/-- Every left module is covered, with no finite generation restriction. -/
theorem all_modules_projectiveDimensionLT (N : ModuleCat.{max u v} A) :
    HasProjectiveDimensionLT N n := by
  let : Module k N := Module.compHom N (algebraMap k A)
  let : IsScalarTower k A N := IsScalarTower.of_compHom k A N
  exact D.supported_projectiveDimensionLT n 0 (by omega) N (by
    intro j hj
    omega)

theorem all_modules_projectiveDimension_le (N : ModuleCat.{max u v} A) :
    projectiveDimension N ≤ (n - 1 : ℕ) := by
  have := D.all_modules_projectiveDimensionLT N
  apply (projectiveDimension_le_iff N (n - 1)).mpr
  exact hasProjectiveDimensionLT_of_ge N n ((n - 1) + 1) (by omega)

/-- Reversing the vertices transfers exactly the hypotheses to right modules. -/
def opposite : DirectedSystem k Aᵐᵒᵖ n where
  e i := MulOpposite.op (D.e i.rev)
  idem i := by
    apply MulOpposite.unop_injective
    exact D.idem i.rev
  orthogonal i j hij := by
    apply MulOpposite.unop_injective
    exact D.orthogonal j.rev i.rev (fun h => hij (Fin.rev_injective h.symm))
  complete := by
    apply MulOpposite.unop_injective
    change (MulOpposite.opAddEquiv.symm : Aᵐᵒᵖ ≃+ A)
      (∑ i : Fin n, MulOpposite.op (D.e i.rev)) = 1
    rw [map_sum]
    change (∑ i : Fin n, D.e i.rev) = 1
    calc
      ∑ i : Fin n, D.e i.rev = ∑ i, D.e i := Equiv.sum_comp Fin.revPerm D.e
      _ = 1 := D.complete
  diagonal i a := by
    obtain ⟨c, hc⟩ := D.diagonal i.rev a.unop
    refine ⟨c, ?_⟩
    apply MulOpposite.unop_injective
    simpa only [MulOpposite.unop_mul, MulOpposite.unop_op, MulOpposite.unop_smul,
      mul_assoc] using hc
  directed i j hij a := by
    apply MulOpposite.unop_injective
    simpa only [MulOpposite.unop_mul, MulOpposite.unop_op, MulOpposite.unop_zero,
      mul_assoc] using D.directed j.rev i.rev (Fin.rev_lt_rev.mpr hij) a.unop

/-- Both sides, quantified over arbitrary modules in any larger universe. -/
theorem both_sides_projectiveDimension_le :
    (∀ N : ModuleCat.{max u v} A, projectiveDimension N ≤ (n - 1 : ℕ)) ∧
    (∀ N : ModuleCat.{max u v} Aᵐᵒᵖ, projectiveDimension N ≤ (n - 1 : ℕ)) :=
  ⟨D.all_modules_projectiveDimension_le, D.opposite.all_modules_projectiveDimension_le⟩

/-- The global dimensions are the suprema of the actual module projective dimensions. -/
theorem both_sides_globalDimension_le :
    (⨆ N : ModuleCat.{max u v} A, projectiveDimension N) ≤ (n - 1 : ℕ) ∧
    (⨆ N : ModuleCat.{max u v} Aᵐᵒᵖ, projectiveDimension N) ≤ (n - 1 : ℕ) :=
  ⟨iSup_le D.all_modules_projectiveDimension_le,
   iSup_le D.opposite.all_modules_projectiveDimension_le⟩
end DirectedSystem

open CategoryTheory
/-- Section 3, Lemma directed-bound, with its displayed hypotheses expanded.
Finite dimensionality is retained here although the proof proves a stronger result. -/
theorem directed_bound [FiniteDimensional k A] (e : Fin n → A)
    (idem : ∀ i, e i * e i = e i)
    (orthogonal : ∀ i j, i ≠ j → e i * e j = 0)
    (complete : ∑ i, e i = 1)
    (diagonal : ∀ i a, ∃ c : k, e i * a * e i = c • e i)
    (directed : ∀ i j, j < i → ∀ a, e j * a * e i = 0) :
    (⨆ N : ModuleCat.{max u v} A, projectiveDimension N) ≤ (n - 1 : ℕ) ∧
    (⨆ N : ModuleCat.{max u v} Aᵐᵒᵖ, projectiveDimension N) ≤ (n - 1 : ℕ) :=
  (DirectedSystem.mk e idem orthogonal complete diagonal directed).both_sides_globalDimension_le
end LittleFinitistic.DirectedBound

end

end OAI