Conjugating twice gets you the original element::
- sage: set_random_seed()
sage: O = Octonions()
sage: x = O.random_element()
sage: x.conjugate().conjugate() == x
This method is idempotent::
- sage: set_random_seed()
sage: O = Octonions()
sage: x = O.random_element()
sage: x.real().real() == x.real()
This method is idempotent::
- sage: set_random_seed()
sage: O = Octonions()
sage: x = O.random_element()
sage: x.imag().imag() == x.imag()
The norm is nonnegative and belongs to the base field::
- sage: set_random_seed()
sage: O = Octonions()
sage: n = O.random_element().norm()
sage: n >= 0 and n in O.base_ring()
The norm is homogeneous::
- sage: set_random_seed()
sage: O = Octonions()
sage: x = O.random_element()
sage: alpha = O.base_ring().random_element()
TESTS::
- sage: set_random_seed()
sage: O = Octonions()
sage: x = O.random_element()
sage: x.is_zero() or ( x*x.inverse() == O.one() )
This gives the correct unit element::
- sage: set_random_seed()
sage: O = Octonions()
sage: x = O.random_element()
sage: x*O.one() == x and O.one()*x == x
class HurwitzMatrixAlgebraElement(MatrixAlgebraElement):
+ def conjugate(self):
+ r"""
+ Return the entrywise conjugate of this matrix.
+
+ SETUP::
+
+ sage: from mjo.hurwitz import ComplexMatrixAlgebra
+
+ EXAMPLES::
+
+ sage: A = ComplexMatrixAlgebra(2, QQbar, ZZ)
+ sage: M = A([ [ I, 1 + 2*I],
+ ....: [ 3*I, 4*I] ])
+ sage: M.conjugate()
+ +------+----------+
+ | -I | -2*I + 1 |
+ +------+----------+
+ | -3*I | -4*I |
+ +------+----------+
+
+ ::
+
+ sage: A = ComplexMatrixAlgebra(2, QQbar, QQ)
+ sage: M = A([ [ 1, 2],
+ ....: [ 3, 4] ])
+ sage: M.conjugate() == M
+ True
+ sage: M.to_vector()
+ (1, 0, 2, 0, 3, 0, 4, 0)
+
+ """
+ d = self.monomial_coefficients()
+ A = self.parent()
+ new_terms = ( A._conjugate_term((k,v)) for (k,v) in d.items() )
+ return self.parent().sum_of_terms(new_terms)
+
+ def conjugate_transpose(self):
+ r"""
+ Return the conjugate-transpose of this matrix.
+
+ SETUP::
+
+ sage: from mjo.hurwitz import ComplexMatrixAlgebra
+
+ EXAMPLES::
+
+ sage: A = ComplexMatrixAlgebra(2, QQbar, ZZ)
+ sage: M = A([ [ I, 2*I],
+ ....: [ 3*I, 4*I] ])
+ sage: M.conjugate_transpose()
+ +------+------+
+ | -I | -3*I |
+ +------+------+
+ | -2*I | -4*I |
+ +------+------+
+ sage: M.conjugate_transpose().to_vector()
+ (0, -1, 0, -3, 0, -2, 0, -4)
+
+ """
+ d = self.monomial_coefficients()
+ A = self.parent()
+ new_terms = ( A._conjugate_term( ((k[1],k[0],k[2]), v) )
+ for (k,v) in d.items() )
+ return self.parent().sum_of_terms(new_terms)
+
def is_hermitian(self):
r"""
SETUP::
- sage: from mjo.hurwitz import HurwitzMatrixAlgebra
+ sage: from mjo.hurwitz import (ComplexMatrixAlgebra,
+ ....: HurwitzMatrixAlgebra)
EXAMPLES::
- sage: A = HurwitzMatrixAlgebra(QQbar, ZZ, 2)
+ sage: A = ComplexMatrixAlgebra(2, QQbar, ZZ)
sage: M = A([ [ 0,I],
....: [-I,0] ])
sage: M.is_hermitian()
True
+ ::
+
+ sage: A = ComplexMatrixAlgebra(2, QQbar, ZZ)
+ sage: M = A([ [ 0,0],
+ ....: [-I,0] ])
+ sage: M.is_hermitian()
+ False
+
+ ::
+
+ sage: A = HurwitzMatrixAlgebra(2, AA, QQ)
+ sage: M = A([ [1, 1],
+ ....: [1, 1] ])
+ 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()) )
+ for j in range(i+1) )
+
+
+ def is_skew_symmetric(self):
+ r"""
+ Return whether or not this matrix is skew-symmetric.
+
+ SETUP::
+
+ sage: from mjo.hurwitz import (ComplexMatrixAlgebra,
+ ....: HurwitzMatrixAlgebra)
+
+ EXAMPLES::
+
+ sage: A = ComplexMatrixAlgebra(2, QQbar, ZZ)
+ sage: M = A([ [ 0,I],
+ ....: [-I,1] ])
+ sage: M.is_skew_symmetric()
+ False
+
+ ::
+
+ sage: A = ComplexMatrixAlgebra(2, QQbar, ZZ)
+ sage: M = A([ [ 0, 1+I],
+ ....: [-1-I, 0] ])
+ sage: M.is_skew_symmetric()
+ True
+
+ ::
+
+ sage: A = HurwitzMatrixAlgebra(2, AA, QQ)
+ sage: M = A([ [1, 1],
+ ....: [1, 1] ])
+ sage: M.is_skew_symmetric()
+ False
+
+ ::
+
+ sage: A = ComplexMatrixAlgebra(2, QQbar, ZZ)
+ sage: M = A([ [2*I , 1 + I],
+ ....: [-1 + I, -2*I] ])
+ sage: M.is_skew_symmetric()
+ False
+
+ """
+ # A tiny bit faster than checking equality with the negation
+ # of the transpose.
+ return all( self[i,j] == -self[j,i]
+ for i in range(self.nrows())
+ for j in range(i+1) )
class HurwitzMatrixAlgebra(MatrixAlgebra):
"""
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)
+
+
+ @staticmethod
+ def _conjugate_term(t):
+ r"""
+ Conjugate the given ``(index, coefficient)`` term, returning
+ another such term.
+
+ Given a term ``((i,j,e), c)``, it's straightforward to
+ conjugate the entry ``e``, but if ``e``-conjugate is ``-e``,
+ then the resulting ``((i,j,-e), c)`` is not a term, since
+ ``(i,j,-e)`` is not a monomial index! So when we build a sum
+ of these conjugates we can wind up with a nonsense object.
+
+ This function handles the case where ``e``-conjugate is
+ ``-e``, but nothing more complicated. Thus it makes sense in
+ Hurwitz matrix algebras, but not more generally.
+
+ SETUP::
+
+ sage: from mjo.hurwitz import ComplexMatrixAlgebra
+
+ EXAMPLES::
+
+ sage: A = ComplexMatrixAlgebra(2, QQbar, ZZ)
+ sage: M = A([ [ I, 1 + 2*I],
+ ....: [ 3*I, 4*I] ])
+ sage: t = list(M.monomial_coefficients().items())[1]
+ sage: t
+ ((1, 0, I), 3)
+ sage: A._conjugate_term(t)
+ ((1, 0, I), -3)
+
+ """
+ if t[0][2].conjugate() == t[0][2]:
+ return t
+ else:
+ return (t[0], -t[1])
+
def entry_algebra_gens(self):
r"""
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 (+)
TESTS::
- sage: set_random_seed()
sage: A = OctonionMatrixAlgebra(ZZ.random_element(10))
sage: x = A.random_element()
sage: x*A.one() == x and A.one()*x == x
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
TESTS::
- sage: set_random_seed()
sage: A = QuaternionMatrixAlgebra(ZZ.random_element(10))
sage: x = A.random_element()
sage: x*A.one() == x and A.one()*x == x
True
"""
- def __init__(self, n, scalars=AA, **kwargs):
- # The -1,-1 gives us the "usual" definition of quaternion
- from sage.algebras.quatalg.quaternion_algebra import QuaternionAlgebra
- 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)
+
+ def _entry_algebra_element_to_vector(self, entry):
+ r"""
+
+ SETUP::
+ sage: from mjo.hurwitz import QuaternionMatrixAlgebra
+
+ EXAMPLES::
+
+ sage: A = QuaternionMatrixAlgebra(2)
+ sage: u = A.entry_algebra().one()
+ sage: A._entry_algebra_element_to_vector(u)
+ (1, 0, 0, 0)
+ sage: i,j,k = A.entry_algebra().gens()
+ sage: A._entry_algebra_element_to_vector(i)
+ (0, 1, 0, 0)
+ sage: A._entry_algebra_element_to_vector(j)
+ (0, 0, 1, 0)
+ sage: A._entry_algebra_element_to_vector(k)
+ (0, 0, 0, 1)
+
+ """
+ from sage.modules.free_module import FreeModule
+ d = len(self.entry_algebra_gens())
+ V = FreeModule(self.entry_algebra().base_ring(), d)
+ return V(entry.coefficient_tuple())
class ComplexMatrixAlgebra(HurwitzMatrixAlgebra):
r"""
sage: ComplexMatrixAlgebra(3)
Module of 3 by 3 matrices with entries in Algebraic Field
over the scalar ring Algebraic Real Field
- sage: ComplexMatrixAlgebra(3,QQ)
+
+ ::
+
+ 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 |
- +-------+----+
+ +---------+------+
+ | 1 + 1*I | 1 |
+ +---------+------+
+ | -1 | -1*I |
+ +---------+------+
::
- sage: A1 = ComplexMatrixAlgebra(1,QQ)
- sage: A2 = ComplexMatrixAlgebra(2,QQ)
+ 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
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, scalars=AA, **kwargs):
- from sage.rings.all import QQbar
- super().__init__(QQbar, scalars, n, **kwargs)
+ 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)
+
+ def _entry_algebra_element_to_vector(self, entry):
+ r"""
+
+ SETUP::
+
+ sage: from mjo.hurwitz import ComplexMatrixAlgebra
+
+ EXAMPLES::
+
+ sage: A = ComplexMatrixAlgebra(2, QQbar, QQ)
+ sage: A._entry_algebra_element_to_vector(QQbar(1))
+ (1, 0)
+ sage: A._entry_algebra_element_to_vector(QQbar(I))
+ (0, 1)
+
+ """
+ from sage.modules.free_module import FreeModule
+ d = len(self.entry_algebra_gens())
+ V = FreeModule(self.entry_algebra().base_ring(), d)
+ return V((entry.real(), entry.imag()))
projects / sage.d.git / blobdiff