from sage.matrix.constructor import matrix from mjo.eja.eja_algebra import FiniteDimensionalEuclideanJordanAlgebra from mjo.eja.eja_element import FiniteDimensionalEuclideanJordanAlgebraElement class FiniteDimensionalEuclideanJordanElementSubalgebraElement(FiniteDimensionalEuclideanJordanAlgebraElement): """ SETUP:: sage: from mjo.eja.eja_algebra import random_eja TESTS:: The natural representation of an element in the subalgebra is the same as its natural representation in the superalgebra:: sage: set_random_seed() sage: A = random_eja().random_element().subalgebra_generated_by() sage: y = A.random_element() sage: actual = y.natural_representation() sage: expected = y.superalgebra_element().natural_representation() sage: actual == expected True """ def superalgebra_element(self): """ Return the object in our algebra's superalgebra that corresponds to myself. SETUP:: sage: from mjo.eja.eja_algebra import (RealSymmetricEJA, ....: random_eja) EXAMPLES:: sage: J = RealSymmetricEJA(3) sage: x = sum(J.gens()) sage: x e0 + e1 + e2 + e3 + e4 + e5 sage: A = x.subalgebra_generated_by() sage: A(x) f1 sage: A(x).superalgebra_element() e0 + e1 + e2 + e3 + e4 + e5 TESTS: We can convert back and forth faithfully:: sage: set_random_seed() sage: J = random_eja() sage: x = J.random_element() sage: A = x.subalgebra_generated_by() sage: A(x).superalgebra_element() == x True sage: y = A.random_element() sage: A(y.superalgebra_element()) == y True """ return self.parent().superalgebra().linear_combination( zip(self.parent()._superalgebra_basis, self.to_vector()) ) class FiniteDimensionalEuclideanJordanElementSubalgebra(FiniteDimensionalEuclideanJordanAlgebra): """ The subalgebra of an EJA generated by a single element. SETUP:: sage: from mjo.eja.eja_algebra import JordanSpinEJA TESTS: Ensure that our generator names don't conflict with the superalgebra:: sage: J = JordanSpinEJA(3) sage: J.one().subalgebra_generated_by().gens() (f0,) sage: J = JordanSpinEJA(3, prefix='f') sage: J.one().subalgebra_generated_by().gens() (g0,) sage: J = JordanSpinEJA(3, prefix='b') sage: J.one().subalgebra_generated_by().gens() (c0,) """ def __init__(self, elt): superalgebra = elt.parent() # First compute the vector subspace spanned by the powers of # the given element. V = superalgebra.vector_space() superalgebra_basis = [superalgebra.one()] basis_vectors = [superalgebra.one().to_vector()] W = V.span_of_basis(basis_vectors) for exponent in range(1, V.dimension()): new_power = elt**exponent basis_vectors.append( new_power.to_vector() ) try: W = V.span_of_basis(basis_vectors) superalgebra_basis.append( new_power ) except ValueError: # Vectors weren't independent; bail and keep the # last subspace that worked. break # Make the basis hashable for UniqueRepresentation. superalgebra_basis = tuple(superalgebra_basis) # Now figure out the entries of the right-multiplication # matrix for the successive basis elements b0, b1,... of # that subspace. field = superalgebra.base_ring() n = len(superalgebra_basis) mult_table = [[W.zero() for i in range(n)] for j in range(n)] for i in range(n): for j in range(n): product = superalgebra_basis[i]*superalgebra_basis[j] mult_table[i][j] = W.coordinate_vector(product.to_vector()) # A half-assed attempt to ensure that we don't collide with # the superalgebra's prefix (ignoring the fact that there # could be super-superelgrbas in scope). If possible, we # try to "increment" the parent algebra's prefix, although # this idea goes out the window fast because some prefixen # are off-limits. prefixen = [ 'f', 'g', 'h', 'a', 'b', 'c', 'd' ] try: prefix = prefixen[prefixen.index(superalgebra.prefix()) + 1] except ValueError: prefix = prefixen[0] # The rank is the highest possible degree of a minimal # polynomial, and is bounded above by the dimension. We know # in this case that there's an element whose minimal # polynomial has the same degree as the space's dimension # (remember how we constructed the space?), so that must be # its rank too. rank = W.dimension() category = superalgebra.category().Associative() natural_basis = tuple( b.natural_representation() for b in superalgebra_basis ) self._superalgebra = superalgebra self._vector_space = W self._superalgebra_basis = superalgebra_basis fdeja = super(FiniteDimensionalEuclideanJordanElementSubalgebra, self) return fdeja.__init__(field, mult_table, rank, prefix=prefix, category=category, natural_basis=natural_basis) def _element_constructor_(self, elt): """ Construct an element of this subalgebra from the given one. The only valid arguments are elements of the parent algebra that happen to live in this subalgebra. SETUP:: sage: from mjo.eja.eja_algebra import RealSymmetricEJA sage: from mjo.eja.eja_subalgebra import FiniteDimensionalEuclideanJordanElementSubalgebra EXAMPLES:: sage: J = RealSymmetricEJA(3) sage: x = sum( i*J.gens()[i] for i in range(6) ) sage: K = FiniteDimensionalEuclideanJordanElementSubalgebra(x) sage: [ K(x^k) for k in range(J.rank()) ] [f0, f1, f2] :: """ if elt == 0: # Just as in the superalgebra class, we need to hack # this special case to ensure that random_element() can # coerce a ring zero into the algebra. return self.zero() if elt in self.superalgebra(): coords = self.vector_space().coordinate_vector(elt.to_vector()) return self.from_vector(coords) def one_basis(self): """ Return the basis-element-index of this algebra's unit element. """ return 0 def one(self): """ Return the multiplicative identity element of this algebra. The superclass method computes the identity element, which is beyond overkill in this case: the algebra identity should be our first basis element. We implement this via :meth:`one_basis` because that method can optionally be used by other parts of the category framework. SETUP:: sage: from mjo.eja.eja_algebra import (RealCartesianProductEJA, ....: random_eja) EXAMPLES:: sage: J = RealCartesianProductEJA(5) sage: J.one() e0 + e1 + e2 + e3 + e4 sage: x = sum(J.gens()) sage: A = x.subalgebra_generated_by() sage: A.one() f0 sage: A.one().superalgebra_element() e0 + e1 + e2 + e3 + e4 TESTS: The identity element acts like the identity:: sage: set_random_seed() sage: J = random_eja().random_element().subalgebra_generated_by() sage: x = J.random_element() sage: J.one()*x == x and x*J.one() == x True The matrix of the unit element's operator is the identity:: sage: set_random_seed() sage: J = random_eja().random_element().subalgebra_generated_by() sage: actual = J.one().operator().matrix() sage: expected = matrix.identity(J.base_ring(), J.dimension()) sage: actual == expected True """ return self.monomial(self.one_basis()) def superalgebra(self): """ Return the superalgebra that this algebra was generated from. """ return self._superalgebra def vector_space(self): """ SETUP:: sage: from mjo.eja.eja_algebra import RealSymmetricEJA sage: from mjo.eja.eja_subalgebra import FiniteDimensionalEuclideanJordanElementSubalgebra EXAMPLES:: sage: J = RealSymmetricEJA(3) sage: x = sum( i*J.gens()[i] for i in range(6) ) sage: K = FiniteDimensionalEuclideanJordanElementSubalgebra(x) sage: K.vector_space() Vector space of degree 6 and dimension 3 over Rational Field User basis matrix: [ 1 0 1 0 0 1] [ 0 1 2 3 4 5] [10 14 21 19 31 50] sage: (x^0).to_vector() (1, 0, 1, 0, 0, 1) sage: (x^1).to_vector() (0, 1, 2, 3, 4, 5) sage: (x^2).to_vector() (10, 14, 21, 19, 31, 50) """ return self._vector_space Element = FiniteDimensionalEuclideanJordanElementSubalgebraElement