X-Git-Url: http://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=mjo%2Fhurwitz.py;h=07eace64fd9e9a92e93a937d3ee9a4352089442b;hb=HEAD;hp=75e856862f735251775506d237aa8b3e1b726a67;hpb=917a76ab0ae48ddd52e7d24de6f51ca8f91aa3c1;p=sage.d.git diff --git a/mjo/hurwitz.py b/mjo/hurwitz.py index 75e8568..07eace6 100644 --- a/mjo/hurwitz.py +++ b/mjo/hurwitz.py @@ -23,7 +23,6 @@ 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 @@ -58,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() @@ -91,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() @@ -121,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() @@ -129,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() @@ -167,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() ) @@ -241,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 @@ -306,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): @@ -344,13 +470,52 @@ 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""" @@ -382,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) """ @@ -414,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 | + +---------------------+) :: @@ -439,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 (+) @@ -449,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): @@ -482,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) @@ -501,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 @@ -512,19 +747,47 @@ 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 - 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""" @@ -545,26 +808,47 @@ class ComplexMatrixAlgebra(HurwitzMatrixAlgebra): 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 @@ -572,13 +856,35 @@ class ComplexMatrixAlgebra(HurwitzMatrixAlgebra): 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()))