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
our basis::
sage: set_random_seed()
- sage: x = random_eja(AA).random_element()
+ sage: x = random_eja(field=AA).random_element()
sage: A = x.subalgebra_generated_by(orthonormalize_basis=True)
sage: y = A.random_element()
sage: y.operator()(A.one()) == y
sage: E22 = matrix(AA, [ [0,0],
....: [0,1] ])
sage: K1 = FiniteDimensionalEuclideanJordanSubalgebra(J, (J(E11),))
- sage: K1.one().natural_representation()
+ sage: K1.one().to_matrix()
[1 0]
[0 0]
sage: K2 = FiniteDimensionalEuclideanJordanSubalgebra(J, (J(E22),))
- sage: K2.one().natural_representation()
+ sage: K2.one().to_matrix()
[0 0]
[0 1]
# 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(b.to_vector()) for b in basis),
+ check=check_axioms)
n = len(basis)
- mult_table = [[W.zero() for i in range(n)] for j in range(n)]
+ if check_axioms:
+ # The tables are square if we're verifying that they
+ # are commutative.
+ mult_table = [[W.zero() for j in range(n)] for i in range(n)]
+ ip_table = [ [ self._superalgebra.inner_product(basis[i],basis[j])
+ for j in range(n) ]
+ for i in range(n) ]
+ else:
+ mult_table = [[W.zero() for j in range(i+1)] for i in range(n)]
+ ip_table = [ [ self._superalgebra.inner_product(basis[i],basis[j])
+ for j in range(i+1) ]
+ for i in range(n) ]
+
for i in range(n):
- for j in range(n):
+ for j in range(i+1):
product = basis[i]*basis[j]
# product.to_vector() might live in a vector subspace
# if our parent algebra is already a subalgebra. We
# that case.
product_vector = V.from_vector(product.to_vector())
mult_table[i][j] = W.coordinate_vector(product_vector)
+ if check_axioms:
+ mult_table[j][i] = mult_table[i][j]
- natural_basis = tuple( b.natural_representation() for b in basis )
+ matrix_basis = tuple( b.to_matrix() for b in basis )
self._vector_space = W
fdeja = super(FiniteDimensionalEuclideanJordanSubalgebra, self)
fdeja.__init__(field,
mult_table,
+ ip_table,
prefix=prefix,
category=category,
- natural_basis=natural_basis,
+ matrix_basis=matrix_basis,
check_field=False,
check_axioms=check_axioms)
- 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):