X-Git-Url: http://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=mjo%2Fhurwitz.py;h=1f7c9dc3781a844d6d77a1e63168c52340bf6770;hb=fc29add6cf1d9ff4e8a240b0f8f2ca6672d4ea57;hp=ff1792bd9f3dc26d8b337fe3a6ff1549ab1f68e2;hpb=e28bd3518185e3a87866c61d973876f84fdeea66;p=sage.d.git diff --git a/mjo/hurwitz.py b/mjo/hurwitz.py index ff1792b..1f7c9dc 100644 --- a/mjo/hurwitz.py +++ b/mjo/hurwitz.py @@ -1,11 +1,7 @@ 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 @@ -34,6 +30,8 @@ class Octonion(IndexedFreeModuleElement): 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()) @@ -181,50 +179,6 @@ class Octonion(IndexedFreeModuleElement): 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""" @@ -245,6 +199,7 @@ class Octonions(CombinatorialFreeModule): prefix="e"): # Not associative, not commutative + from sage.categories.magmatic_algebras import MagmaticAlgebras category = MagmaticAlgebras(field).FiniteDimensional() category = category.WithBasis().Unital() @@ -343,6 +298,7 @@ class Octonions(CombinatorialFreeModule): 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) @@ -350,6 +306,31 @@ class Octonions(CombinatorialFreeModule): 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""" @@ -359,13 +340,15 @@ class HurwitzMatrixAlgebraElement(MatrixAlgebraElement): 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()) ) @@ -388,18 +371,18 @@ 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) 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. @@ -426,15 +409,15 @@ class HurwitzMatrixAlgebra(MatrixAlgebra): 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) """ @@ -458,16 +441,57 @@ class OctonionMatrixAlgebra(HurwitzMatrixAlgebra): 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 | + +---------------------+) :: @@ -483,8 +507,8 @@ class OctonionMatrixAlgebra(HurwitzMatrixAlgebra): :: - 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 (+) @@ -500,11 +524,12 @@ class OctonionMatrixAlgebra(HurwitzMatrixAlgebra): 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): @@ -526,11 +551,40 @@ 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) @@ -545,8 +599,8 @@ class QuaternionMatrixAlgebra(HurwitzMatrixAlgebra): :: - 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 @@ -563,7 +617,92 @@ class QuaternionMatrixAlgebra(HurwitzMatrixAlgebra): 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)