| 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] |
|
|
| / |
| 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)) |
| |
| / |
| 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 |
| / |
| 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 |
|
|
