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],
323 entries
= [ [ self
[i
,j
].conjugate()
324 for j
in range(self
.ncols())]
325 for i
in range(self
.nrows()) ]
326 return self
.parent()._element
_constructor
_(entries
)
328 def conjugate_transpose(self
):
330 Return the conjugate-transpose of this matrix.
334 sage: from mjo.hurwitz import ComplexMatrixAlgebra
338 sage: A = ComplexMatrixAlgebra(2, QQbar, ZZ)
339 sage: M = A([ [ I, 2*I],
341 sage: M.conjugate_transpose()
347 sage: M.conjugate_transpose().to_vector()
348 (0, -1, 0, -3, 0, -2, 0, -4)
351 entries
= [ [ self
[j
,i
].conjugate()
352 for j
in range(self
.ncols())]
353 for i
in range(self
.nrows()) ]
354 return self
.parent()._element
_constructor
_(entries
)
356 def is_hermitian(self
):
361 sage: from mjo.hurwitz import (ComplexMatrixAlgebra,
362 ....: HurwitzMatrixAlgebra)
366 sage: A = ComplexMatrixAlgebra(2, QQbar, ZZ)
367 sage: M = A([ [ 0,I],
369 sage: M.is_hermitian()
374 sage: A = HurwitzMatrixAlgebra(2, AA, QQ)
375 sage: M = A([ [1, 1],
377 sage: M.is_hermitian()
381 # A tiny bit faster than checking equality with the conjugate
383 return all( self
[i
,j
] == self
[j
,i
].conjugate()
384 for i
in range(self
.nrows())
385 for j
in range(self
.ncols()) )
388 def is_skew_symmetric(self
):
390 Return whether or not this matrix is skew-symmetric.
394 sage: from mjo.hurwitz import (ComplexMatrixAlgebra,
395 ....: HurwitzMatrixAlgebra)
399 sage: A = ComplexMatrixAlgebra(2, QQbar, ZZ)
400 sage: M = A([ [ 0,I],
402 sage: M.is_skew_symmetric()
407 sage: A = ComplexMatrixAlgebra(2, QQbar, ZZ)
408 sage: M = A([ [ 0, 1+I],
410 sage: M.is_skew_symmetric()
415 sage: A = HurwitzMatrixAlgebra(2, AA, QQ)
416 sage: M = A([ [1, 1],
418 sage: M.is_skew_symmetric()
423 sage: A = ComplexMatrixAlgebra(2, QQbar, ZZ)
424 sage: M = A([ [2*I , 1 + I],
425 ....: [-1 + I, -2*I] ])
426 sage: M.is_skew_symmetric()
430 # A tiny bit faster than checking equality with the negation
432 return all( self
[i
,j
] == -self
[j
,i
]
433 for i
in range(self
.nrows())
434 for j
in range(self
.ncols()) )
437 class HurwitzMatrixAlgebra(MatrixAlgebra
):
439 A class of matrix algebras whose entries come from a Hurwitz
442 For our purposes, we consider "a Hurwitz" algebra to be the real
443 or complex numbers, the quaternions, or the octonions. These are
444 typically also referred to as the Euclidean Hurwitz algebras, or
445 the normed division algebras.
447 By the Cayley-Dickson construction, each Hurwitz algebra is an
448 algebra over the real numbers, so we restrict the scalar field in
449 this case to be real. This also allows us to more accurately
450 produce the generators of the matrix algebra.
452 Element
= HurwitzMatrixAlgebraElement
454 def __init__(self
, n
, entry_algebra
, scalars
, **kwargs
):
455 from sage
.rings
.all
import RR
456 if not scalars
.is_subring(RR
):
457 # Not perfect, but it's what we're using.
458 raise ValueError("scalar field is not real")
460 super().__init
__(n
, entry_algebra
, scalars
, **kwargs
)
462 def entry_algebra_gens(self
):
464 Return a tuple of the generators of (that is, a basis for) the
465 entries of this matrix algebra.
467 This works around the inconsistency in the ``gens()`` methods
468 of the real/complex numbers, quaternions, and octonions.
472 sage: from mjo.hurwitz import Octonions, HurwitzMatrixAlgebra
476 The inclusion of the unit element is inconsistent across
477 (subalgebras of) Hurwitz algebras::
483 sage: QuaternionAlgebra(AA,1,-1).gens()
485 sage: Octonions().gens()
486 (e0, e1, e2, e3, e4, e5, e6, e7)
488 The unit element is always returned by this method, so the
489 sets of generators have cartinality 1,2,4, and 8 as you'd
492 sage: HurwitzMatrixAlgebra(2, AA, AA).entry_algebra_gens()
494 sage: HurwitzMatrixAlgebra(2, QQbar, AA).entry_algebra_gens()
496 sage: Q = QuaternionAlgebra(AA,-1,-1)
497 sage: HurwitzMatrixAlgebra(2, Q, AA).entry_algebra_gens()
499 sage: O = Octonions()
500 sage: HurwitzMatrixAlgebra(2, O, AA).entry_algebra_gens()
501 (e0, e1, e2, e3, e4, e5, e6, e7)
504 gs
= self
.entry_algebra().gens()
505 one
= self
.entry_algebra().one()
509 return (one
,) + tuple(gs
)
513 class OctonionMatrixAlgebra(HurwitzMatrixAlgebra
):
515 The algebra of ``n``-by-``n`` matrices with octonion entries over
516 (a subfield of) the real numbers.
518 The usual matrix spaces in SageMath don't support octonion entries
519 because they assume that the entries of the matrix come from a
520 commutative and associative ring, and the octonions are neither.
524 sage: from mjo.hurwitz import Octonions, OctonionMatrixAlgebra
528 sage: OctonionMatrixAlgebra(3)
529 Module of 3 by 3 matrices with entries in Octonion algebra with base
530 ring Algebraic Real Field over the scalar ring Algebraic Real Field
534 sage: OctonionMatrixAlgebra(3,scalars=QQ)
535 Module of 3 by 3 matrices with entries in Octonion algebra with
536 base ring Rational Field over the scalar ring Rational Field
540 sage: O = Octonions(RR)
541 sage: A = OctonionMatrixAlgebra(1,O)
543 Module of 1 by 1 matrices with entries in Octonion algebra with
544 base ring Real Field with 53 bits of precision over the scalar
545 ring Algebraic Real Field
547 +---------------------+
548 | 1.00000000000000*e0 |
549 +---------------------+
551 (+---------------------+
552 | 1.00000000000000*e0 |
553 +---------------------+,
554 +---------------------+
555 | 1.00000000000000*e1 |
556 +---------------------+,
557 +---------------------+
558 | 1.00000000000000*e2 |
559 +---------------------+,
560 +---------------------+
561 | 1.00000000000000*e3 |
562 +---------------------+,
563 +---------------------+
564 | 1.00000000000000*e4 |
565 +---------------------+,
566 +---------------------+
567 | 1.00000000000000*e5 |
568 +---------------------+,
569 +---------------------+
570 | 1.00000000000000*e6 |
571 +---------------------+,
572 +---------------------+
573 | 1.00000000000000*e7 |
574 +---------------------+)
578 sage: A = OctonionMatrixAlgebra(2)
579 sage: e0,e1,e2,e3,e4,e5,e6,e7 = A.entry_algebra().gens()
580 sage: A([ [e0+e4, e1+e5],
581 ....: [e2-e6, e3-e7] ])
582 +---------+---------+
583 | e0 + e4 | e1 + e5 |
584 +---------+---------+
585 | e2 - e6 | e3 - e7 |
586 +---------+---------+
590 sage: A1 = OctonionMatrixAlgebra(1,scalars=QQ)
591 sage: A2 = OctonionMatrixAlgebra(1,scalars=QQ)
592 sage: cartesian_product([A1,A2])
593 Module of 1 by 1 matrices with entries in Octonion algebra with
594 base ring Rational Field over the scalar ring Rational Field (+)
595 Module of 1 by 1 matrices with entries in Octonion algebra with
596 base ring Rational Field over the scalar ring Rational Field
600 sage: A = OctonionMatrixAlgebra(ZZ.random_element(10))
601 sage: x = A.random_element()
602 sage: x*A.one() == x and A.one()*x == x
606 def __init__(self
, n
, entry_algebra
=None, scalars
=AA
, **kwargs
):
607 if entry_algebra
is None:
608 entry_algebra
= Octonions(field
=scalars
)
614 class QuaternionMatrixAlgebra(HurwitzMatrixAlgebra
):
616 The algebra of ``n``-by-``n`` matrices with quaternion entries over
617 (a subfield of) the real numbers.
619 The usual matrix spaces in SageMath don't support quaternion entries
620 because they assume that the entries of the matrix come from a
621 commutative ring, and the quaternions are not commutative.
625 sage: from mjo.hurwitz import QuaternionMatrixAlgebra
629 sage: QuaternionMatrixAlgebra(3)
630 Module of 3 by 3 matrices with entries in Quaternion
631 Algebra (-1, -1) with base ring Algebraic Real Field
632 over the scalar ring Algebraic Real Field
636 sage: QuaternionMatrixAlgebra(3,scalars=QQ)
637 Module of 3 by 3 matrices with entries in Quaternion
638 Algebra (-1, -1) with base ring Rational Field over
639 the scalar ring Rational Field
643 sage: Q = QuaternionAlgebra(RDF, -1, -1)
644 sage: A = QuaternionMatrixAlgebra(1,Q)
646 Module of 1 by 1 matrices with entries in Quaternion Algebra
647 (-1.0, -1.0) with base ring Real Double Field over the scalar
648 ring Algebraic Real Field
669 sage: A = QuaternionMatrixAlgebra(2)
670 sage: i,j,k = A.entry_algebra().gens()
671 sage: A([ [1+i, j-2],
681 sage: A1 = QuaternionMatrixAlgebra(1,scalars=QQ)
682 sage: A2 = QuaternionMatrixAlgebra(2,scalars=QQ)
683 sage: cartesian_product([A1,A2])
684 Module of 1 by 1 matrices with entries in Quaternion Algebra
685 (-1, -1) with base ring Rational Field over the scalar ring
686 Rational Field (+) Module of 2 by 2 matrices with entries in
687 Quaternion Algebra (-1, -1) with base ring Rational Field over
688 the scalar ring Rational Field
692 sage: A = QuaternionMatrixAlgebra(ZZ.random_element(10))
693 sage: x = A.random_element()
694 sage: x*A.one() == x and A.one()*x == x
698 def __init__(self
, n
, entry_algebra
=None, scalars
=AA
, **kwargs
):
699 if entry_algebra
is None:
700 # The -1,-1 gives us the "usual" definition of quaternion
701 from sage
.algebras
.quatalg
.quaternion_algebra
import (
704 entry_algebra
= QuaternionAlgebra(scalars
,-1,-1)
705 super().__init
__(n
, entry_algebra
, scalars
, **kwargs
)
707 def _entry_algebra_element_to_vector(self
, entry
):
712 sage: from mjo.hurwitz import QuaternionMatrixAlgebra
716 sage: A = QuaternionMatrixAlgebra(2)
717 sage: u = A.entry_algebra().one()
718 sage: A._entry_algebra_element_to_vector(u)
720 sage: i,j,k = A.entry_algebra().gens()
721 sage: A._entry_algebra_element_to_vector(i)
723 sage: A._entry_algebra_element_to_vector(j)
725 sage: A._entry_algebra_element_to_vector(k)
729 from sage
.modules
.free_module
import FreeModule
730 d
= len(self
.entry_algebra_gens())
731 V
= FreeModule(self
.entry_algebra().base_ring(), d
)
732 return V(entry
.coefficient_tuple())
734 class ComplexMatrixAlgebra(HurwitzMatrixAlgebra
):
736 The algebra of ``n``-by-``n`` matrices with complex entries over
737 (a subfield of) the real numbers.
739 These differ from the usual complex matrix spaces in SageMath
740 because the scalar field is real (and not assumed to be the same
741 as the space from which the entries are drawn). The space of
742 `1`-by-`1` complex matrices will have dimension two, for example.
746 sage: from mjo.hurwitz import ComplexMatrixAlgebra
750 sage: ComplexMatrixAlgebra(3)
751 Module of 3 by 3 matrices with entries in Algebraic Field
752 over the scalar ring Algebraic Real Field
756 sage: ComplexMatrixAlgebra(3,scalars=QQ)
757 Module of 3 by 3 matrices with entries in Algebraic Field
758 over the scalar ring Rational Field
762 sage: A = ComplexMatrixAlgebra(1,CC)
764 Module of 1 by 1 matrices with entries in Complex Field with
765 53 bits of precision over the scalar ring Algebraic Real Field
771 (+------------------+
773 +------------------+,
774 +--------------------+
775 | 1.00000000000000*I |
776 +--------------------+)
780 sage: A = ComplexMatrixAlgebra(2)
781 sage: (I,) = A.entry_algebra().gens()
792 sage: A1 = ComplexMatrixAlgebra(1,scalars=QQ)
793 sage: A2 = ComplexMatrixAlgebra(2,scalars=QQ)
794 sage: cartesian_product([A1,A2])
795 Module of 1 by 1 matrices with entries in Algebraic Field over
796 the scalar ring Rational Field (+) Module of 2 by 2 matrices with
797 entries in Algebraic Field over the scalar ring Rational Field
801 sage: A = ComplexMatrixAlgebra(ZZ.random_element(10))
802 sage: x = A.random_element()
803 sage: x*A.one() == x and A.one()*x == x
807 def __init__(self
, n
, entry_algebra
=None, scalars
=AA
, **kwargs
):
808 if entry_algebra
is None:
809 from sage
.rings
.all
import QQbar
810 entry_algebra
= QQbar
811 super().__init
__(n
, entry_algebra
, scalars
, **kwargs
)
813 def _entry_algebra_element_to_vector(self
, entry
):
818 sage: from mjo.hurwitz import ComplexMatrixAlgebra
822 sage: A = ComplexMatrixAlgebra(2, QQbar, QQ)
823 sage: A._entry_algebra_element_to_vector(QQbar(1))
825 sage: A._entry_algebra_element_to_vector(QQbar(I))
829 from sage
.modules
.free_module
import FreeModule
830 d
= len(self
.entry_algebra_gens())
831 V
= FreeModule(self
.entry_algebra().base_ring(), d
)
832 return V((entry
.real(), entry
.imag()))