- 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()
+ def __init__(self, superalgebra, basis, rank=None, category=None):
+ self._superalgebra = superalgebra
+ V = self._superalgebra.vector_space()
+ field = self._superalgebra.base_ring()
+ if category is None:
+ category = self._superalgebra.category()
+
+ # 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(self._superalgebra.prefix()) + 1]
+ 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 ]
+
+ W = V.span_of_basis( V.from_vector(v) for v in basis_vectors )