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::
26 sage: set_random_seed()
28 sage: x = O.random_element()
29 sage: x.conjugate().conjugate() == x
33 from sage
.rings
.all
import ZZ
34 from sage
.matrix
.matrix_space
import MatrixSpace
35 C
= MatrixSpace(ZZ
,8).diagonal_matrix((1,-1,-1,-1,-1,-1,-1,-1))
36 return self
.parent().from_vector(C
*self
.to_vector())
40 Return the real part of this octonion.
42 The real part of an octonion is its projection onto the span
43 of the first generator. In other words, the "first dimension"
44 is real and the others are imaginary.
48 sage: from mjo.hurwitz import Octonions
53 sage: x = sum(O.gens())
59 This method is idempotent::
61 sage: set_random_seed()
63 sage: x = O.random_element()
64 sage: x.real().real() == x.real()
68 return (self
+ self
.conjugate())/2
72 Return the imaginary part of this octonion.
74 The imaginary part of an octonion is its projection onto the
75 orthogonal complement of the span of the first generator. In
76 other words, the "first dimension" is real and the others are
81 sage: from mjo.hurwitz import Octonions
86 sage: x = sum(O.gens())
88 e1 + e2 + e3 + e4 + e5 + e6 + e7
92 This method is idempotent::
94 sage: set_random_seed()
96 sage: x = O.random_element()
97 sage: x.imag().imag() == x.imag()
101 return (self
- self
.conjugate())/2
103 def _norm_squared(self
):
104 return (self
*self
.conjugate()).coefficient(0)
108 Return the norm of this octonion.
112 sage: from mjo.hurwitz import Octonions
116 sage: O = Octonions()
122 The norm is nonnegative and belongs to the base field::
124 sage: set_random_seed()
125 sage: O = Octonions()
126 sage: n = O.random_element().norm()
127 sage: n >= 0 and n in O.base_ring()
130 The norm is homogeneous::
132 sage: set_random_seed()
133 sage: O = Octonions()
134 sage: x = O.random_element()
135 sage: alpha = O.base_ring().random_element()
136 sage: (alpha*x).norm() == alpha.abs()*x.norm()
140 return self
._norm
_squared
().sqrt()
142 # The absolute value notation is typically used for complex numbers...
143 # and norm() isn't supported in AA, so this lets us use abs() in all
144 # of the division algebras we need.
149 Return the inverse of this element if it exists.
153 sage: from mjo.hurwitz import Octonions
157 sage: O = Octonions()
158 sage: x = sum(O.gens())
159 sage: x*x.inverse() == O.one()
164 sage: O = Octonions()
165 sage: O.one().inverse() == O.one()
170 sage: set_random_seed()
171 sage: O = Octonions()
172 sage: x = O.random_element()
173 sage: x.is_zero() or ( x*x.inverse() == O.one() )
178 raise ValueError("zero is not invertible")
179 return self
.conjugate()/self
._norm
_squared
()
183 class Octonions(CombinatorialFreeModule
):
187 sage: from mjo.hurwitz import Octonions
192 Octonion algebra with base ring Algebraic Real Field
193 sage: Octonions(field=QQ)
194 Octonion algebra with base ring Rational Field
201 # Not associative, not commutative
202 from sage
.categories
.magmatic_algebras
import MagmaticAlgebras
203 category
= MagmaticAlgebras(field
).FiniteDimensional()
204 category
= category
.WithBasis().Unital()
206 super().__init
__(field
,
208 element_class
=Octonion
,
213 # The product of each basis element is plus/minus another
214 # basis element that can simply be looked up on
215 # https://en.wikipedia.org/wiki/Octonion
216 e0
, e1
, e2
, e3
, e4
, e5
, e6
, e7
= self
.gens()
217 self
._multiplication
_table
= (
218 (e0
, e1
, e2
, e3
, e4
, e5
, e6
, e7
),
219 (e1
,-e0
, e3
,-e2
, e5
,-e4
,-e7
, e6
),
220 (e2
,-e3
,-e0
, e1
, e6
, e7
,-e4
,-e5
),
221 (e3
, e2
,-e1
,-e0
, e7
,-e6
, e5
,-e4
),
222 (e4
,-e5
,-e6
,-e7
,-e0
, e1
, e2
, e3
),
223 (e5
, e4
,-e7
, e6
,-e1
,-e0
,-e3
, e2
),
224 (e6
, e7
, e4
,-e5
,-e2
, e3
,-e0
,-e1
),
225 (e7
,-e6
, e5
, e4
,-e3
,-e2
, e1
,-e0
),
228 def product_on_basis(self
, i
, j
):
229 return self
._multiplication
_table
[i
][j
]
233 Return the monomial index (basis element) corresponding to the
234 octonion unit element.
238 sage: from mjo.hurwitz import Octonions
242 This gives the correct unit element::
244 sage: set_random_seed()
245 sage: O = Octonions()
246 sage: x = O.random_element()
247 sage: x*O.one() == x and O.one()*x == x
254 return ("Octonion algebra with base ring %s" % self
.base_ring())
256 def multiplication_table(self
):
258 Return a visual representation of this algebra's multiplication
259 table (on basis elements).
263 sage: from mjo.hurwitz import Octonions
267 The multiplication table is what Wikipedia says it is::
269 sage: Octonions().multiplication_table()
270 +----++----+-----+-----+-----+-----+-----+-----+-----+
271 | * || e0 | e1 | e2 | e3 | e4 | e5 | e6 | e7 |
272 +====++====+=====+=====+=====+=====+=====+=====+=====+
273 | e0 || e0 | e1 | e2 | e3 | e4 | e5 | e6 | e7 |
274 +----++----+-----+-----+-----+-----+-----+-----+-----+
275 | e1 || e1 | -e0 | e3 | -e2 | e5 | -e4 | -e7 | e6 |
276 +----++----+-----+-----+-----+-----+-----+-----+-----+
277 | e2 || e2 | -e3 | -e0 | e1 | e6 | e7 | -e4 | -e5 |
278 +----++----+-----+-----+-----+-----+-----+-----+-----+
279 | e3 || e3 | e2 | -e1 | -e0 | e7 | -e6 | e5 | -e4 |
280 +----++----+-----+-----+-----+-----+-----+-----+-----+
281 | e4 || e4 | -e5 | -e6 | -e7 | -e0 | e1 | e2 | e3 |
282 +----++----+-----+-----+-----+-----+-----+-----+-----+
283 | e5 || e5 | e4 | -e7 | e6 | -e1 | -e0 | -e3 | e2 |
284 +----++----+-----+-----+-----+-----+-----+-----+-----+
285 | e6 || e6 | e7 | e4 | -e5 | -e2 | e3 | -e0 | -e1 |
286 +----++----+-----+-----+-----+-----+-----+-----+-----+
287 | e7 || e7 | -e6 | e5 | e4 | -e3 | -e2 | e1 | -e0 |
288 +----++----+-----+-----+-----+-----+-----+-----+-----+
292 # Prepend the header row.
293 M
= [["*"] + list(self
.gens())]
295 # And to each subsequent row, prepend an entry that belongs to
296 # the left-side "header column."
297 M
+= [ [self
.monomial(i
)] + [ self
.monomial(i
)*self
.monomial(j
)
301 from sage
.misc
.table
import table
302 return table(M
, header_row
=True, header_column
=True, frame
=True)
308 class HurwitzMatrixAlgebraElement(MatrixAlgebraElement
):
309 def conjugate_transpose(self
):
311 Return the conjugate-transpose of this matrix.
315 sage: from mjo.hurwitz import ComplexMatrixAlgebra
319 sage: A = ComplexMatrixAlgebra(2, QQbar, ZZ)
320 sage: M = A([ [ I, 2*I],
322 sage: M.conjugate_transpose()
328 sage: M.conjugate_transpose().to_vector()
329 (0, -1, 0, -3, 0, -2, 0, -4)
332 entries
= [ [ self
[j
,i
].conjugate()
333 for j
in range(self
.ncols())]
334 for i
in range(self
.nrows()) ]
335 return self
.parent()._element
_constructor
_(entries
)
337 def is_hermitian(self
):
342 sage: from mjo.hurwitz import (ComplexMatrixAlgebra,
343 ....: HurwitzMatrixAlgebra)
347 sage: A = ComplexMatrixAlgebra(2, QQbar, ZZ)
348 sage: M = A([ [ 0,I],
350 sage: M.is_hermitian()
355 sage: A = HurwitzMatrixAlgebra(2, AA, QQ)
356 sage: M = A([ [1, 1],
358 sage: M.is_hermitian()
362 # A tiny bit faster than checking equality with the conjugate
364 return all( self
[i
,j
] == self
[j
,i
].conjugate()
365 for i
in range(self
.nrows())
366 for j
in range(self
.ncols()) )
369 class HurwitzMatrixAlgebra(MatrixAlgebra
):
371 A class of matrix algebras whose entries come from a Hurwitz
374 For our purposes, we consider "a Hurwitz" algebra to be the real
375 or complex numbers, the quaternions, or the octonions. These are
376 typically also referred to as the Euclidean Hurwitz algebras, or
377 the normed division algebras.
379 By the Cayley-Dickson construction, each Hurwitz algebra is an
380 algebra over the real numbers, so we restrict the scalar field in
381 this case to be real. This also allows us to more accurately
382 produce the generators of the matrix algebra.
384 Element
= HurwitzMatrixAlgebraElement
386 def __init__(self
, n
, entry_algebra
, scalars
, **kwargs
):
387 from sage
.rings
.all
import RR
388 if not scalars
.is_subring(RR
):
389 # Not perfect, but it's what we're using.
390 raise ValueError("scalar field is not real")
392 super().__init
__(n
, entry_algebra
, scalars
, **kwargs
)
394 def entry_algebra_gens(self
):
396 Return a tuple of the generators of (that is, a basis for) the
397 entries of this matrix algebra.
399 This works around the inconsistency in the ``gens()`` methods
400 of the real/complex numbers, quaternions, and octonions.
404 sage: from mjo.hurwitz import Octonions, HurwitzMatrixAlgebra
408 The inclusion of the unit element is inconsistent across
409 (subalgebras of) Hurwitz algebras::
415 sage: QuaternionAlgebra(AA,1,-1).gens()
417 sage: Octonions().gens()
418 (e0, e1, e2, e3, e4, e5, e6, e7)
420 The unit element is always returned by this method, so the
421 sets of generators have cartinality 1,2,4, and 8 as you'd
424 sage: HurwitzMatrixAlgebra(2, AA, AA).entry_algebra_gens()
426 sage: HurwitzMatrixAlgebra(2, QQbar, AA).entry_algebra_gens()
428 sage: Q = QuaternionAlgebra(AA,-1,-1)
429 sage: HurwitzMatrixAlgebra(2, Q, AA).entry_algebra_gens()
431 sage: O = Octonions()
432 sage: HurwitzMatrixAlgebra(2, O, AA).entry_algebra_gens()
433 (e0, e1, e2, e3, e4, e5, e6, e7)
436 gs
= self
.entry_algebra().gens()
437 one
= self
.entry_algebra().one()
441 return (one
,) + tuple(gs
)
445 class OctonionMatrixAlgebra(HurwitzMatrixAlgebra
):
447 The algebra of ``n``-by-``n`` matrices with octonion entries over
448 (a subfield of) the real numbers.
450 The usual matrix spaces in SageMath don't support octonion entries
451 because they assume that the entries of the matrix come from a
452 commutative and associative ring, and the octonions are neither.
456 sage: from mjo.hurwitz import Octonions, OctonionMatrixAlgebra
460 sage: OctonionMatrixAlgebra(3)
461 Module of 3 by 3 matrices with entries in Octonion algebra with base
462 ring Algebraic Real Field over the scalar ring Algebraic Real Field
466 sage: OctonionMatrixAlgebra(3,scalars=QQ)
467 Module of 3 by 3 matrices with entries in Octonion algebra with
468 base ring Rational Field over the scalar ring Rational Field
472 sage: O = Octonions(RR)
473 sage: A = OctonionMatrixAlgebra(1,O)
475 Module of 1 by 1 matrices with entries in Octonion algebra with
476 base ring Real Field with 53 bits of precision over the scalar
477 ring Algebraic Real Field
479 +---------------------+
480 | 1.00000000000000*e0 |
481 +---------------------+
483 (+---------------------+
484 | 1.00000000000000*e0 |
485 +---------------------+,
486 +---------------------+
487 | 1.00000000000000*e1 |
488 +---------------------+,
489 +---------------------+
490 | 1.00000000000000*e2 |
491 +---------------------+,
492 +---------------------+
493 | 1.00000000000000*e3 |
494 +---------------------+,
495 +---------------------+
496 | 1.00000000000000*e4 |
497 +---------------------+,
498 +---------------------+
499 | 1.00000000000000*e5 |
500 +---------------------+,
501 +---------------------+
502 | 1.00000000000000*e6 |
503 +---------------------+,
504 +---------------------+
505 | 1.00000000000000*e7 |
506 +---------------------+)
510 sage: A = OctonionMatrixAlgebra(2)
511 sage: e0,e1,e2,e3,e4,e5,e6,e7 = A.entry_algebra().gens()
512 sage: A([ [e0+e4, e1+e5],
513 ....: [e2-e6, e3-e7] ])
514 +---------+---------+
515 | e0 + e4 | e1 + e5 |
516 +---------+---------+
517 | e2 - e6 | e3 - e7 |
518 +---------+---------+
522 sage: A1 = OctonionMatrixAlgebra(1,scalars=QQ)
523 sage: A2 = OctonionMatrixAlgebra(1,scalars=QQ)
524 sage: cartesian_product([A1,A2])
525 Module of 1 by 1 matrices with entries in Octonion algebra with
526 base ring Rational Field over the scalar ring Rational Field (+)
527 Module of 1 by 1 matrices with entries in Octonion algebra with
528 base ring Rational Field over the scalar ring Rational Field
532 sage: set_random_seed()
533 sage: A = OctonionMatrixAlgebra(ZZ.random_element(10))
534 sage: x = A.random_element()
535 sage: x*A.one() == x and A.one()*x == x
539 def __init__(self
, n
, entry_algebra
=None, scalars
=AA
, **kwargs
):
540 if entry_algebra
is None:
541 entry_algebra
= Octonions(field
=scalars
)
547 class QuaternionMatrixAlgebra(HurwitzMatrixAlgebra
):
549 The algebra of ``n``-by-``n`` matrices with quaternion entries over
550 (a subfield of) the real numbers.
552 The usual matrix spaces in SageMath don't support quaternion entries
553 because they assume that the entries of the matrix come from a
554 commutative ring, and the quaternions are not commutative.
558 sage: from mjo.hurwitz import QuaternionMatrixAlgebra
562 sage: QuaternionMatrixAlgebra(3)
563 Module of 3 by 3 matrices with entries in Quaternion
564 Algebra (-1, -1) with base ring Algebraic Real Field
565 over the scalar ring Algebraic Real Field
569 sage: QuaternionMatrixAlgebra(3,scalars=QQ)
570 Module of 3 by 3 matrices with entries in Quaternion
571 Algebra (-1, -1) with base ring Rational Field over
572 the scalar ring Rational Field
576 sage: Q = QuaternionAlgebra(RDF, -1, -1)
577 sage: A = QuaternionMatrixAlgebra(1,Q)
579 Module of 1 by 1 matrices with entries in Quaternion Algebra
580 (-1.0, -1.0) with base ring Real Double Field over the scalar
581 ring Algebraic Real Field
602 sage: A = QuaternionMatrixAlgebra(2)
603 sage: i,j,k = A.entry_algebra().gens()
604 sage: A([ [1+i, j-2],
614 sage: A1 = QuaternionMatrixAlgebra(1,scalars=QQ)
615 sage: A2 = QuaternionMatrixAlgebra(2,scalars=QQ)
616 sage: cartesian_product([A1,A2])
617 Module of 1 by 1 matrices with entries in Quaternion Algebra
618 (-1, -1) with base ring Rational Field over the scalar ring
619 Rational Field (+) Module of 2 by 2 matrices with entries in
620 Quaternion Algebra (-1, -1) with base ring Rational Field over
621 the scalar ring Rational Field
625 sage: set_random_seed()
626 sage: A = QuaternionMatrixAlgebra(ZZ.random_element(10))
627 sage: x = A.random_element()
628 sage: x*A.one() == x and A.one()*x == x
632 def __init__(self
, n
, entry_algebra
=None, scalars
=AA
, **kwargs
):
633 if entry_algebra
is None:
634 # The -1,-1 gives us the "usual" definition of quaternion
635 from sage
.algebras
.quatalg
.quaternion_algebra
import (
638 entry_algebra
= QuaternionAlgebra(scalars
,-1,-1)
639 super().__init
__(n
, entry_algebra
, scalars
, **kwargs
)
641 def _entry_algebra_element_to_vector(self
, entry
):
646 sage: from mjo.hurwitz import QuaternionMatrixAlgebra
650 sage: A = QuaternionMatrixAlgebra(2)
651 sage: u = A.entry_algebra().one()
652 sage: A._entry_algebra_element_to_vector(u)
654 sage: i,j,k = A.entry_algebra().gens()
655 sage: A._entry_algebra_element_to_vector(i)
657 sage: A._entry_algebra_element_to_vector(j)
659 sage: A._entry_algebra_element_to_vector(k)
663 from sage
.modules
.free_module
import FreeModule
664 d
= len(self
.entry_algebra_gens())
665 V
= FreeModule(self
.entry_algebra().base_ring(), d
)
666 return V(entry
.coefficient_tuple())
668 class ComplexMatrixAlgebra(HurwitzMatrixAlgebra
):
670 The algebra of ``n``-by-``n`` matrices with complex entries over
671 (a subfield of) the real numbers.
673 These differ from the usual complex matrix spaces in SageMath
674 because the scalar field is real (and not assumed to be the same
675 as the space from which the entries are drawn). The space of
676 `1`-by-`1` complex matrices will have dimension two, for example.
680 sage: from mjo.hurwitz import ComplexMatrixAlgebra
684 sage: ComplexMatrixAlgebra(3)
685 Module of 3 by 3 matrices with entries in Algebraic Field
686 over the scalar ring Algebraic Real Field
690 sage: ComplexMatrixAlgebra(3,scalars=QQ)
691 Module of 3 by 3 matrices with entries in Algebraic Field
692 over the scalar ring Rational Field
696 sage: A = ComplexMatrixAlgebra(1,CC)
698 Module of 1 by 1 matrices with entries in Complex Field with
699 53 bits of precision over the scalar ring Algebraic Real Field
705 (+------------------+
707 +------------------+,
708 +--------------------+
709 | 1.00000000000000*I |
710 +--------------------+)
714 sage: A = ComplexMatrixAlgebra(2)
715 sage: (I,) = A.entry_algebra().gens()
726 sage: A1 = ComplexMatrixAlgebra(1,scalars=QQ)
727 sage: A2 = ComplexMatrixAlgebra(2,scalars=QQ)
728 sage: cartesian_product([A1,A2])
729 Module of 1 by 1 matrices with entries in Algebraic Field over
730 the scalar ring Rational Field (+) Module of 2 by 2 matrices with
731 entries in Algebraic Field over the scalar ring Rational Field
735 sage: set_random_seed()
736 sage: A = ComplexMatrixAlgebra(ZZ.random_element(10))
737 sage: x = A.random_element()
738 sage: x*A.one() == x and A.one()*x == x
742 def __init__(self
, n
, entry_algebra
=None, scalars
=AA
, **kwargs
):
743 if entry_algebra
is None:
744 from sage
.rings
.all
import QQbar
745 entry_algebra
= QQbar
746 super().__init
__(n
, entry_algebra
, scalars
, **kwargs
)
748 def _entry_algebra_element_to_vector(self
, entry
):
753 sage: from mjo.hurwitz import ComplexMatrixAlgebra
757 sage: A = ComplexMatrixAlgebra(2, QQbar, QQ)
758 sage: A._entry_algebra_element_to_vector(QQbar(1))
760 sage: A._entry_algebra_element_to_vector(QQbar(I))
764 from sage
.modules
.free_module
import FreeModule
765 d
= len(self
.entry_algebra_gens())
766 V
= FreeModule(self
.entry_algebra().base_ring(), d
)
767 return V((entry
.real(), entry
.imag()))