1 from sage
.misc
.cachefunc
import cached_method
2 from sage
.combinat
.free_module
import CombinatorialFreeModule
3 from sage
.modules
.with_basis
.indexed_element
import IndexedFreeModuleElement
4 from sage
.rings
.all
import AA
6 from mjo
.matrix_algebra
import MatrixAlgebra
, MatrixAlgebraElement
8 class Octonion(IndexedFreeModuleElement
):
13 sage: from mjo.hurwitz import Octonions
18 sage: x = sum(O.gens())
20 e0 - e1 - e2 - e3 - e4 - e5 - e6 - e7
24 Conjugating twice gets you the original element::
27 sage: x = O.random_element()
28 sage: x.conjugate().conjugate() == x
32 from sage
.rings
.all
import ZZ
33 from sage
.matrix
.matrix_space
import MatrixSpace
34 C
= MatrixSpace(ZZ
,8).diagonal_matrix((1,-1,-1,-1,-1,-1,-1,-1))
35 return self
.parent().from_vector(C
*self
.to_vector())
39 Return the real part of this octonion.
41 The real part of an octonion is its projection onto the span
42 of the first generator. In other words, the "first dimension"
43 is real and the others are imaginary.
47 sage: from mjo.hurwitz import Octonions
52 sage: x = sum(O.gens())
58 This method is idempotent::
61 sage: x = O.random_element()
62 sage: x.real().real() == x.real()
66 return (self
+ self
.conjugate())/2
70 Return the imaginary part of this octonion.
72 The imaginary part of an octonion is its projection onto the
73 orthogonal complement of the span of the first generator. In
74 other words, the "first dimension" is real and the others are
79 sage: from mjo.hurwitz import Octonions
84 sage: x = sum(O.gens())
86 e1 + e2 + e3 + e4 + e5 + e6 + e7
90 This method is idempotent::
93 sage: x = O.random_element()
94 sage: x.imag().imag() == x.imag()
98 return (self
- self
.conjugate())/2
100 def _norm_squared(self
):
101 return (self
*self
.conjugate()).coefficient(0)
105 Return the norm of this octonion.
109 sage: from mjo.hurwitz import Octonions
113 sage: O = Octonions()
119 The norm is nonnegative and belongs to the base field::
121 sage: O = Octonions()
122 sage: n = O.random_element().norm()
123 sage: n >= 0 and n in O.base_ring()
126 The norm is homogeneous::
128 sage: O = Octonions()
129 sage: x = O.random_element()
130 sage: alpha = O.base_ring().random_element()
131 sage: (alpha*x).norm() == alpha.abs()*x.norm()
135 return self
._norm
_squared
().sqrt()
137 # The absolute value notation is typically used for complex numbers...
138 # and norm() isn't supported in AA, so this lets us use abs() in all
139 # of the division algebras we need.
144 Return the inverse of this element if it exists.
148 sage: from mjo.hurwitz import Octonions
152 sage: O = Octonions()
153 sage: x = sum(O.gens())
154 sage: x*x.inverse() == O.one()
159 sage: O = Octonions()
160 sage: O.one().inverse() == O.one()
165 sage: O = Octonions()
166 sage: x = O.random_element()
167 sage: x.is_zero() or ( x*x.inverse() == O.one() )
172 raise ValueError("zero is not invertible")
173 return self
.conjugate()/self
._norm
_squared
()
177 class Octonions(CombinatorialFreeModule
):
181 sage: from mjo.hurwitz import Octonions
186 Octonion algebra with base ring Algebraic Real Field
187 sage: Octonions(field=QQ)
188 Octonion algebra with base ring Rational Field
195 # Not associative, not commutative
196 from sage
.categories
.magmatic_algebras
import MagmaticAlgebras
197 category
= MagmaticAlgebras(field
).FiniteDimensional()
198 category
= category
.WithBasis().Unital()
200 super().__init
__(field
,
202 element_class
=Octonion
,
207 # The product of each basis element is plus/minus another
208 # basis element that can simply be looked up on
209 # https://en.wikipedia.org/wiki/Octonion
210 e0
, e1
, e2
, e3
, e4
, e5
, e6
, e7
= self
.gens()
211 self
._multiplication
_table
= (
212 (e0
, e1
, e2
, e3
, e4
, e5
, e6
, e7
),
213 (e1
,-e0
, e3
,-e2
, e5
,-e4
,-e7
, e6
),
214 (e2
,-e3
,-e0
, e1
, e6
, e7
,-e4
,-e5
),
215 (e3
, e2
,-e1
,-e0
, e7
,-e6
, e5
,-e4
),
216 (e4
,-e5
,-e6
,-e7
,-e0
, e1
, e2
, e3
),
217 (e5
, e4
,-e7
, e6
,-e1
,-e0
,-e3
, e2
),
218 (e6
, e7
, e4
,-e5
,-e2
, e3
,-e0
,-e1
),
219 (e7
,-e6
, e5
, e4
,-e3
,-e2
, e1
,-e0
),
222 def product_on_basis(self
, i
, j
):
223 return self
._multiplication
_table
[i
][j
]
227 Return the monomial index (basis element) corresponding to the
228 octonion unit element.
232 sage: from mjo.hurwitz import Octonions
236 This gives the correct unit element::
238 sage: O = Octonions()
239 sage: x = O.random_element()
240 sage: x*O.one() == x and O.one()*x == x
247 return ("Octonion algebra with base ring %s" % self
.base_ring())
249 def multiplication_table(self
):
251 Return a visual representation of this algebra's multiplication
252 table (on basis elements).
256 sage: from mjo.hurwitz import Octonions
260 The multiplication table is what Wikipedia says it is::
262 sage: Octonions().multiplication_table()
263 +----++----+-----+-----+-----+-----+-----+-----+-----+
264 | * || e0 | e1 | e2 | e3 | e4 | e5 | e6 | e7 |
265 +====++====+=====+=====+=====+=====+=====+=====+=====+
266 | e0 || e0 | e1 | e2 | e3 | e4 | e5 | e6 | e7 |
267 +----++----+-----+-----+-----+-----+-----+-----+-----+
268 | e1 || e1 | -e0 | e3 | -e2 | e5 | -e4 | -e7 | e6 |
269 +----++----+-----+-----+-----+-----+-----+-----+-----+
270 | e2 || e2 | -e3 | -e0 | e1 | e6 | e7 | -e4 | -e5 |
271 +----++----+-----+-----+-----+-----+-----+-----+-----+
272 | e3 || e3 | e2 | -e1 | -e0 | e7 | -e6 | e5 | -e4 |
273 +----++----+-----+-----+-----+-----+-----+-----+-----+
274 | e4 || e4 | -e5 | -e6 | -e7 | -e0 | e1 | e2 | e3 |
275 +----++----+-----+-----+-----+-----+-----+-----+-----+
276 | e5 || e5 | e4 | -e7 | e6 | -e1 | -e0 | -e3 | e2 |
277 +----++----+-----+-----+-----+-----+-----+-----+-----+
278 | e6 || e6 | e7 | e4 | -e5 | -e2 | e3 | -e0 | -e1 |
279 +----++----+-----+-----+-----+-----+-----+-----+-----+
280 | e7 || e7 | -e6 | e5 | e4 | -e3 | -e2 | e1 | -e0 |
281 +----++----+-----+-----+-----+-----+-----+-----+-----+
285 # Prepend the header row.
286 M
= [["*"] + list(self
.gens())]
288 # And to each subsequent row, prepend an entry that belongs to
289 # the left-side "header column."
290 M
+= [ [self
.monomial(i
)] + [ self
.monomial(i
)*self
.monomial(j
)
294 from sage
.misc
.table
import table
295 return table(M
, header_row
=True, header_column
=True, frame
=True)
301 class HurwitzMatrixAlgebraElement(MatrixAlgebraElement
):
304 Return the entrywise conjugate of this matrix.
308 sage: from mjo.hurwitz import ComplexMatrixAlgebra
312 sage: A = ComplexMatrixAlgebra(2, QQbar, ZZ)
313 sage: M = A([ [ I, 1 + 2*I],
324 sage: A = ComplexMatrixAlgebra(2, QQbar, QQ)
325 sage: M = A([ [ 1, 2],
327 sage: M.conjugate() == M
330 (1, 0, 2, 0, 3, 0, 4, 0)
333 d
= self
.monomial_coefficients()
335 new_terms
= ( A
._conjugate
_term
((k
,v
)) for (k
,v
) in d
.items() )
336 return self
.parent().sum_of_terms(new_terms
)
338 def conjugate_transpose(self
):
340 Return the conjugate-transpose of this matrix.
344 sage: from mjo.hurwitz import ComplexMatrixAlgebra
348 sage: A = ComplexMatrixAlgebra(2, QQbar, ZZ)
349 sage: M = A([ [ I, 2*I],
351 sage: M.conjugate_transpose()
357 sage: M.conjugate_transpose().to_vector()
358 (0, -1, 0, -3, 0, -2, 0, -4)
361 d
= self
.monomial_coefficients()
363 new_terms
= ( A
._conjugate
_term
( ((k
[1],k
[0],k
[2]), v
) )
364 for (k
,v
) in d
.items() )
365 return self
.parent().sum_of_terms(new_terms
)
367 def is_hermitian(self
):
372 sage: from mjo.hurwitz import (ComplexMatrixAlgebra,
373 ....: HurwitzMatrixAlgebra)
377 sage: A = ComplexMatrixAlgebra(2, QQbar, ZZ)
378 sage: M = A([ [ 0,I],
380 sage: M.is_hermitian()
385 sage: A = ComplexMatrixAlgebra(2, QQbar, ZZ)
386 sage: M = A([ [ 0,0],
388 sage: M.is_hermitian()
393 sage: A = HurwitzMatrixAlgebra(2, AA, QQ)
394 sage: M = A([ [1, 1],
396 sage: M.is_hermitian()
400 # A tiny bit faster than checking equality with the conjugate
402 return all( self
[i
,j
] == self
[j
,i
].conjugate()
403 for i
in range(self
.nrows())
404 for j
in range(i
+1) )
407 def is_skew_symmetric(self
):
409 Return whether or not this matrix is skew-symmetric.
413 sage: from mjo.hurwitz import (ComplexMatrixAlgebra,
414 ....: HurwitzMatrixAlgebra)
418 sage: A = ComplexMatrixAlgebra(2, QQbar, ZZ)
419 sage: M = A([ [ 0,I],
421 sage: M.is_skew_symmetric()
426 sage: A = ComplexMatrixAlgebra(2, QQbar, ZZ)
427 sage: M = A([ [ 0, 1+I],
429 sage: M.is_skew_symmetric()
434 sage: A = HurwitzMatrixAlgebra(2, AA, QQ)
435 sage: M = A([ [1, 1],
437 sage: M.is_skew_symmetric()
442 sage: A = ComplexMatrixAlgebra(2, QQbar, ZZ)
443 sage: M = A([ [2*I , 1 + I],
444 ....: [-1 + I, -2*I] ])
445 sage: M.is_skew_symmetric()
449 # A tiny bit faster than checking equality with the negation
451 return all( self
[i
,j
] == -self
[j
,i
]
452 for i
in range(self
.nrows())
453 for j
in range(i
+1) )
456 class HurwitzMatrixAlgebra(MatrixAlgebra
):
458 A class of matrix algebras whose entries come from a Hurwitz
461 For our purposes, we consider "a Hurwitz" algebra to be the real
462 or complex numbers, the quaternions, or the octonions. These are
463 typically also referred to as the Euclidean Hurwitz algebras, or
464 the normed division algebras.
466 By the Cayley-Dickson construction, each Hurwitz algebra is an
467 algebra over the real numbers, so we restrict the scalar field in
468 this case to be real. This also allows us to more accurately
469 produce the generators of the matrix algebra.
471 Element
= HurwitzMatrixAlgebraElement
473 def __init__(self
, n
, entry_algebra
, scalars
, **kwargs
):
474 from sage
.rings
.all
import RR
475 if not scalars
.is_subring(RR
):
476 # Not perfect, but it's what we're using.
477 raise ValueError("scalar field is not real")
479 super().__init
__(n
, entry_algebra
, scalars
, **kwargs
)
483 def _conjugate_term(t
):
485 Conjugate the given ``(index, coefficient)`` term, returning
488 Given a term ``((i,j,e), c)``, it's straightforward to
489 conjugate the entry ``e``, but if ``e``-conjugate is ``-e``,
490 then the resulting ``((i,j,-e), c)`` is not a term, since
491 ``(i,j,-e)`` is not a monomial index! So when we build a sum
492 of these conjugates we can wind up with a nonsense object.
494 This function handles the case where ``e``-conjugate is
495 ``-e``, but nothing more complicated. Thus it makes sense in
496 Hurwitz matrix algebras, but not more generally.
500 sage: from mjo.hurwitz import ComplexMatrixAlgebra
504 sage: A = ComplexMatrixAlgebra(2, QQbar, ZZ)
505 sage: M = A([ [ I, 1 + 2*I],
507 sage: t = list(M.monomial_coefficients().items())[1]
510 sage: A._conjugate_term(t)
514 if t
[0][2].conjugate() == t
[0][2]:
520 def entry_algebra_gens(self
):
522 Return a tuple of the generators of (that is, a basis for) the
523 entries of this matrix algebra.
525 This works around the inconsistency in the ``gens()`` methods
526 of the real/complex numbers, quaternions, and octonions.
530 sage: from mjo.hurwitz import Octonions, HurwitzMatrixAlgebra
534 The inclusion of the unit element is inconsistent across
535 (subalgebras of) Hurwitz algebras::
541 sage: QuaternionAlgebra(AA,1,-1).gens()
543 sage: Octonions().gens()
544 (e0, e1, e2, e3, e4, e5, e6, e7)
546 The unit element is always returned by this method, so the
547 sets of generators have cartinality 1,2,4, and 8 as you'd
550 sage: HurwitzMatrixAlgebra(2, AA, AA).entry_algebra_gens()
552 sage: HurwitzMatrixAlgebra(2, QQbar, AA).entry_algebra_gens()
554 sage: Q = QuaternionAlgebra(AA,-1,-1)
555 sage: HurwitzMatrixAlgebra(2, Q, AA).entry_algebra_gens()
557 sage: O = Octonions()
558 sage: HurwitzMatrixAlgebra(2, O, AA).entry_algebra_gens()
559 (e0, e1, e2, e3, e4, e5, e6, e7)
562 gs
= self
.entry_algebra().gens()
563 one
= self
.entry_algebra().one()
567 return (one
,) + tuple(gs
)
571 class OctonionMatrixAlgebra(HurwitzMatrixAlgebra
):
573 The algebra of ``n``-by-``n`` matrices with octonion entries over
574 (a subfield of) the real numbers.
576 The usual matrix spaces in SageMath don't support octonion entries
577 because they assume that the entries of the matrix come from a
578 commutative and associative ring, and the octonions are neither.
582 sage: from mjo.hurwitz import Octonions, OctonionMatrixAlgebra
586 sage: OctonionMatrixAlgebra(3)
587 Module of 3 by 3 matrices with entries in Octonion algebra with base
588 ring Algebraic Real Field over the scalar ring Algebraic Real Field
592 sage: OctonionMatrixAlgebra(3,scalars=QQ)
593 Module of 3 by 3 matrices with entries in Octonion algebra with
594 base ring Rational Field over the scalar ring Rational Field
598 sage: O = Octonions(RR)
599 sage: A = OctonionMatrixAlgebra(1,O)
601 Module of 1 by 1 matrices with entries in Octonion algebra with
602 base ring Real Field with 53 bits of precision over the scalar
603 ring Algebraic Real Field
605 +---------------------+
606 | 1.00000000000000*e0 |
607 +---------------------+
609 (+---------------------+
610 | 1.00000000000000*e0 |
611 +---------------------+,
612 +---------------------+
613 | 1.00000000000000*e1 |
614 +---------------------+,
615 +---------------------+
616 | 1.00000000000000*e2 |
617 +---------------------+,
618 +---------------------+
619 | 1.00000000000000*e3 |
620 +---------------------+,
621 +---------------------+
622 | 1.00000000000000*e4 |
623 +---------------------+,
624 +---------------------+
625 | 1.00000000000000*e5 |
626 +---------------------+,
627 +---------------------+
628 | 1.00000000000000*e6 |
629 +---------------------+,
630 +---------------------+
631 | 1.00000000000000*e7 |
632 +---------------------+)
636 sage: A = OctonionMatrixAlgebra(2)
637 sage: e0,e1,e2,e3,e4,e5,e6,e7 = A.entry_algebra().gens()
638 sage: A([ [e0+e4, e1+e5],
639 ....: [e2-e6, e3-e7] ])
640 +---------+---------+
641 | e0 + e4 | e1 + e5 |
642 +---------+---------+
643 | e2 - e6 | e3 - e7 |
644 +---------+---------+
648 sage: A1 = OctonionMatrixAlgebra(1,scalars=QQ)
649 sage: A2 = OctonionMatrixAlgebra(1,scalars=QQ)
650 sage: cartesian_product([A1,A2])
651 Module of 1 by 1 matrices with entries in Octonion algebra with
652 base ring Rational Field over the scalar ring Rational Field (+)
653 Module of 1 by 1 matrices with entries in Octonion algebra with
654 base ring Rational Field over the scalar ring Rational Field
658 sage: A = OctonionMatrixAlgebra(ZZ.random_element(10))
659 sage: x = A.random_element()
660 sage: x*A.one() == x and A.one()*x == x
664 def __init__(self
, n
, entry_algebra
=None, scalars
=AA
, **kwargs
):
665 if entry_algebra
is None:
666 entry_algebra
= Octonions(field
=scalars
)
672 class QuaternionMatrixAlgebra(HurwitzMatrixAlgebra
):
674 The algebra of ``n``-by-``n`` matrices with quaternion entries over
675 (a subfield of) the real numbers.
677 The usual matrix spaces in SageMath don't support quaternion entries
678 because they assume that the entries of the matrix come from a
679 commutative ring, and the quaternions are not commutative.
683 sage: from mjo.hurwitz import QuaternionMatrixAlgebra
687 sage: QuaternionMatrixAlgebra(3)
688 Module of 3 by 3 matrices with entries in Quaternion
689 Algebra (-1, -1) with base ring Algebraic Real Field
690 over the scalar ring Algebraic Real Field
694 sage: QuaternionMatrixAlgebra(3,scalars=QQ)
695 Module of 3 by 3 matrices with entries in Quaternion
696 Algebra (-1, -1) with base ring Rational Field over
697 the scalar ring Rational Field
701 sage: Q = QuaternionAlgebra(RDF, -1, -1)
702 sage: A = QuaternionMatrixAlgebra(1,Q)
704 Module of 1 by 1 matrices with entries in Quaternion Algebra
705 (-1.0, -1.0) with base ring Real Double Field over the scalar
706 ring Algebraic Real Field
727 sage: A = QuaternionMatrixAlgebra(2)
728 sage: i,j,k = A.entry_algebra().gens()
729 sage: A([ [1+i, j-2],
739 sage: A1 = QuaternionMatrixAlgebra(1,scalars=QQ)
740 sage: A2 = QuaternionMatrixAlgebra(2,scalars=QQ)
741 sage: cartesian_product([A1,A2])
742 Module of 1 by 1 matrices with entries in Quaternion Algebra
743 (-1, -1) with base ring Rational Field over the scalar ring
744 Rational Field (+) Module of 2 by 2 matrices with entries in
745 Quaternion Algebra (-1, -1) with base ring Rational Field over
746 the scalar ring Rational Field
750 sage: A = QuaternionMatrixAlgebra(ZZ.random_element(10))
751 sage: x = A.random_element()
752 sage: x*A.one() == x and A.one()*x == x
756 def __init__(self
, n
, entry_algebra
=None, scalars
=AA
, **kwargs
):
757 if entry_algebra
is None:
758 # The -1,-1 gives us the "usual" definition of quaternion
759 from sage
.algebras
.quatalg
.quaternion_algebra
import (
762 entry_algebra
= QuaternionAlgebra(scalars
,-1,-1)
763 super().__init
__(n
, entry_algebra
, scalars
, **kwargs
)
765 def _entry_algebra_element_to_vector(self
, entry
):
770 sage: from mjo.hurwitz import QuaternionMatrixAlgebra
774 sage: A = QuaternionMatrixAlgebra(2)
775 sage: u = A.entry_algebra().one()
776 sage: A._entry_algebra_element_to_vector(u)
778 sage: i,j,k = A.entry_algebra().gens()
779 sage: A._entry_algebra_element_to_vector(i)
781 sage: A._entry_algebra_element_to_vector(j)
783 sage: A._entry_algebra_element_to_vector(k)
787 from sage
.modules
.free_module
import FreeModule
788 d
= len(self
.entry_algebra_gens())
789 V
= FreeModule(self
.entry_algebra().base_ring(), d
)
790 return V(entry
.coefficient_tuple())
792 class ComplexMatrixAlgebra(HurwitzMatrixAlgebra
):
794 The algebra of ``n``-by-``n`` matrices with complex entries over
795 (a subfield of) the real numbers.
797 These differ from the usual complex matrix spaces in SageMath
798 because the scalar field is real (and not assumed to be the same
799 as the space from which the entries are drawn). The space of
800 `1`-by-`1` complex matrices will have dimension two, for example.
804 sage: from mjo.hurwitz import ComplexMatrixAlgebra
808 sage: ComplexMatrixAlgebra(3)
809 Module of 3 by 3 matrices with entries in Algebraic Field
810 over the scalar ring Algebraic Real Field
814 sage: ComplexMatrixAlgebra(3,scalars=QQ)
815 Module of 3 by 3 matrices with entries in Algebraic Field
816 over the scalar ring Rational Field
820 sage: A = ComplexMatrixAlgebra(1,CC)
822 Module of 1 by 1 matrices with entries in Complex Field with
823 53 bits of precision over the scalar ring Algebraic Real Field
829 (+------------------+
831 +------------------+,
832 +--------------------+
833 | 1.00000000000000*I |
834 +--------------------+)
838 sage: A = ComplexMatrixAlgebra(2)
839 sage: (I,) = A.entry_algebra().gens()
850 sage: A1 = ComplexMatrixAlgebra(1,scalars=QQ)
851 sage: A2 = ComplexMatrixAlgebra(2,scalars=QQ)
852 sage: cartesian_product([A1,A2])
853 Module of 1 by 1 matrices with entries in Algebraic Field over
854 the scalar ring Rational Field (+) Module of 2 by 2 matrices with
855 entries in Algebraic Field over the scalar ring Rational Field
859 sage: A = ComplexMatrixAlgebra(ZZ.random_element(10))
860 sage: x = A.random_element()
861 sage: x*A.one() == x and A.one()*x == x
865 def __init__(self
, n
, entry_algebra
=None, scalars
=AA
, **kwargs
):
866 if entry_algebra
is None:
867 from sage
.rings
.all
import QQbar
868 entry_algebra
= QQbar
869 super().__init
__(n
, entry_algebra
, scalars
, **kwargs
)
871 def _entry_algebra_element_to_vector(self
, entry
):
876 sage: from mjo.hurwitz import ComplexMatrixAlgebra
880 sage: A = ComplexMatrixAlgebra(2, QQbar, QQ)
881 sage: A._entry_algebra_element_to_vector(QQbar(1))
883 sage: A._entry_algebra_element_to_vector(QQbar(I))
887 from sage
.modules
.free_module
import FreeModule
888 d
= len(self
.entry_algebra_gens())
889 V
= FreeModule(self
.entry_algebra().base_ring(), d
)
890 return V((entry
.real(), entry
.imag()))