what can be supported in a general Jordan Algebra.
"""
-from sage.algebras.finite_dimensional_algebras.finite_dimensional_algebra import FiniteDimensionalAlgebra
from sage.algebras.quatalg.quaternion_algebra import QuaternionAlgebra
-from sage.categories.finite_dimensional_algebras_with_basis import FiniteDimensionalAlgebrasWithBasis
+from sage.categories.magmatic_algebras import MagmaticAlgebras
+from sage.combinat.free_module import CombinatorialFreeModule
from sage.matrix.constructor import matrix
+from sage.matrix.matrix_space import MatrixSpace
from sage.misc.cachefunc import cached_method
from sage.misc.prandom import choice
-from sage.modules.free_module import VectorSpace
+from sage.misc.table import table
+from sage.modules.free_module import FreeModule, VectorSpace
from sage.rings.integer_ring import ZZ
-from sage.rings.number_field.number_field import QuadraticField
+from sage.rings.number_field.number_field import NumberField, QuadraticField
from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
from sage.rings.rational_field import QQ
+from sage.rings.real_lazy import CLF, RLF
from sage.structure.element import is_Matrix
-from sage.structure.category_object import normalize_names
from mjo.eja.eja_element import FiniteDimensionalEuclideanJordanAlgebraElement
-from mjo.eja.eja_utils import _vec2mat, _mat2vec
-
-class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra):
- @staticmethod
- def __classcall_private__(cls,
- field,
- mult_table,
- rank,
- names='e',
- assume_associative=False,
- category=None,
- natural_basis=None):
- n = len(mult_table)
- mult_table = [b.base_extend(field) for b in mult_table]
- for b in mult_table:
- b.set_immutable()
- if not (is_Matrix(b) and b.dimensions() == (n, n)):
- raise ValueError("input is not a multiplication table")
- mult_table = tuple(mult_table)
-
- cat = FiniteDimensionalAlgebrasWithBasis(field)
- cat.or_subcategory(category)
- if assume_associative:
- cat = cat.Associative()
-
- names = normalize_names(n, names)
-
- fda = super(FiniteDimensionalEuclideanJordanAlgebra, cls)
- return fda.__classcall__(cls,
- field,
- mult_table,
- rank,
- assume_associative=assume_associative,
- names=names,
- category=cat,
- natural_basis=natural_basis)
+from mjo.eja.eja_utils import _mat2vec
+class FiniteDimensionalEuclideanJordanAlgebra(CombinatorialFreeModule):
+ # This is an ugly hack needed to prevent the category framework
+ # from implementing a coercion from our base ring (e.g. the
+ # rationals) into the algebra. First of all -- such a coercion is
+ # nonsense to begin with. But more importantly, it tries to do so
+ # in the category of rings, and since our algebras aren't
+ # associative they generally won't be rings.
+ _no_generic_basering_coercion = True
def __init__(self,
field,
mult_table,
rank,
- names='e',
- assume_associative=False,
+ prefix='e',
category=None,
natural_basis=None):
"""
"""
self._rank = rank
self._natural_basis = natural_basis
- self._multiplication_table = mult_table
+
+ # TODO: HACK for the charpoly.. needs redesign badly.
+ self._basis_normalizers = None
+
+ if category is None:
+ category = MagmaticAlgebras(field).FiniteDimensional()
+ category = category.WithBasis().Unital()
+
fda = super(FiniteDimensionalEuclideanJordanAlgebra, self)
fda.__init__(field,
- mult_table,
- names=names,
+ range(len(mult_table)),
+ prefix=prefix,
category=category)
+ self.print_options(bracket='')
+
+ # The multiplication table we're given is necessarily in terms
+ # of vectors, because we don't have an algebra yet for
+ # anything to be an element of. However, it's faster in the
+ # long run to have the multiplication table be in terms of
+ # algebra elements. We do this after calling the superclass
+ # constructor so that from_vector() knows what to do.
+ self._multiplication_table = [ map(lambda x: self.from_vector(x), ls)
+ for ls in mult_table ]
+
+
+ def _element_constructor_(self, elt):
+ """
+ Construct an element of this algebra from its natural
+ representation.
+
+ This gets called only after the parent element _call_ method
+ fails to find a coercion for the argument.
+
+ SETUP::
+
+ sage: from mjo.eja.eja_algebra import (JordanSpinEJA,
+ ....: RealCartesianProductEJA,
+ ....: RealSymmetricEJA)
+
+ EXAMPLES:
+
+ The identity in `S^n` is converted to the identity in the EJA::
+
+ sage: J = RealSymmetricEJA(3)
+ sage: I = matrix.identity(QQ,3)
+ sage: J(I) == J.one()
+ True
+
+ This skew-symmetric matrix can't be represented in the EJA::
+
+ sage: J = RealSymmetricEJA(3)
+ sage: A = matrix(QQ,3, lambda i,j: i-j)
+ sage: J(A)
+ Traceback (most recent call last):
+ ...
+ ArithmeticError: vector is not in free module
+
+ TESTS:
+
+ Ensure that we can convert any element of the two non-matrix
+ simple algebras (whose natural representations are their usual
+ vector representations) back and forth faithfully::
+
+ sage: set_random_seed()
+ sage: J = RealCartesianProductEJA(5)
+ sage: x = J.random_element()
+ sage: J(x.to_vector().column()) == x
+ True
+ sage: J = JordanSpinEJA(5)
+ sage: x = J.random_element()
+ sage: J(x.to_vector().column()) == x
+ True
+
+ """
+ if elt == 0:
+ # The superclass implementation of random_element()
+ # needs to be able to coerce "0" into the algebra.
+ return self.zero()
+
+ natural_basis = self.natural_basis()
+ basis_space = natural_basis[0].matrix_space()
+ if elt not in basis_space:
+ raise ValueError("not a naturally-represented algebra element")
+
+ # Thanks for nothing! Matrix spaces aren't vector spaces in
+ # Sage, so we have to figure out its natural-basis coordinates
+ # ourselves. We use the basis space's ring instead of the
+ # element's ring because the basis space might be an algebraic
+ # closure whereas the base ring of the 3-by-3 identity matrix
+ # could be QQ instead of QQbar.
+ V = VectorSpace(basis_space.base_ring(), elt.nrows()*elt.ncols())
+ W = V.span_of_basis( _mat2vec(s) for s in natural_basis )
+ coords = W.coordinate_vector(_mat2vec(elt))
+ return self.from_vector(coords)
def _repr_(self):
Ensure that it says what we think it says::
sage: JordanSpinEJA(2, field=QQ)
- Euclidean Jordan algebra of degree 2 over Rational Field
+ Euclidean Jordan algebra of dimension 2 over Rational Field
sage: JordanSpinEJA(3, field=RDF)
- Euclidean Jordan algebra of degree 3 over Real Double Field
+ Euclidean Jordan algebra of dimension 3 over Real Double Field
"""
- fmt = "Euclidean Jordan algebra of degree {} over {}"
- return fmt.format(self.degree(), self.base_ring())
+ fmt = "Euclidean Jordan algebra of dimension {} over {}"
+ return fmt.format(self.dimension(), self.base_ring())
+ def product_on_basis(self, i, j):
+ return self._multiplication_table[i][j]
def _a_regular_element(self):
"""
determinant).
"""
z = self._a_regular_element()
- V = self.vector_space()
- V1 = V.span_of_basis( (z**k).vector() for k in range(self.rank()) )
+ # Don't use the parent vector space directly here in case this
+ # happens to be a subalgebra. In that case, we would be e.g.
+ # two-dimensional but span_of_basis() would expect three
+ # coordinates.
+ V = VectorSpace(self.base_ring(), self.vector_space().dimension())
+ basis = [ (z**k).to_vector() for k in range(self.rank()) ]
+ V1 = V.span_of_basis( basis )
b = (V1.basis() + V1.complement().basis())
return V.span_of_basis(b)
+
@cached_method
def _charpoly_coeff(self, i):
"""
store the trace/determinant (a_{r-1} and a_{0} respectively)
separate from the entire characteristic polynomial.
"""
+ if self._basis_normalizers is not None:
+ # Must be a matrix class?
+ # WARNING/TODO: this whole mess is mis-designed.
+ n = self.natural_basis_space().nrows()
+ field = self.base_ring().base_ring() # yeeeeaaaahhh
+ J = self.__class__(n, field, False)
+ (_,x,_,_) = J._charpoly_matrix_system()
+ p = J._charpoly_coeff(i)
+ # p might be missing some vars, have to substitute "optionally"
+ pairs = zip(x.base_ring().gens(), self._basis_normalizers)
+ substitutions = { v: v*c for (v,c) in pairs }
+ return p.subs(substitutions)
+
(A_of_x, x, xr, detA) = self._charpoly_matrix_system()
R = A_of_x.base_ring()
if i >= self.rank():
r = self.rank()
n = self.dimension()
- # Construct a new algebra over a multivariate polynomial ring...
- names = ['X' + str(i) for i in range(1,n+1)]
+ # Turn my vector space into a module so that "vectors" can
+ # have multivatiate polynomial entries.
+ names = tuple('X' + str(i) for i in range(1,n+1))
R = PolynomialRing(self.base_ring(), names)
- J = FiniteDimensionalEuclideanJordanAlgebra(R,
- self._multiplication_table,
- r)
- idmat = matrix.identity(J.base_ring(), n)
+ # Using change_ring() on the parent's vector space doesn't work
+ # here because, in a subalgebra, that vector space has a basis
+ # and change_ring() tries to bring the basis along with it. And
+ # that doesn't work unless the new ring is a PID, which it usually
+ # won't be.
+ V = FreeModule(R,n)
+
+ # Now let x = (X1,X2,...,Xn) be the vector whose entries are
+ # indeterminates...
+ x = V(names)
+
+ # And figure out the "left multiplication by x" matrix in
+ # that setting.
+ lmbx_cols = []
+ monomial_matrices = [ self.monomial(i).operator().matrix()
+ for i in range(n) ] # don't recompute these!
+ for k in range(n):
+ ek = self.monomial(k).to_vector()
+ lmbx_cols.append(
+ sum( x[i]*(monomial_matrices[i]*ek)
+ for i in range(n) ) )
+ Lx = matrix.column(R, lmbx_cols)
+
+ # Now we can compute powers of x "symbolically"
+ x_powers = [self.one().to_vector(), x]
+ for d in range(2, r+1):
+ x_powers.append( Lx*(x_powers[-1]) )
+
+ idmat = matrix.identity(R, n)
W = self._charpoly_basis_space()
W = W.change_ring(R.fraction_field())
# We want the middle equivalent thing in our matrix, but use
# the first equivalent thing instead so that we can pass in
# standard coordinates.
- x = J(W(R.gens()))
-
- # Handle the zeroth power separately, because computing
- # the unit element in J is mathematically suspect.
- x0 = W.coordinates(self.one().vector())
- l1 = [ matrix.column(x0) ]
- l1 += [ matrix.column(W.coordinates((x**k).vector()))
- for k in range(1,r) ]
- l2 = [idmat.column(k-1).column() for k in range(r+1, n+1)]
- A_of_x = matrix.block(R, 1, n, (l1 + l2))
- xr = W.coordinates((x**r).vector())
- return (A_of_x, x, xr, A_of_x.det())
+ x_powers = [ W.coordinate_vector(xp) for xp in x_powers ]
+ l2 = [idmat.column(k-1) for k in range(r+1, n+1)]
+ A_of_x = matrix.column(R, n, (x_powers[:r] + l2))
+ return (A_of_x, x, x_powers[r], A_of_x.det())
@cached_method
sage: J = JordanSpinEJA(3)
sage: p = J.characteristic_polynomial(); p
X1^2 - X2^2 - X3^2 + (-2*t)*X1 + t^2
- sage: xvec = J.one().vector()
+ sage: xvec = J.one().to_vector()
sage: p(*xvec)
t^2 - 2*t + 1
True
"""
- if (not x in self) or (not y in self):
- raise TypeError("arguments must live in this algebra")
- return x.trace_inner_product(y)
+ X = x.natural_representation()
+ Y = y.natural_representation()
+ return self.__class__.natural_inner_product(X,Y)
+
+
+ def is_trivial(self):
+ """
+ Return whether or not this algebra is trivial.
+
+ A trivial algebra contains only the zero element.
+
+ SETUP::
+
+ sage: from mjo.eja.eja_algebra import ComplexHermitianEJA
+
+ EXAMPLES::
+
+ sage: J = ComplexHermitianEJA(3)
+ sage: J.is_trivial()
+ False
+ sage: A = J.zero().subalgebra_generated_by()
+ sage: A.is_trivial()
+ True
+
+ """
+ return self.dimension() == 0
+
+
+ def multiplication_table(self):
+ """
+ Return a visual representation of this algebra's multiplication
+ table (on basis elements).
+
+ SETUP::
+
+ sage: from mjo.eja.eja_algebra import JordanSpinEJA
+
+ EXAMPLES::
+
+ sage: J = JordanSpinEJA(4)
+ sage: J.multiplication_table()
+ +----++----+----+----+----+
+ | * || e0 | e1 | e2 | e3 |
+ +====++====+====+====+====+
+ | e0 || e0 | e1 | e2 | e3 |
+ +----++----+----+----+----+
+ | e1 || e1 | e0 | 0 | 0 |
+ +----++----+----+----+----+
+ | e2 || e2 | 0 | e0 | 0 |
+ +----++----+----+----+----+
+ | e3 || e3 | 0 | 0 | e0 |
+ +----++----+----+----+----+
+
+ """
+ M = list(self._multiplication_table) # copy
+ for i in range(len(M)):
+ # M had better be "square"
+ M[i] = [self.monomial(i)] + M[i]
+ M = [["*"] + list(self.gens())] + M
+ return table(M, header_row=True, header_column=True, frame=True)
def natural_basis(self):
sage: J = RealSymmetricEJA(2)
sage: J.basis()
- Family (e0, e1, e2)
+ Finite family {0: e0, 1: e1, 2: e2}
sage: J.natural_basis()
(
- [1 0] [0 1] [0 0]
- [0 0], [1 0], [0 1]
+ [1 0] [ 0 1/2*sqrt2] [0 0]
+ [0 0], [1/2*sqrt2 0], [0 1]
)
::
sage: J = JordanSpinEJA(2)
sage: J.basis()
- Family (e0, e1)
+ Finite family {0: e0, 1: e1}
sage: J.natural_basis()
(
[1] [0]
"""
if self._natural_basis is None:
- return tuple( b.vector().column() for b in self.basis() )
+ M = self.natural_basis_space()
+ return tuple( M(b.to_vector()) for b in self.basis() )
else:
return self._natural_basis
+ def natural_basis_space(self):
+ """
+ Return the matrix space in which this algebra's natural basis
+ elements live.
+ """
+ if self._natural_basis is None or len(self._natural_basis) == 0:
+ return MatrixSpace(self.base_ring(), self.dimension(), 1)
+ else:
+ return self._natural_basis[0].matrix_space()
+
+
+ @staticmethod
+ def natural_inner_product(X,Y):
+ """
+ Compute the inner product of two naturally-represented elements.
+
+ For example in the real symmetric matrix EJA, this will compute
+ the trace inner-product of two n-by-n symmetric matrices. The
+ default should work for the real cartesian product EJA, the
+ Jordan spin EJA, and the real symmetric matrices. The others
+ will have to be overridden.
+ """
+ return (X.conjugate_transpose()*Y).trace()
+
+
@cached_method
def one(self):
"""
sage: J.one()
e0 + e1 + e2 + e3 + e4
- TESTS::
+ TESTS:
The identity element acts like the identity::
# Now if there's an identity element in the algebra, this should work.
coeffs = A.solve_right(b)
- return self.linear_combination(zip(coeffs,self.gens()))
+ return self.linear_combination(zip(self.gens(), coeffs))
+
+
+ def random_element(self):
+ # Temporary workaround for https://trac.sagemath.org/ticket/28327
+ if self.is_trivial():
+ return self.zero()
+ else:
+ s = super(FiniteDimensionalEuclideanJordanAlgebra, self)
+ return s.random_element()
def rank(self):
sage: J = RealSymmetricEJA(2)
sage: J.vector_space()
- Vector space of dimension 3 over Rational Field
+ Vector space of dimension 3 over...
"""
- return self.zero().vector().parent().ambient_vector_space()
+ return self.zero().to_vector().parent().ambient_vector_space()
Element = FiniteDimensionalEuclideanJordanAlgebraElement
sage: e2*e2
e2
+ TESTS:
+
+ We can change the generator prefix::
+
+ sage: RealCartesianProductEJA(3, prefix='r').gens()
+ (r0, r1, r2)
+
+ Our inner product satisfies the Jordan axiom::
+
+ sage: set_random_seed()
+ sage: n = ZZ.random_element(1,5)
+ sage: J = RealCartesianProductEJA(n)
+ sage: x = J.random_element()
+ sage: y = J.random_element()
+ sage: z = J.random_element()
+ sage: (x*y).inner_product(z) == y.inner_product(x*z)
+ True
+
"""
- @staticmethod
- def __classcall_private__(cls, n, field=QQ):
- # The FiniteDimensionalAlgebra constructor takes a list of
- # matrices, the ith representing right multiplication by the ith
- # basis element in the vector space. So if e_1 = (1,0,0), then
- # right (Hadamard) multiplication of x by e_1 picks out the first
- # component of x; and likewise for the ith basis element e_i.
- Qs = [ matrix(field, n, n, lambda k,j: 1*(k == j == i))
- for i in xrange(n) ]
-
- fdeja = super(RealCartesianProductEJA, cls)
- return fdeja.__classcall_private__(cls, field, Qs, rank=n)
+ def __init__(self, n, field=QQ, **kwargs):
+ V = VectorSpace(field, n)
+ mult_table = [ [ V.gen(i)*(i == j) for j in range(n) ]
+ for i in range(n) ]
+
+ fdeja = super(RealCartesianProductEJA, self)
+ return fdeja.__init__(field, mult_table, rank=n, **kwargs)
def inner_product(self, x, y):
- return _usual_ip(x,y)
+ """
+ Faster to reimplement than to use natural representations.
+
+ SETUP::
+
+ sage: from mjo.eja.eja_algebra import RealCartesianProductEJA
+
+ TESTS:
+
+ Ensure that this is the usual inner product for the algebras
+ over `R^n`::
+
+ sage: set_random_seed()
+ sage: n = ZZ.random_element(1,5)
+ sage: J = RealCartesianProductEJA(n)
+ sage: x = J.random_element()
+ sage: y = J.random_element()
+ sage: X = x.natural_representation()
+ sage: Y = y.natural_representation()
+ sage: x.inner_product(y) == J.__class__.natural_inner_product(X,Y)
+ True
+
+ """
+ return x.to_vector().inner_product(y.to_vector())
def random_eja():
TESTS::
sage: random_eja()
- Euclidean Jordan algebra of degree...
+ Euclidean Jordan algebra of dimension...
"""
-def _real_symmetric_basis(n, field=QQ):
+def _real_symmetric_basis(n, field):
"""
Return a basis for the space of real symmetric n-by-n matrices.
+
+ SETUP::
+
+ sage: from mjo.eja.eja_algebra import _real_symmetric_basis
+
+ TESTS::
+
+ sage: set_random_seed()
+ sage: n = ZZ.random_element(1,5)
+ sage: B = _real_symmetric_basis(n, QQ)
+ sage: all( M.is_symmetric() for M in B)
+ True
+
"""
# The basis of symmetric matrices, as matrices, in their R^(n-by-n)
# coordinates.
if i == j:
Sij = Eij
else:
- # Beware, orthogonal but not normalized!
Sij = Eij + Eij.transpose()
S.append(Sij)
return tuple(S)
-def _complex_hermitian_basis(n, field=QQ):
+def _complex_hermitian_basis(n, field):
"""
Returns a basis for the space of complex Hermitian n-by-n matrices.
+ Why do we embed these? Basically, because all of numerical linear
+ algebra assumes that you're working with vectors consisting of `n`
+ entries from a field and scalars from the same field. There's no way
+ to tell SageMath that (for example) the vectors contain complex
+ numbers, while the scalar field is real.
+
SETUP::
sage: from mjo.eja.eja_algebra import _complex_hermitian_basis
sage: set_random_seed()
sage: n = ZZ.random_element(1,5)
- sage: all( M.is_symmetric() for M in _complex_hermitian_basis(n) )
+ sage: field = QuadraticField(2, 'sqrt2')
+ sage: B = _complex_hermitian_basis(n, field)
+ sage: all( M.is_symmetric() for M in B)
True
"""
- F = QuadraticField(-1, 'I')
+ R = PolynomialRing(field, 'z')
+ z = R.gen()
+ F = NumberField(z**2 + 1, 'I', embedding=CLF(-1).sqrt())
I = F.gen()
# This is like the symmetric case, but we need to be careful:
S = []
for i in xrange(n):
for j in xrange(i+1):
- Eij = matrix(field, n, lambda k,l: k==i and l==j)
+ Eij = matrix(F, n, lambda k,l: k==i and l==j)
if i == j:
Sij = _embed_complex_matrix(Eij)
S.append(Sij)
else:
- # Beware, orthogonal but not normalized! The second one
- # has a minus because it's conjugated.
+ # The second one has a minus because it's conjugated.
Sij_real = _embed_complex_matrix(Eij + Eij.transpose())
S.append(Sij_real)
Sij_imag = _embed_complex_matrix(I*Eij - I*Eij.transpose())
S.append(Sij_imag)
- return tuple(S)
+ # Since we embedded these, we can drop back to the "field" that we
+ # started with instead of the complex extension "F".
+ return tuple( s.change_ring(field) for s in S )
-def _quaternion_hermitian_basis(n, field=QQ):
+
+
+def _quaternion_hermitian_basis(n, field):
"""
Returns a basis for the space of quaternion Hermitian n-by-n matrices.
+ Why do we embed these? Basically, because all of numerical linear
+ algebra assumes that you're working with vectors consisting of `n`
+ entries from a field and scalars from the same field. There's no way
+ to tell SageMath that (for example) the vectors contain complex
+ numbers, while the scalar field is real.
+
SETUP::
sage: from mjo.eja.eja_algebra import _quaternion_hermitian_basis
sage: set_random_seed()
sage: n = ZZ.random_element(1,5)
- sage: all( M.is_symmetric() for M in _quaternion_hermitian_basis(n) )
+ sage: B = _quaternion_hermitian_basis(n, QQ)
+ sage: all( M.is_symmetric() for M in B )
True
"""
multiplication on the right is matrix multiplication. Given a basis
for the underlying matrix space, this function returns a
multiplication table (obtained by looping through the basis
- elements) for an algebra of those matrices. A reordered copy
- of the basis is also returned to work around the fact that
- the ``span()`` in this function will change the order of the basis
- from what we think it is, to... something else.
+ elements) for an algebra of those matrices.
"""
# In S^2, for example, we nominally have four coordinates even
# though the space is of dimension three only. The vector space V
dimension = basis[0].nrows()
V = VectorSpace(field, dimension**2)
- W = V.span( _mat2vec(s) for s in basis )
-
- # 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 = tuple( _vec2mat(b) for b in W.basis() )
-
- Qs = []
- 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, W.dimension(), Q_rows)
- Qs.append(Q)
-
- return (Qs, S)
+ W = V.span_of_basis( _mat2vec(s) for s in basis )
+ n = len(basis)
+ mult_table = [[W.zero() for j in range(n)] for i in range(n)]
+ for i in range(n):
+ for j in range(n):
+ mat_entry = (basis[i]*basis[j] + basis[j]*basis[i])/2
+ mult_table[i][j] = W.coordinate_vector(_mat2vec(mat_entry))
+
+ return mult_table
def _embed_complex_matrix(M):
EXAMPLES::
- sage: F = QuadraticField(-1,'i')
+ sage: F = QuadraticField(-1, 'i')
sage: x1 = F(4 - 2*i)
sage: x2 = F(1 + 2*i)
sage: x3 = F(-i)
field = M.base_ring()
blocks = []
for z in M.list():
- a = z.real()
- b = z.imag()
+ a = z.vector()[0] # real part, I guess
+ b = z.vector()[1] # imag part, I guess
blocks.append(matrix(field, 2, [[a,b],[-b,a]]))
# We can drop the imaginaries here.
if not n.mod(2).is_zero():
raise ValueError("the matrix 'M' must be a complex embedding")
- F = QuadraticField(-1, 'i')
+ field = M.base_ring() # This should already have sqrt2
+ R = PolynomialRing(field, 'z')
+ z = R.gen()
+ F = NumberField(z**2 + 1,'i', embedding=CLF(-1).sqrt())
i = F.gen()
# Go top-left to bottom-right (reading order), converting every
return matrix(Q, n/4, elements)
-# The usual inner product on R^n.
-def _usual_ip(x,y):
- return x.vector().inner_product(y.vector())
-
# The inner product used for the real symmetric simple EJA.
# We keep it as a separate function because e.g. the complex
# algebra uses the same inner product, except divided by 2.
sage: e0*e0
e0
sage: e1*e1
- e0 + e2
+ 1/2*e0 + 1/2*e2
sage: e2*e2
e2
TESTS:
- The degree of this algebra is `(n^2 + n) / 2`::
+ The dimension of this algebra is `(n^2 + n) / 2`::
sage: set_random_seed()
sage: n = ZZ.random_element(1,5)
sage: J = RealSymmetricEJA(n)
- sage: J.degree() == (n^2 + n)/2
+ sage: J.dimension() == (n^2 + n)/2
True
The Jordan multiplication is what we think it is::
sage: J(expected) == x*y
True
- """
- @staticmethod
- def __classcall_private__(cls, n, field=QQ):
- S = _real_symmetric_basis(n, field=field)
- (Qs, T) = _multiplication_table_from_matrix_basis(S)
+ We can change the generator prefix::
- fdeja = super(RealSymmetricEJA, cls)
- return fdeja.__classcall_private__(cls,
- field,
- Qs,
- rank=n,
- natural_basis=T)
+ sage: RealSymmetricEJA(3, prefix='q').gens()
+ (q0, q1, q2, q3, q4, q5)
+
+ Our inner product satisfies the Jordan axiom::
+
+ sage: set_random_seed()
+ sage: n = ZZ.random_element(1,5)
+ sage: J = RealSymmetricEJA(n)
+ sage: x = J.random_element()
+ sage: y = J.random_element()
+ sage: z = J.random_element()
+ sage: (x*y).inner_product(z) == y.inner_product(x*z)
+ True
+
+ Our basis is normalized with respect to the natural inner product::
+
+ sage: set_random_seed()
+ sage: n = ZZ.random_element(1,5)
+ sage: J = RealSymmetricEJA(n)
+ sage: all( b.norm() == 1 for b in J.gens() )
+ True
+
+ Left-multiplication operators are symmetric because they satisfy
+ the Jordan axiom::
+
+ sage: set_random_seed()
+ sage: n = ZZ.random_element(1,5)
+ sage: x = RealSymmetricEJA(n).random_element()
+ sage: x.operator().matrix().is_symmetric()
+ True
+
+ """
+ def __init__(self, n, field=QQ, normalize_basis=True, **kwargs):
+ S = _real_symmetric_basis(n, field)
+
+ if n > 1 and normalize_basis:
+ # We'll need sqrt(2) to normalize the basis, and this
+ # winds up in the multiplication table, so the whole
+ # algebra needs to be over the field extension.
+ R = PolynomialRing(field, 'z')
+ z = R.gen()
+ p = z**2 - 2
+ if p.is_irreducible():
+ field = NumberField(p, 'sqrt2', embedding=RLF(2).sqrt())
+ S = [ s.change_ring(field) for s in S ]
+ self._basis_normalizers = tuple(
+ ~(self.__class__.natural_inner_product(s,s).sqrt())
+ for s in S )
+ S = tuple( s*c for (s,c) in zip(S,self._basis_normalizers) )
+
+ Qs = _multiplication_table_from_matrix_basis(S)
+
+ fdeja = super(RealSymmetricEJA, self)
+ return fdeja.__init__(field,
+ Qs,
+ rank=n,
+ natural_basis=S,
+ **kwargs)
- def inner_product(self, x, y):
- return _matrix_ip(x,y)
class ComplexHermitianEJA(FiniteDimensionalEuclideanJordanAlgebra):
TESTS:
- The degree of this algebra is `n^2`::
+ The dimension of this algebra is `n^2`::
sage: set_random_seed()
sage: n = ZZ.random_element(1,5)
sage: J = ComplexHermitianEJA(n)
- sage: J.degree() == n^2
+ sage: J.dimension() == n^2
True
The Jordan multiplication is what we think it is::
sage: J(expected) == x*y
True
- """
- @staticmethod
- def __classcall_private__(cls, n, field=QQ):
- S = _complex_hermitian_basis(n)
- (Qs, T) = _multiplication_table_from_matrix_basis(S)
+ We can change the generator prefix::
- fdeja = super(ComplexHermitianEJA, cls)
- return fdeja.__classcall_private__(cls,
- field,
- Qs,
- rank=n,
- natural_basis=T)
+ sage: ComplexHermitianEJA(2, prefix='z').gens()
+ (z0, z1, z2, z3)
- def inner_product(self, x, y):
- # Since a+bi on the diagonal is represented as
- #
- # a + bi = [ a b ]
- # [ -b a ],
- #
- # we'll double-count the "a" entries if we take the trace of
- # the embedding.
- return _matrix_ip(x,y)/2
+ Our inner product satisfies the Jordan axiom::
+ sage: set_random_seed()
+ sage: n = ZZ.random_element(1,5)
+ sage: J = ComplexHermitianEJA(n)
+ sage: x = J.random_element()
+ sage: y = J.random_element()
+ sage: z = J.random_element()
+ sage: (x*y).inner_product(z) == y.inner_product(x*z)
+ True
+
+ Our basis is normalized with respect to the natural inner product::
+
+ sage: set_random_seed()
+ sage: n = ZZ.random_element(1,4)
+ sage: J = ComplexHermitianEJA(n)
+ sage: all( b.norm() == 1 for b in J.gens() )
+ True
+
+ Left-multiplication operators are symmetric because they satisfy
+ the Jordan axiom::
+
+ sage: set_random_seed()
+ sage: n = ZZ.random_element(1,5)
+ sage: x = ComplexHermitianEJA(n).random_element()
+ sage: x.operator().matrix().is_symmetric()
+ True
+
+ """
+ def __init__(self, n, field=QQ, normalize_basis=True, **kwargs):
+ S = _complex_hermitian_basis(n, field)
+
+ if n > 1 and normalize_basis:
+ # We'll need sqrt(2) to normalize the basis, and this
+ # winds up in the multiplication table, so the whole
+ # algebra needs to be over the field extension.
+ R = PolynomialRing(field, 'z')
+ z = R.gen()
+ p = z**2 - 2
+ if p.is_irreducible():
+ field = NumberField(p, 'sqrt2', embedding=RLF(2).sqrt())
+ S = [ s.change_ring(field) for s in S ]
+ self._basis_normalizers = tuple(
+ ~(self.__class__.natural_inner_product(s,s).sqrt())
+ for s in S )
+ S = tuple( s*c for (s,c) in zip(S,self._basis_normalizers) )
+
+ Qs = _multiplication_table_from_matrix_basis(S)
+
+ fdeja = super(ComplexHermitianEJA, self)
+ return fdeja.__init__(field,
+ Qs,
+ rank=n,
+ natural_basis=S,
+ **kwargs)
+
+
+ @staticmethod
+ def natural_inner_product(X,Y):
+ Xu = _unembed_complex_matrix(X)
+ Yu = _unembed_complex_matrix(Y)
+ # The trace need not be real; consider Xu = (i*I) and Yu = I.
+ return ((Xu*Yu).trace()).vector()[0] # real part, I guess
class QuaternionHermitianEJA(FiniteDimensionalEuclideanJordanAlgebra):
"""
TESTS:
- The degree of this algebra is `n^2`::
+ The dimension of this algebra is `n^2`::
sage: set_random_seed()
sage: n = ZZ.random_element(1,5)
sage: J = QuaternionHermitianEJA(n)
- sage: J.degree() == 2*(n^2) - n
+ sage: J.dimension() == 2*(n^2) - n
True
The Jordan multiplication is what we think it is::
sage: J(expected) == x*y
True
+ We can change the generator prefix::
+
+ sage: QuaternionHermitianEJA(2, prefix='a').gens()
+ (a0, a1, a2, a3, a4, a5)
+
+ Our inner product satisfies the Jordan axiom::
+
+ sage: set_random_seed()
+ sage: n = ZZ.random_element(1,5)
+ sage: J = QuaternionHermitianEJA(n)
+ sage: x = J.random_element()
+ sage: y = J.random_element()
+ sage: z = J.random_element()
+ sage: (x*y).inner_product(z) == y.inner_product(x*z)
+ True
+
"""
- @staticmethod
- def __classcall_private__(cls, n, field=QQ):
- S = _quaternion_hermitian_basis(n)
- (Qs, T) = _multiplication_table_from_matrix_basis(S)
+ def __init__(self, n, field=QQ, normalize_basis=True, **kwargs):
+ S = _quaternion_hermitian_basis(n, field, normalize_basis)
+ Qs = _multiplication_table_from_matrix_basis(S)
- fdeja = super(QuaternionHermitianEJA, cls)
- return fdeja.__classcall_private__(cls,
- field,
- Qs,
- rank=n,
- natural_basis=T)
+ fdeja = super(QuaternionHermitianEJA, self)
+ return fdeja.__init__(field,
+ Qs,
+ rank=n,
+ natural_basis=S,
+ **kwargs)
def inner_product(self, x, y):
# Since a+bi+cj+dk on the diagonal is represented as
sage: e2*e3
0
+ We can change the generator prefix::
+
+ sage: JordanSpinEJA(2, prefix='B').gens()
+ (B0, B1)
+
+ Our inner product satisfies the Jordan axiom::
+
+ sage: set_random_seed()
+ sage: n = ZZ.random_element(1,5)
+ sage: J = JordanSpinEJA(n)
+ sage: x = J.random_element()
+ sage: y = J.random_element()
+ sage: z = J.random_element()
+ sage: (x*y).inner_product(z) == y.inner_product(x*z)
+ True
+
"""
- @staticmethod
- def __classcall_private__(cls, n, field=QQ):
- Qs = []
- id_matrix = matrix.identity(field, n)
- for i in xrange(n):
- ei = id_matrix.column(i)
- Qi = matrix.zero(field, n)
- Qi.set_row(0, ei)
- Qi.set_column(0, ei)
- Qi += matrix.diagonal(n, [ei[0]]*n)
- # The addition of the diagonal matrix adds an extra ei[0] in the
- # upper-left corner of the matrix.
- Qi[0,0] = Qi[0,0] * ~field(2)
- Qs.append(Qi)
+ def __init__(self, n, field=QQ, **kwargs):
+ V = VectorSpace(field, n)
+ mult_table = [[V.zero() for j in range(n)] for i in range(n)]
+ for i in range(n):
+ for j in range(n):
+ x = V.gen(i)
+ y = V.gen(j)
+ x0 = x[0]
+ xbar = x[1:]
+ y0 = y[0]
+ ybar = y[1:]
+ # z = x*y
+ z0 = x.inner_product(y)
+ zbar = y0*xbar + x0*ybar
+ z = V([z0] + zbar.list())
+ mult_table[i][j] = z
# The rank of the spin algebra is two, unless we're in a
# one-dimensional ambient space (because the rank is bounded by
# the ambient dimension).
- fdeja = super(JordanSpinEJA, cls)
- return fdeja.__classcall_private__(cls, field, Qs, rank=min(n,2))
+ fdeja = super(JordanSpinEJA, self)
+ return fdeja.__init__(field, mult_table, rank=min(n,2), **kwargs)
def inner_product(self, x, y):
- return _usual_ip(x,y)
+ """
+ Faster to reimplement than to use natural representations.
+
+ SETUP::
+
+ sage: from mjo.eja.eja_algebra import JordanSpinEJA
+
+ TESTS:
+
+ Ensure that this is the usual inner product for the algebras
+ over `R^n`::
+
+ sage: set_random_seed()
+ sage: n = ZZ.random_element(1,5)
+ sage: J = JordanSpinEJA(n)
+ sage: x = J.random_element()
+ sage: y = J.random_element()
+ sage: X = x.natural_representation()
+ sage: Y = y.natural_representation()
+ sage: x.inner_product(y) == J.__class__.natural_inner_product(X,Y)
+ True
+
+ """
+ return x.to_vector().inner_product(y.to_vector())