math / data /lean /OAI /Algebra /Finitistic /Encoding /ThreeVertexAlgebra.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
6.07 kB
import OAI.Algebra.Finitistic.Encoding.DirectedBound
import Mathlib.LinearAlgebra.FiniteDimensional.Basic
import Mathlib.Tactic.FinCases
namespace OAI
noncomputable section
namespace LittleFinitistic
universe u v
variable {k V W U : Type u} [Field k]
[AddCommGroup V] [Module k V] [AddCommGroup W] [Module k W]
[AddCommGroup U] [Module k U]
/-- Coordinates by the six possible path endpoints: three vertices,
0-to-1 arrows, 1-to-2 arrows, and length-two paths modulo relations. -/
abbrev ThreeVertexAlgebra (_μ : W →ₗ[k] V →ₗ[k] U) := k × k × k × V × W × U
namespace ThreeVertexAlgebra
variable (μ : W →ₗ[k] V →ₗ[k] U)
instance : AddCommGroup (ThreeVertexAlgebra μ) :=
inferInstanceAs (AddCommGroup (k × k × k × V × W × U))
instance : Module k (ThreeVertexAlgebra μ) :=
inferInstanceAs (Module k (k × k × k × V × W × U))
@[simp] theorem zero_eq : (0 : ThreeVertexAlgebra μ) = (0, 0, 0, 0, 0, 0) := rfl
@[simp] theorem add_eq (x y : ThreeVertexAlgebra μ) :
x + y = (x.1+y.1, x.2.1+y.2.1, x.2.2.1+y.2.2.1,
x.2.2.2.1+y.2.2.2.1, x.2.2.2.2.1+y.2.2.2.2.1,
x.2.2.2.2.2+y.2.2.2.2.2) := rfl
@[simp] theorem smul_eq (c : k) (x : ThreeVertexAlgebra μ) :
c • x = (c*x.1, c*x.2.1, c*x.2.2.1,
c • x.2.2.2.1, c • x.2.2.2.2.1, c • x.2.2.2.2.2) := rfl
def mul (x y : ThreeVertexAlgebra μ) : ThreeVertexAlgebra μ :=
(x.1 * y.1, x.2.1 * y.2.1, x.2.2.1 * y.2.2.1,
y.1 • x.2.2.2.1 + x.2.1 • y.2.2.2.1,
y.2.1 • x.2.2.2.2.1 + x.2.2.1 • y.2.2.2.2.1,
y.1 • x.2.2.2.2.2 + μ x.2.2.2.2.1 y.2.2.2.1 + x.2.2.1 • y.2.2.2.2.2)
def unit : ThreeVertexAlgebra μ := (1, 1, 1, 0, 0, 0)
@[ext] theorem ext (x y : ThreeVertexAlgebra μ)
(h0 : x.1 = y.1) (h1 : x.2.1 = y.2.1) (h2 : x.2.2.1 = y.2.2.1)
(hv : x.2.2.2.1 = y.2.2.2.1) (hw : x.2.2.2.2.1 = y.2.2.2.2.1)
(hu : x.2.2.2.2.2 = y.2.2.2.2.2) : x = y :=
Prod.ext h0 (Prod.ext h1 (Prod.ext h2 (Prod.ext hv (Prod.ext hw hu))))
instance : Ring (ThreeVertexAlgebra μ) where
__ := (inferInstance : AddCommGroup (ThreeVertexAlgebra μ))
mul := mul μ
one := unit μ
mul_assoc x y z := by
change mul μ (mul μ x y) z = mul μ x (mul μ y z)
apply Prod.ext <;> dsimp [mul]
· ring
apply Prod.ext
· ring
apply Prod.ext
· ring
apply Prod.ext
· simp only [smul_add, smul_smul]; module
apply Prod.ext
· simp only [smul_add, smul_smul]; module
· simp only [map_add, map_smul, LinearMap.add_apply, LinearMap.smul_apply,
smul_add, smul_smul]; module
one_mul x := by
change mul μ (unit μ) x = x
apply Prod.ext <;> dsimp [mul, unit]
· simp
apply Prod.ext
· simp
apply Prod.ext
· simp
apply Prod.ext
· simp
apply Prod.ext <;> simp
mul_one x := by
change mul μ x (unit μ) = x
apply Prod.ext <;> dsimp [mul, unit]
· simp
apply Prod.ext
· simp
apply Prod.ext
· simp
apply Prod.ext
· simp
apply Prod.ext <;> simp
left_distrib x y z := by
change mul μ x (y + z) = mul μ x y + mul μ x z
rw [add_eq μ (mul μ x y) (mul μ x z), add_eq μ y z]
ext <;> simp [mul, mul_add, smul_add, add_smul, map_add] <;> abel
right_distrib x y z := by
change mul μ (x + y) z = mul μ x z + mul μ y z
rw [add_eq μ (mul μ x z) (mul μ y z), add_eq μ x y]
ext <;> simp [mul, add_mul, smul_add, add_smul, map_add] <;> abel
zero_mul x := by
change (mul μ 0 x : k × k × k × V × W × U) = 0
ext <;> simp [mul]
mul_zero x := by
change (mul μ x 0 : k × k × k × V × W × U) = 0
ext <;> simp [mul]
@[simp] theorem mul_eq (x y : ThreeVertexAlgebra μ) : x * y = mul μ x y := rfl
@[simp] theorem one_eq : (1 : ThreeVertexAlgebra μ) = unit μ := rfl
instance : Algebra k (ThreeVertexAlgebra μ) where
algebraMap :=
{ toFun := fun c => (c, c, c, 0, 0, 0)
map_zero' := (zero_eq μ).symm
map_one' := rfl
map_add' := fun a b => by
change ((a+b, a+b, a+b, 0, 0, 0) : ThreeVertexAlgebra μ) =
(a, a, a, 0, 0, 0) + (b, b, b, 0, 0, 0)
rw [add_eq μ]
simp
map_mul' := fun a b => by
change ((a*b, a*b, a*b, 0, 0, 0) : ThreeVertexAlgebra μ) =
mul μ (a, a, a, 0, 0, 0) (b, b, b, 0, 0, 0)
simp [mul] }
commutes' c x := by
change mul μ (c, c, c, 0, 0, 0) x = mul μ x (c, c, c, 0, 0, 0)
ext <;> simp [mul, mul_comm]
smul_def' c x := by
change c • x = mul μ (c, c, c, 0, 0, 0) x
rw [smul_eq μ]
simp [mul]
instance [FiniteDimensional k V] [FiniteDimensional k W] [FiniteDimensional k U] :
FiniteDimensional k (ThreeVertexAlgebra μ) :=
inferInstanceAs (FiniteDimensional k (k × k × k × V × W × U))
/-- The three vertex idempotents, in the manuscript's order. -/
def vertex : Fin 3 → ThreeVertexAlgebra μ
| ⟨0, _⟩ => (1, 0, 0, 0, 0, 0)
| ⟨1, _⟩ => (0, 1, 0, 0, 0, 0)
| ⟨2, _⟩ => (0, 0, 1, 0, 0, 0)
def directedSystem : DirectedBound.DirectedSystem k (ThreeVertexAlgebra μ) 3 where
e := vertex μ
idem i := by fin_cases i <;> ext <;> simp [vertex, mul]
orthogonal i j hij := by
fin_cases i <;> fin_cases j <;> simp_all [vertex, mul]
complete := by
simp [Fin.sum_univ_succ, vertex, unit, add_eq μ]
diagonal i a := by
fin_cases i
· exact ⟨a.1, by ext <;> simp [vertex, mul, smul_eq μ]⟩
· exact ⟨a.2.1, by ext <;> simp [vertex, mul, smul_eq μ]⟩
· exact ⟨a.2.2.1, by ext <;> simp [vertex, mul, smul_eq μ]⟩
directed i j hij a := by
fin_cases i <;> fin_cases j <;> simp_all [vertex, mul]
open CategoryTheory
/-- The three-vertex coordinate algebra has global dimension at most two on both sides. -/
theorem globalDimension_le_two :
(⨆ N : ModuleCat.{max u v} (ThreeVertexAlgebra μ), projectiveDimension N) ≤ (2 : ℕ) ∧
(⨆ N : ModuleCat.{max u v} (ThreeVertexAlgebra μ)ᵐᵒᵖ, projectiveDimension N) ≤ (2 : ℕ) :=
(directedSystem μ).both_sides_globalDimension_le
end ThreeVertexAlgebra
end LittleFinitistic
end
end OAI