from sage.algebras.quatalg.quaternion_algebra import QuaternionAlgebra
from sage.categories.magmatic_algebras import MagmaticAlgebras
from sage.categories.sets_cat import cartesian_product
-from sage.combinat.free_module import (CombinatorialFreeModule,
- CombinatorialFreeModule_CartesianProduct)
+from sage.combinat.free_module import CombinatorialFreeModule
from sage.matrix.constructor import matrix
from sage.matrix.matrix_space import MatrixSpace
from sage.misc.cachefunc import cached_method
check_axioms=True,
prefix='e'):
- # Keep track of whether or not the matrix basis consists of
- # tuples, since we need special cases for them damned near
- # everywhere. This is INDEPENDENT of whether or not the
- # algebra is a cartesian product, since a subalgebra of a
- # cartesian product will have a basis of tuples, but will not
- # in general itself be a cartesian product algebra.
- self._matrix_basis_is_cartesian = False
n = len(basis)
- if n > 0:
- if hasattr(basis[0], 'cartesian_factors'):
- self._matrix_basis_is_cartesian = True
if check_field:
if not field.is_subring(RR):
# we've specified a real embedding.
raise ValueError("scalar field is not real")
+ from mjo.eja.eja_utils import _change_ring
# If the basis given to us wasn't over the field that it's
# supposed to be over, fix that. Or, you know, crash.
- if not cartesian_product:
- # The field for a cartesian product algebra comes from one
- # of its factors and is the same for all factors, so
- # there's no need to "reapply" it on product algebras.
- if self._matrix_basis_is_cartesian:
- # OK since if n == 0, the basis does not consist of tuples.
- P = basis[0].parent()
- basis = tuple( P(tuple(b_i.change_ring(field) for b_i in b))
- for b in basis )
- else:
- basis = tuple( b.change_ring(field) for b in basis )
-
+ basis = tuple( _change_ring(b, field) for b in basis )
if check_axioms:
# Check commutativity of the Jordan and inner-products.
# Element subalgebras can take advantage of this.
category = category.Associative()
if cartesian_product:
- category = category.CartesianProducts()
+ # Use join() here because otherwise we only get the
+ # "Cartesian product of..." and not the things themselves.
+ category = category.join([category,
+ category.CartesianProducts()])
# Call the superclass constructor so that we can use its from_vector()
# method to build our multiplication table.
sage: if n > 0:
....: i = ZZ.random_element(n)
....: j = ZZ.random_element(n)
- ....: ei = J.gens()[i]
- ....: ej = J.gens()[j]
+ ....: ei = J.monomial(i)
+ ....: ej = J.monomial(j)
....: ei_ej = J.product_on_basis(i,j)
sage: ei*ej == ei_ej
True
return ``True``, unless this algebra was constructed with
``check_axioms=False`` and passed an invalid multiplication table.
"""
- return all( (self.gens()[i]**2)*(self.gens()[i]*self.gens()[j])
+ return all( (self.monomial(i)**2)*(self.monomial(i)*self.monomial(j))
==
- (self.gens()[i])*((self.gens()[i]**2)*self.gens()[j])
+ (self.monomial(i))*((self.monomial(i)**2)*self.monomial(j))
for i in range(self.dimension())
for j in range(self.dimension()) )
for i in range(self.dimension()):
for j in range(self.dimension()):
for k in range(self.dimension()):
- x = self.gens()[i]
- y = self.gens()[j]
- z = self.gens()[k]
+ x = self.monomial(i)
+ y = self.monomial(j)
+ z = self.monomial(k)
diff = (x*y)*z - x*(y*z)
if diff.norm() > epsilon:
for i in range(self.dimension()):
for j in range(self.dimension()):
for k in range(self.dimension()):
- x = self.gens()[i]
- y = self.gens()[j]
- z = self.gens()[k]
+ x = self.monomial(i)
+ y = self.monomial(j)
+ z = self.monomial(k)
diff = (x*y).inner_product(z) - x.inner_product(y*z)
if diff.abs() > epsilon:
sage: J2 = RealSymmetricEJA(2)
sage: J = cartesian_product([J1,J2])
sage: J( (J1.matrix_basis()[1], J2.matrix_basis()[2]) )
- e(0, 1) + e(1, 2)
+ e1 + e5
TESTS:
# And to each subsequent row, prepend an entry that belongs to
# the left-side "header column."
- M += [ [self.gens()[i]] + [ self.gens()[i]*self.gens()[j]
+ M += [ [self.monomial(i)] + [ self.monomial(i)*self.monomial(j)
for j in range(n) ]
for i in range(n) ]
def L_x_i_j(i,j):
# From a result in my book, these are the entries of the
# basis representation of L_x.
- return sum( vars[k]*self.gens()[k].operator().matrix()[i,j]
+ return sum( vars[k]*self.monomial(k).operator().matrix()[i,j]
for k in range(n) )
L_x = matrix(F, n, n, L_x_i_j)
True
"""
- Xu = cls.real_unembed(X)
- Yu = cls.real_unembed(Y)
- tr = (Xu*Yu).trace()
-
- try:
- # Works in QQ, AA, RDF, et cetera.
- return tr.real()
- except AttributeError:
- # A quaternion doesn't have a real() method, but does
- # have coefficient_tuple() method that returns the
- # coefficients of 1, i, j, and k -- in that order.
- return tr.coefficient_tuple()[0]
+ # This does in fact compute the real part of the trace.
+ # If we compute the trace of e.g. a complex matrix M,
+ # then we do so by adding up its diagonal entries --
+ # call them z_1 through z_n. The real embedding of z_1
+ # will be a 2-by-2 REAL matrix [a, b; -b, a] whose trace
+ # as a REAL matrix will be 2*a = 2*Re(z_1). And so forth.
+ return (X*Y).trace()/cls.dimension_over_reals()
class RealMatrixEJA(MatrixEJA):
sage: J3 = JordanSpinEJA(1)
sage: J = cartesian_product([J1,cartesian_product([J2,J3])])
sage: J.multiplication_table()
- +--------------++---------+--------------+--------------+
- | * || e(0, 0) | e(1, (0, 0)) | e(1, (1, 0)) |
- +==============++=========+==============+==============+
- | e(0, 0) || e(0, 0) | 0 | 0 |
- +--------------++---------+--------------+--------------+
- | e(1, (0, 0)) || 0 | e(1, (0, 0)) | 0 |
- +--------------++---------+--------------+--------------+
- | e(1, (1, 0)) || 0 | 0 | e(1, (1, 0)) |
- +--------------++---------+--------------+--------------+
+ +----++----+----+----+
+ | * || e0 | e1 | e2 |
+ +====++====+====+====+
+ | e0 || e0 | 0 | 0 |
+ +----++----+----+----+
+ | e1 || 0 | e1 | 0 |
+ +----++----+----+----+
+ | e2 || 0 | 0 | e2 |
+ +----++----+----+----+
sage: HadamardEJA(3).multiplication_table()
+----++----+----+----+
| * || e0 | e1 | e2 |
# Define jordan/inner products that operate on that matrix_basis.
def jordan_product(x,y):
return MS(tuple(
- (factors[i](x[i])*factors[i](y[i])).to_matrix() for i in range(m)
+ (factors[i](x[i])*factors[i](y[i])).to_matrix()
+ for i in range(m)
))
def inner_product(x, y):
return sum(
- factors[i](x[i]).inner_product(factors[i](y[i])) for i in range(m)
+ factors[i](x[i]).inner_product(factors[i](y[i]))
+ for i in range(m)
)
# There's no need to check the field since it already came
self.rank.set_cache(sum(J.rank() for J in factors))
def cartesian_factors(self):
+ # Copy/pasted from CombinatorialFreeModule_CartesianProduct.
return self._sets
+ def cartesian_factor(self, i):
+ r"""
+ Return the ``i``th factor of this algebra.
+ """
+ return self._sets[i]
+
+ def _repr_(self):
+ # Copy/pasted from CombinatorialFreeModule_CartesianProduct.
+ from sage.categories.cartesian_product import cartesian_product
+ return cartesian_product.symbol.join("%s" % factor
+ for factor in self._sets)
+
def matrix_space(self):
r"""
Return the space that our matrix basis lives in as a Cartesian
True
"""
- Ji = self.cartesian_factors()[i]
-
- Pi = self._module_morphism(lambda j_t: Ji.monomial(j_t[1])
- if i == j_t[0] else Ji.zero(),
+ offset = sum( self.cartesian_factor(k).dimension()
+ for k in range(i) )
+ Ji = self.cartesian_factor(i)
+ Pi = self._module_morphism(lambda j: Ji.monomial(j - offset),
codomain=Ji)
return FiniteDimensionalEJAOperator(self,Ji,Pi.matrix())
True
"""
- Ji = self.cartesian_factors()[i]
- Ei = Ji._module_morphism(lambda t: self.monomial((i, t)),
+ offset = sum( self.cartesian_factor(k).dimension()
+ for k in range(i) )
+ Ji = self.cartesian_factor(i)
+ Ei = Ji._module_morphism(lambda j: self.monomial(j + offset),
codomain=self)
return FiniteDimensionalEJAOperator(Ji,self,Ei.matrix())
RationalBasisEJA.CartesianProduct = RationalBasisCartesianProductEJA
-random_eja = ConcreteEJA.random_instance
-
-# def random_eja(*args, **kwargs):
-# J1 = ConcreteEJA.random_instance(*args, **kwargs)
-
-# # This might make Cartesian products appear roughly as often as
-# # any other ConcreteEJA.
-# if ZZ.random_element(len(ConcreteEJA.__subclasses__()) + 1) == 0:
-# # Use random_eja() again so we can get more than two factors.
-# J2 = random_eja(*args, **kwargs)
-# J = cartesian_product([J1,J2])
-# return J
-# else:
-# return J1
+def random_eja(*args, **kwargs):
+ J1 = ConcreteEJA.random_instance(*args, **kwargs)
+
+ # This might make Cartesian products appear roughly as often as
+ # any other ConcreteEJA.
+ if ZZ.random_element(len(ConcreteEJA.__subclasses__()) + 1) == 0:
+ # Use random_eja() again so we can get more than two factors.
+ J2 = random_eja(*args, **kwargs)
+ J = cartesian_product([J1,J2])
+ return J
+ else:
+ return J1
projects / sage.d.git / blobdiff