+ # This list is guaranteed to contain all independent powers,
+ # because it's the maximal set of powers that could possibly
+ # be independent (by a dimension argument).
+ powers = [ elt**k for k in range(V.dimension()) ]
+ power_vectors = [ p.to_vector() for p in powers ]
+ P = matrix(field, power_vectors)
+
+ if orthonormalize_basis == False:
+ # In this case, we just need to figure out which elements
+ # of the "powers" list are redundant... First compute the
+ # vector subspace spanned by the powers of the given
+ # element.
+
+ # Figure out which powers form a linearly-independent set.
+ ind_rows = P.pivot_rows()
+
+ # Pick those out of the list of all powers.
+ superalgebra_basis = tuple(map(powers.__getitem__, ind_rows))
+
+ # 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.
+ basis_vectors = map(power_vectors.__getitem__, ind_rows)
+ else:
+ # If we're going to orthonormalize the basis anyway, we
+ # might as well just do Gram-Schmidt on the whole list of
+ # powers. The redundant ones will get zero'd out. If this
+ # looks like a roundabout way to orthonormalize, it is.
+ # But converting everything from algebra elements to vectors
+ # to matrices and then back again turns out to be about
+ # as fast as reimplementing our own Gram-Schmidt that
+ # works in an EJA.
+ G,_ = P.gram_schmidt(orthonormal=True)
+ basis_vectors = [ g for g in G.rows() if not g.is_zero() ]
+ 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 )
+ 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]
+ # 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
+ # that case.
+ product_vector = V.from_vector(product.to_vector())
+ mult_table[i][j] = W.coordinate_vector(product_vector)
+