from sage.algebras.quatalg.quaternion_algebra import QuaternionAlgebra
from sage.categories.magmatic_algebras import MagmaticAlgebras
-from sage.combinat.free_module import CombinatorialFreeModule
+from sage.categories.sets_cat import cartesian_product
+from sage.combinat.free_module import (CombinatorialFreeModule,
+ CombinatorialFreeModule_CartesianProduct)
from sage.matrix.constructor import matrix
from sage.matrix.matrix_space import MatrixSpace
from sage.misc.cachefunc import cached_method
Why implement this for non-matrix algebras? Avoiding special
cases for the :class:`BilinearFormEJA` pays with simplicity in
its own right. But mainly, we would like to be able to assume
- that elements of a :class:`DirectSumEJA` can be displayed
+ that elements of a :class:`CartesianProductEJA` can be displayed
nicely, without having to have special classes for direct sums
one of whose components was a matrix algebra.
if self.is_trivial():
return MatrixSpace(self.base_ring(), 0)
else:
- return self._matrix_basis[0].matrix_space()
+ return self.matrix_basis()[0].parent()
@cached_method
r"""
The `r` polynomial coefficients of the "characteristic polynomial
of" function.
+
+ SETUP::
+
+ sage: from mjo.eja.eja_algebra import random_eja
+
+ TESTS:
+
+ The theory shows that these are all homogeneous polynomials of
+ a known degree::
+
+ sage: set_random_seed()
+ sage: J = random_eja()
+ sage: all(p.is_homogeneous() for p in J._charpoly_coefficients())
+ True
+
"""
n = self.dimension()
R = self.coordinate_polynomial_ring()
# The theory says that only the first "r" coefficients are
# nonzero, and they actually live in the original polynomial
- # ring and not the fraction field. We negate them because
- # in the actual characteristic polynomial, they get moved
- # to the other side where x^r lives.
- return -A_rref.solve_right(E*b).change_ring(R)[:r]
+ # ring and not the fraction field. We negate them because in
+ # the actual characteristic polynomial, they get moved to the
+ # other side where x^r lives. We don't bother to trim A_rref
+ # down to a square matrix and solve the resulting system,
+ # because the upper-left r-by-r portion of A_rref is
+ # guaranteed to be the identity matrix, so e.g.
+ #
+ # A_rref.solve_right(Y)
+ #
+ # would just be returning Y.
+ return (-E*b)[:r].change_ring(R)
@cached_method
def rank(self):
sage: set_random_seed() # long time
sage: J = random_eja() # long time
- sage: caches = J.rank() # long time
+ sage: cached = J.rank() # long time
sage: J.rank.clear_cache() # long time
sage: J.rank() == cached # long time
True
class ComplexMatrixEJA(MatrixEJA):
+ # A manual dictionary-cache for the complex_extension() method,
+ # since apparently @classmethods can't also be @cached_methods.
+ _complex_extension = {}
+
+ @classmethod
+ def complex_extension(cls,field):
+ r"""
+ The complex field that we embed/unembed, as an extension
+ of the given ``field``.
+ """
+ if field in cls._complex_extension:
+ return cls._complex_extension[field]
+
+ # Sage doesn't know how to adjoin the complex "i" (the root of
+ # x^2 + 1) to a field in a general way. Here, we just enumerate
+ # all of the cases that I have cared to support so far.
+ if field is AA:
+ # Sage doesn't know how to embed AA into QQbar, i.e. how
+ # to adjoin sqrt(-1) to AA.
+ F = QQbar
+ elif not field.is_exact():
+ # RDF or RR
+ F = field.complex_field()
+ else:
+ # Works for QQ and... maybe some other fields.
+ R = PolynomialRing(field, 'z')
+ z = R.gen()
+ F = field.extension(z**2 + 1, 'I', embedding=CLF(-1).sqrt())
+
+ cls._complex_extension[field] = F
+ return F
+
@staticmethod
def dimension_over_reals():
return 2
super(ComplexMatrixEJA,cls).real_unembed(M)
n = ZZ(M.nrows())
d = cls.dimension_over_reals()
-
- # If "M" was normalized, its base ring might have roots
- # adjoined and they can stick around after unembedding.
- field = M.base_ring()
- R = PolynomialRing(field, 'z')
- z = R.gen()
-
- # Sage doesn't know how to adjoin the complex "i" (the root of
- # x^2 + 1) to a field in a general way. Here, we just enumerate
- # all of the cases that I have cared to support so far.
- if field is AA:
- # Sage doesn't know how to embed AA into QQbar, i.e. how
- # to adjoin sqrt(-1) to AA.
- F = QQbar
- elif not field.is_exact():
- # RDF or RR
- F = field.complex_field()
- else:
- # Works for QQ and... maybe some other fields.
- F = field.extension(z**2 + 1, 'I', embedding=CLF(-1).sqrt())
+ F = cls.complex_extension(M.base_ring())
i = F.gen()
# Go top-left to bottom-right (reading order), converting every
return cls(n, **kwargs)
class QuaternionMatrixEJA(MatrixEJA):
+
+ # A manual dictionary-cache for the quaternion_extension() method,
+ # since apparently @classmethods can't also be @cached_methods.
+ _quaternion_extension = {}
+
+ @classmethod
+ def quaternion_extension(cls,field):
+ r"""
+ The quaternion field that we embed/unembed, as an extension
+ of the given ``field``.
+ """
+ if field in cls._quaternion_extension:
+ return cls._quaternion_extension[field]
+
+ Q = QuaternionAlgebra(field,-1,-1)
+
+ cls._quaternion_extension[field] = Q
+ return Q
+
@staticmethod
def dimension_over_reals():
return 4
# Use the base ring of the matrix to ensure that its entries can be
# multiplied by elements of the quaternion algebra.
- field = M.base_ring()
- Q = QuaternionAlgebra(field,-1,-1)
+ Q = cls.quaternion_extension(M.base_ring())
i,j,k = Q.gens()
# Go top-left to bottom-right (reading order), converting every
# inappropriate for us.
return cls(**kwargs)
-# class DirectSumEJA(ConcreteEJA):
-# r"""
-# The external (orthogonal) direct sum of two other Euclidean Jordan
-# algebras. Essentially the Cartesian product of its two factors.
-# Every Euclidean Jordan algebra decomposes into an orthogonal
-# direct sum of simple Euclidean Jordan algebras, so no generality
-# is lost by providing only this construction.
-
-# SETUP::
-
-# sage: from mjo.eja.eja_algebra import (random_eja,
-# ....: HadamardEJA,
-# ....: RealSymmetricEJA,
-# ....: DirectSumEJA)
-
-# EXAMPLES::
-
-# sage: J1 = HadamardEJA(2)
-# sage: J2 = RealSymmetricEJA(3)
-# sage: J = DirectSumEJA(J1,J2)
-# sage: J.dimension()
-# 8
-# sage: J.rank()
-# 5
-
-# TESTS:
-
-# The external direct sum construction is only valid when the two factors
-# have the same base ring; an error is raised otherwise::
-
-# sage: set_random_seed()
-# sage: J1 = random_eja(field=AA)
-# sage: J2 = random_eja(field=QQ,orthonormalize=False)
-# sage: J = DirectSumEJA(J1,J2)
-# Traceback (most recent call last):
-# ...
-# ValueError: algebras must share the same base field
-
-# """
-# def __init__(self, J1, J2, **kwargs):
-# if J1.base_ring() != J2.base_ring():
-# raise ValueError("algebras must share the same base field")
-# field = J1.base_ring()
-
-# self._factors = (J1, J2)
-# n1 = J1.dimension()
-# n2 = J2.dimension()
-# n = n1+n2
-# V = VectorSpace(field, n)
-# mult_table = [ [ V.zero() for j in range(i+1) ]
-# for i in range(n) ]
-# for i in range(n1):
-# for j in range(i+1):
-# p = (J1.monomial(i)*J1.monomial(j)).to_vector()
-# mult_table[i][j] = V(p.list() + [field.zero()]*n2)
-
-# for i in range(n2):
-# for j in range(i+1):
-# p = (J2.monomial(i)*J2.monomial(j)).to_vector()
-# mult_table[n1+i][n1+j] = V([field.zero()]*n1 + p.list())
-
-# # TODO: build the IP table here from the two constituent IP
-# # matrices (it'll be block diagonal, I think).
-# ip_table = [ [ field.zero() for j in range(i+1) ]
-# for i in range(n) ]
-# super(DirectSumEJA, self).__init__(field,
-# mult_table,
-# ip_table,
-# check_axioms=False,
-# **kwargs)
-# self.rank.set_cache(J1.rank() + J2.rank())
-
-
-# def factors(self):
-# r"""
-# Return the pair of this algebra's factors.
-# SETUP::
+class CartesianProductEJA(CombinatorialFreeModule_CartesianProduct,
+ FiniteDimensionalEJA):
+ r"""
+ The external (orthogonal) direct sum of two or more Euclidean
+ Jordan algebras. Every Euclidean Jordan algebra decomposes into an
+ orthogonal direct sum of simple Euclidean Jordan algebras which is
+ then isometric to a Cartesian product, so no generality is lost by
+ providing only this construction.
-# sage: from mjo.eja.eja_algebra import (HadamardEJA,
-# ....: JordanSpinEJA,
-# ....: DirectSumEJA)
+ SETUP::
-# EXAMPLES::
+ sage: from mjo.eja.eja_algebra import (CartesianProductEJA,
+ ....: HadamardEJA,
+ ....: JordanSpinEJA,
+ ....: RealSymmetricEJA)
-# sage: J1 = HadamardEJA(2, field=QQ)
-# sage: J2 = JordanSpinEJA(3, field=QQ)
-# sage: J = DirectSumEJA(J1,J2)
-# sage: J.factors()
-# (Euclidean Jordan algebra of dimension 2 over Rational Field,
-# Euclidean Jordan algebra of dimension 3 over Rational Field)
+ EXAMPLES:
+
+ The Jordan product is inherited from our factors and implemented by
+ our CombinatorialFreeModule Cartesian product superclass::
+
+ sage: set_random_seed()
+ sage: J1 = HadamardEJA(2)
+ sage: J2 = RealSymmetricEJA(2)
+ sage: J = cartesian_product([J1,J2])
+ sage: x,y = J.random_elements(2)
+ sage: x*y in J
+ True
+
+ The ability to retrieve the original factors is implemented by our
+ CombinatorialFreeModule Cartesian product superclass::
+
+ sage: J1 = HadamardEJA(2, field=QQ)
+ sage: J2 = JordanSpinEJA(3, field=QQ)
+ sage: J = cartesian_product([J1,J2])
+ sage: J.cartesian_factors()
+ (Euclidean Jordan algebra of dimension 2 over Rational Field,
+ Euclidean Jordan algebra of dimension 3 over Rational Field)
+
+ TESTS:
+
+ All factors must share the same base field::
+
+ sage: J1 = HadamardEJA(2, field=QQ)
+ sage: J2 = RealSymmetricEJA(2)
+ sage: CartesianProductEJA((J1,J2))
+ Traceback (most recent call last):
+ ...
+ ValueError: all factors must share the same base field
+ """
+ def __init__(self, modules, **kwargs):
+ CombinatorialFreeModule_CartesianProduct.__init__(self, modules, **kwargs)
+ field = modules[0].base_ring()
+ if not all( J.base_ring() == field for J in modules ):
+ raise ValueError("all factors must share the same base field")
+
+ M = cartesian_product( [J.matrix_space() for J in modules] )
+
+ m = len(modules)
+ W = VectorSpace(field,m)
+ self._matrix_basis = []
+ for k in range(m):
+ for a in modules[k].matrix_basis():
+ v = W.zero().list()
+ v[k] = a
+ self._matrix_basis.append(M(v))
+
+ self._matrix_basis = tuple(self._matrix_basis)
+
+ n = len(self._matrix_basis)
+ # TODO:
+ #
+ # Initialize the FDEJA class, too. Does this override the
+ # initialization that we did for the
+ # CombinatorialFreeModule_CartesianProduct class? If not, we
+ # will probably have to duplicate some of the work (i.e. one
+ # of the constructors). Since the CartesianProduct one is
+ # smaller, that makes the most sense to copy/paste if it comes
+ # down to that.
+ #
+
+ self.rank.set_cache(sum(J.rank() for J in modules))
+
+ @cached_method
+ def cartesian_projection(self, i):
+ r"""
+ SETUP::
+
+ sage: from mjo.eja.eja_algebra import (random_eja,
+ ....: HadamardEJA,
+ ....: RealSymmetricEJA)
+
+ EXAMPLES::
+
+ sage: J1 = HadamardEJA(2)
+ sage: J2 = RealSymmetricEJA(2)
+ sage: J = cartesian_product([J1,J2])
+ sage: J.cartesian_projection(0)
+ Linear operator between finite-dimensional Euclidean Jordan
+ algebras represented by the matrix:
+ [1 0 0 0 0]
+ [0 1 0 0 0]
+ Domain: Euclidean Jordan algebra of dimension 2 over Algebraic
+ Real Field (+) Euclidean Jordan algebra of dimension 3 over
+ Algebraic Real Field
+ Codomain: Euclidean Jordan algebra of dimension 2 over Algebraic
+ Real Field
+ sage: J.cartesian_projection(1)
+ Linear operator between finite-dimensional Euclidean Jordan
+ algebras represented by the matrix:
+ [0 0 1 0 0]
+ [0 0 0 1 0]
+ [0 0 0 0 1]
+ Domain: Euclidean Jordan algebra of dimension 2 over Algebraic
+ Real Field (+) Euclidean Jordan algebra of dimension 3 over
+ Algebraic Real Field
+ Codomain: Euclidean Jordan algebra of dimension 3 over Algebraic
+ Real Field
+
+ TESTS:
+
+ The answer never changes::
+
+ sage: set_random_seed()
+ sage: J1 = random_eja()
+ sage: J2 = random_eja()
+ sage: J = cartesian_product([J1,J2])
+ sage: P0 = J.cartesian_projection(0)
+ sage: P1 = J.cartesian_projection(0)
+ sage: P0 == P1
+ True
+
+ """
+ Ji = self.cartesian_factors()[i]
+ # We reimplement the CombinatorialFreeModule superclass method
+ # because if we don't, something gets messed up with the caching
+ # and the answer changes the second time you run it. See the TESTS.
+ Pi = self._module_morphism(lambda j_t: Ji.monomial(j_t[1])
+ if i == j_t[0] else Ji.zero(),
+ codomain=Ji)
+ return FiniteDimensionalEJAOperator(self,Ji,Pi.matrix())
+
+ @cached_method
+ def cartesian_embedding(self, i):
+ r"""
+ SETUP::
+
+ sage: from mjo.eja.eja_algebra import (random_eja,
+ ....: HadamardEJA,
+ ....: RealSymmetricEJA)
+
+ EXAMPLES::
+
+ sage: J1 = HadamardEJA(2)
+ sage: J2 = RealSymmetricEJA(2)
+ sage: J = cartesian_product([J1,J2])
+ sage: J
+ foo
+ sage: J.cartesian_embedding
+ bar
+ sage: J.cartesian_embedding(0)
+ Linear operator between finite-dimensional Euclidean Jordan
+ algebras represented by the matrix:
+ [1 0]
+ [0 1]
+ [0 0]
+ [0 0]
+ [0 0]
+ Domain: Euclidean Jordan algebra of dimension 2 over
+ Algebraic Real Field
+ Codomain: Euclidean Jordan algebra of dimension 2 over
+ Algebraic Real Field (+) Euclidean Jordan algebra of
+ dimension 3 over Algebraic Real Field
+ sage: J.cartesian_embedding(1)
+ Linear operator between finite-dimensional Euclidean Jordan
+ algebras represented by the matrix:
+ [0 0 0]
+ [0 0 0]
+ [1 0 0]
+ [0 1 0]
+ [0 0 1]
+ Domain: Euclidean Jordan algebra of dimension 3 over
+ Algebraic Real Field
+ Codomain: Euclidean Jordan algebra of dimension 2 over
+ Algebraic Real Field (+) Euclidean Jordan algebra of
+ dimension 3 over Algebraic Real Field
+
+ TESTS:
+
+ The answer never changes::
+
+ sage: set_random_seed()
+ sage: J1 = random_eja()
+ sage: J2 = random_eja()
+ sage: J = cartesian_product([J1,J2])
+ sage: E0 = J.cartesian_embedding(0)
+ sage: E1 = J.cartesian_embedding(0)
+ sage: E0 == E1
+ True
+
+ """
+ Ji = self.cartesian_factors()[i]
+ # We reimplement the CombinatorialFreeModule superclass method
+ # because if we don't, something gets messed up with the caching
+ # and the answer changes the second time you run it. See the TESTS.
+ Ei = Ji._module_morphism(lambda t: self.monomial((i, t)), codomain=self)
+ return FiniteDimensionalEJAOperator(Ji,self,Ei.matrix())
+
+
+FiniteDimensionalEJA.CartesianProduct = CartesianProductEJA
-# """
-# return self._factors
# def projections(self):
# r"""