X-Git-Url: http://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=mjo%2Feja%2Feja_algebra.py;h=827d40214cac92cb6e1ee46eb17f4285a44398f6;hb=a46720db62543983ab375654dee211ca844ac46c;hp=abf2aa36879abf97905bb749783c158a9aba5600;hpb=77f0119f043a9ceac891dc82229e550574a2a03f;p=sage.d.git diff --git a/mjo/eja/eja_algebra.py b/mjo/eja/eja_algebra.py index abf2aa3..827d402 100644 --- a/mjo/eja/eja_algebra.py +++ b/mjo/eja/eja_algebra.py @@ -32,22 +32,25 @@ for these simple algebras: * :class:`RealSymmetricEJA` * :class:`ComplexHermitianEJA` * :class:`QuaternionHermitianEJA` + * :class:`OctonionHermitianEJA` -Missing from this list is the algebra of three-by-three octononion -Hermitian matrices, as there is (as of yet) no implementation of the -octonions in SageMath. In addition to these, we provide two other -example constructions, +In addition to these, we provide two other example constructions, + * :class:`JordanSpinEJA` * :class:`HadamardEJA` + * :class:`AlbertEJA` * :class:`TrivialEJA` The Jordan spin algebra is a bilinear form algebra where the bilinear form is the identity. The Hadamard EJA is simply a Cartesian product -of one-dimensional spin algebras. And last but not least, the trivial -EJA is exactly what you think. Cartesian products of these are also -supported using the usual ``cartesian_product()`` function; as a -result, we support (up to isomorphism) all Euclidean Jordan algebras -that don't involve octonions. +of one-dimensional spin algebras. The Albert EJA is simply a special +case of the :class:`OctonionHermitianEJA` where the matrices are +three-by-three and the resulting space has dimension 27. And +last/least, the trivial EJA is exactly what you think it is; it could +also be obtained by constructing a dimension-zero instance of any of +the other algebras. Cartesian products of these are also supported +using the usual ``cartesian_product()`` function; as a result, we +support (up to isomorphism) all Euclidean Jordan algebras. SETUP:: @@ -59,8 +62,6 @@ EXAMPLES:: Euclidean Jordan algebra of dimension... """ -from itertools import repeat - from sage.algebras.quatalg.quaternion_algebra import QuaternionAlgebra from sage.categories.magmatic_algebras import MagmaticAlgebras from sage.categories.sets_cat import cartesian_product @@ -1018,7 +1019,9 @@ class FiniteDimensionalEJA(CombinatorialFreeModule): Full MatrixSpace of 4 by 4 dense matrices over Rational Field sage: J = QuaternionHermitianEJA(1,field=QQ,orthonormalize=False) sage: J.matrix_space() - Full MatrixSpace of 4 by 4 dense matrices over Rational Field + Module of 1 by 1 matrices with entries in Quaternion + Algebra (-1, -1) with base ring Rational Field over + the scalar ring Rational Field """ if self.is_trivial(): @@ -1543,7 +1546,7 @@ class FiniteDimensionalEJA(CombinatorialFreeModule): class RationalBasisEJA(FiniteDimensionalEJA): r""" - New class for algebras whose supplied basis elements have all rational entries. + Algebras whose supplied basis elements have all rational entries. SETUP:: @@ -1574,7 +1577,11 @@ class RationalBasisEJA(FiniteDimensionalEJA): if check_field: # Abuse the check_field parameter to check that the entries of # out basis (in ambient coordinates) are in the field QQ. - if not all( all(b_i in QQ for b_i in b.list()) for b in basis ): + # Use _all2list to get the vector coordinates of octonion + # entries and not the octonions themselves (which are not + # rational). + if not all( all(b_i in QQ for b_i in _all2list(b)) + for b in basis ): raise TypeError("basis not rational") super().__init__(basis, @@ -1656,7 +1663,7 @@ class RationalBasisEJA(FiniteDimensionalEJA): subs_dict = { X[i]: BX[i] for i in range(len(X)) } return tuple( a_i.subs(subs_dict) for a_i in a ) -class ConcreteEJA(RationalBasisEJA): +class ConcreteEJA(FiniteDimensionalEJA): r""" A class for the Euclidean Jordan algebras that we know by name. @@ -1791,8 +1798,7 @@ class RealEmbeddedMatrixEJA(MatrixEJA): SETUP:: - sage: from mjo.eja.eja_algebra import (ComplexHermitianEJA, - ....: QuaternionHermitianEJA) + sage: from mjo.eja.eja_algebra import ComplexHermitianEJA EXAMPLES:: @@ -1808,20 +1814,6 @@ class RealEmbeddedMatrixEJA(MatrixEJA): sage: actual == expected True - :: - - sage: set_random_seed() - sage: J = QuaternionHermitianEJA.random_instance() - sage: x,y = J.random_elements(2) - sage: Xe = x.to_matrix() - sage: Ye = y.to_matrix() - sage: X = J.real_unembed(Xe) - sage: Y = J.real_unembed(Ye) - sage: expected = (X*Y).trace().coefficient_tuple()[0] - sage: actual = J.trace_inner_product(Xe,Ye) - sage: actual == expected - True - """ # This does in fact compute the real part of the trace. # If we compute the trace of e.g. a complex matrix M, @@ -1831,7 +1823,7 @@ class RealEmbeddedMatrixEJA(MatrixEJA): # as a REAL matrix will be 2*a = 2*Re(z_1). And so forth. return (X*Y).trace()/cls.dimension_over_reals() -class RealSymmetricEJA(ConcreteEJA, MatrixEJA): +class RealSymmetricEJA(RationalBasisEJA, ConcreteEJA, MatrixEJA): """ The rank-n simple EJA consisting of real symmetric n-by-n matrices, the usual symmetric Jordan product, and the trace inner @@ -2113,7 +2105,7 @@ class ComplexMatrixEJA(RealEmbeddedMatrixEJA): return matrix(F, n/d, elements) -class ComplexHermitianEJA(ConcreteEJA, ComplexMatrixEJA): +class ComplexHermitianEJA(RationalBasisEJA, ConcreteEJA, ComplexMatrixEJA): """ The rank-n simple EJA consisting of complex Hermitian n-by-n matrices over the real numbers, the usual symmetric Jordan product, @@ -2267,155 +2259,8 @@ class ComplexHermitianEJA(ConcreteEJA, ComplexMatrixEJA): n = ZZ.random_element(cls._max_random_instance_size() + 1) return cls(n, **kwargs) -class QuaternionMatrixEJA(RealEmbeddedMatrixEJA): - - # A manual dictionary-cache for the quaternion_extension() method, - # since apparently @classmethods can't also be @cached_methods. - _quaternion_extension = {} - - @classmethod - def quaternion_extension(cls,field): - r""" - The quaternion field that we embed/unembed, as an extension - of the given ``field``. - """ - if field in cls._quaternion_extension: - return cls._quaternion_extension[field] - - Q = QuaternionAlgebra(field,-1,-1) - - cls._quaternion_extension[field] = Q - return Q - - @staticmethod - def dimension_over_reals(): - return 4 - - @classmethod - def real_embed(cls,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:: - - sage: from mjo.eja.eja_algebra import QuaternionMatrixEJA - 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: QuaternionMatrixEJA.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 = ZZ.random_element(2) - sage: Q = QuaternionAlgebra(QQ,-1,-1) - sage: X = random_matrix(Q, n) - sage: Y = random_matrix(Q, n) - sage: Xe = QuaternionMatrixEJA.real_embed(X) - sage: Ye = QuaternionMatrixEJA.real_embed(Y) - sage: XYe = QuaternionMatrixEJA.real_embed(X*Y) - sage: Xe*Ye == XYe - True - - """ - super().real_embed(M) - quaternions = M.base_ring() - n = M.nrows() - - 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 = ComplexMatrixEJA.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) - - - - @classmethod - def real_unembed(cls,M): - """ - The inverse of _embed_quaternion_matrix(). - - SETUP:: - - sage: from mjo.eja.eja_algebra import QuaternionMatrixEJA - - EXAMPLES:: - - sage: M = matrix(QQ, [[ 1, 2, 3, 4], - ....: [-2, 1, -4, 3], - ....: [-3, 4, 1, -2], - ....: [-4, -3, 2, 1]]) - sage: QuaternionMatrixEJA.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 = QuaternionMatrixEJA.real_embed(M) - sage: QuaternionMatrixEJA.real_unembed(Me) == M - True - - """ - super().real_unembed(M) - n = ZZ(M.nrows()) - d = cls.dimension_over_reals() - - # Use the base ring of the matrix to ensure that its entries can be - # multiplied by elements of the quaternion algebra. - Q = cls.quaternion_extension(M.base_ring()) - 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 range(n/d): - for m in range(n/d): - submat = ComplexMatrixEJA.real_unembed( - M[d*l:d*l+d,d*m:d*m+d] ) - 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() - z += submat[0,0].imag()*i - z += submat[0,1].real()*j - z += submat[0,1].imag()*k - elements.append(z) - - return matrix(Q, n/d, elements) - - -class QuaternionHermitianEJA(ConcreteEJA, QuaternionMatrixEJA): +class QuaternionHermitianEJA(RationalBasisEJA, ConcreteEJA, MatrixEJA): r""" The rank-n simple EJA consisting of self-adjoint n-by-n quaternion matrices, the usual symmetric Jordan product, and the @@ -2491,59 +2336,56 @@ class QuaternionHermitianEJA(ConcreteEJA, QuaternionMatrixEJA): sage: set_random_seed() sage: n = ZZ.random_element(1,5) - sage: B = QuaternionHermitianEJA._denormalized_basis(n,ZZ) - sage: all( M.is_symmetric() for M in B ) + sage: B = QuaternionHermitianEJA._denormalized_basis(n,QQ) + sage: all( M.is_hermitian() for M in B ) True """ - Q = QuaternionAlgebra(QQ,-1,-1) - I,J,K = Q.gens() + from mjo.hurwitz import QuaternionMatrixAlgebra + A = QuaternionMatrixAlgebra(n, scalars=field) + es = A.entry_algebra_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 = [] - Eij = matrix.zero(Q,n) + basis = [] for i in range(n): for j in range(i+1): - # "build" E_ij - Eij[i,j] = 1 if i == j: - Sij = cls.real_embed(Eij) - S.append(Sij) + E_ii = A.monomial( (i,j,es[0]) ) + basis.append(E_ii) else: - # The second, third, and fourth ones have a minus - # because they're conjugated. - # Eij = Eij + Eij.transpose() - Eij[j,i] = 1 - Sij_real = cls.real_embed(Eij) - S.append(Sij_real) - # Eij = I*(Eij - Eij.transpose()) - Eij[i,j] = I - Eij[j,i] = -I - Sij_I = cls.real_embed(Eij) - S.append(Sij_I) - # Eij = J*(Eij - Eij.transpose()) - Eij[i,j] = J - Eij[j,i] = -J - Sij_J = cls.real_embed(Eij) - S.append(Sij_J) - # Eij = K*(Eij - Eij.transpose()) - Eij[i,j] = K - Eij[j,i] = -K - Sij_K = cls.real_embed(Eij) - S.append(Sij_K) - Eij[j,i] = 0 - # "erase" E_ij - Eij[i,j] = 0 + for e in es: + E_ij = A.monomial( (i,j,e) ) + ec = e.conjugate() + # If the conjugate has a negative sign in front + # of it, (j,i,ec) won't be a monomial! + if (j,i,ec) in A.indices(): + E_ij += A.monomial( (j,i,ec) ) + else: + E_ij -= A.monomial( (j,i,-ec) ) + basis.append(E_ij) - # Since we embedded the entries, we can drop back to the - # desired real "field" instead of the quaternion algebra "Q". - return tuple( s.change_ring(field) for s in S ) + return tuple( basis ) + @staticmethod + def trace_inner_product(X,Y): + r""" + Overload the superclass method because the quaternions are weird + and we need to use ``coefficient_tuple()`` to get the realpart. + + SETUP:: + + sage: from mjo.eja.eja_algebra import QuaternionHermitianEJA + + TESTS:: + + sage: J = QuaternionHermitianEJA(2,field=QQ,orthonormalize=False) + sage: I = J.one().to_matrix() + sage: J.trace_inner_product(I, -I) + -2 + + """ + return (X*Y).trace().coefficient_tuple()[0] + def __init__(self, n, field=AA, **kwargs): # We know this is a valid EJA, but will double-check # if the user passes check_axioms=True. @@ -2564,7 +2406,7 @@ class QuaternionHermitianEJA(ConcreteEJA, QuaternionMatrixEJA): # because the MatrixEJA is not presently a subclass of the # FDEJA class that defines rank() and one(). self.rank.set_cache(n) - idV = matrix.identity(ZZ, self.dimension_over_reals()*n) + idV = self.matrix_space().one() self.one.set_cache(self(idV)) @@ -2583,7 +2425,7 @@ class QuaternionHermitianEJA(ConcreteEJA, QuaternionMatrixEJA): n = ZZ.random_element(cls._max_random_instance_size() + 1) return cls(n, **kwargs) -class OctonionHermitianEJA(FiniteDimensionalEJA, MatrixEJA): +class OctonionHermitianEJA(RationalBasisEJA, ConcreteEJA, MatrixEJA): r""" SETUP:: @@ -2666,7 +2508,23 @@ class OctonionHermitianEJA(FiniteDimensionalEJA, MatrixEJA): sage: J.rank.clear_cache() # long time sage: J.rank() # long time 2 + """ + @staticmethod + def _max_random_instance_size(): + r""" + The maximum rank of a random QuaternionHermitianEJA. + """ + return 1 # Dimension 1 + + @classmethod + def random_instance(cls, **kwargs): + """ + Return a random instance of this type of algebra. + """ + n = ZZ.random_element(cls._max_random_instance_size() + 1) + return cls(n, **kwargs) + def __init__(self, n, field=AA, **kwargs): if n > 3: # Otherwise we don't get an EJA. @@ -2709,26 +2567,26 @@ class OctonionHermitianEJA(FiniteDimensionalEJA, MatrixEJA): 27 """ - from mjo.octonions import OctonionMatrixAlgebra - MS = OctonionMatrixAlgebra(n, scalars=field) - es = MS.entry_algebra().gens() + from mjo.hurwitz import OctonionMatrixAlgebra + A = OctonionMatrixAlgebra(n, scalars=field) + es = A.entry_algebra_gens() basis = [] for i in range(n): for j in range(i+1): if i == j: - E_ii = MS.monomial( (i,j,es[0]) ) + E_ii = A.monomial( (i,j,es[0]) ) basis.append(E_ii) else: for e in es: - E_ij = MS.monomial( (i,j,e) ) + E_ij = A.monomial( (i,j,e) ) ec = e.conjugate() # If the conjugate has a negative sign in front # of it, (j,i,ec) won't be a monomial! - if (j,i,ec) in MS.indices(): - E_ij += MS.monomial( (j,i,ec) ) + if (j,i,ec) in A.indices(): + E_ij += A.monomial( (j,i,ec) ) else: - E_ij -= MS.monomial( (j,i,-ec) ) + E_ij -= A.monomial( (j,i,-ec) ) basis.append(E_ij) return tuple( basis ) @@ -2751,16 +2609,39 @@ class OctonionHermitianEJA(FiniteDimensionalEJA, MatrixEJA): -2 """ - return (X*Y).trace().real().coefficient(0) + return (X*Y).trace().coefficient(0) + + +class AlbertEJA(OctonionHermitianEJA): + r""" + The Albert algebra is the algebra of three-by-three Hermitian + matrices whose entries are octonions. + + SETUP:: + + sage: from mjo.eja.eja_algebra import AlbertEJA + + EXAMPLES:: + + sage: AlbertEJA(field=QQ, orthonormalize=False) + Euclidean Jordan algebra of dimension 27 over Rational Field + sage: AlbertEJA() # long time + Euclidean Jordan algebra of dimension 27 over Algebraic Real Field -class HadamardEJA(ConcreteEJA): """ - Return the Euclidean Jordan Algebra corresponding to the set - `R^n` under the Hadamard product. + def __init__(self, *args, **kwargs): + super().__init__(3, *args, **kwargs) - Note: this is nothing more than the Cartesian product of ``n`` - copies of the spin algebra. Once Cartesian product algebras - are implemented, this can go. + +class HadamardEJA(RationalBasisEJA, ConcreteEJA): + """ + Return the Euclidean Jordan algebra on `R^n` with the Hadamard + (pointwise real-number multiplication) Jordan product and the + usual inner-product. + + This is nothing more than the Cartesian product of ``n`` copies of + the one-dimensional Jordan spin algebra, and is the most common + example of a non-simple Euclidean Jordan algebra. SETUP:: @@ -2791,7 +2672,6 @@ class HadamardEJA(ConcreteEJA): sage: HadamardEJA(3, prefix='r').gens() (r0, r1, r2) - """ def __init__(self, n, field=AA, **kwargs): if n == 0: @@ -2845,7 +2725,7 @@ class HadamardEJA(ConcreteEJA): return cls(n, **kwargs) -class BilinearFormEJA(ConcreteEJA): +class BilinearFormEJA(RationalBasisEJA, ConcreteEJA): r""" The rank-2 simple EJA consisting of real vectors ``x=(x0, x_bar)`` with the half-trace inner product and jordan product ``x*y = @@ -3093,7 +2973,7 @@ class JordanSpinEJA(BilinearFormEJA): return cls(n, **kwargs) -class TrivialEJA(ConcreteEJA): +class TrivialEJA(RationalBasisEJA, ConcreteEJA): """ The trivial Euclidean Jordan algebra consisting of only a zero element. @@ -3378,9 +3258,17 @@ class CartesianProductEJA(FiniteDimensionalEJA): Return the space that our matrix basis lives in as a Cartesian product. + We don't simply use the ``cartesian_product()`` functor here + because it acts differently on SageMath MatrixSpaces and our + custom MatrixAlgebras, which are CombinatorialFreeModules. We + always want the result to be represented (and indexed) as + an ordered tuple. + SETUP:: - sage: from mjo.eja.eja_algebra import (HadamardEJA, + sage: from mjo.eja.eja_algebra import (ComplexHermitianEJA, + ....: HadamardEJA, + ....: OctonionHermitianEJA, ....: RealSymmetricEJA) EXAMPLES:: @@ -3393,10 +3281,44 @@ class CartesianProductEJA(FiniteDimensionalEJA): matrices over Algebraic Real Field, Full MatrixSpace of 2 by 2 dense matrices over Algebraic Real Field) + :: + + sage: J1 = ComplexHermitianEJA(1) + sage: J2 = ComplexHermitianEJA(1) + sage: J = cartesian_product([J1,J2]) + sage: J.one().to_matrix()[0] + [1 0] + [0 1] + sage: J.one().to_matrix()[1] + [1 0] + [0 1] + + :: + + sage: J1 = OctonionHermitianEJA(1) + sage: J2 = OctonionHermitianEJA(1) + sage: J = cartesian_product([J1,J2]) + sage: J.one().to_matrix()[0] + +----+ + | e0 | + +----+ + sage: J.one().to_matrix()[1] + +----+ + | e0 | + +----+ + """ - from sage.categories.cartesian_product import cartesian_product - return cartesian_product( [J.matrix_space() - for J in self.cartesian_factors()] ) + scalars = self.cartesian_factor(0).base_ring() + + # This category isn't perfect, but is good enough for what we + # need to do. + cat = MagmaticAlgebras(scalars).FiniteDimensional().WithBasis() + cat = cat.Unital().CartesianProducts() + factors = tuple( J.matrix_space() for J in self.cartesian_factors() ) + + from sage.sets.cartesian_product import CartesianProduct + return CartesianProduct(factors, cat) + @cached_method def cartesian_projection(self, i): @@ -3598,7 +3520,9 @@ class RationalBasisCartesianProductEJA(CartesianProductEJA, SETUP:: - sage: from mjo.eja.eja_algebra import (JordanSpinEJA, + sage: from mjo.eja.eja_algebra import (HadamardEJA, + ....: JordanSpinEJA, + ....: OctonionHermitianEJA, ....: RealSymmetricEJA) EXAMPLES: @@ -3615,15 +3539,32 @@ class RationalBasisCartesianProductEJA(CartesianProductEJA, sage: J.rank() 5 + TESTS: + + The ``cartesian_product()`` function only uses the first factor to + decide where the result will live; thus we have to be careful to + check that all factors do indeed have a `_rational_algebra` member + before we try to access it:: + + sage: J1 = OctonionHermitianEJA(1) # no rational basis + sage: J2 = HadamardEJA(2) + sage: cartesian_product([J1,J2]) + Euclidean Jordan algebra of dimension 1 over Algebraic Real Field + (+) Euclidean Jordan algebra of dimension 2 over Algebraic Real Field + sage: cartesian_product([J2,J1]) + Euclidean Jordan algebra of dimension 2 over Algebraic Real Field + (+) Euclidean Jordan algebra of dimension 1 over Algebraic Real Field + """ def __init__(self, algebras, **kwargs): CartesianProductEJA.__init__(self, algebras, **kwargs) self._rational_algebra = None if self.vector_space().base_field() is not QQ: - self._rational_algebra = cartesian_product([ - r._rational_algebra for r in algebras - ]) + if all( hasattr(r, "_rational_algebra") for r in algebras ): + self._rational_algebra = cartesian_product([ + r._rational_algebra for r in algebras + ]) RationalBasisEJA.CartesianProduct = RationalBasisCartesianProductEJA