X-Git-Url: http://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=mjo%2Fhurwitz.py;h=07eace64fd9e9a92e93a937d3ee9a4352089442b;hb=HEAD;hp=ff1792bd9f3dc26d8b337fe3a6ff1549ab1f68e2;hpb=e28bd3518185e3a87866c61d973876f84fdeea66;p=sage.d.git diff --git a/mjo/hurwitz.py b/mjo/hurwitz.py index ff1792b..07eace6 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 @@ -27,13 +23,14 @@ class Octonion(IndexedFreeModuleElement): Conjugating twice gets you the original element:: - sage: set_random_seed() sage: O = Octonions() sage: x = O.random_element() sage: x.conjugate().conjugate() == x 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()) @@ -60,7 +57,6 @@ class Octonion(IndexedFreeModuleElement): This method is idempotent:: - sage: set_random_seed() sage: O = Octonions() sage: x = O.random_element() sage: x.real().real() == x.real() @@ -93,7 +89,6 @@ class Octonion(IndexedFreeModuleElement): This method is idempotent:: - sage: set_random_seed() sage: O = Octonions() sage: x = O.random_element() sage: x.imag().imag() == x.imag() @@ -123,7 +118,6 @@ class Octonion(IndexedFreeModuleElement): 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() @@ -131,7 +125,6 @@ class Octonion(IndexedFreeModuleElement): The norm is homogeneous:: - sage: set_random_seed() sage: O = Octonions() sage: x = O.random_element() sage: alpha = O.base_ring().random_element() @@ -169,7 +162,6 @@ class Octonion(IndexedFreeModuleElement): TESTS:: - sage: set_random_seed() sage: O = Octonions() sage: x = O.random_element() sage: x.is_zero() or ( x*x.inverse() == O.one() ) @@ -181,50 +173,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 +193,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() @@ -286,7 +235,6 @@ class Octonions(CombinatorialFreeModule): 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 @@ -343,6 +291,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,25 +299,158 @@ class Octonions(CombinatorialFreeModule): 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): @@ -388,18 +470,57 @@ 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""" - 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 +547,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 +579,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 +645,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 (+) @@ -493,18 +655,18 @@ class OctonionMatrixAlgebra(HurwitzMatrixAlgebra): 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): @@ -526,11 +688,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 +736,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 @@ -556,14 +747,144 @@ class QuaternionMatrixAlgebra(HurwitzMatrixAlgebra): 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 - 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""" + 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] ]) + +---------+------+ + | 1 + 1*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: 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) + + 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()))