X-Git-Url: http://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=mjo%2Feja%2Feja_algebra.py;h=580c923c37a7c00ed492272161eec70ced95c2de;hb=16dfa403c6eb709d3a5188a0f19919652b6a225d;hp=76a8ce624d526b8c3bd67de6d3b169b4b866d73b;hpb=e20375c18a22ff8dd3ed114c57d63ef8eca3a209;p=sage.d.git diff --git a/mjo/eja/eja_algebra.py b/mjo/eja/eja_algebra.py index 76a8ce6..580c923 100644 --- a/mjo/eja/eja_algebra.py +++ b/mjo/eja/eja_algebra.py @@ -6,11 +6,12 @@ what can be supported in a general Jordan Algebra. """ from sage.algebras.quatalg.quaternion_algebra import QuaternionAlgebra -from sage.categories.finite_dimensional_algebras_with_basis import FiniteDimensionalAlgebrasWithBasis +from sage.categories.magmatic_algebras import MagmaticAlgebras from sage.combinat.free_module import CombinatorialFreeModule from sage.matrix.constructor import matrix from sage.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.rings.integer_ring import ZZ from sage.rings.number_field.number_field import QuadraticField @@ -22,6 +23,14 @@ from mjo.eja.eja_element import FiniteDimensionalEuclideanJordanAlgebraElement from mjo.eja.eja_utils import _mat2vec class FiniteDimensionalEuclideanJordanAlgebra(CombinatorialFreeModule): + # This is an ugly hack needed to prevent the category framework + # from implementing a coercion from our base ring (e.g. the + # rationals) into the algebra. First of all -- such a coercion is + # nonsense to begin with. But more importantly, it tries to do so + # in the category of rings, and since our algebras aren't + # associative they generally won't be rings. + _no_generic_basering_coercion = True + def __init__(self, field, mult_table, @@ -50,7 +59,9 @@ class FiniteDimensionalEuclideanJordanAlgebra(CombinatorialFreeModule): self._natural_basis = natural_basis if category is None: - category = FiniteDimensionalAlgebrasWithBasis(field).Unital() + category = MagmaticAlgebras(field).FiniteDimensional() + category = category.WithBasis().Unital() + fda = super(FiniteDimensionalEuclideanJordanAlgebra, self) fda.__init__(field, range(len(mult_table)), @@ -117,6 +128,11 @@ class FiniteDimensionalEuclideanJordanAlgebra(CombinatorialFreeModule): True """ + if elt == 0: + # The superclass implementation of random_element() + # needs to be able to coerce "0" into the algebra. + return self.zero() + natural_basis = self.natural_basis() if elt not in natural_basis[0].matrix_space(): raise ValueError("not a naturally-represented algebra element") @@ -143,13 +159,12 @@ class FiniteDimensionalEuclideanJordanAlgebra(CombinatorialFreeModule): Ensure that it says what we think it says:: sage: JordanSpinEJA(2, field=QQ) - Euclidean Jordan algebra of degree 2 over Rational Field + Euclidean Jordan algebra of dimension 2 over Rational Field sage: JordanSpinEJA(3, field=RDF) - Euclidean Jordan algebra of degree 3 over Real Double Field + Euclidean Jordan algebra of dimension 3 over Real Double Field """ - # TODO: change this to say "dimension" and fix all the tests. - fmt = "Euclidean Jordan algebra of degree {} over {}" + fmt = "Euclidean Jordan algebra of dimension {} over {}" return fmt.format(self.dimension(), self.base_ring()) def product_on_basis(self, i, j): @@ -244,16 +259,34 @@ class FiniteDimensionalEuclideanJordanAlgebra(CombinatorialFreeModule): r = self.rank() n = self.dimension() - # Construct a new algebra over a multivariate polynomial ring... + # Turn my vector space into a module so that "vectors" can + # have multivatiate polynomial entries. names = tuple('X' + str(i) for i in range(1,n+1)) R = PolynomialRing(self.base_ring(), names) - # Hack around the fact that our multiplication table is in terms of - # algebra elements but the constructor wants it in terms of vectors. - vmt = [ tuple(map(lambda x: x.to_vector(), ls)) - for ls in self._multiplication_table ] - J = FiniteDimensionalEuclideanJordanAlgebra(R, tuple(vmt), r) - - idmat = matrix.identity(J.base_ring(), n) + V = self.vector_space().change_ring(R) + + # Now let x = (X1,X2,...,Xn) be the vector whose entries are + # indeterminates... + x = V(names) + + # And figure out the "left multiplication by x" matrix in + # that setting. + lmbx_cols = [] + monomial_matrices = [ self.monomial(i).operator().matrix() + for i in range(n) ] # don't recompute these! + for k in range(n): + ek = self.monomial(k).to_vector() + lmbx_cols.append( + sum( x[i]*(monomial_matrices[i]*ek) + for i in range(n) ) ) + Lx = matrix.column(R, lmbx_cols) + + # Now we can compute powers of x "symbolically" + x_powers = [self.one().to_vector(), x] + for d in range(2, r+1): + x_powers.append( Lx*(x_powers[-1]) ) + + idmat = matrix.identity(R, n) W = self._charpoly_basis_space() W = W.change_ring(R.fraction_field()) @@ -273,18 +306,10 @@ class FiniteDimensionalEuclideanJordanAlgebra(CombinatorialFreeModule): # We want the middle equivalent thing in our matrix, but use # the first equivalent thing instead so that we can pass in # standard coordinates. - x = J.from_vector(W(R.gens())) - - # Handle the zeroth power separately, because computing - # the unit element in J is mathematically suspect. - x0 = W.coordinate_vector(self.one().to_vector()) - l1 = [ x0.column() ] - l1 += [ W.coordinate_vector((x**k).to_vector()).column() - for k in range(1,r) ] - l2 = [idmat.column(k-1).column() for k in range(r+1, n+1)] - A_of_x = matrix.block(R, 1, n, (l1 + l2)) - xr = W.coordinate_vector((x**r).to_vector()) - return (A_of_x, x, xr, A_of_x.det()) + x_powers = [ W.coordinate_vector(xp) for xp in x_powers ] + l2 = [idmat.column(k-1) for k in range(r+1, n+1)] + A_of_x = matrix.column(R, n, (x_powers[:r] + l2)) + return (A_of_x, x, x_powers[r], A_of_x.det()) @cached_method @@ -381,32 +406,36 @@ class FiniteDimensionalEuclideanJordanAlgebra(CombinatorialFreeModule): def multiplication_table(self): """ - Return a readable matrix representation of this algebra's - multiplication table. The (i,j)th entry in the matrix contains - the product of the ith basis element with the jth. - - This is not extraordinarily useful, but it overrides a superclass - method that would otherwise just crash and complain about the - algebra being infinite. + Return a visual representation of this algebra's multiplication + table (on basis elements). - EXAMPLES:: + SETUP:: - sage: J = RealCartesianProductEJA(3) - sage: J.multiplication_table() - [e0 0 0] - [ 0 e1 0] - [ 0 0 e2] + sage: from mjo.eja.eja_algebra import JordanSpinEJA - :: + EXAMPLES:: - sage: J = JordanSpinEJA(3) + sage: J = JordanSpinEJA(4) sage: J.multiplication_table() - [e0 e1 e2] - [e1 e0 0] - [e2 0 e0] + +----++----+----+----+----+ + | * || e0 | e1 | e2 | e3 | + +====++====+====+====+====+ + | e0 || e0 | e1 | e2 | e3 | + +----++----+----+----+----+ + | e1 || e1 | e0 | 0 | 0 | + +----++----+----+----+----+ + | e2 || e2 | 0 | e0 | 0 | + +----++----+----+----+----+ + | e3 || e3 | 0 | 0 | e0 | + +----++----+----+----+----+ """ - return matrix(self._multiplication_table) + M = list(self._multiplication_table) # copy + for i in range(len(M)): + # M had better be "square" + M[i] = [self.monomial(i)] + M[i] + M = [["*"] + list(self.gens())] + M + return table(M, header_row=True, header_column=True, frame=True) def natural_basis(self): @@ -472,7 +501,7 @@ class FiniteDimensionalEuclideanJordanAlgebra(CombinatorialFreeModule): sage: J.one() e0 + e1 + e2 + e3 + e4 - TESTS:: + TESTS: The identity element acts like the identity:: @@ -630,14 +659,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.basis()[i]*(i == j) for i in range(n) ] - for j in range(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) @@ -676,7 +712,7 @@ def random_eja(): TESTS:: sage: random_eja() - Euclidean Jordan algebra of degree... + Euclidean Jordan algebra of dimension... """ @@ -821,7 +857,7 @@ def _multiplication_table_from_matrix_basis(basis): V = VectorSpace(field, dimension**2) W = V.span_of_basis( _mat2vec(s) for s in basis ) n = len(basis) - mult_table = [[W.zero() for i in range(n)] for j in range(n)] + 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 @@ -1116,8 +1152,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) @@ -1125,7 +1166,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) @@ -1168,8 +1210,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) @@ -1177,7 +1224,8 @@ class ComplexHermitianEJA(FiniteDimensionalEuclideanJordanAlgebra): return fdeja.__init__(field, Qs, rank=n, - natural_basis=S) + natural_basis=S, + **kwargs) def inner_product(self, x, y): @@ -1228,8 +1276,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) @@ -1237,7 +1290,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 @@ -1284,14 +1338,19 @@ 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 i in range(n)] for j in range(n)] + mult_table = [[V.zero() for j in range(n)] for i in range(n)] for i in range(n): for j in range(n): - x = V.basis()[i] - y = V.basis()[j] + x = V.gen(i) + y = V.gen(j) x0 = x[0] xbar = x[1:] y0 = y[0] @@ -1306,7 +1365,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)