File size: 7,982 Bytes
216fb31 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 | 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
|