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
):
302 def conjugate_transpose(self
):
304 Return the conjugate-transpose of this matrix.
308 sage: from mjo.hurwitz import ComplexMatrixAlgebra
312 sage: A = ComplexMatrixAlgebra(2, QQbar, ZZ)
313 sage: M = A([ [ I, 2*I],
315 sage: M.conjugate_transpose()
321 sage: M.conjugate_transpose().to_vector()
322 (0, -1, 0, -3, 0, -2, 0, -4)
325 entries
= [ [ self
[j
,i
].conjugate()
326 for j
in range(self
.ncols())]
327 for i
in range(self
.nrows()) ]
328 return self
.parent()._element
_constructor
_(entries
)
330 def is_hermitian(self
):
335 sage: from mjo.hurwitz import (ComplexMatrixAlgebra,
336 ....: HurwitzMatrixAlgebra)
340 sage: A = ComplexMatrixAlgebra(2, QQbar, ZZ)
341 sage: M = A([ [ 0,I],
343 sage: M.is_hermitian()
348 sage: A = HurwitzMatrixAlgebra(2, AA, QQ)
349 sage: M = A([ [1, 1],
351 sage: M.is_hermitian()
355 # A tiny bit faster than checking equality with the conjugate
357 return all( self
[i
,j
] == self
[j
,i
].conjugate()
358 for i
in range(self
.nrows())
359 for j
in range(self
.ncols()) )
362 def is_skew_hermitian(self
):
367 sage: from mjo.hurwitz import (ComplexMatrixAlgebra,
368 ....: HurwitzMatrixAlgebra)
372 sage: A = ComplexMatrixAlgebra(2, QQbar, ZZ)
373 sage: M = A([ [ 0,I],
375 sage: M.is_skew_hermitian()
380 sage: A = HurwitzMatrixAlgebra(2, AA, QQ)
381 sage: M = A([ [1, 1],
383 sage: M.is_skew_hermitian()
388 sage: A = ComplexMatrixAlgebra(2, QQbar, ZZ)
389 sage: M = A([ [2*I , 1 + I],
390 ....: [-1 + I, -2*I] ])
391 sage: M.is_skew_hermitian()
395 # A tiny bit faster than checking equality with the conjugate
397 return all( self
[i
,j
] == -self
[j
,i
].conjugate()
398 for i
in range(self
.nrows())
399 for j
in range(self
.ncols()) )
402 class HurwitzMatrixAlgebra(MatrixAlgebra
):
404 A class of matrix algebras whose entries come from a Hurwitz
407 For our purposes, we consider "a Hurwitz" algebra to be the real
408 or complex numbers, the quaternions, or the octonions. These are
409 typically also referred to as the Euclidean Hurwitz algebras, or
410 the normed division algebras.
412 By the Cayley-Dickson construction, each Hurwitz algebra is an
413 algebra over the real numbers, so we restrict the scalar field in
414 this case to be real. This also allows us to more accurately
415 produce the generators of the matrix algebra.
417 Element
= HurwitzMatrixAlgebraElement
419 def __init__(self
, n
, entry_algebra
, scalars
, **kwargs
):
420 from sage
.rings
.all
import RR
421 if not scalars
.is_subring(RR
):
422 # Not perfect, but it's what we're using.
423 raise ValueError("scalar field is not real")
425 super().__init
__(n
, entry_algebra
, scalars
, **kwargs
)
427 def entry_algebra_gens(self
):
429 Return a tuple of the generators of (that is, a basis for) the
430 entries of this matrix algebra.
432 This works around the inconsistency in the ``gens()`` methods
433 of the real/complex numbers, quaternions, and octonions.
437 sage: from mjo.hurwitz import Octonions, HurwitzMatrixAlgebra
441 The inclusion of the unit element is inconsistent across
442 (subalgebras of) Hurwitz algebras::
448 sage: QuaternionAlgebra(AA,1,-1).gens()
450 sage: Octonions().gens()
451 (e0, e1, e2, e3, e4, e5, e6, e7)
453 The unit element is always returned by this method, so the
454 sets of generators have cartinality 1,2,4, and 8 as you'd
457 sage: HurwitzMatrixAlgebra(2, AA, AA).entry_algebra_gens()
459 sage: HurwitzMatrixAlgebra(2, QQbar, AA).entry_algebra_gens()
461 sage: Q = QuaternionAlgebra(AA,-1,-1)
462 sage: HurwitzMatrixAlgebra(2, Q, AA).entry_algebra_gens()
464 sage: O = Octonions()
465 sage: HurwitzMatrixAlgebra(2, O, AA).entry_algebra_gens()
466 (e0, e1, e2, e3, e4, e5, e6, e7)
469 gs
= self
.entry_algebra().gens()
470 one
= self
.entry_algebra().one()
474 return (one
,) + tuple(gs
)
478 class OctonionMatrixAlgebra(HurwitzMatrixAlgebra
):
480 The algebra of ``n``-by-``n`` matrices with octonion entries over
481 (a subfield of) the real numbers.
483 The usual matrix spaces in SageMath don't support octonion entries
484 because they assume that the entries of the matrix come from a
485 commutative and associative ring, and the octonions are neither.
489 sage: from mjo.hurwitz import Octonions, OctonionMatrixAlgebra
493 sage: OctonionMatrixAlgebra(3)
494 Module of 3 by 3 matrices with entries in Octonion algebra with base
495 ring Algebraic Real Field over the scalar ring Algebraic Real Field
499 sage: OctonionMatrixAlgebra(3,scalars=QQ)
500 Module of 3 by 3 matrices with entries in Octonion algebra with
501 base ring Rational Field over the scalar ring Rational Field
505 sage: O = Octonions(RR)
506 sage: A = OctonionMatrixAlgebra(1,O)
508 Module of 1 by 1 matrices with entries in Octonion algebra with
509 base ring Real Field with 53 bits of precision over the scalar
510 ring Algebraic Real Field
512 +---------------------+
513 | 1.00000000000000*e0 |
514 +---------------------+
516 (+---------------------+
517 | 1.00000000000000*e0 |
518 +---------------------+,
519 +---------------------+
520 | 1.00000000000000*e1 |
521 +---------------------+,
522 +---------------------+
523 | 1.00000000000000*e2 |
524 +---------------------+,
525 +---------------------+
526 | 1.00000000000000*e3 |
527 +---------------------+,
528 +---------------------+
529 | 1.00000000000000*e4 |
530 +---------------------+,
531 +---------------------+
532 | 1.00000000000000*e5 |
533 +---------------------+,
534 +---------------------+
535 | 1.00000000000000*e6 |
536 +---------------------+,
537 +---------------------+
538 | 1.00000000000000*e7 |
539 +---------------------+)
543 sage: A = OctonionMatrixAlgebra(2)
544 sage: e0,e1,e2,e3,e4,e5,e6,e7 = A.entry_algebra().gens()
545 sage: A([ [e0+e4, e1+e5],
546 ....: [e2-e6, e3-e7] ])
547 +---------+---------+
548 | e0 + e4 | e1 + e5 |
549 +---------+---------+
550 | e2 - e6 | e3 - e7 |
551 +---------+---------+
555 sage: A1 = OctonionMatrixAlgebra(1,scalars=QQ)
556 sage: A2 = OctonionMatrixAlgebra(1,scalars=QQ)
557 sage: cartesian_product([A1,A2])
558 Module of 1 by 1 matrices with entries in Octonion algebra with
559 base ring Rational Field over the scalar ring Rational Field (+)
560 Module of 1 by 1 matrices with entries in Octonion algebra with
561 base ring Rational Field over the scalar ring Rational Field
565 sage: A = OctonionMatrixAlgebra(ZZ.random_element(10))
566 sage: x = A.random_element()
567 sage: x*A.one() == x and A.one()*x == x
571 def __init__(self
, n
, entry_algebra
=None, scalars
=AA
, **kwargs
):
572 if entry_algebra
is None:
573 entry_algebra
= Octonions(field
=scalars
)
579 class QuaternionMatrixAlgebra(HurwitzMatrixAlgebra
):
581 The algebra of ``n``-by-``n`` matrices with quaternion entries over
582 (a subfield of) the real numbers.
584 The usual matrix spaces in SageMath don't support quaternion entries
585 because they assume that the entries of the matrix come from a
586 commutative ring, and the quaternions are not commutative.
590 sage: from mjo.hurwitz import QuaternionMatrixAlgebra
594 sage: QuaternionMatrixAlgebra(3)
595 Module of 3 by 3 matrices with entries in Quaternion
596 Algebra (-1, -1) with base ring Algebraic Real Field
597 over the scalar ring Algebraic Real Field
601 sage: QuaternionMatrixAlgebra(3,scalars=QQ)
602 Module of 3 by 3 matrices with entries in Quaternion
603 Algebra (-1, -1) with base ring Rational Field over
604 the scalar ring Rational Field
608 sage: Q = QuaternionAlgebra(RDF, -1, -1)
609 sage: A = QuaternionMatrixAlgebra(1,Q)
611 Module of 1 by 1 matrices with entries in Quaternion Algebra
612 (-1.0, -1.0) with base ring Real Double Field over the scalar
613 ring Algebraic Real Field
634 sage: A = QuaternionMatrixAlgebra(2)
635 sage: i,j,k = A.entry_algebra().gens()
636 sage: A([ [1+i, j-2],
646 sage: A1 = QuaternionMatrixAlgebra(1,scalars=QQ)
647 sage: A2 = QuaternionMatrixAlgebra(2,scalars=QQ)
648 sage: cartesian_product([A1,A2])
649 Module of 1 by 1 matrices with entries in Quaternion Algebra
650 (-1, -1) with base ring Rational Field over the scalar ring
651 Rational Field (+) Module of 2 by 2 matrices with entries in
652 Quaternion Algebra (-1, -1) with base ring Rational Field over
653 the scalar ring Rational Field
657 sage: A = QuaternionMatrixAlgebra(ZZ.random_element(10))
658 sage: x = A.random_element()
659 sage: x*A.one() == x and A.one()*x == x
663 def __init__(self
, n
, entry_algebra
=None, scalars
=AA
, **kwargs
):
664 if entry_algebra
is None:
665 # The -1,-1 gives us the "usual" definition of quaternion
666 from sage
.algebras
.quatalg
.quaternion_algebra
import (
669 entry_algebra
= QuaternionAlgebra(scalars
,-1,-1)
670 super().__init
__(n
, entry_algebra
, scalars
, **kwargs
)
672 def _entry_algebra_element_to_vector(self
, entry
):
677 sage: from mjo.hurwitz import QuaternionMatrixAlgebra
681 sage: A = QuaternionMatrixAlgebra(2)
682 sage: u = A.entry_algebra().one()
683 sage: A._entry_algebra_element_to_vector(u)
685 sage: i,j,k = A.entry_algebra().gens()
686 sage: A._entry_algebra_element_to_vector(i)
688 sage: A._entry_algebra_element_to_vector(j)
690 sage: A._entry_algebra_element_to_vector(k)
694 from sage
.modules
.free_module
import FreeModule
695 d
= len(self
.entry_algebra_gens())
696 V
= FreeModule(self
.entry_algebra().base_ring(), d
)
697 return V(entry
.coefficient_tuple())
699 class ComplexMatrixAlgebra(HurwitzMatrixAlgebra
):
701 The algebra of ``n``-by-``n`` matrices with complex entries over
702 (a subfield of) the real numbers.
704 These differ from the usual complex matrix spaces in SageMath
705 because the scalar field is real (and not assumed to be the same
706 as the space from which the entries are drawn). The space of
707 `1`-by-`1` complex matrices will have dimension two, for example.
711 sage: from mjo.hurwitz import ComplexMatrixAlgebra
715 sage: ComplexMatrixAlgebra(3)
716 Module of 3 by 3 matrices with entries in Algebraic Field
717 over the scalar ring Algebraic Real Field
721 sage: ComplexMatrixAlgebra(3,scalars=QQ)
722 Module of 3 by 3 matrices with entries in Algebraic Field
723 over the scalar ring Rational Field
727 sage: A = ComplexMatrixAlgebra(1,CC)
729 Module of 1 by 1 matrices with entries in Complex Field with
730 53 bits of precision over the scalar ring Algebraic Real Field
736 (+------------------+
738 +------------------+,
739 +--------------------+
740 | 1.00000000000000*I |
741 +--------------------+)
745 sage: A = ComplexMatrixAlgebra(2)
746 sage: (I,) = A.entry_algebra().gens()
757 sage: A1 = ComplexMatrixAlgebra(1,scalars=QQ)
758 sage: A2 = ComplexMatrixAlgebra(2,scalars=QQ)
759 sage: cartesian_product([A1,A2])
760 Module of 1 by 1 matrices with entries in Algebraic Field over
761 the scalar ring Rational Field (+) Module of 2 by 2 matrices with
762 entries in Algebraic Field over the scalar ring Rational Field
766 sage: A = ComplexMatrixAlgebra(ZZ.random_element(10))
767 sage: x = A.random_element()
768 sage: x*A.one() == x and A.one()*x == x
772 def __init__(self
, n
, entry_algebra
=None, scalars
=AA
, **kwargs
):
773 if entry_algebra
is None:
774 from sage
.rings
.all
import QQbar
775 entry_algebra
= QQbar
776 super().__init
__(n
, entry_algebra
, scalars
, **kwargs
)
778 def _entry_algebra_element_to_vector(self
, entry
):
783 sage: from mjo.hurwitz import ComplexMatrixAlgebra
787 sage: A = ComplexMatrixAlgebra(2, QQbar, QQ)
788 sage: A._entry_algebra_element_to_vector(QQbar(1))
790 sage: A._entry_algebra_element_to_vector(QQbar(I))
794 from sage
.modules
.free_module
import FreeModule
795 d
= len(self
.entry_algebra_gens())
796 V
= FreeModule(self
.entry_algebra().base_ring(), d
)
797 return V((entry
.real(), entry
.imag()))