what can be supported in a general Jordan Algebra.
"""
-from sage.all import *
+from sage.algebras.finite_dimensional_algebras.finite_dimensional_algebra import FiniteDimensionalAlgebra
+from sage.algebras.finite_dimensional_algebras.finite_dimensional_algebra_element import FiniteDimensionalAlgebraElement
+
+class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra):
+ @staticmethod
+ def __classcall__(cls, field, mult_table, names='e', category=None):
+ fda = super(FiniteDimensionalEuclideanJordanAlgebra, cls)
+ return fda.__classcall_private__(cls,
+ field,
+ mult_table,
+ names,
+ category)
+
+ def __init__(self, field, mult_table, names='e', category=None):
+ fda = super(FiniteDimensionalEuclideanJordanAlgebra, self)
+ fda.__init__(field, mult_table, names, category)
+
+
+ def _repr_(self):
+ """
+ Return a string representation of ``self``.
+ """
+ return "Euclidean Jordan algebra of degree {} over {}".format(self.degree(), self.base_ring())
+
+ def rank(self):
+ """
+ Return the rank of this EJA.
+ """
+ raise NotImplementedError
+
+
+ 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: J = eja_ln(5)
+ sage: J.random_element().matrix().is_symmetric()
+ True
+
+ """
+
+ def __pow__(self, n):
+ """
+ Return ``self`` raised to the power ``n``.
+
+ Jordan algebras are always power-associative; see for
+ example Faraut and Koranyi, Proposition II.1.2 (ii).
+ """
+ A = self.parent()
+ if n == 0:
+ return A.one()
+ elif n == 1:
+ return self
+ else:
+ return A.element_class(A, self.vector()*(self.matrix()**(n-1)))
+
+
+ def span_of_powers(self):
+ """
+ Return the vector space spanned by successive powers of
+ this element.
+ """
+ # The dimension of the subalgebra can't be greater than
+ # the big algebra, so just put everything into a list
+ # and let span() get rid of the excess.
+ V = self.vector().parent()
+ return V.span( (self**d).vector() for d in xrange(V.dimension()) )
+
+
+ def degree(self):
+ """
+ Compute the degree of this element the straightforward way
+ according to the definition; by appending powers to a list
+ and figuring out its dimension (that is, whether or not
+ they're linearly dependent).
+
+ EXAMPLES::
+
+ sage: J = eja_ln(4)
+ sage: J.one().degree()
+ 1
+ sage: e0,e1,e2,e3 = J.gens()
+ sage: (e0 - e1).degree()
+ 2
+
+ In the spin factor algebra (of rank two), all elements that
+ aren't multiples of the identity are regular::
+
+ sage: set_random_seed()
+ sage: n = ZZ.random_element(1,10).abs()
+ sage: J = eja_ln(n)
+ sage: x = J.random_element()
+ sage: x == x.coefficient(0)*J.one() or x.degree() == 2
+ True
+
+ """
+ return self.span_of_powers().dimension()
+
+
+ def subalgebra_generated_by(self):
+ """
+ Return the subalgebra of the parent EJA generated by this element.
+ """
+ # First get the subspace spanned by the powers of myself...
+ V = self.span_of_powers()
+ F = self.base_ring()
+
+ # Now figure out the entries of the right-multiplication
+ # matrix for the successive basis elements b0, b1,... of
+ # that subspace.
+ mats = []
+ for b_right in V.basis():
+ eja_b_right = self.parent()(b_right)
+ b_right_rows = []
+ # The first row of the right-multiplication matrix by
+ # b1 is what we get if we apply that matrix to b1. The
+ # second row of the right multiplication matrix by b1
+ # is what we get when we apply that matrix to b2...
+ for b_left in V.basis():
+ eja_b_left = self.parent()(b_left)
+ # Multiply in the original EJA, but then get the
+ # coordinates from the subalgebra in terms of its
+ # basis.
+ this_row = V.coordinates((eja_b_left*eja_b_right).vector())
+ b_right_rows.append(this_row)
+ b_right_matrix = matrix(F, b_right_rows)
+ mats.append(b_right_matrix)
+
+ return FiniteDimensionalEuclideanJordanAlgebra(F, mats)
+
+
+ def minimal_polynomial(self):
+ return self.matrix().minimal_polynomial()
+
+ def characteristic_polynomial(self):
+ return self.matrix().characteristic_polynomial()
+
def eja_rn(dimension, field=QQ):
"""
# component of x; and likewise for the ith basis element e_i.
Qs = [ matrix(field, dimension, dimension, lambda k,j: 1*(k == j == i))
for i in xrange(dimension) ]
- A = FiniteDimensionalAlgebra(QQ,Qs,assume_associative=True)
- return JordanAlgebra(A)
+
+ return FiniteDimensionalEuclideanJordanAlgebra(field,Qs)
def eja_ln(dimension, field=QQ):
"""
- Return the Jordan algebra corresponding to the Lorenzt "ice cream"
+ Return the Jordan algebra corresponding to the Lorentz "ice cream"
cone of the given ``dimension``.
EXAMPLES:
Qi[0,0] = Qi[0,0] * ~field(2)
Qs.append(Qi)
- A = FiniteDimensionalAlgebra(QQ,Qs,assume_associative=True)
- return JordanAlgebra(A)
+ return FiniteDimensionalEuclideanJordanAlgebra(field,Qs)
projects / sage.d.git / blobdiff