class Element(FiniteDimensionalAlgebraElement):
"""
An element of a Euclidean Jordan algebra.
-
- Since EJAs are commutative, the "right multiplication" matrix is
- also the left multiplication matrix and must be symmetric::
-
- sage: set_random_seed()
- sage: n = ZZ.random_element(1,10).abs()
- sage: J = eja_rn(5)
- sage: J.random_element().matrix().is_symmetric()
- True
- sage: J = eja_ln(5)
- sage: J.random_element().matrix().is_symmetric()
- True
-
"""
def __pow__(self, n):
EXAMPLES:
sage: set_random_seed()
- sage: J = eja_ln(5)
- sage: x = J.random_element()
+ sage: x = random_eja().random_element()
sage: x.matrix()*x.vector() == (x**2).vector()
True
if self.is_regular():
return self.minimal_polynomial()
else:
- return NotImplementedError('irregular element')
+ raise NotImplementedError('irregular element')
+
+
+ def det(self):
+ """
+ Return my determinant, the product of my eigenvalues.
+
+ EXAMPLES::
+
+ sage: J = eja_ln(2)
+ sage: e0,e1 = J.gens()
+ sage: x = e0 + e1
+ sage: x.det()
+ 0
+ sage: J = eja_ln(3)
+ sage: e0,e1,e2 = J.gens()
+ sage: x = e0 + e1 + e2
+ sage: x.det()
+ -1
+
+ """
+ cs = self.characteristic_polynomial().coefficients(sparse=False)
+ r = len(cs) - 1
+ if r >= 0:
+ return cs[0] * (-1)**r
+ else:
+ raise ValueError('charpoly had no coefficients')
def is_nilpotent(self):
The identity element is never nilpotent::
sage: set_random_seed()
- sage: n = ZZ.random_element(2,10).abs()
- sage: J = eja_rn(n)
- sage: J.one().is_nilpotent()
- False
- sage: J = eja_ln(n)
- sage: J.one().is_nilpotent()
+ sage: random_eja().one().is_nilpotent()
False
The additive identity is always nilpotent::
sage: set_random_seed()
- sage: n = ZZ.random_element(2,10).abs()
- sage: J = eja_rn(n)
- sage: J.zero().is_nilpotent()
- True
- sage: J = eja_ln(n)
- sage: J.zero().is_nilpotent()
+ sage: random_eja().zero().is_nilpotent()
True
"""
EXAMPLES::
sage: set_random_seed()
- sage: n = ZZ.random_element(1,10).abs()
- sage: J = eja_rn(n)
- sage: x = J.random_element()
+ sage: x = random_eja().random_element()
sage: x.degree() == x.minimal_polynomial().degree()
True
::
sage: set_random_seed()
- sage: n = ZZ.random_element(1,10).abs()
- sage: J = eja_ln(n)
- sage: x = J.random_element()
+ sage: x = random_eja().random_element()
sage: x.degree() == x.minimal_polynomial().degree()
True
TESTS::
sage: set_random_seed()
- sage: n = ZZ.random_element(1,10).abs()
- sage: J = eja_rn(n)
- sage: x = J.random_element()
- sage: x.subalgebra_generated_by().is_associative()
- True
- sage: J = eja_ln(n)
- sage: x = J.random_element()
+ sage: x = random_eja().random_element()
sage: x.subalgebra_generated_by().is_associative()
True
Squaring in the subalgebra should be the same thing as
squaring in the superalgebra::
- sage: J = eja_ln(5)
- sage: x = J.random_element()
+ sage: set_random_seed()
+ sage: x = random_eja().random_element()
sage: u = x.subalgebra_generated_by().random_element()
sage: u.matrix()*u.vector() == (u**2).vector()
True
return self.parent().linear_combination(zip(c_coordinates, basis))
+ def trace(self):
+ """
+ Return my trace, the sum of my eigenvalues.
+
+ EXAMPLES::
+
+ sage: J = eja_ln(3)
+ sage: e0,e1,e2 = J.gens()
+ sage: x = e0 + e1 + e2
+ sage: x.trace()
+ 2
+
+ """
+ cs = self.characteristic_polynomial().coefficients(sparse=False)
+ if len(cs) >= 2:
+ return -1*cs[-2]
+ else:
+ raise ValueError('charpoly had fewer than 2 coefficients')
+
def eja_rn(dimension, field=QQ):
"""
# ambient dimension).
rank = min(dimension,2)
return FiniteDimensionalEuclideanJordanAlgebra(field,Qs,rank=rank)
+
+
+def eja_sn(dimension, field=QQ):
+ """
+ Return the simple Jordan algebra of ``dimension``-by-``dimension``
+ symmetric matrices over ``field``.
+
+ EXAMPLES::
+
+ sage: J = eja_sn(2)
+ sage: e0, e1, e2 = J.gens()
+ sage: e0*e0
+ e0
+ sage: e1*e1
+ e0 + e2
+ sage: e2*e2
+ e2
+
+ """
+ Qs = []
+
+ # In S^2, for example, we nominally have four coordinates even
+ # though the space is of dimension three only. The vector space V
+ # is supposed to hold the entire long vector, and the subspace W
+ # of V will be spanned by the vectors that arise from symmetric
+ # matrices. Thus for S^2, dim(V) == 4 and dim(W) == 3.
+ V = VectorSpace(field, dimension**2)
+
+ # The basis of symmetric matrices, as matrices, in their R^(n-by-n)
+ # coordinates.
+ S = []
+
+ for i in xrange(dimension):
+ for j in xrange(i+1):
+ Eij = matrix(field, dimension, lambda k,l: k==i and l==j)
+ if i == j:
+ Sij = Eij
+ else:
+ Sij = Eij + Eij.transpose()
+ S.append(Sij)
+
+ def mat2vec(m):
+ return vector(field, m.list())
+
+ def vec2mat(v):
+ return matrix(field, dimension, v.list())
+
+ W = V.span( mat2vec(s) for s in S )
+
+ # Taking the span above reorders our basis (thanks, jerk!) so we
+ # need to put our "matrix basis" in the same order as the
+ # (reordered) vector basis.
+ S = [ vec2mat(b) for b in W.basis() ]
+
+ for s in S:
+ # Brute force the multiplication-by-s matrix by looping
+ # through all elements of the basis and doing the computation
+ # to find out what the corresponding row should be. BEWARE:
+ # these multiplication tables won't be symmetric! It therefore
+ # becomes REALLY IMPORTANT that the underlying algebra
+ # constructor uses ROW vectors and not COLUMN vectors. That's
+ # why we're computing rows here and not columns.
+ Q_rows = []
+ for t in S:
+ this_row = mat2vec((s*t + t*s)/2)
+ Q_rows.append(W.coordinates(this_row))
+ Q = matrix(field,Q_rows)
+ Qs.append(Q)
+
+ return FiniteDimensionalEuclideanJordanAlgebra(field,Qs,rank=dimension)
+
+
+def random_eja():
+ """
+ Return a "random" finite-dimensional Euclidean Jordan Algebra.
+
+ ALGORITHM:
+
+ For now, we choose a random natural number ``n`` (greater than zero)
+ and then give you back one of the following:
+
+ * The cartesian product of the rational numbers ``n`` times; this is
+ ``QQ^n`` with the Hadamard product.
+
+ * The Jordan spin algebra on ``QQ^n``.
+
+ * The ``n``-by-``n`` rational symmetric matrices with the symmetric
+ product.
+
+ Later this might be extended to return Cartesian products of the
+ EJAs above.
+
+ TESTS::
+
+ sage: random_eja()
+ Euclidean Jordan algebra of degree...
+
+ """
+ n = ZZ.random_element(1,10).abs()
+ constructor = choice([eja_rn, eja_ln, eja_sn])
+ return constructor(dimension=n, field=QQ)