| import OAI.Algebra.Finitistic.Encoding.QuadraticEncoding |
| import Mathlib.LinearAlgebra.Pi |
|
|
| namespace OAI |
| noncomputable section |
| open scoped TensorProduct |
| namespace LittleFinitistic.QuadraticEncoding |
| universe u v |
| variable {k : Type u} [Field k] {d t : ℕ} |
| variable {Y : Type v} [AddCommGroup Y] [Module k Y] |
|
|
| /-- An arbitrary vector-space representation of the presented quadratic algebra. -/ |
| structure Representation (P : Relations k d t) (Y : Type v) |
| [AddCommGroup Y] [Module k Y] where |
| generator : Fin d → Module.End k Y |
| relation : ∀ j, (∑ h, ∑ l, P.quadratic j h l • (generator h * generator l)) + |
| (∑ h, P.linear j h • generator h) + P.constant j • (1 : Module.End k Y) = 0 |
|
|
| namespace Representation |
| variable {P : Relations k d t} (X : Representation P Y) |
|
|
| def arrowAction : Arrows k d →ₗ[k] Module.End k Y := |
| ∑ i, (LinearMap.proj i).smulRight (Fin.cases 1 X.generator i) |
|
|
| @[simp] theorem arrowAction_basis (i : Fin (d+1)) : |
| X.arrowAction (basis i) = Fin.cases 1 X.generator i := by |
| classical |
| simp [arrowAction, basis, Pi.single_apply] |
|
|
| def rawPathAction : Paths k d →ₗ[k] Module.End k Y := |
| TensorProduct.lift ((LinearMap.mul k (Module.End k Y)).compl₁₂ X.arrowAction X.arrowAction) |
|
|
| @[simp] theorem rawPathAction_tmul (w v : Arrows k d) : |
| X.rawPathAction (w ⊗ₜ[k] v) = X.arrowAction w * X.arrowAction v := rfl |
|
|
| theorem relations_killed : relationSpace P ≤ X.rawPathAction.ker := by |
| rw [relationSpace, Submodule.span_le] |
| rintro z (⟨h, rfl⟩ | ⟨j, rfl⟩) |
| · simp [LinearMap.mem_ker, commutation] |
| · simpa [LinearMap.mem_ker, homogenized] using X.relation j |
|
|
| /-- The actual descended length-two action, using the proved relation ideal. -/ |
| def pathAction : (Paths k d ⧸ relationSpace P) →ₗ[k] Module.End k Y := |
| (relationSpace P).liftQ X.rawPathAction X.relations_killed |
|
|
| @[simp] theorem pathAction_mk (z : Paths k d) : |
| X.pathAction ((relationSpace P).mkQ z) = X.rawPathAction z := rfl |
|
|
| @[simp] theorem pathAction_composition (w v : Arrows k d) : |
| X.pathAction (composition P w v) = X.arrowAction w * X.arrowAction v := rfl |
|
|
| /-- Three copies of Y, with its representation kept in the type. -/ |
| def Evaluation (_X : Representation P Y) := Y × Y × Y |
| instance : AddCommGroup X.Evaluation := inferInstanceAs (AddCommGroup (Y × Y × Y)) |
| instance : Module k X.Evaluation := inferInstanceAs (Module k (Y × Y × Y)) |
|
|
| @[simp] theorem evaluation_add (y z : X.Evaluation) : |
| y + z = (y.1+z.1,y.2.1+z.2.1,y.2.2+z.2.2) := rfl |
| @[simp] theorem evaluation_zero : (0 : X.Evaluation) = (0,0,0) := rfl |
| @[simp] theorem evaluation_smul (c : k) (y : X.Evaluation) : |
| c • y = (c • y.1,c • y.2.1,c • y.2.2) := rfl |
|
|
| def act (a : B P) (y : X.Evaluation) : X.Evaluation := |
| (a.1 • y.1, |
| X.arrowAction a.2.2.2.1 y.1 + a.2.1 • y.2.1, |
| X.pathAction a.2.2.2.2.2 y.1 + X.arrowAction a.2.2.2.2.1 y.2.1 + a.2.2.1 • y.2.2) |
|
|
| instance evaluationModule : Module (B P) X.Evaluation where |
| smul := X.act |
| one_smul y := by |
| change X.act (ThreeVertexAlgebra.unit (composition P)) y = y |
| rcases y with ⟨a,b,c⟩ |
| simp [act, ThreeVertexAlgebra.unit]; rfl |
| mul_smul a b y := by |
| change X.act (ThreeVertexAlgebra.mul (composition P) a b) y = X.act a (X.act b y) |
| apply Prod.ext |
| · simp [act, ThreeVertexAlgebra.mul, mul_smul] |
| apply Prod.ext |
| · simp [act, ThreeVertexAlgebra.mul, map_add, map_smul, smul_add, smul_smul] |
| module |
| · simp [act, ThreeVertexAlgebra.mul, map_add, map_smul, smul_add, smul_smul, |
| Module.End.mul_apply] |
| module |
| smul_zero a := by |
| change X.act a (0,0,0) = (0,0,0) |
| simp [act]; rfl |
| smul_add a y z := by |
| change X.act a (y.1+z.1,y.2.1+z.2.1,y.2.2+z.2.2) = |
| ((X.act a y).1+(X.act a z).1,(X.act a y).2.1+(X.act a z).2.1, |
| (X.act a y).2.2+(X.act a z).2.2) |
| apply Prod.ext |
| · simp [act, smul_add] |
| apply Prod.ext <;> simp [act, smul_add, map_add] <;> abel |
| add_smul a b y := by |
| change X.act (a+b) y = |
| ((X.act a y).1+(X.act b y).1,(X.act a y).2.1+(X.act b y).2.1, |
| (X.act a y).2.2+(X.act b y).2.2) |
| rw [ThreeVertexAlgebra.add_eq] |
| apply Prod.ext |
| · simp [act, add_smul] |
| apply Prod.ext <;> simp [act, add_smul, map_add] <;> abel |
| zero_smul y := by |
| change X.act (0,0,0,0,0,0) y = (0,0,0) |
| simp [act]; rfl |
| |
| theorem smul_eq (a : B P) (y : X.Evaluation) : a • y = X.act a y := rfl |
|
|
|
|
| instance : IsScalarTower k (B P) X.Evaluation where |
| smul_assoc c a y := by |
| change X.act (c • a) y = c • X.act a y |
| rw [ThreeVertexAlgebra.smul_eq, evaluation_smul] |
| apply Prod.ext |
| · simp [act, mul_smul] |
| apply Prod.ext <;> simp [act, smul_add, smul_smul] |
| |
| instance : SMulCommClass k (B P) X.Evaluation where |
| smul_comm c a y := by |
| change c • X.act a y = X.act a (c • y) |
| rw [evaluation_smul, evaluation_smul] |
| apply Prod.ext |
| · simp [act, smul_comm c a.1] |
| apply Prod.ext <;> simp [act, smul_add, smul_smul, mul_comm] |
| |
| instance [FiniteDimensional k Y] : FiniteDimensional k X.Evaluation := |
| inferInstanceAs (FiniteDimensional k (Y × Y × Y)) |
|
|
| @[simp] theorem vertex0_smul (y : X.Evaluation) : |
| ThreeVertexAlgebra.vertex (composition P) 0 • y = (y.1,0,0) := by |
| simp [smul_eq, act, ThreeVertexAlgebra.vertex]; rfl |
| @[simp] theorem vertex1_smul (y : X.Evaluation) : |
| ThreeVertexAlgebra.vertex (composition P) 1 • y = (0,y.2.1,0) := by |
| simp [smul_eq, act, ThreeVertexAlgebra.vertex]; rfl |
| @[simp] theorem vertex2_smul (y : X.Evaluation) : |
| ThreeVertexAlgebra.vertex (composition P) 2 • y = (0,0,y.2.2) := by |
| simp [smul_eq, act, ThreeVertexAlgebra.vertex]; rfl |
| |
| @[simp] theorem arrow01_smul (i : Fin (d+1)) (y : X.Evaluation) : |
| arrow01 P i • y = (0, (Fin.cases (motive := fun _ => Module.End k Y) 1 X.generator i) y.1, 0) := by |
| simp [smul_eq, act, arrow01]; rfl |
| @[simp] theorem arrow12_smul (i : Fin (d+1)) (y : X.Evaluation) : |
| arrow12 P i • y = (0, 0, (Fin.cases (motive := fun _ => Module.End k Y) 1 X.generator i) y.2.1) := by |
| simp [smul_eq, act, arrow12]; rfl |
| |
| @[simp] theorem s_smul (y : X.Evaluation) : arrow01 P 0 • y = (0,y.1,0) := by |
| simp; rfl |
| @[simp] theorem s'_smul (y : X.Evaluation) : arrow12 P 0 • y = (0,0,y.2.1) := by |
| simp; rfl |
| @[simp] theorem generator01_smul (h : Fin d) (y : X.Evaluation) : |
| arrow01 P h.succ • y = (0,X.generator h y.1,0) := by simp; rfl |
| @[simp] theorem generator12_smul (h : Fin d) (y : X.Evaluation) : |
| arrow12 P h.succ • y = (0,0,X.generator h y.2.1) := by simp; rfl |
| |
| @[simp] theorem pathMap_smul (z : Paths k d) (y : X.Evaluation) : |
| pathMap P z • y = (0,0,X.rawPathAction z y.1) := by |
| simp [smul_eq, act, pathMap, lengthTwo, pathAction]; rfl |
| |
| /-- Inclusion of the copy of Y at each vertex. -/ |
| def inclusion (i : Fin 3) : Y →ₗ[k] X.Evaluation where |
| toFun y := match i with |
| | 0 => (y,0,0) |
| | 1 => (0,y,0) |
| | 2 => (0,0,y) |
| map_add' y z := by fin_cases i <;> rw [evaluation_add] <;> simp <;> rfl |
| map_smul' c y := by fin_cases i <;> rw [evaluation_smul] <;> simp <;> rfl |
| |
| def projection (i : Fin 3) : X.Evaluation →ₗ[k] Y where |
| toFun y := match i with |
| | 0 => y.1 |
| | 1 => y.2.1 |
| | 2 => y.2.2 |
| map_add' y z := by fin_cases i <;> rfl |
| map_smul' c y := by fin_cases i <;> rfl |
| |
| @[simp] theorem projection_inclusion (i : Fin 3) (y : Y) : |
| X.projection i (X.inclusion i y) = y := by fin_cases i <;> rfl |
| |
| theorem vertex_smul (i : Fin 3) (y : X.Evaluation) : |
| ThreeVertexAlgebra.vertex (composition P) i • y = X.inclusion i (X.projection i y) := by |
| fin_cases i <;> simp [inclusion, projection] <;> rfl |
| |
| /-- The vertex space e_i M(Y), as an actual k-subspace of the constructed module. -/ |
| def vertexSpace (i : Fin 3) : Submodule k X.Evaluation := (X.inclusion i).range |
|
|
| def vertexEquiv (i : Fin 3) : Y ≃ₗ[k] X.vertexSpace i := |
| LinearEquiv.ofInjective (X.inclusion i) (Function.LeftInverse.injective |
| (X.projection_inclusion i)) |
| end Representation |
| end LittleFinitistic.QuadraticEncoding |
|
|
| end |
|
|
| end OAI |
|
|
