from sage.misc.cachefunc import cached_method
-from sage.algebras.quatalg.quaternion_algebra import QuaternionAlgebra
from sage.combinat.free_module import CombinatorialFreeModule
from sage.modules.with_basis.indexed_element import IndexedFreeModuleElement
-from sage.categories.magmatic_algebras import MagmaticAlgebras
-from sage.rings.all import AA, ZZ
-from sage.matrix.matrix_space import MatrixSpace
-from sage.misc.table import table
+from sage.rings.all import AA
from mjo.matrix_algebra import MatrixAlgebra, MatrixAlgebraElement
True
"""
+ from sage.rings.all import ZZ
+ from sage.matrix.matrix_space import MatrixSpace
C = MatrixSpace(ZZ,8).diagonal_matrix((1,-1,-1,-1,-1,-1,-1,-1))
return self.parent().from_vector(C*self.to_vector())
return self.conjugate()/self._norm_squared()
- def cayley_dickson(self, Q=None):
- r"""
- Return the Cayley-Dickson representation of this element in terms
- of the quaternion algebra ``Q``.
-
- The Cayley-Dickson representation is an identification of
- octionions `x` and `y` with pairs of quaternions `(a,b)` and
- `(c,d)` respectively such that:
-
- * `x + y = (a+b, c+d)`
- * `xy` = (ac - \bar{d}*b, da + b\bar{c})`
- * `\bar{x} = (a,-b)`
-
- where `\bar{x}` denotes the conjugate of `x`.
-
- SETUP::
-
- sage: from mjo.hurwitz import Octonions
-
- EXAMPLES::
-
- sage: O = Octonions()
- sage: x = sum(O.gens())
- sage: x.cayley_dickson()
- (1 + i + j + k, 1 + i + j + k)
-
- """
- if Q is None:
- Q = QuaternionAlgebra(self.base_ring(), -1, -1)
-
- i,j,k = Q.gens()
- a = (self.coefficient(0)*Q.one() +
- self.coefficient(1)*i +
- self.coefficient(2)*j +
- self.coefficient(3)*k )
- b = (self.coefficient(4)*Q.one() +
- self.coefficient(5)*i +
- self.coefficient(6)*j +
- self.coefficient(7)*k )
-
- from sage.categories.sets_cat import cartesian_product
- P = cartesian_product([Q,Q])
- return P((a,b))
-
class Octonions(CombinatorialFreeModule):
r"""
prefix="e"):
# Not associative, not commutative
+ from sage.categories.magmatic_algebras import MagmaticAlgebras
category = MagmaticAlgebras(field).FiniteDimensional()
category = category.WithBasis().Unital()
for j in range(n) ]
for i in range(n) ]
+ from sage.misc.table import table
return table(M, header_row=True, header_column=True, frame=True)
class HurwitzMatrixAlgebraElement(MatrixAlgebraElement):
+ def conjugate_transpose(self):
+ r"""
+ Return the conjugate-transpose of this matrix.
+
+ SETUP::
+
+ sage: from mjo.hurwitz import HurwitzMatrixAlgebra
+
+ EXAMPLES::
+
+ sage: A = HurwitzMatrixAlgebra(2, QQbar, ZZ)
+ sage: M = A([ [ I, 2*I],
+ ....: [ 3*I, 4*I] ])
+ +------+------+
+ | -1*I | -3*I |
+ +------+------+
+ | -2*I | -4*I |
+ +------+------+
+
+ """
+ entries = [ [ self[j,i].conjugate()
+ for j in range(self.ncols())]
+ for i in range(self.nrows()) ]
+ return self.parent()._element_constructor_(entries)
+
def is_hermitian(self):
r"""
EXAMPLES::
- sage: A = HurwitzMatrixAlgebra(QQbar, ZZ, 2)
+ sage: A = HurwitzMatrixAlgebra(2, QQbar, ZZ)
sage: M = A([ [ 0,I],
....: [-I,0] ])
sage: M.is_hermitian()
True
"""
+ # A tiny bit faster than checking equality with the conjugate
+ # transpose.
return all( self[i,j] == self[j,i].conjugate()
for i in range(self.nrows())
for j in range(self.ncols()) )
"""
Element = HurwitzMatrixAlgebraElement
- def __init__(self, entry_algebra, scalars, n, **kwargs):
+ def __init__(self, n, entry_algebra, scalars, **kwargs):
from sage.rings.all import RR
if not scalars.is_subring(RR):
# Not perfect, but it's what we're using.
raise ValueError("scalar field is not real")
- super().__init__(entry_algebra, scalars, n, **kwargs)
+ super().__init__(n, entry_algebra, scalars, **kwargs)
def entry_algebra_gens(self):
r"""
- Return the generators of (that is, a basis for) the entries of
- this matrix algebra.
+ Return a tuple of the generators of (that is, a basis for) the
+ entries of this matrix algebra.
This works around the inconsistency in the ``gens()`` methods
of the real/complex numbers, quaternions, and octonions.
sets of generators have cartinality 1,2,4, and 8 as you'd
expect::
- sage: HurwitzMatrixAlgebra(AA, AA, 2).entry_algebra_gens()
+ sage: HurwitzMatrixAlgebra(2, AA, AA).entry_algebra_gens()
(1,)
- sage: HurwitzMatrixAlgebra(QQbar, AA, 2).entry_algebra_gens()
+ sage: HurwitzMatrixAlgebra(2, QQbar, AA).entry_algebra_gens()
(1, I)
sage: Q = QuaternionAlgebra(AA,-1,-1)
- sage: HurwitzMatrixAlgebra(Q, AA, 2).entry_algebra_gens()
+ sage: HurwitzMatrixAlgebra(2, Q, AA).entry_algebra_gens()
(1, i, j, k)
sage: O = Octonions()
- sage: HurwitzMatrixAlgebra(O, AA, 2).entry_algebra_gens()
+ sage: HurwitzMatrixAlgebra(2, O, AA).entry_algebra_gens()
(e0, e1, e2, e3, e4, e5, e6, e7)
"""
SETUP::
- sage: from mjo.hurwitz import OctonionMatrixAlgebra
+ sage: from mjo.hurwitz import Octonions, OctonionMatrixAlgebra
EXAMPLES::
sage: OctonionMatrixAlgebra(3)
Module of 3 by 3 matrices with entries in Octonion algebra with base
ring Algebraic Real Field over the scalar ring Algebraic Real Field
- sage: OctonionMatrixAlgebra(3,QQ)
- Module of 3 by 3 matrices with entries in Octonion algebra with base
- ring Rational Field over the scalar ring Rational Field
+
+ ::
+
+ sage: OctonionMatrixAlgebra(3,scalars=QQ)
+ Module of 3 by 3 matrices with entries in Octonion algebra with
+ base ring Rational Field over the scalar ring Rational Field
+
+ ::
+
+ sage: O = Octonions(RR)
+ sage: A = OctonionMatrixAlgebra(1,O)
+ sage: A
+ Module of 1 by 1 matrices with entries in Octonion algebra with
+ base ring Real Field with 53 bits of precision over the scalar
+ ring Algebraic Real Field
+ sage: A.one()
+ +---------------------+
+ | 1.00000000000000*e0 |
+ +---------------------+
+ sage: A.gens()
+ (+---------------------+
+ | 1.00000000000000*e0 |
+ +---------------------+,
+ +---------------------+
+ | 1.00000000000000*e1 |
+ +---------------------+,
+ +---------------------+
+ | 1.00000000000000*e2 |
+ +---------------------+,
+ +---------------------+
+ | 1.00000000000000*e3 |
+ +---------------------+,
+ +---------------------+
+ | 1.00000000000000*e4 |
+ +---------------------+,
+ +---------------------+
+ | 1.00000000000000*e5 |
+ +---------------------+,
+ +---------------------+
+ | 1.00000000000000*e6 |
+ +---------------------+,
+ +---------------------+
+ | 1.00000000000000*e7 |
+ +---------------------+)
::
::
- sage: A1 = OctonionMatrixAlgebra(1,QQ)
- sage: A2 = OctonionMatrixAlgebra(1,QQ)
+ sage: A1 = OctonionMatrixAlgebra(1,scalars=QQ)
+ sage: A2 = OctonionMatrixAlgebra(1,scalars=QQ)
sage: cartesian_product([A1,A2])
Module of 1 by 1 matrices with entries in Octonion algebra with
base ring Rational Field over the scalar ring Rational Field (+)
True
"""
- def __init__(self, n, scalars=AA, prefix="E", **kwargs):
- super().__init__(Octonions(field=scalars),
+ def __init__(self, n, entry_algebra=None, scalars=AA, **kwargs):
+ if entry_algebra is None:
+ entry_algebra = Octonions(field=scalars)
+ super().__init__(n,
+ entry_algebra,
scalars,
- n,
- prefix=prefix,
**kwargs)
class QuaternionMatrixAlgebra(HurwitzMatrixAlgebra):
Module of 3 by 3 matrices with entries in Quaternion
Algebra (-1, -1) with base ring Algebraic Real Field
over the scalar ring Algebraic Real Field
- sage: QuaternionMatrixAlgebra(3,QQ)
+
+ ::
+
+ sage: QuaternionMatrixAlgebra(3,scalars=QQ)
Module of 3 by 3 matrices with entries in Quaternion
Algebra (-1, -1) with base ring Rational Field over
the scalar ring Rational Field
+ ::
+
+ sage: Q = QuaternionAlgebra(RDF, -1, -1)
+ sage: A = QuaternionMatrixAlgebra(1,Q)
+ sage: A
+ Module of 1 by 1 matrices with entries in Quaternion Algebra
+ (-1.0, -1.0) with base ring Real Double Field over the scalar
+ ring Algebraic Real Field
+ sage: A.one()
+ +-----+
+ | 1.0 |
+ +-----+
+ sage: A.gens()
+ (+-----+
+ | 1.0 |
+ +-----+,
+ +---+
+ | i |
+ +---+,
+ +---+
+ | j |
+ +---+,
+ +---+
+ | k |
+ +---+)
+
::
sage: A = QuaternionMatrixAlgebra(2)
::
- sage: A1 = QuaternionMatrixAlgebra(1,QQ)
- sage: A2 = QuaternionMatrixAlgebra(2,QQ)
+ sage: A1 = QuaternionMatrixAlgebra(1,scalars=QQ)
+ sage: A2 = QuaternionMatrixAlgebra(2,scalars=QQ)
sage: cartesian_product([A1,A2])
Module of 1 by 1 matrices with entries in Quaternion Algebra
(-1, -1) with base ring Rational Field over the scalar ring
True
"""
- def __init__(self, n, scalars=AA, **kwargs):
- # The -1,-1 gives us the "usual" definition of quaternion
- Q = QuaternionAlgebra(scalars,-1,-1)
- super().__init__(Q, scalars, n, **kwargs)
+ def __init__(self, n, entry_algebra=None, scalars=AA, **kwargs):
+ if entry_algebra is None:
+ # The -1,-1 gives us the "usual" definition of quaternion
+ from sage.algebras.quatalg.quaternion_algebra import (
+ QuaternionAlgebra
+ )
+ entry_algebra = QuaternionAlgebra(scalars,-1,-1)
+ super().__init__(n, entry_algebra, scalars, **kwargs)
+
+
+class ComplexMatrixAlgebra(HurwitzMatrixAlgebra):
+ r"""
+ The algebra of ``n``-by-``n`` matrices with complex entries over
+ (a subfield of) the real numbers.
+
+ These differ from the usual complex matrix spaces in SageMath
+ because the scalar field is real (and not assumed to be the same
+ as the space from which the entries are drawn). The space of
+ `1`-by-`1` complex matrices will have dimension two, for example.
+
+ SETUP::
+
+ sage: from mjo.hurwitz import ComplexMatrixAlgebra
+
+ EXAMPLES::
+
+ sage: ComplexMatrixAlgebra(3)
+ Module of 3 by 3 matrices with entries in Algebraic Field
+ over the scalar ring Algebraic Real Field
+
+ ::
+
+ sage: ComplexMatrixAlgebra(3,scalars=QQ)
+ Module of 3 by 3 matrices with entries in Algebraic Field
+ over the scalar ring Rational Field
+
+ ::
+
+ sage: A = ComplexMatrixAlgebra(1,CC)
+ sage: A
+ Module of 1 by 1 matrices with entries in Complex Field with
+ 53 bits of precision over the scalar ring Algebraic Real Field
+ sage: A.one()
+ +------------------+
+ | 1.00000000000000 |
+ +------------------+
+ sage: A.gens()
+ (+------------------+
+ | 1.00000000000000 |
+ +------------------+,
+ +--------------------+
+ | 1.00000000000000*I |
+ +--------------------+)
+
+ ::
+
+ sage: A = ComplexMatrixAlgebra(2)
+ sage: (I,) = A.entry_algebra().gens()
+ sage: A([ [1+I, 1],
+ ....: [-1, -I] ])
+ +-------+----+
+ | I + 1 | 1 |
+ +-------+----+
+ | -1 | -I |
+ +-------+----+
+
+ ::
+
+ sage: A1 = ComplexMatrixAlgebra(1,scalars=QQ)
+ sage: A2 = ComplexMatrixAlgebra(2,scalars=QQ)
+ sage: cartesian_product([A1,A2])
+ Module of 1 by 1 matrices with entries in Algebraic Field over
+ the scalar ring Rational Field (+) Module of 2 by 2 matrices with
+ entries in Algebraic Field over the scalar ring Rational Field
+
+ TESTS::
+
+ sage: set_random_seed()
+ sage: A = ComplexMatrixAlgebra(ZZ.random_element(10))
+ sage: x = A.random_element()
+ sage: x*A.one() == x and A.one()*x == x
+ True
+
+ """
+ def __init__(self, n, entry_algebra=None, scalars=AA, **kwargs):
+ if entry_algebra is None:
+ from sage.rings.all import QQbar
+ entry_algebra = QQbar
+ super().__init__(n, entry_algebra, scalars, **kwargs)
projects / sage.d.git / blobdiff