X-Git-Url: http://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=mjo%2Feja%2Feja_subalgebra.py;h=6eca475b961d6951e4c3ecbe2097bc36d5b80bca;hb=8207ab8350d947b557bf6682da9e3c3ffe638523;hp=024dfbe72ee6fb0f6f7fe2c00648b79a121d13a5;hpb=372770929343f5a75e8e8231894b466b3382dd9d;p=sage.d.git diff --git a/mjo/eja/eja_subalgebra.py b/mjo/eja/eja_subalgebra.py index 024dfbe..6eca475 100644 --- a/mjo/eja/eja_subalgebra.py +++ b/mjo/eja/eja_subalgebra.py @@ -11,14 +11,14 @@ class FiniteDimensionalEuclideanJordanSubalgebraElement(FiniteDimensionalEuclide TESTS:: - The natural representation of an element in the subalgebra is - the same as its natural representation in the superalgebra:: + The matrix representation of an element in the subalgebra is + the same as its matrix 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 = y.to_matrix() + sage: expected = y.superalgebra_element().to_matrix() sage: actual == expected True @@ -56,6 +56,14 @@ class FiniteDimensionalEuclideanJordanSubalgebraElement(FiniteDimensionalEuclide f1 sage: A(x).superalgebra_element() e0 + e1 + e2 + e3 + e4 + e5 + sage: y = sum(A.gens()) + sage: y + f0 + f1 + sage: B = y.subalgebra_generated_by() + sage: B(y) + g1 + sage: B(y).superalgebra_element() + f0 + f1 TESTS: @@ -70,10 +78,23 @@ class FiniteDimensionalEuclideanJordanSubalgebraElement(FiniteDimensionalEuclide sage: y = A.random_element() sage: A(y.superalgebra_element()) == y True + sage: B = y.subalgebra_generated_by() + sage: B(y).superalgebra_element() == y + True """ - return self.parent().superalgebra().linear_combination( - zip(self.parent()._superalgebra_basis, self.to_vector()) ) + # As with the _element_constructor_() method on the + # algebra... even in a subspace of a subspace, the basis + # elements belong to the ambient space. As a result, only one + # level of coordinate_vector() is needed, regardless of how + # deeply we're nested. + W = self.parent().vector_space() + V = self.parent().superalgebra().vector_space() + + # Multiply on the left because basis_matrix() is row-wise. + ambient_coords = self.to_vector()*W.basis_matrix() + V_coords = V.coordinate_vector(ambient_coords) + return self.parent().superalgebra().from_vector(V_coords) @@ -85,7 +106,28 @@ class FiniteDimensionalEuclideanJordanSubalgebra(FiniteDimensionalEuclideanJorda SETUP:: sage: from mjo.eja.eja_algebra import (ComplexHermitianEJA, - ....: JordanSpinEJA) + ....: JordanSpinEJA, + ....: RealSymmetricEJA) + sage: from mjo.eja.eja_subalgebra import FiniteDimensionalEuclideanJordanSubalgebra + + EXAMPLES: + + The following Peirce subalgebras of the 2-by-2 real symmetric + matrices do not contain the superalgebra's identity element:: + + sage: J = RealSymmetricEJA(2) + sage: E11 = matrix(AA, [ [1,0], + ....: [0,0] ]) + sage: E22 = matrix(AA, [ [0,0], + ....: [0,1] ]) + sage: K1 = FiniteDimensionalEuclideanJordanSubalgebra(J, (J(E11),)) + sage: K1.one().to_matrix() + [1 0] + [0 0] + sage: K2 = FiniteDimensionalEuclideanJordanSubalgebra(J, (J(E22),)) + sage: K2.one().to_matrix() + [0 0] + [0 1] TESTS: @@ -109,7 +151,7 @@ class FiniteDimensionalEuclideanJordanSubalgebra(FiniteDimensionalEuclideanJorda 1 """ - def __init__(self, superalgebra, basis, rank=None, category=None): + def __init__(self, superalgebra, basis, category=None, check_axioms=True): self._superalgebra = superalgebra V = self._superalgebra.vector_space() field = self._superalgebra.base_ring() @@ -128,16 +170,20 @@ class FiniteDimensionalEuclideanJordanSubalgebra(FiniteDimensionalEuclideanJorda except ValueError: prefix = prefixen[0] - basis_vectors = [ b.to_vector() for b in basis ] - superalgebra_basis = [ self._superalgebra.from_vector(b) - for b in basis_vectors ] + # If our superalgebra is a subalgebra of something else, then + # these vectors won't have the right coordinates for + # V.span_of_basis() unless we use V.from_vector() on them. + W = V.span_of_basis( V.from_vector(b.to_vector()) for b in basis ) - W = V.span_of_basis( V.from_vector(v) for v in basis_vectors ) - n = len(superalgebra_basis) + n = len(basis) mult_table = [[W.zero() for i in range(n)] for j in range(n)] + ip_table = [ [ self._superalgebra.inner_product(basis[i],basis[j]) + 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] + product = basis[i]*basis[j] # product.to_vector() might live in a vector subspace # if our parent algebra is already a subalgebra. We # use V.from_vector() to make it "the right size" in @@ -145,21 +191,20 @@ class FiniteDimensionalEuclideanJordanSubalgebra(FiniteDimensionalEuclideanJorda product_vector = V.from_vector(product.to_vector()) mult_table[i][j] = W.coordinate_vector(product_vector) - natural_basis = tuple( b.natural_representation() - for b in superalgebra_basis ) + matrix_basis = tuple( b.to_matrix() for b in basis ) self._vector_space = W - self._superalgebra_basis = superalgebra_basis - fdeja = super(FiniteDimensionalEuclideanJordanSubalgebra, self) - return fdeja.__init__(field, - mult_table, - rank, - prefix=prefix, - category=category, - natural_basis=natural_basis) + fdeja.__init__(field, + mult_table, + ip_table, + prefix=prefix, + category=category, + matrix_basis=matrix_basis, + check_field=False, + check_axioms=check_axioms) @@ -177,7 +222,7 @@ class FiniteDimensionalEuclideanJordanSubalgebra(FiniteDimensionalEuclideanJorda EXAMPLES:: sage: J = RealSymmetricEJA(3) - sage: X = matrix(QQ, [ [0,0,1], + sage: X = matrix(AA, [ [0,0,1], ....: [0,1,0], ....: [1,0,0] ]) sage: x = J(X) @@ -194,21 +239,33 @@ class FiniteDimensionalEuclideanJordanSubalgebra(FiniteDimensionalEuclideanJorda if elt not in self.superalgebra(): raise ValueError("not an element of this subalgebra") - coords = self.vector_space().coordinate_vector(elt.to_vector()) - return self.from_vector(coords) + # The extra hackery is because foo.to_vector() might not live + # in foo.parent().vector_space()! Subspaces of subspaces still + # have user bases in the ambient space, though, so only one + # level of coordinate_vector() is needed. In other words, if V + # is itself a subspace, the basis elements for W will be of + # the same length as the basis elements for V -- namely + # whatever the dimension of the ambient (parent of V?) space is. + V = self.superalgebra().vector_space() + W = self.vector_space() + + # Multiply on the left because basis_matrix() is row-wise. + ambient_coords = elt.to_vector()*V.basis_matrix() + W_coords = W.coordinate_vector(ambient_coords) + return self.from_vector(W_coords) - def natural_basis_space(self): + def matrix_space(self): """ - Return the natural basis space of this algebra, which is identical - to that of its superalgebra. + Return the matrix space of this algebra, which is identical to + that of its superalgebra. - This is correct "by definition," and avoids a mismatch when the - subalgebra is trivial (with no natural basis to infer anything - from) and the parent is not. + This is correct "by definition," and avoids a mismatch when + the subalgebra is trivial (with no matrix basis elements to + infer anything from) and the parent is not. """ - return self.superalgebra().natural_basis_space() + return self.superalgebra().matrix_space() def superalgebra(self): @@ -228,10 +285,10 @@ class FiniteDimensionalEuclideanJordanSubalgebra(FiniteDimensionalEuclideanJorda EXAMPLES:: sage: J = RealSymmetricEJA(3) - sage: E11 = matrix(QQ, [ [1,0,0], + sage: E11 = matrix(ZZ, [ [1,0,0], ....: [0,0,0], ....: [0,0,0] ]) - sage: E22 = matrix(QQ, [ [0,0,0], + sage: E22 = matrix(ZZ, [ [0,0,0], ....: [0,1,0], ....: [0,0,0] ]) sage: b1 = J(E11)