X-Git-Url: http://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=mjo%2Feja%2Feja_algebra.py;h=42b2474d6971d81c8a1fcda67b079892a3e8af25;hb=723fd0f50c7997768c3d098c707df30197b88afd;hp=3855f0ef41e0e95efcadb359d6c7b908960a13b2;hpb=13a49fd59d57cf34b026460ace004ddbd60d4b68;p=sage.d.git diff --git a/mjo/eja/eja_algebra.py b/mjo/eja/eja_algebra.py index 3855f0e..42b2474 100644 --- a/mjo/eja/eja_algebra.py +++ b/mjo/eja/eja_algebra.py @@ -9,10 +9,11 @@ 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.prandom import choice from sage.misc.table import table -from sage.modules.free_module import VectorSpace +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.polynomial.polynomial_ring_constructor import PolynomialRing @@ -207,8 +208,13 @@ class FiniteDimensionalEuclideanJordanAlgebra(CombinatorialFreeModule): determinant). """ z = self._a_regular_element() - V = self.vector_space() - V1 = V.span_of_basis( (z**k).to_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) @@ -263,7 +269,13 @@ class FiniteDimensionalEuclideanJordanAlgebra(CombinatorialFreeModule): # have multivatiate polynomial entries. names = tuple('X' + str(i) for i in range(1,n+1)) R = PolynomialRing(self.base_ring(), names) - V = self.vector_space().change_ring(R) + + # 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... @@ -404,6 +416,29 @@ class FiniteDimensionalEuclideanJordanAlgebra(CombinatorialFreeModule): return x.trace_inner_product(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 @@ -480,11 +515,23 @@ class FiniteDimensionalEuclideanJordanAlgebra(CombinatorialFreeModule): """ if self._natural_basis is None: - return tuple( b.to_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() + + @cached_method def one(self): """ @@ -546,6 +593,15 @@ class FiniteDimensionalEuclideanJordanAlgebra(CombinatorialFreeModule): 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): """ Return the rank of this EJA. @@ -659,14 +715,21 @@ class RealCartesianProductEJA(FiniteDimensionalEuclideanJordanAlgebra): sage: e2*e2 e2 + TESTS: + + We can change the generator prefix:: + + sage: RealCartesianProductEJA(3, prefix='r').gens() + (r0, r1, r2) + """ - def __init__(self, n, field=QQ): + 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) + return fdeja.__init__(field, mult_table, rank=n, **kwargs) def inner_product(self, x, y): return _usual_ip(x,y) @@ -1145,8 +1208,13 @@ class RealSymmetricEJA(FiniteDimensionalEuclideanJordanAlgebra): sage: J(expected) == x*y True + We can change the generator prefix:: + + sage: RealSymmetricEJA(3, prefix='q').gens() + (q0, q1, q2, q3, q4, q5) + """ - def __init__(self, n, field=QQ): + def __init__(self, n, field=QQ, **kwargs): S = _real_symmetric_basis(n, field=field) Qs = _multiplication_table_from_matrix_basis(S) @@ -1154,7 +1222,8 @@ class RealSymmetricEJA(FiniteDimensionalEuclideanJordanAlgebra): return fdeja.__init__(field, Qs, rank=n, - natural_basis=S) + natural_basis=S, + **kwargs) def inner_product(self, x, y): return _matrix_ip(x,y) @@ -1197,8 +1266,13 @@ class ComplexHermitianEJA(FiniteDimensionalEuclideanJordanAlgebra): sage: J(expected) == x*y True + We can change the generator prefix:: + + sage: ComplexHermitianEJA(2, prefix='z').gens() + (z0, z1, z2, z3) + """ - def __init__(self, n, field=QQ): + def __init__(self, n, field=QQ, **kwargs): S = _complex_hermitian_basis(n) Qs = _multiplication_table_from_matrix_basis(S) @@ -1206,7 +1280,8 @@ class ComplexHermitianEJA(FiniteDimensionalEuclideanJordanAlgebra): return fdeja.__init__(field, Qs, rank=n, - natural_basis=S) + natural_basis=S, + **kwargs) def inner_product(self, x, y): @@ -1257,8 +1332,13 @@ class QuaternionHermitianEJA(FiniteDimensionalEuclideanJordanAlgebra): sage: J(expected) == x*y True + We can change the generator prefix:: + + sage: QuaternionHermitianEJA(2, prefix='a').gens() + (a0, a1, a2, a3, a4, a5) + """ - def __init__(self, n, field=QQ): + def __init__(self, n, field=QQ, **kwargs): S = _quaternion_hermitian_basis(n) Qs = _multiplication_table_from_matrix_basis(S) @@ -1266,7 +1346,8 @@ class QuaternionHermitianEJA(FiniteDimensionalEuclideanJordanAlgebra): return fdeja.__init__(field, Qs, rank=n, - natural_basis=S) + natural_basis=S, + **kwargs) def inner_product(self, x, y): # Since a+bi+cj+dk on the diagonal is represented as @@ -1313,8 +1394,13 @@ class JordanSpinEJA(FiniteDimensionalEuclideanJordanAlgebra): sage: e2*e3 0 + We can change the generator prefix:: + + sage: JordanSpinEJA(2, prefix='B').gens() + (B0, B1) + """ - def __init__(self, n, field=QQ): + 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): @@ -1335,7 +1421,7 @@ class JordanSpinEJA(FiniteDimensionalEuclideanJordanAlgebra): # one-dimensional ambient space (because the rank is bounded by # the ambient dimension). fdeja = super(JordanSpinEJA, self) - return fdeja.__init__(field, mult_table, rank=min(n,2)) + return fdeja.__init__(field, mult_table, rank=min(n,2), **kwargs) def inner_product(self, x, y): return _usual_ip(x,y)