what can be supported in a general Jordan Algebra.
"""
+from itertools import izip, repeat
+
from sage.algebras.quatalg.quaternion_algebra import QuaternionAlgebra
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.lazy_import import lazy_import
from sage.misc.prandom import choice
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 NumberField
-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.rings.all import (ZZ, QQ, RR, RLF, CLF,
+ PolynomialRing,
+ QuadraticField)
from mjo.eja.eja_element import FiniteDimensionalEuclideanJordanAlgebraElement
+lazy_import('mjo.eja.eja_subalgebra',
+ 'FiniteDimensionalEuclideanJordanSubalgebra')
from mjo.eja.eja_utils import _mat2vec
class FiniteDimensionalEuclideanJordanAlgebra(CombinatorialFreeModule):
rank,
prefix='e',
category=None,
- natural_basis=None):
+ natural_basis=None,
+ check=True):
"""
SETUP::
- sage: from mjo.eja.eja_algebra import random_eja
+ sage: from mjo.eja.eja_algebra import (JordanSpinEJA, random_eja)
EXAMPLES:
sage: set_random_seed()
sage: J = random_eja()
- sage: x = J.random_element()
- sage: y = J.random_element()
+ sage: x,y = J.random_elements(2)
sage: x*y == y*x
True
+ TESTS:
+
+ The ``field`` we're given must be real::
+
+ sage: JordanSpinEJA(2,QQbar)
+ Traceback (most recent call last):
+ ...
+ ValueError: field is not real
+
"""
+ if check:
+ if not field.is_subring(RR):
+ # Note: this does return true for the real algebraic
+ # field, and any quadratic field where we've specified
+ # a real embedding.
+ raise ValueError('field is not real')
+
self._rank = rank
self._natural_basis = natural_basis
vector representations) back and forth faithfully::
sage: set_random_seed()
- sage: J = RealCartesianProductEJA(5)
+ sage: J = RealCartesianProductEJA.random_instance()
sage: x = J.random_element()
sage: J(x.to_vector().column()) == x
True
- sage: J = JordanSpinEJA(5)
+ sage: J = JordanSpinEJA.random_instance()
sage: x = J.random_element()
sage: J(x.to_vector().column()) == x
True
return V.span_of_basis(b)
+
@cached_method
def _charpoly_coeff(self, i):
"""
"""
(A_of_x, x, xr, detA) = self._charpoly_matrix_system()
R = A_of_x.base_ring()
- if i >= self.rank():
+
+ if i == self.rank():
+ return R.one()
+ if i > self.rank():
# Guaranteed by theory
return R.zero()
SETUP::
- sage: from mjo.eja.eja_algebra import JordanSpinEJA
+ sage: from mjo.eja.eja_algebra import JordanSpinEJA, TrivialEJA
EXAMPLES:
sage: p(*xvec)
t^2 - 2*t + 1
+ By definition, the characteristic polynomial is a monic
+ degree-zero polynomial in a rank-zero algebra. Note that
+ Cayley-Hamilton is indeed satisfied since the polynomial
+ ``1`` evaluates to the identity element of the algebra on
+ any argument::
+
+ sage: J = TrivialEJA()
+ sage: J.characteristic_polynomial()
+ 1
+
"""
r = self.rank()
n = self.dimension()
- # The list of coefficient polynomials a_1, a_2, ..., a_n.
- a = [ self._charpoly_coeff(i) for i in range(n) ]
+ # The list of coefficient polynomials a_0, a_1, a_2, ..., a_n.
+ a = [ self._charpoly_coeff(i) for i in range(r+1) ]
# We go to a bit of trouble here to reorder the
# indeterminates, so that it's easier to evaluate the
S = PolynomialRing(S, R.variable_names())
t = S(t)
- # Note: all entries past the rth should be zero. The
- # coefficient of the highest power (x^r) is 1, but it doesn't
- # appear in the solution vector which contains coefficients
- # for the other powers (to make them sum to x^r).
- if (r < n):
- a[r] = 1 # corresponds to x^r
- else:
- # When the rank is equal to the dimension, trying to
- # assign a[r] goes out-of-bounds.
- a.append(1) # corresponds to x^r
-
- return sum( a[k]*(t**k) for k in range(len(a)) )
+ return sum( a[k]*(t**k) for k in xrange(len(a)) )
def inner_product(self, x, y):
EXAMPLES:
- The inner product must satisfy its axiom for this algebra to truly
- be a Euclidean Jordan Algebra::
+ Our inner product is "associative," which means the following for
+ a symmetric bilinear form::
sage: set_random_seed()
sage: J = random_eja()
- sage: x = J.random_element()
- sage: y = J.random_element()
- sage: z = J.random_element()
+ sage: x,y,z = J.random_elements(3)
sage: (x*y).inner_product(z) == y.inner_product(x*z)
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.natural_inner_product(X,Y)
def is_trivial(self):
SETUP::
- sage: from mjo.eja.eja_algebra import ComplexHermitianEJA
+ sage: from mjo.eja.eja_algebra import (ComplexHermitianEJA,
+ ....: TrivialEJA)
EXAMPLES::
sage: J = ComplexHermitianEJA(3)
sage: J.is_trivial()
False
- sage: A = J.zero().subalgebra_generated_by()
- sage: A.is_trivial()
+
+ ::
+
+ sage: J = TrivialEJA()
+ sage: J.is_trivial()
True
"""
"""
M = list(self._multiplication_table) # copy
- for i in range(len(M)):
+ for i in xrange(len(M)):
# M had better be "square"
M[i] = [self.monomial(i)] + M[i]
M = [["*"] + list(self.gens())] + M
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):
"""
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 peirce_decomposition(self, c):
+ """
+ The Peirce decomposition of this algebra relative to the
+ idempotent ``c``.
+
+ In the future, this can be extended to a complete system of
+ orthogonal idempotents.
+ """
+ if not c.is_idempotent():
+ raise ValueError("element is not idempotent: %s" % c)
+
+ # Default these to what they should be if they turn out to be
+ # trivial, because eigenspaces_left() won't return eigenvalues
+ # corresponding to trivial spaces (e.g. it returns only the
+ # eigenspace corresponding to lambda=1 if you take the
+ # decomposition relative to the identity element).
+ trivial = FiniteDimensionalEuclideanJordanSubalgebra(self, ())
+ J0 = trivial # eigenvalue zero
+ J2 = trivial # eigenvalue one-half
+ J1 = trivial # eigenvalue one
+
+ for (eigval, eigspace) in c.operator().matrix().left_eigenspaces():
+ gens = tuple( self.from_vector(b) for b in eigspace.basis() )
+ subalg = FiniteDimensionalEuclideanJordanSubalgebra(self, gens)
+ if eigval == 0:
+ J0 = subalg
+ elif eigval == ~(self.base_ring()(2)):
+ J2 = subalg
+ elif eigval == 1:
+ J1 = subalg
+ else:
+ raise ValueError("unexpected eigenvalue: %s" % eigval)
+
+ return (J0, J2, J1)
+
+
+ def random_elements(self, count):
+ """
+ Return ``count`` random elements as a tuple.
+
+ SETUP::
+
+ sage: from mjo.eja.eja_algebra import JordanSpinEJA
+
+ EXAMPLES::
+
+ sage: J = JordanSpinEJA(3)
+ sage: x,y,z = J.random_elements(3)
+ sage: all( [ x in J, y in J, z in J ])
+ True
+ sage: len( J.random_elements(10) ) == 10
+ True
+
+ """
+ return tuple( self.random_element() for idx in xrange(count) )
def rank(self):
The rank of the `n`-by-`n` Hermitian real, complex, or
quaternion matrices is `n`::
- sage: RealSymmetricEJA(2).rank()
- 2
- sage: ComplexHermitianEJA(2).rank()
- 2
+ sage: RealSymmetricEJA(4).rank()
+ 4
+ sage: ComplexHermitianEJA(3).rank()
+ 3
sage: QuaternionHermitianEJA(2).rank()
2
- sage: RealSymmetricEJA(5).rank()
- 5
- sage: ComplexHermitianEJA(5).rank()
- 5
- sage: QuaternionHermitianEJA(5).rank()
- 5
TESTS:
Ensure that every EJA that we know how to construct has a
- positive integer rank::
+ positive integer rank, unless the algebra is trivial in
+ which case its rank will be zero::
sage: set_random_seed()
- sage: r = random_eja().rank()
- sage: r in ZZ and r > 0
+ sage: J = random_eja()
+ sage: r = J.rank()
+ sage: r in ZZ
+ True
+ sage: r > 0 or (r == 0 and J.is_trivial())
True
"""
Element = FiniteDimensionalEuclideanJordanAlgebraElement
-class RealCartesianProductEJA(FiniteDimensionalEuclideanJordanAlgebra):
+class KnownRankEJA(object):
+ """
+ A class for algebras that we actually know we can construct. The
+ main issue is that, for most of our methods to make sense, we need
+ to know the rank of our algebra. Thus we can't simply generate a
+ "random" algebra, or even check that a given basis and product
+ satisfy the axioms; because even if everything looks OK, we wouldn't
+ know the rank we need to actuallty build the thing.
+
+ Not really a subclass of FDEJA because doing that causes method
+ resolution errors, e.g.
+
+ TypeError: Error when calling the metaclass bases
+ Cannot create a consistent method resolution
+ order (MRO) for bases FiniteDimensionalEuclideanJordanAlgebra,
+ KnownRankEJA
+
+ """
+ @staticmethod
+ def _max_test_case_size():
+ """
+ Return an integer "size" that is an upper bound on the size of
+ this algebra when it is used in a random test
+ case. Unfortunately, the term "size" is quite vague -- when
+ dealing with `R^n` under either the Hadamard or Jordan spin
+ product, the "size" refers to the dimension `n`. When dealing
+ with a matrix algebra (real symmetric or complex/quaternion
+ Hermitian), it refers to the size of the matrix, which is
+ far less than the dimension of the underlying vector space.
+
+ We default to five in this class, which is safe in `R^n`. The
+ matrix algebra subclasses (or any class where the "size" is
+ interpreted to be far less than the dimension) should override
+ with a smaller number.
+ """
+ return 5
+
+ @classmethod
+ def random_instance(cls, field=QQ, **kwargs):
+ """
+ Return a random instance of this type of algebra.
+
+ Beware, this will crash for "most instances" because the
+ constructor below looks wrong.
+ """
+ if cls is TrivialEJA:
+ # The TrivialEJA class doesn't take an "n" argument because
+ # there's only one.
+ return cls(field)
+
+ n = ZZ.random_element(cls._max_test_case_size()) + 1
+ return cls(n, field, **kwargs)
+
+
+class RealCartesianProductEJA(FiniteDimensionalEuclideanJordanAlgebra,
+ KnownRankEJA):
"""
Return the Euclidean Jordan Algebra corresponding to the set
`R^n` under the Hadamard product.
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
-
"""
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) ]
+ mult_table = [ [ V.gen(i)*(i == j) for j in xrange(n) ]
+ for i in xrange(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)
-
-
-def random_eja():
- """
- Return a "random" finite-dimensional Euclidean Jordan Algebra.
+ """
+ Faster to reimplement than to use natural representations.
- ALGORITHM:
+ SETUP::
- For now, we choose a random natural number ``n`` (greater than zero)
- and then give you back one of the following:
+ sage: from mjo.eja.eja_algebra import RealCartesianProductEJA
- * The cartesian product of the rational numbers ``n`` times; this is
- ``QQ^n`` with the Hadamard product.
+ TESTS:
- * The Jordan spin algebra on ``QQ^n``.
+ Ensure that this is the usual inner product for the algebras
+ over `R^n`::
- * The ``n``-by-``n`` rational symmetric matrices with the symmetric
- product.
+ sage: set_random_seed()
+ sage: J = RealCartesianProductEJA.random_instance()
+ sage: x,y = J.random_elements(2)
+ sage: X = x.natural_representation()
+ sage: Y = y.natural_representation()
+ sage: x.inner_product(y) == J.natural_inner_product(X,Y)
+ True
- * The ``n``-by-``n`` complex-rational Hermitian matrices embedded
- in the space of ``2n``-by-``2n`` real symmetric matrices.
+ """
+ return x.to_vector().inner_product(y.to_vector())
- * The ``n``-by-``n`` quaternion-rational Hermitian matrices embedded
- in the space of ``4n``-by-``4n`` real symmetric matrices.
- Later this might be extended to return Cartesian products of the
- EJAs above.
+def random_eja(field=QQ, nontrivial=False):
+ """
+ Return a "random" finite-dimensional Euclidean Jordan Algebra.
SETUP::
Euclidean Jordan algebra of dimension...
"""
-
- # The max_n component lets us choose different upper bounds on the
- # value "n" that gets passed to the constructor. This is needed
- # because e.g. R^{10} is reasonable to test, while the Hermitian
- # 10-by-10 quaternion matrices are not.
- (constructor, max_n) = choice([(RealCartesianProductEJA, 6),
- (JordanSpinEJA, 6),
- (RealSymmetricEJA, 5),
- (ComplexHermitianEJA, 4),
- (QuaternionHermitianEJA, 3)])
- n = ZZ.random_element(1, max_n)
- return constructor(n, field=QQ)
+ eja_classes = KnownRankEJA.__subclasses__()
+ if nontrivial:
+ eja_classes.remove(TrivialEJA)
+ classname = choice(eja_classes)
+ return classname.random_instance(field=field)
-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::
+class MatrixEuclideanJordanAlgebra(FiniteDimensionalEuclideanJordanAlgebra):
+ @staticmethod
+ def _max_test_case_size():
+ # Play it safe, since this will be squared and the underlying
+ # field can have dimension 4 (quaternions) too.
+ return 2
- sage: set_random_seed()
- sage: n = ZZ.random_element(1,5)
- sage: B = _real_symmetric_basis(n, QQbar)
- sage: all( M.is_symmetric() for M in B)
- True
-
- """
- # The basis of symmetric matrices, as matrices, in their R^(n-by-n)
- # coordinates.
- S = []
- for i in xrange(n):
- for j in xrange(i+1):
- Eij = matrix(field, n, lambda k,l: k==i and l==j)
- if i == j:
- Sij = Eij
- else:
- Sij = Eij + Eij.transpose()
- # Now normalize it.
- Sij = Sij / _real_symmetric_matrix_ip(Sij,Sij).sqrt()
- S.append(Sij)
- return tuple(S)
-
-
-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
-
- TESTS::
-
- sage: set_random_seed()
- sage: n = ZZ.random_element(1,5)
- sage: R = PolynomialRing(QQ, 'z')
- sage: z = R.gen()
- sage: field = NumberField(z**2 - 2, 'sqrt2', embedding=RLF(2).sqrt())
- sage: B = _complex_hermitian_basis(n, field)
- sage: all( M.is_symmetric() for M in B)
- True
-
- """
- 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:
- #
- # * We want conjugate-symmetry, not just symmetry.
- # * The diagonal will (as a result) be real.
- #
- S = []
- for i in xrange(n):
- for j in xrange(i+1):
- 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.
- 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)
-
- # Normalize these with our inner product before handing them back.
- # And since we embedded them, we can drop back to the "field" that
- # we started with instead of the complex extension "F".
- return tuple( (s / _complex_hermitian_matrix_ip(s,s).sqrt()).change_ring(field)
- for s in S )
-
-
-
-def _quaternion_hermitian_basis(n, field):
- """
- Returns a basis for the space of quaternion Hermitian n-by-n matrices.
+ def __init__(self, field, basis, rank, normalize_basis=True, **kwargs):
+ """
+ Compared to the superclass constructor, we take a basis instead of
+ a multiplication table because the latter can be computed in terms
+ of the former when the product is known (like it is here).
+ """
+ # Used in this class's fast _charpoly_coeff() override.
+ self._basis_normalizers = None
- 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.
+ # We're going to loop through this a few times, so now's a good
+ # time to ensure that it isn't a generator expression.
+ basis = tuple(basis)
- SETUP::
+ if rank > 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 = field.extension(p, 'sqrt2', embedding=RLF(2).sqrt())
+ basis = tuple( s.change_ring(field) for s in basis )
+ self._basis_normalizers = tuple(
+ ~(self.natural_inner_product(s,s).sqrt()) for s in basis )
+ basis = tuple(s*c for (s,c) in izip(basis,self._basis_normalizers))
- sage: from mjo.eja.eja_algebra import _quaternion_hermitian_basis
+ Qs = self.multiplication_table_from_matrix_basis(basis)
- TESTS::
+ fdeja = super(MatrixEuclideanJordanAlgebra, self)
+ return fdeja.__init__(field,
+ Qs,
+ rank=rank,
+ natural_basis=basis,
+ **kwargs)
- sage: set_random_seed()
- sage: n = ZZ.random_element(1,5)
- sage: B = _quaternion_hermitian_basis(n, QQ)
- sage: all( M.is_symmetric() for M in B )
- True
- """
- Q = QuaternionAlgebra(QQ,-1,-1)
- I,J,K = Q.gens()
-
- # This is like the symmetric case, but we need to be careful:
- #
- # * We want conjugate-symmetry, not just symmetry.
- # * The diagonal will (as a result) be real.
- #
- S = []
- for i in xrange(n):
- for j in xrange(i+1):
- Eij = matrix(Q, n, lambda k,l: k==i and l==j)
- if i == j:
- Sij = _embed_quaternion_matrix(Eij)
- S.append(Sij)
+ @cached_method
+ def _charpoly_coeff(self, i):
+ """
+ Override the parent method with something that tries to compute
+ over a faster (non-extension) field.
+ """
+ if self._basis_normalizers is None:
+ # We didn't normalize, so assume that the basis we started
+ # with had entries in a nice field.
+ return super(MatrixEuclideanJordanAlgebra, self)._charpoly_coeff(i)
+ else:
+ basis = ( (b/n) for (b,n) in izip(self.natural_basis(),
+ self._basis_normalizers) )
+
+ # Do this over the rationals and convert back at the end.
+ J = MatrixEuclideanJordanAlgebra(QQ,
+ basis,
+ self.rank(),
+ normalize_basis=False)
+ (_,x,_,_) = J._charpoly_matrix_system()
+ p = J._charpoly_coeff(i)
+ # p might be missing some vars, have to substitute "optionally"
+ pairs = izip(x.base_ring().gens(), self._basis_normalizers)
+ substitutions = { v: v*c for (v,c) in pairs }
+ result = p.subs(substitutions)
+
+ # The result of "subs" can be either a coefficient-ring
+ # element or a polynomial. Gotta handle both cases.
+ if result in QQ:
+ return self.base_ring()(result)
else:
- # Beware, orthogonal but not normalized! The second,
- # third, and fourth ones have a minus because they're
- # conjugated.
- Sij_real = _embed_quaternion_matrix(Eij + Eij.transpose())
- S.append(Sij_real)
- Sij_I = _embed_quaternion_matrix(I*Eij - I*Eij.transpose())
- S.append(Sij_I)
- Sij_J = _embed_quaternion_matrix(J*Eij - J*Eij.transpose())
- S.append(Sij_J)
- Sij_K = _embed_quaternion_matrix(K*Eij - K*Eij.transpose())
- S.append(Sij_K)
- return tuple(S)
-
-
-
-def _multiplication_table_from_matrix_basis(basis):
- """
- At least three of the five simple Euclidean Jordan algebras have the
- symmetric multiplication (A,B) |-> (AB + BA)/2, where the
- 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.
- """
- # 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.
- field = basis[0].base_ring()
- dimension = basis[0].nrows()
-
- V = VectorSpace(field, dimension**2)
- 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):
- """
- Embed the n-by-n complex matrix ``M`` into the space of real
- matrices of size 2n-by-2n via the map the sends each entry `z = a +
- bi` to the block matrix ``[[a,b],[-b,a]]``.
-
- SETUP::
-
- sage: from mjo.eja.eja_algebra import _embed_complex_matrix
-
- EXAMPLES::
-
- sage: R = PolynomialRing(QQ, 'z')
- sage: z = R.gen()
- sage: F = NumberField(z**2 + 1, 'i', embedding=CLF(-1).sqrt())
- sage: x1 = F(4 - 2*i)
- sage: x2 = F(1 + 2*i)
- sage: x3 = F(-i)
- sage: x4 = F(6)
- sage: M = matrix(F,2,[[x1,x2],[x3,x4]])
- sage: _embed_complex_matrix(M)
- [ 4 -2| 1 2]
- [ 2 4|-2 1]
- [-----+-----]
- [ 0 -1| 6 0]
- [ 1 0| 0 6]
-
- TESTS:
-
- Embedding is a homomorphism (isomorphism, in fact)::
-
- sage: set_random_seed()
- sage: n = ZZ.random_element(5)
- sage: R = PolynomialRing(QQ, 'z')
- sage: z = R.gen()
- sage: F = NumberField(z**2 + 1, 'i', embedding=CLF(-1).sqrt())
- sage: X = random_matrix(F, n)
- sage: Y = random_matrix(F, n)
- sage: actual = _embed_complex_matrix(X) * _embed_complex_matrix(Y)
- sage: expected = _embed_complex_matrix(X*Y)
- sage: actual == expected
- True
-
- """
- n = M.nrows()
- if M.ncols() != n:
- raise ValueError("the matrix 'M' must be square")
- field = M.base_ring()
- blocks = []
- for z in M.list():
- 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.
- return matrix.block(field.base_ring(), n, blocks)
-
-
-def _unembed_complex_matrix(M):
- """
- The inverse of _embed_complex_matrix().
+ return result.change_ring(self.base_ring())
- SETUP::
-
- sage: from mjo.eja.eja_algebra import (_embed_complex_matrix,
- ....: _unembed_complex_matrix)
-
- EXAMPLES::
-
- sage: A = matrix(QQ,[ [ 1, 2, 3, 4],
- ....: [-2, 1, -4, 3],
- ....: [ 9, 10, 11, 12],
- ....: [-10, 9, -12, 11] ])
- sage: _unembed_complex_matrix(A)
- [ 2*i + 1 4*i + 3]
- [ 10*i + 9 12*i + 11]
-
- TESTS:
-
- Unembedding is the inverse of embedding::
-
- sage: set_random_seed()
- sage: R = PolynomialRing(QQ, 'z')
- sage: z = R.gen()
- sage: F = NumberField(z**2 + 1, 'i', embedding=CLF(-1).sqrt())
- sage: M = random_matrix(F, 3)
- sage: _unembed_complex_matrix(_embed_complex_matrix(M)) == M
- True
-
- """
- n = ZZ(M.nrows())
- if M.ncols() != n:
- raise ValueError("the matrix 'M' must be square")
- if not n.mod(2).is_zero():
- raise ValueError("the matrix 'M' must be a complex embedding")
-
- 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
- # 2-by-2 block we see to a single complex element.
- elements = []
- for k in xrange(n/2):
- for j in xrange(n/2):
- submat = M[2*k:2*k+2,2*j:2*j+2]
- if submat[0,0] != submat[1,1]:
- raise ValueError('bad on-diagonal submatrix')
- if submat[0,1] != -submat[1,0]:
- raise ValueError('bad off-diagonal submatrix')
- z = submat[0,0] + submat[0,1]*i
- elements.append(z)
-
- return matrix(F, n/2, elements)
-
-
-def _embed_quaternion_matrix(M):
- """
- Embed the n-by-n quaternion matrix ``M`` into the space of real
- matrices of size 4n-by-4n by first sending each quaternion entry
- `z = a + bi + cj + dk` to the block-complex matrix
- ``[[a + bi, c+di],[-c + di, a-bi]]`, and then embedding those into
- a real matrix.
- SETUP::
+ @staticmethod
+ def multiplication_table_from_matrix_basis(basis):
+ """
+ At least three of the five simple Euclidean Jordan algebras have the
+ symmetric multiplication (A,B) |-> (AB + BA)/2, where the
+ 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.
+ """
+ # 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.
+ field = basis[0].base_ring()
+ dimension = basis[0].nrows()
+
+ V = VectorSpace(field, dimension**2)
+ W = V.span_of_basis( _mat2vec(s) for s in basis )
+ n = len(basis)
+ mult_table = [[W.zero() for j in xrange(n)] for i in xrange(n)]
+ for i in xrange(n):
+ for j in xrange(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
+
+
+ @staticmethod
+ def real_embed(M):
+ """
+ Embed the matrix ``M`` into a space of real matrices.
- sage: from mjo.eja.eja_algebra import _embed_quaternion_matrix
+ The matrix ``M`` can have entries in any field at the moment:
+ the real numbers, complex numbers, or quaternions. And although
+ they are not a field, we can probably support octonions at some
+ point, too. This function returns a real matrix that "acts like"
+ the original with respect to matrix multiplication; i.e.
- EXAMPLES::
+ real_embed(M*N) = real_embed(M)*real_embed(N)
- sage: Q = QuaternionAlgebra(QQ,-1,-1)
- sage: i,j,k = Q.gens()
- sage: x = 1 + 2*i + 3*j + 4*k
- sage: M = matrix(Q, 1, [[x]])
- sage: _embed_quaternion_matrix(M)
- [ 1 2 3 4]
- [-2 1 -4 3]
- [-3 4 1 -2]
- [-4 -3 2 1]
+ """
+ raise NotImplementedError
- Embedding is a homomorphism (isomorphism, in fact)::
- sage: set_random_seed()
- sage: n = ZZ.random_element(5)
- sage: Q = QuaternionAlgebra(QQ,-1,-1)
- sage: X = random_matrix(Q, n)
- sage: Y = random_matrix(Q, n)
- sage: actual = _embed_quaternion_matrix(X)*_embed_quaternion_matrix(Y)
- sage: expected = _embed_quaternion_matrix(X*Y)
- sage: actual == expected
- True
+ @staticmethod
+ def real_unembed(M):
+ """
+ The inverse of :meth:`real_embed`.
+ """
+ raise NotImplementedError
- """
- quaternions = M.base_ring()
- n = M.nrows()
- if M.ncols() != n:
- raise ValueError("the matrix 'M' must be square")
-
- R = PolynomialRing(QQ, 'z')
- z = R.gen()
- F = NumberField(z**2 + 1, 'i', embedding=CLF(-1).sqrt())
- i = F.gen()
-
- blocks = []
- for z in M.list():
- t = z.coefficient_tuple()
- a = t[0]
- b = t[1]
- c = t[2]
- d = t[3]
- cplx_matrix = matrix(F, 2, [[ a + b*i, c + d*i],
- [-c + d*i, a - b*i]])
- blocks.append(_embed_complex_matrix(cplx_matrix))
-
- # We should have real entries by now, so use the realest field
- # we've got for the return value.
- return matrix.block(quaternions.base_ring(), n, blocks)
-
-
-def _unembed_quaternion_matrix(M):
- """
- The inverse of _embed_quaternion_matrix().
- SETUP::
+ @classmethod
+ def natural_inner_product(cls,X,Y):
+ Xu = cls.real_unembed(X)
+ Yu = cls.real_unembed(Y)
+ tr = (Xu*Yu).trace()
- sage: from mjo.eja.eja_algebra import (_embed_quaternion_matrix,
- ....: _unembed_quaternion_matrix)
+ if tr in RLF:
+ # It's real already.
+ return tr
- EXAMPLES::
+ # Otherwise, try the thing that works for complex numbers; and
+ # if that doesn't work, the thing that works for quaternions.
+ try:
+ return tr.vector()[0] # real part, imag part is index 1
+ except AttributeError:
+ # A quaternions doesn't have a vector() method, but does
+ # have coefficient_tuple() method that returns the
+ # coefficients of 1, i, j, and k -- in that order.
+ return tr.coefficient_tuple()[0]
- sage: M = matrix(QQ, [[ 1, 2, 3, 4],
- ....: [-2, 1, -4, 3],
- ....: [-3, 4, 1, -2],
- ....: [-4, -3, 2, 1]])
- sage: _unembed_quaternion_matrix(M)
- [1 + 2*i + 3*j + 4*k]
- TESTS:
+class RealMatrixEuclideanJordanAlgebra(MatrixEuclideanJordanAlgebra):
+ @staticmethod
+ def real_embed(M):
+ """
+ The identity function, for embedding real matrices into real
+ matrices.
+ """
+ return M
- Unembedding is the inverse of embedding::
+ @staticmethod
+ def real_unembed(M):
+ """
+ The identity function, for unembedding real matrices from real
+ matrices.
+ """
+ return M
- sage: set_random_seed()
- sage: Q = QuaternionAlgebra(QQ, -1, -1)
- sage: M = random_matrix(Q, 3)
- sage: _unembed_quaternion_matrix(_embed_quaternion_matrix(M)) == M
- True
- """
- n = ZZ(M.nrows())
- if M.ncols() != n:
- raise ValueError("the matrix 'M' must be square")
- if not n.mod(4).is_zero():
- raise ValueError("the matrix 'M' must be a complex embedding")
-
- Q = QuaternionAlgebra(QQ,-1,-1)
- i,j,k = Q.gens()
-
- # Go top-left to bottom-right (reading order), converting every
- # 4-by-4 block we see to a 2-by-2 complex block, to a 1-by-1
- # quaternion block.
- elements = []
- for l in xrange(n/4):
- for m in xrange(n/4):
- submat = _unembed_complex_matrix(M[4*l:4*l+4,4*m:4*m+4])
- if submat[0,0] != submat[1,1].conjugate():
- raise ValueError('bad on-diagonal submatrix')
- if submat[0,1] != -submat[1,0].conjugate():
- raise ValueError('bad off-diagonal submatrix')
- z = submat[0,0].real() + submat[0,0].imag()*i
- z += submat[0,1].real()*j + submat[0,1].imag()*k
- elements.append(z)
-
- return matrix(Q, n/4, elements)
-
-
-# The usual inner product on R^n.
-def _usual_ip(x,y):
- return x.to_vector().inner_product(y.to_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.
-def _matrix_ip(X,Y):
- X_mat = X.natural_representation()
- Y_mat = Y.natural_representation()
- return (X_mat*Y_mat).trace()
-
-def _real_symmetric_matrix_ip(X,Y):
- return (X*Y).trace()
-
-def _complex_hermitian_matrix_ip(X,Y):
- # This takes EMBEDDED matrices.
- 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 RealSymmetricEJA(FiniteDimensionalEuclideanJordanAlgebra):
+class RealSymmetricEJA(RealMatrixEuclideanJordanAlgebra, KnownRankEJA):
"""
The rank-n simple EJA consisting of real symmetric n-by-n
matrices, the usual symmetric Jordan product, and the trace inner
sage: e2*e2
e2
+ In theory, our "field" can be any subfield of the reals::
+
+ sage: RealSymmetricEJA(2, AA)
+ Euclidean Jordan algebra of dimension 3 over Algebraic Real Field
+ sage: RealSymmetricEJA(2, RR)
+ Euclidean Jordan algebra of dimension 3 over Real Field with
+ 53 bits of precision
+
TESTS:
The dimension of this algebra is `(n^2 + n) / 2`::
sage: set_random_seed()
- sage: n = ZZ.random_element(1,5)
+ sage: n_max = RealSymmetricEJA._max_test_case_size()
+ sage: n = ZZ.random_element(1, n_max)
sage: J = RealSymmetricEJA(n)
sage: J.dimension() == (n^2 + n)/2
True
The Jordan multiplication is what we think it is::
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: J = RealSymmetricEJA.random_instance()
+ sage: x,y = J.random_elements(2)
sage: actual = (x*y).natural_representation()
sage: X = x.natural_representation()
sage: Y = y.natural_representation()
sage: RealSymmetricEJA(3, prefix='q').gens()
(q0, q1, q2, q3, q4, q5)
- Our inner product satisfies the Jordan axiom::
+ Our natural basis is normalized with respect to the natural inner
+ product unless we specify otherwise::
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: J = RealSymmetricEJA.random_instance()
sage: all( b.norm() == 1 for b in J.gens() )
True
- Left-multiplication operators are symmetric because they satisfy
- the Jordan axiom::
+ Since our natural basis is normalized with respect to the natural
+ inner product, and since we know that this algebra is an EJA, any
+ left-multiplication operator's matrix will be symmetric because
+ natural->EJA basis representation is an isometry and within the EJA
+ the operator is self-adjoint by the Jordan axiom::
sage: set_random_seed()
- sage: n = ZZ.random_element(1,5)
- sage: x = RealSymmetricEJA(n).random_element()
+ sage: x = RealSymmetricEJA.random_instance().random_element()
sage: x.operator().matrix().is_symmetric()
True
"""
+ @classmethod
+ def _denormalized_basis(cls, n, field):
+ """
+ Return a basis for the space of real symmetric n-by-n matrices.
+
+ SETUP::
+
+ sage: from mjo.eja.eja_algebra import RealSymmetricEJA
+
+ TESTS::
+
+ sage: set_random_seed()
+ sage: n = ZZ.random_element(1,5)
+ sage: B = RealSymmetricEJA._denormalized_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.
+ S = []
+ for i in xrange(n):
+ for j in xrange(i+1):
+ Eij = matrix(field, n, lambda k,l: k==i and l==j)
+ if i == j:
+ Sij = Eij
+ else:
+ Sij = Eij + Eij.transpose()
+ S.append(Sij)
+ return S
+
+
+ @staticmethod
+ def _max_test_case_size():
+ return 4 # Dimension 10
+
+
def __init__(self, n, field=QQ, **kwargs):
- if n > 1:
- # 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())
+ basis = self._denormalized_basis(n, field)
+ super(RealSymmetricEJA, self).__init__(field, basis, n, **kwargs)
- S = _real_symmetric_basis(n, field)
- Qs = _multiplication_table_from_matrix_basis(S)
- fdeja = super(RealSymmetricEJA, self)
- return fdeja.__init__(field,
- Qs,
- rank=n,
- natural_basis=S,
- **kwargs)
+class ComplexMatrixEuclideanJordanAlgebra(MatrixEuclideanJordanAlgebra):
+ @staticmethod
+ def real_embed(M):
+ """
+ Embed the n-by-n complex matrix ``M`` into the space of real
+ matrices of size 2n-by-2n via the map the sends each entry `z = a +
+ bi` to the block matrix ``[[a,b],[-b,a]]``.
- def inner_product(self, x, y):
- X = x.natural_representation()
- Y = y.natural_representation()
- return _real_symmetric_matrix_ip(X,Y)
+ SETUP::
+ sage: from mjo.eja.eja_algebra import \
+ ....: ComplexMatrixEuclideanJordanAlgebra
-class ComplexHermitianEJA(FiniteDimensionalEuclideanJordanAlgebra):
+ EXAMPLES::
+
+ sage: F = QuadraticField(-1, 'i')
+ sage: x1 = F(4 - 2*i)
+ sage: x2 = F(1 + 2*i)
+ sage: x3 = F(-i)
+ sage: x4 = F(6)
+ sage: M = matrix(F,2,[[x1,x2],[x3,x4]])
+ sage: ComplexMatrixEuclideanJordanAlgebra.real_embed(M)
+ [ 4 -2| 1 2]
+ [ 2 4|-2 1]
+ [-----+-----]
+ [ 0 -1| 6 0]
+ [ 1 0| 0 6]
+
+ TESTS:
+
+ Embedding is a homomorphism (isomorphism, in fact)::
+
+ sage: set_random_seed()
+ sage: n_max = ComplexMatrixEuclideanJordanAlgebra._max_test_case_size()
+ sage: n = ZZ.random_element(n_max)
+ sage: F = QuadraticField(-1, 'i')
+ sage: X = random_matrix(F, n)
+ sage: Y = random_matrix(F, n)
+ sage: Xe = ComplexMatrixEuclideanJordanAlgebra.real_embed(X)
+ sage: Ye = ComplexMatrixEuclideanJordanAlgebra.real_embed(Y)
+ sage: XYe = ComplexMatrixEuclideanJordanAlgebra.real_embed(X*Y)
+ sage: Xe*Ye == XYe
+ True
+
+ """
+ n = M.nrows()
+ if M.ncols() != n:
+ raise ValueError("the matrix 'M' must be square")
+
+ # We don't need any adjoined elements...
+ field = M.base_ring().base_ring()
+
+ blocks = []
+ for z in M.list():
+ a = z.list()[0] # real part, I guess
+ b = z.list()[1] # imag part, I guess
+ blocks.append(matrix(field, 2, [[a,b],[-b,a]]))
+
+ return matrix.block(field, n, blocks)
+
+
+ @staticmethod
+ def real_unembed(M):
+ """
+ The inverse of _embed_complex_matrix().
+
+ SETUP::
+
+ sage: from mjo.eja.eja_algebra import \
+ ....: ComplexMatrixEuclideanJordanAlgebra
+
+ EXAMPLES::
+
+ sage: A = matrix(QQ,[ [ 1, 2, 3, 4],
+ ....: [-2, 1, -4, 3],
+ ....: [ 9, 10, 11, 12],
+ ....: [-10, 9, -12, 11] ])
+ sage: ComplexMatrixEuclideanJordanAlgebra.real_unembed(A)
+ [ 2*i + 1 4*i + 3]
+ [ 10*i + 9 12*i + 11]
+
+ TESTS:
+
+ Unembedding is the inverse of embedding::
+
+ sage: set_random_seed()
+ sage: F = QuadraticField(-1, 'i')
+ sage: M = random_matrix(F, 3)
+ sage: Me = ComplexMatrixEuclideanJordanAlgebra.real_embed(M)
+ sage: ComplexMatrixEuclideanJordanAlgebra.real_unembed(Me) == M
+ True
+
+ """
+ n = ZZ(M.nrows())
+ if M.ncols() != n:
+ raise ValueError("the matrix 'M' must be square")
+ if not n.mod(2).is_zero():
+ raise ValueError("the matrix 'M' must be a complex embedding")
+
+ # If "M" was normalized, its base ring might have roots
+ # adjoined and they can stick around after unembedding.
+ field = M.base_ring()
+ R = PolynomialRing(field, 'z')
+ z = R.gen()
+ F = field.extension(z**2 + 1, 'i', embedding=CLF(-1).sqrt())
+ i = F.gen()
+
+ # Go top-left to bottom-right (reading order), converting every
+ # 2-by-2 block we see to a single complex element.
+ elements = []
+ for k in xrange(n/2):
+ for j in xrange(n/2):
+ submat = M[2*k:2*k+2,2*j:2*j+2]
+ if submat[0,0] != submat[1,1]:
+ raise ValueError('bad on-diagonal submatrix')
+ if submat[0,1] != -submat[1,0]:
+ raise ValueError('bad off-diagonal submatrix')
+ z = submat[0,0] + submat[0,1]*i
+ elements.append(z)
+
+ return matrix(F, n/2, elements)
+
+
+ @classmethod
+ def natural_inner_product(cls,X,Y):
+ """
+ Compute a natural inner product in this algebra directly from
+ its real embedding.
+
+ SETUP::
+
+ sage: from mjo.eja.eja_algebra import ComplexHermitianEJA
+
+ TESTS:
+
+ This gives the same answer as the slow, default method implemented
+ in :class:`MatrixEuclideanJordanAlgebra`::
+
+ sage: set_random_seed()
+ sage: J = ComplexHermitianEJA.random_instance()
+ sage: x,y = J.random_elements(2)
+ sage: Xe = x.natural_representation()
+ sage: Ye = y.natural_representation()
+ sage: X = ComplexHermitianEJA.real_unembed(Xe)
+ sage: Y = ComplexHermitianEJA.real_unembed(Ye)
+ sage: expected = (X*Y).trace().vector()[0]
+ sage: actual = ComplexHermitianEJA.natural_inner_product(Xe,Ye)
+ sage: actual == expected
+ True
+
+ """
+ return RealMatrixEuclideanJordanAlgebra.natural_inner_product(X,Y)/2
+
+
+class ComplexHermitianEJA(ComplexMatrixEuclideanJordanAlgebra, KnownRankEJA):
"""
The rank-n simple EJA consisting of complex Hermitian n-by-n
matrices over the real numbers, the usual symmetric Jordan product,
sage: from mjo.eja.eja_algebra import ComplexHermitianEJA
+ EXAMPLES:
+
+ In theory, our "field" can be any subfield of the reals::
+
+ sage: ComplexHermitianEJA(2, AA)
+ Euclidean Jordan algebra of dimension 4 over Algebraic Real Field
+ sage: ComplexHermitianEJA(2, RR)
+ Euclidean Jordan algebra of dimension 4 over Real Field with
+ 53 bits of precision
+
TESTS:
The dimension of this algebra is `n^2`::
sage: set_random_seed()
- sage: n = ZZ.random_element(1,5)
+ sage: n_max = ComplexHermitianEJA._max_test_case_size()
+ sage: n = ZZ.random_element(1, n_max)
sage: J = ComplexHermitianEJA(n)
sage: J.dimension() == n^2
True
The Jordan multiplication is what we think it is::
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: J = ComplexHermitianEJA.random_instance()
+ sage: x,y = J.random_elements(2)
sage: actual = (x*y).natural_representation()
sage: X = x.natural_representation()
sage: Y = y.natural_representation()
sage: ComplexHermitianEJA(2, prefix='z').gens()
(z0, z1, z2, z3)
- Our inner product satisfies the Jordan axiom::
+ Our natural basis is normalized with respect to the natural inner
+ product unless we specify otherwise::
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: J = ComplexHermitianEJA.random_instance()
sage: all( b.norm() == 1 for b in J.gens() )
True
- Left-multiplication operators are symmetric because they satisfy
- the Jordan axiom::
+ Since our natural basis is normalized with respect to the natural
+ inner product, and since we know that this algebra is an EJA, any
+ left-multiplication operator's matrix will be symmetric because
+ natural->EJA basis representation is an isometry and within the EJA
+ the operator is self-adjoint by the Jordan axiom::
sage: set_random_seed()
- sage: n = ZZ.random_element(1,5)
- sage: x = ComplexHermitianEJA(n).random_element()
+ sage: x = ComplexHermitianEJA.random_instance().random_element()
sage: x.operator().matrix().is_symmetric()
True
"""
+
+ @classmethod
+ def _denormalized_basis(cls, 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 ComplexHermitianEJA
+
+ TESTS::
+
+ sage: set_random_seed()
+ sage: n = ZZ.random_element(1,5)
+ sage: field = QuadraticField(2, 'sqrt2')
+ sage: B = ComplexHermitianEJA._denormalized_basis(n, field)
+ sage: all( M.is_symmetric() for M in B)
+ True
+
+ """
+ R = PolynomialRing(field, 'z')
+ z = R.gen()
+ F = field.extension(z**2 + 1, 'I')
+ I = F.gen()
+
+ # This is like the symmetric case, but we need to be careful:
+ #
+ # * We want conjugate-symmetry, not just symmetry.
+ # * The diagonal will (as a result) be real.
+ #
+ S = []
+ for i in xrange(n):
+ for j in xrange(i+1):
+ Eij = matrix(F, n, lambda k,l: k==i and l==j)
+ if i == j:
+ Sij = cls.real_embed(Eij)
+ S.append(Sij)
+ else:
+ # The second one has a minus because it's conjugated.
+ Sij_real = cls.real_embed(Eij + Eij.transpose())
+ S.append(Sij_real)
+ Sij_imag = cls.real_embed(I*Eij - I*Eij.transpose())
+ S.append(Sij_imag)
+
+ # Since we embedded these, we can drop back to the "field" that we
+ # started with instead of the complex extension "F".
+ return ( s.change_ring(field) for s in S )
+
+
def __init__(self, n, field=QQ, **kwargs):
- if n > 1:
- # 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())
+ basis = self._denormalized_basis(n,field)
+ super(ComplexHermitianEJA,self).__init__(field, basis, n, **kwargs)
- S = _complex_hermitian_basis(n, field)
- Qs = _multiplication_table_from_matrix_basis(S)
- fdeja = super(ComplexHermitianEJA, self)
- return fdeja.__init__(field,
- Qs,
- rank=n,
- natural_basis=S,
- **kwargs)
+class QuaternionMatrixEuclideanJordanAlgebra(MatrixEuclideanJordanAlgebra):
+ @staticmethod
+ def real_embed(M):
+ """
+ Embed the n-by-n quaternion matrix ``M`` into the space of real
+ matrices of size 4n-by-4n by first sending each quaternion entry `z
+ = a + bi + cj + dk` to the block-complex matrix ``[[a + bi,
+ c+di],[-c + di, a-bi]]`, and then embedding those into a real
+ matrix.
+ SETUP::
- def inner_product(self, x, y):
- X = x.natural_representation()
- Y = y.natural_representation()
- return _complex_hermitian_matrix_ip(X,Y)
+ sage: from mjo.eja.eja_algebra import \
+ ....: QuaternionMatrixEuclideanJordanAlgebra
+
+ EXAMPLES::
+
+ sage: Q = QuaternionAlgebra(QQ,-1,-1)
+ sage: i,j,k = Q.gens()
+ sage: x = 1 + 2*i + 3*j + 4*k
+ sage: M = matrix(Q, 1, [[x]])
+ sage: QuaternionMatrixEuclideanJordanAlgebra.real_embed(M)
+ [ 1 2 3 4]
+ [-2 1 -4 3]
+ [-3 4 1 -2]
+ [-4 -3 2 1]
+
+ Embedding is a homomorphism (isomorphism, in fact)::
+
+ sage: set_random_seed()
+ sage: n_max = QuaternionMatrixEuclideanJordanAlgebra._max_test_case_size()
+ sage: n = ZZ.random_element(n_max)
+ sage: Q = QuaternionAlgebra(QQ,-1,-1)
+ sage: X = random_matrix(Q, n)
+ sage: Y = random_matrix(Q, n)
+ sage: Xe = QuaternionMatrixEuclideanJordanAlgebra.real_embed(X)
+ sage: Ye = QuaternionMatrixEuclideanJordanAlgebra.real_embed(Y)
+ sage: XYe = QuaternionMatrixEuclideanJordanAlgebra.real_embed(X*Y)
+ sage: Xe*Ye == XYe
+ True
+
+ """
+ quaternions = M.base_ring()
+ n = M.nrows()
+ if M.ncols() != n:
+ raise ValueError("the matrix 'M' must be square")
+
+ F = QuadraticField(-1, 'i')
+ i = F.gen()
+
+ blocks = []
+ for z in M.list():
+ t = z.coefficient_tuple()
+ a = t[0]
+ b = t[1]
+ c = t[2]
+ d = t[3]
+ cplxM = matrix(F, 2, [[ a + b*i, c + d*i],
+ [-c + d*i, a - b*i]])
+ realM = ComplexMatrixEuclideanJordanAlgebra.real_embed(cplxM)
+ blocks.append(realM)
+
+ # We should have real entries by now, so use the realest field
+ # we've got for the return value.
+ return matrix.block(quaternions.base_ring(), n, blocks)
+
+
+
+ @staticmethod
+ def real_unembed(M):
+ """
+ The inverse of _embed_quaternion_matrix().
+
+ SETUP::
+
+ sage: from mjo.eja.eja_algebra import \
+ ....: QuaternionMatrixEuclideanJordanAlgebra
+
+ EXAMPLES::
+
+ sage: M = matrix(QQ, [[ 1, 2, 3, 4],
+ ....: [-2, 1, -4, 3],
+ ....: [-3, 4, 1, -2],
+ ....: [-4, -3, 2, 1]])
+ sage: QuaternionMatrixEuclideanJordanAlgebra.real_unembed(M)
+ [1 + 2*i + 3*j + 4*k]
+
+ TESTS:
+
+ Unembedding is the inverse of embedding::
+
+ sage: set_random_seed()
+ sage: Q = QuaternionAlgebra(QQ, -1, -1)
+ sage: M = random_matrix(Q, 3)
+ sage: Me = QuaternionMatrixEuclideanJordanAlgebra.real_embed(M)
+ sage: QuaternionMatrixEuclideanJordanAlgebra.real_unembed(Me) == M
+ True
+ """
+ n = ZZ(M.nrows())
+ if M.ncols() != n:
+ raise ValueError("the matrix 'M' must be square")
+ if not n.mod(4).is_zero():
+ raise ValueError("the matrix 'M' must be a quaternion embedding")
+
+ # Use the base ring of the matrix to ensure that its entries can be
+ # multiplied by elements of the quaternion algebra.
+ field = M.base_ring()
+ Q = QuaternionAlgebra(field,-1,-1)
+ i,j,k = Q.gens()
+
+ # Go top-left to bottom-right (reading order), converting every
+ # 4-by-4 block we see to a 2-by-2 complex block, to a 1-by-1
+ # quaternion block.
+ elements = []
+ for l in xrange(n/4):
+ for m in xrange(n/4):
+ submat = ComplexMatrixEuclideanJordanAlgebra.real_unembed(
+ M[4*l:4*l+4,4*m:4*m+4] )
+ if submat[0,0] != submat[1,1].conjugate():
+ raise ValueError('bad on-diagonal submatrix')
+ if submat[0,1] != -submat[1,0].conjugate():
+ raise ValueError('bad off-diagonal submatrix')
+ z = submat[0,0].vector()[0] # real part
+ z += submat[0,0].vector()[1]*i # imag part
+ z += submat[0,1].vector()[0]*j # real part
+ z += submat[0,1].vector()[1]*k # imag part
+ elements.append(z)
+
+ return matrix(Q, n/4, elements)
+
+
+ @classmethod
+ def natural_inner_product(cls,X,Y):
+ """
+ Compute a natural inner product in this algebra directly from
+ its real embedding.
+
+ SETUP::
+
+ sage: from mjo.eja.eja_algebra import QuaternionHermitianEJA
+
+ TESTS:
+
+ This gives the same answer as the slow, default method implemented
+ in :class:`MatrixEuclideanJordanAlgebra`::
+
+ sage: set_random_seed()
+ sage: J = QuaternionHermitianEJA.random_instance()
+ sage: x,y = J.random_elements(2)
+ sage: Xe = x.natural_representation()
+ sage: Ye = y.natural_representation()
+ sage: X = QuaternionHermitianEJA.real_unembed(Xe)
+ sage: Y = QuaternionHermitianEJA.real_unembed(Ye)
+ sage: expected = (X*Y).trace().coefficient_tuple()[0]
+ sage: actual = QuaternionHermitianEJA.natural_inner_product(Xe,Ye)
+ sage: actual == expected
+ True
+
+ """
+ return RealMatrixEuclideanJordanAlgebra.natural_inner_product(X,Y)/4
-class QuaternionHermitianEJA(FiniteDimensionalEuclideanJordanAlgebra):
+
+class QuaternionHermitianEJA(QuaternionMatrixEuclideanJordanAlgebra,
+ KnownRankEJA):
"""
The rank-n simple EJA consisting of self-adjoint n-by-n quaternion
matrices, the usual symmetric Jordan product, and the
sage: from mjo.eja.eja_algebra import QuaternionHermitianEJA
+ EXAMPLES:
+
+ In theory, our "field" can be any subfield of the reals::
+
+ sage: QuaternionHermitianEJA(2, AA)
+ Euclidean Jordan algebra of dimension 6 over Algebraic Real Field
+ sage: QuaternionHermitianEJA(2, RR)
+ Euclidean Jordan algebra of dimension 6 over Real Field with
+ 53 bits of precision
+
TESTS:
- The dimension of this algebra is `n^2`::
+ The dimension of this algebra is `2*n^2 - n`::
sage: set_random_seed()
- sage: n = ZZ.random_element(1,5)
+ sage: n_max = QuaternionHermitianEJA._max_test_case_size()
+ sage: n = ZZ.random_element(1, n_max)
sage: J = QuaternionHermitianEJA(n)
sage: J.dimension() == 2*(n^2) - n
True
The Jordan multiplication is what we think it is::
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: J = QuaternionHermitianEJA.random_instance()
+ sage: x,y = J.random_elements(2)
sage: actual = (x*y).natural_representation()
sage: X = x.natural_representation()
sage: Y = y.natural_representation()
sage: QuaternionHermitianEJA(2, prefix='a').gens()
(a0, a1, a2, a3, a4, a5)
- Our inner product satisfies the Jordan axiom::
+ Our natural basis is normalized with respect to the natural inner
+ product unless we specify otherwise::
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)
+ sage: J = QuaternionHermitianEJA.random_instance()
+ sage: all( b.norm() == 1 for b in J.gens() )
+ True
+
+ Since our natural basis is normalized with respect to the natural
+ inner product, and since we know that this algebra is an EJA, any
+ left-multiplication operator's matrix will be symmetric because
+ natural->EJA basis representation is an isometry and within the EJA
+ the operator is self-adjoint by the Jordan axiom::
+
+ sage: set_random_seed()
+ sage: x = QuaternionHermitianEJA.random_instance().random_element()
+ sage: x.operator().matrix().is_symmetric()
True
"""
- def __init__(self, n, field=QQ, **kwargs):
- S = _quaternion_hermitian_basis(n, field)
- Qs = _multiplication_table_from_matrix_basis(S)
+ @classmethod
+ def _denormalized_basis(cls, n, field):
+ """
+ Returns a basis for the space of quaternion Hermitian n-by-n matrices.
- fdeja = super(QuaternionHermitianEJA, self)
- return fdeja.__init__(field,
- Qs,
- rank=n,
- natural_basis=S,
- **kwargs)
+ 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.
- def inner_product(self, x, y):
- # Since a+bi+cj+dk on the diagonal is represented as
+ SETUP::
+
+ sage: from mjo.eja.eja_algebra import QuaternionHermitianEJA
+
+ TESTS::
+
+ sage: set_random_seed()
+ sage: n = ZZ.random_element(1,5)
+ sage: B = QuaternionHermitianEJA._denormalized_basis(n,QQ)
+ sage: all( M.is_symmetric() for M in B )
+ True
+
+ """
+ Q = QuaternionAlgebra(QQ,-1,-1)
+ I,J,K = Q.gens()
+
+ # This is like the symmetric case, but we need to be careful:
#
- # a + bi +cj + dk = [ a b c d]
- # [ -b a -d c]
- # [ -c d a -b]
- # [ -d -c b a],
+ # * We want conjugate-symmetry, not just symmetry.
+ # * The diagonal will (as a result) be real.
#
- # we'll quadruple-count the "a" entries if we take the trace of
- # the embedding.
- return _matrix_ip(x,y)/4
+ S = []
+ for i in xrange(n):
+ for j in xrange(i+1):
+ Eij = matrix(Q, n, lambda k,l: k==i and l==j)
+ if i == j:
+ Sij = cls.real_embed(Eij)
+ S.append(Sij)
+ else:
+ # The second, third, and fourth ones have a minus
+ # because they're conjugated.
+ Sij_real = cls.real_embed(Eij + Eij.transpose())
+ S.append(Sij_real)
+ Sij_I = cls.real_embed(I*Eij - I*Eij.transpose())
+ S.append(Sij_I)
+ Sij_J = cls.real_embed(J*Eij - J*Eij.transpose())
+ S.append(Sij_J)
+ Sij_K = cls.real_embed(K*Eij - K*Eij.transpose())
+ S.append(Sij_K)
+
+ # Since we embedded these, we can drop back to the "field" that we
+ # started with instead of the quaternion algebra "Q".
+ return ( s.change_ring(field) for s in S )
-class JordanSpinEJA(FiniteDimensionalEuclideanJordanAlgebra):
+ def __init__(self, n, field=QQ, **kwargs):
+ basis = self._denormalized_basis(n,field)
+ super(QuaternionHermitianEJA,self).__init__(field, basis, n, **kwargs)
+
+
+class JordanSpinEJA(FiniteDimensionalEuclideanJordanAlgebra, KnownRankEJA):
"""
The rank-2 simple EJA consisting of real vectors ``x=(x0, x_bar)``
with the usual inner product and jordan product ``x*y =
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
-
"""
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):
+ mult_table = [[V.zero() for j in xrange(n)] for i in xrange(n)]
+ for i in xrange(n):
+ for j in xrange(n):
x = V.gen(i)
y = V.gen(j)
x0 = x[0]
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: J = JordanSpinEJA.random_instance()
+ sage: x,y = J.random_elements(2)
+ sage: X = x.natural_representation()
+ sage: Y = y.natural_representation()
+ sage: x.inner_product(y) == J.natural_inner_product(X,Y)
+ True
+
+ """
+ return x.to_vector().inner_product(y.to_vector())
+
+
+class TrivialEJA(FiniteDimensionalEuclideanJordanAlgebra, KnownRankEJA):
+ """
+ The trivial Euclidean Jordan algebra consisting of only a zero element.
+
+ SETUP::
+
+ sage: from mjo.eja.eja_algebra import TrivialEJA
+
+ EXAMPLES::
+
+ sage: J = TrivialEJA()
+ sage: J.dimension()
+ 0
+ sage: J.zero()
+ 0
+ sage: J.one()
+ 0
+ sage: 7*J.one()*12*J.one()
+ 0
+ sage: J.one().inner_product(J.one())
+ 0
+ sage: J.one().norm()
+ 0
+ sage: J.one().subalgebra_generated_by()
+ Euclidean Jordan algebra of dimension 0 over Rational Field
+ sage: J.rank()
+ 0
+
+ """
+ def __init__(self, field=QQ, **kwargs):
+ mult_table = []
+ fdeja = super(TrivialEJA, self)
+ # The rank is zero using my definition, namely the dimension of the
+ # largest subalgebra generated by any element.
+ return fdeja.__init__(field, mult_table, rank=0, **kwargs)