-"""
+r"""
Representations and constructions for Euclidean Jordan algebras.
A Euclidean Jordan algebra is a Jordan algebra that has some
* :class:`QuaternionHermitianEJA`
* :class:`OctonionHermitianEJA`
-In addition to these, we provide two other example constructions,
+In addition to these, we provide a few other example constructions,
* :class:`JordanSpinEJA`
* :class:`HadamardEJA`
* :class:`AlbertEJA`
* :class:`TrivialEJA`
+ * :class:`ComplexSkewSymmetricEJA`
The Jordan spin algebra is a bilinear form algebra where the bilinear
form is the identity. The Hadamard EJA is simply a Cartesian product
sage: x = J.random_element()
sage: J.one()*x == x and x*J.one() == x
True
- sage: A = x.subalgebra_generated_by()
+ sage: A = x.subalgebra_generated_by(orthonormalize=False)
sage: y = A.random_element()
sage: A.one()*y == y and y*A.one() == y
True
sage: actual == expected
True
sage: x = J.random_element()
- sage: A = x.subalgebra_generated_by()
+ sage: A = x.subalgebra_generated_by(orthonormalize=False)
sage: actual = A.one().operator().matrix()
sage: expected = matrix.identity(A.base_ring(), A.dimension())
sage: actual == expected
# For a general base ring... maybe we can trust this to do the
# right thing? Unlikely, but.
V = self.vector_space()
- v = V.random_element()
-
- if self.base_ring() is AA:
- # The "random element" method of the algebraic reals is
- # stupid at the moment, and only returns integers between
- # -2 and 2, inclusive:
- #
- # https://trac.sagemath.org/ticket/30875
- #
- # Instead, we implement our own "random vector" method,
- # and then coerce that into the algebra. We use the vector
- # space degree here instead of the dimension because a
- # subalgebra could (for example) be spanned by only two
- # vectors, each with five coordinates. We need to
- # generate all five coordinates.
- if thorough:
- v *= QQbar.random_element().real()
- else:
- v *= QQ.random_element()
+ if self.base_ring() is AA and not thorough:
+ # Now that AA generates actually random random elements
+ # (post Trac 30875), we only need to de-thorough the
+ # randomness when asked to.
+ V = V.change_ring(QQ)
+ v = V.random_element()
return self.from_vector(V.coordinate_vector(v))
def random_elements(self, count, thorough=False):
# Bypass the hijinks if they won't benefit us.
return super()._charpoly_coefficients()
- # Do the computation over the rationals. The answer will be
- # the same, because all we've done is a change of basis.
- # Then, change back from QQ to our real base ring
+ # Do the computation over the rationals.
a = ( a_i.change_ring(self.base_ring())
for a_i in self.rational_algebra()._charpoly_coefficients() )
- # Otherwise, convert the coordinate variables back to the
- # deorthonormalized ones.
+ # Convert our coordinate variables into deorthonormalized ones
+ # and substitute them into the deorthonormalized charpoly
+ # coefficients.
R = self.coordinate_polynomial_ring()
from sage.modules.free_module_element import vector
X = vector(R, R.gens())
...
TypeError: Illegal initializer for algebraic number
- This causes the following error when we try to scale a matrix of
- complex numbers by an inexact real number::
-
- sage: ComplexHermitianEJA(2,field=RR)
- Traceback (most recent call last):
- ...
- TypeError: Unable to coerce entries (=(1.00000000000000,
- -0.000000000000000)) to coefficients in Algebraic Real Field
-
TESTS:
The dimension of this algebra is `n^2`::
@staticmethod
def _max_random_instance_size(max_dimension):
r"""
- The maximum rank of a random QuaternionHermitianEJA.
+ The maximum rank of a random OctonionHermitianEJA.
"""
# There's certainly a formula for this, but with only four
# cases to worry about, I'm not that motivated to derive it.
# if the sub-call also Decides on a cartesian product.
J2 = random_eja(new_max_dimension, *args, **kwargs)
return cartesian_product([J1,J2])
+
+
+class ComplexSkewSymmetricEJA(RationalBasisEJA, ConcreteEJA):
+ r"""
+ The skew-symmetric EJA of order `2n` described in Faraut and
+ Koranyi's Exercise III.1.b. It has dimension `2n^2 - n`.
+
+ It is (not obviously) isomorphic to the QuaternionHermitianEJA of
+ order `n`, as can be inferred by comparing rank/dimension or
+ explicitly from their "characteristic polynomial of" functions,
+ which just so happen to align nicely.
+
+ SETUP::
+
+ sage: from mjo.eja.eja_algebra import (ComplexSkewSymmetricEJA,
+ ....: QuaternionHermitianEJA)
+ sage: from mjo.eja.eja_operator import FiniteDimensionalEJAOperator
+
+ EXAMPLES:
+
+ This EJA is isomorphic to the quaternions::
+
+ sage: J = ComplexSkewSymmetricEJA(2, field=QQ, orthonormalize=False)
+ sage: K = QuaternionHermitianEJA(2, field=QQ, orthonormalize=False)
+ sage: jordan_isom_matrix = matrix.diagonal(QQ,[-1,1,1,1,1,-1])
+ sage: phi = FiniteDimensionalEJAOperator(J,K,jordan_isom_matrix)
+ sage: all( phi(x*y) == phi(x)*phi(y)
+ ....: for x in J.gens()
+ ....: for y in J.gens() )
+ True
+ sage: x,y = J.random_elements(2)
+ sage: phi(x*y) == phi(x)*phi(y)
+ True
+
+ TESTS:
+
+ Random elements should satisfy the same conditions that the basis
+ elements do::
+
+ sage: K = ComplexSkewSymmetricEJA.random_instance(field=QQ,
+ ....: orthonormalize=False)
+ sage: x,y = K.random_elements(2)
+ sage: z = x*y
+ sage: x = x.to_matrix()
+ sage: y = y.to_matrix()
+ sage: z = z.to_matrix()
+ sage: all( e.is_skew_symmetric() for e in (x,y,z) )
+ True
+ sage: J = -K.one().to_matrix()
+ sage: all( e*J == J*e.conjugate() for e in (x,y,z) )
+ True
+
+ The power law in Faraut & Koranyi's II.7.a is satisfied.
+ We're in a subalgebra of theirs, but powers are still
+ defined the same::
+
+ sage: K = ComplexSkewSymmetricEJA.random_instance(field=QQ,
+ ....: orthonormalize=False)
+ sage: x = K.random_element()
+ sage: k = ZZ.random_element(5)
+ sage: actual = x^k
+ sage: J = -K.one().to_matrix()
+ sage: expected = K(-J*(J*x.to_matrix())^k)
+ sage: actual == expected
+ True
+
+ """
+ @staticmethod
+ def _max_random_instance_size(max_dimension):
+ # Obtained by solving d = 2n^2 - n, which comes from noticing
+ # that, in 2x2 block form, any element of this algebra has a
+ # free skew-symmetric top-left block, a Hermitian top-right
+ # block, and two bottom blocks that are determined by the top.
+ # The ZZ-int-ZZ thing is just "floor."
+ return ZZ(int(ZZ(8*max_dimension + 1).sqrt()/4 + 1/4))
+
+ @classmethod
+ def random_instance(cls, max_dimension=None, *args, **kwargs):
+ """
+ Return a random instance of this type of algebra.
+ """
+ class_max_d = cls._max_random_instance_dimension()
+ if (max_dimension is None or max_dimension > class_max_d):
+ max_dimension = class_max_d
+ max_size = cls._max_random_instance_size(max_dimension)
+ n = ZZ.random_element(max_size + 1)
+ return cls(n, **kwargs)
+
+ @staticmethod
+ def _denormalized_basis(A):
+ """
+ SETUP::
+
+ sage: from mjo.hurwitz import ComplexMatrixAlgebra
+ sage: from mjo.eja.eja_algebra import ComplexSkewSymmetricEJA
+
+ TESTS:
+
+ The basis elements are all skew-Hermitian::
+
+ sage: d_max = ComplexSkewSymmetricEJA._max_random_instance_dimension()
+ sage: n_max = ComplexSkewSymmetricEJA._max_random_instance_size(d_max)
+ sage: n = ZZ.random_element(n_max + 1)
+ sage: A = ComplexMatrixAlgebra(2*n, scalars=QQ)
+ sage: B = ComplexSkewSymmetricEJA._denormalized_basis(A)
+ sage: all( M.is_skew_symmetric() for M in B)
+ True
+
+ The basis elements ``b`` all satisfy ``b*J == J*b.conjugate()``,
+ as in the definition of the algebra::
+
+ sage: d_max = ComplexSkewSymmetricEJA._max_random_instance_dimension()
+ sage: n_max = ComplexSkewSymmetricEJA._max_random_instance_size(d_max)
+ sage: n = ZZ.random_element(n_max + 1)
+ sage: A = ComplexMatrixAlgebra(2*n, scalars=QQ)
+ sage: I_n = matrix.identity(ZZ, n)
+ sage: J = matrix.block(ZZ, 2, 2, (0, I_n, -I_n, 0), subdivide=False)
+ sage: J = A.from_list(J.rows())
+ sage: B = ComplexSkewSymmetricEJA._denormalized_basis(A)
+ sage: all( b*J == J*b.conjugate() for b in B )
+ True
+
+ """
+ es = A.entry_algebra_gens()
+ gen = lambda A,m: A.monomial(m)
+
+ basis = []
+
+ # The size of the blocks. We're going to treat these thing as
+ # 2x2 block matrices,
+ #
+ # [ x1 x2 ]
+ # [ -x2-conj x1-conj ]
+ #
+ # where x1 is skew-symmetric and x2 is Hermitian.
+ #
+ m = A.nrows()/2
+
+ # We only loop through the top half of the matrix, because the
+ # bottom can be constructed from the top.
+ for i in range(m):
+ # First do the top-left block, which is skew-symmetric.
+ # We can compute the bottom-right block in the process.
+ for j in range(i+1):
+ if i != j:
+ # Skew-symmetry implies zeros for (i == j).
+ for e in es:
+ # Top-left block's entry.
+ E_ij = gen(A, (i,j,e))
+ E_ij -= gen(A, (j,i,e))
+
+ # Bottom-right block's entry.
+ F_ij = gen(A, (i+m,j+m,e)).conjugate()
+ F_ij -= gen(A, (j+m,i+m,e)).conjugate()
+
+ basis.append(E_ij + F_ij)
+
+ # Now do the top-right block, which is Hermitian, and compute
+ # the bottom-left block along the way.
+ for j in range(m,i+m+1):
+ if (i+m) == j:
+ # Hermitian matrices have real diagonal entries.
+ # Top-right block's entry.
+ E_ii = gen(A, (i,j,es[0]))
+
+ # Bottom-left block's entry. Don't conjugate
+ # 'cause it's real.
+ E_ii -= gen(A, (i+m,j-m,es[0]))
+ basis.append(E_ii)
+ else:
+ for e in es:
+ # Top-right block's entry. BEWARE! We're not
+ # reflecting across the main diagonal as in
+ # (i,j)~(j,i). We're only reflecting across
+ # the diagonal for the top-right block.
+ E_ij = gen(A, (i,j,e))
+
+ # Shift it back to non-offset coords, transpose,
+ # conjugate, and put it back:
+ #
+ # (i,j) -> (i,j-m) -> (j-m, i) -> (j-m, i+m)
+ E_ij += gen(A, (j-m,i+m,e)).conjugate()
+
+ # Bottom-left's block's below-diagonal entry.
+ # Just shift the top-right coords down m and
+ # left m.
+ F_ij = -gen(A, (i+m,j-m,e)).conjugate()
+ F_ij += -gen(A, (j,i,e)) # double-conjugate cancels
+
+ basis.append(E_ij + F_ij)
+
+ return tuple( basis )
+
+ @staticmethod
+ @cached_method
+ def _J_matrix(matrix_space):
+ n = matrix_space.nrows() // 2
+ F = matrix_space.base_ring()
+ I_n = matrix.identity(F, n)
+ J = matrix.block(F, 2, 2, (0, I_n, -I_n, 0), subdivide=False)
+ return matrix_space.from_list(J.rows())
+
+ def J_matrix(self):
+ return ComplexSkewSymmetricEJA._J_matrix(self.matrix_space())
+
+ def __init__(self, n, field=AA, **kwargs):
+ # New code; always check the axioms.
+ #if "check_axioms" not in kwargs: kwargs["check_axioms"] = False
+
+ from mjo.hurwitz import ComplexMatrixAlgebra
+ A = ComplexMatrixAlgebra(2*n, scalars=field)
+ J = ComplexSkewSymmetricEJA._J_matrix(A)
+
+ def jordan_product(X,Y):
+ return (X*J*Y + Y*J*X)/2
+
+ def inner_product(X,Y):
+ return (X.conjugate_transpose()*Y).trace().real()
+
+ super().__init__(self._denormalized_basis(A),
+ jordan_product,
+ inner_product,
+ field=field,
+ matrix_space=A,
+ **kwargs)
+
+ # This algebra is conjectured (by me) to be isomorphic to
+ # the quaternion Hermitian EJA of size n, and the rank
+ # would follow from that.
+ #self.rank.set_cache(n)
+ self.one.set_cache( self(-J) )