2 Euclidean Jordan Algebras. These are formally-real Jordan Algebras;
3 specifically those where u^2 + v^2 = 0 implies that u = v = 0. They
4 are used in optimization, and have some additional nice methods beyond
5 what can be supported in a general Jordan Algebra.
8 from sage
.categories
.magmatic_algebras
import MagmaticAlgebras
9 from sage
.structure
.element
import is_Matrix
10 from sage
.structure
.category_object
import normalize_names
12 from sage
.algebras
.finite_dimensional_algebras
.finite_dimensional_algebra
import FiniteDimensionalAlgebra
13 from sage
.algebras
.finite_dimensional_algebras
.finite_dimensional_algebra_element
import FiniteDimensionalAlgebraElement
15 class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra
):
17 def __classcall_private__(cls
,
21 assume_associative
=False,
25 mult_table
= [b
.base_extend(field
) for b
in mult_table
]
28 if not (is_Matrix(b
) and b
.dimensions() == (n
, n
)):
29 raise ValueError("input is not a multiplication table")
30 mult_table
= tuple(mult_table
)
32 cat
= MagmaticAlgebras(field
).FiniteDimensional().WithBasis()
33 cat
.or_subcategory(category
)
34 if assume_associative
:
35 cat
= cat
.Associative()
37 names
= normalize_names(n
, names
)
39 fda
= super(FiniteDimensionalEuclideanJordanAlgebra
, cls
)
40 return fda
.__classcall
__(cls
,
43 assume_associative
=assume_associative
,
49 def __init__(self
, field
,
52 assume_associative
=False,
58 By definition, Jordan multiplication commutes::
60 sage: set_random_seed()
61 sage: J = random_eja()
62 sage: x = J.random_element()
63 sage: y = J.random_element()
69 fda
= super(FiniteDimensionalEuclideanJordanAlgebra
, self
)
78 Return a string representation of ``self``.
80 fmt
= "Euclidean Jordan algebra of degree {} over {}"
81 return fmt
.format(self
.degree(), self
.base_ring())
85 Return the rank of this EJA.
87 if self
._rank
is None:
88 raise ValueError("no rank specified at genesis")
93 class Element(FiniteDimensionalAlgebraElement
):
95 An element of a Euclidean Jordan algebra.
100 Return ``self`` raised to the power ``n``.
102 Jordan algebras are always power-associative; see for
103 example Faraut and Koranyi, Proposition II.1.2 (ii).
107 We have to override this because our superclass uses row vectors
108 instead of column vectors! We, on the other hand, assume column
113 sage: set_random_seed()
114 sage: x = random_eja().random_element()
115 sage: x.matrix()*x.vector() == (x^2).vector()
118 A few examples of power-associativity::
120 sage: set_random_seed()
121 sage: x = random_eja().random_element()
122 sage: x*(x*x)*(x*x) == x^5
124 sage: (x*x)*(x*x*x) == x^5
127 We also know that powers operator-commute (Koecher, Chapter
130 sage: set_random_seed()
131 sage: x = random_eja().random_element()
132 sage: m = ZZ.random_element(0,10)
133 sage: n = ZZ.random_element(0,10)
134 sage: Lxm = (x^m).matrix()
135 sage: Lxn = (x^n).matrix()
136 sage: Lxm*Lxn == Lxn*Lxm
146 return A
.element_class(A
, (self
.matrix()**(n
-1))*self
.vector())
149 def characteristic_polynomial(self
):
151 Return my characteristic polynomial (if I'm a regular
154 Eventually this should be implemented in terms of the parent
155 algebra's characteristic polynomial that works for ALL
158 if self
.is_regular():
159 return self
.minimal_polynomial()
161 raise NotImplementedError('irregular element')
164 def operator_commutes_with(self
, other
):
166 Return whether or not this element operator-commutes
171 The definition of a Jordan algebra says that any element
172 operator-commutes with its square::
174 sage: set_random_seed()
175 sage: x = random_eja().random_element()
176 sage: x.operator_commutes_with(x^2)
181 Test Lemma 1 from Chapter III of Koecher::
183 sage: set_random_seed()
184 sage: J = random_eja()
185 sage: u = J.random_element()
186 sage: v = J.random_element()
187 sage: lhs = u.operator_commutes_with(u*v)
188 sage: rhs = v.operator_commutes_with(u^2)
193 if not other
in self
.parent():
194 raise ArgumentError("'other' must live in the same algebra")
203 Return my determinant, the product of my eigenvalues.
207 sage: J = JordanSpinSimpleEJA(2)
208 sage: e0,e1 = J.gens()
212 sage: J = JordanSpinSimpleEJA(3)
213 sage: e0,e1,e2 = J.gens()
214 sage: x = e0 + e1 + e2
219 cs
= self
.characteristic_polynomial().coefficients(sparse
=False)
222 return cs
[0] * (-1)**r
224 raise ValueError('charpoly had no coefficients')
229 Return the Jordan-multiplicative inverse of this element.
231 We can't use the superclass method because it relies on the
232 algebra being associative.
236 The inverse in the spin factor algebra is given in Alizadeh's
239 sage: set_random_seed()
240 sage: n = ZZ.random_element(1,10)
241 sage: J = JordanSpinSimpleEJA(n)
242 sage: x = J.random_element()
243 sage: while x.is_zero():
244 ....: x = J.random_element()
245 sage: x_vec = x.vector()
247 sage: x_bar = x_vec[1:]
248 sage: coeff = 1/(x0^2 - x_bar.inner_product(x_bar))
249 sage: inv_vec = x_vec.parent()([x0] + (-x_bar).list())
250 sage: x_inverse = coeff*inv_vec
251 sage: x.inverse() == J(x_inverse)
256 The identity element is its own inverse::
258 sage: set_random_seed()
259 sage: J = random_eja()
260 sage: J.one().inverse() == J.one()
263 If an element has an inverse, it acts like one. TODO: this
264 can be a lot less ugly once ``is_invertible`` doesn't crash
265 on irregular elements::
267 sage: set_random_seed()
268 sage: J = random_eja()
269 sage: x = J.random_element()
271 ....: x.inverse()*x == J.one()
277 if self
.parent().is_associative():
278 elt
= FiniteDimensionalAlgebraElement(self
.parent(), self
)
281 # TODO: we can do better once the call to is_invertible()
282 # doesn't crash on irregular elements.
283 #if not self.is_invertible():
284 # raise ArgumentError('element is not invertible')
286 # We do this a little different than the usual recursive
287 # call to a finite-dimensional algebra element, because we
288 # wind up with an inverse that lives in the subalgebra and
289 # we need information about the parent to convert it back.
290 V
= self
.span_of_powers()
291 assoc_subalg
= self
.subalgebra_generated_by()
292 # Mis-design warning: the basis used for span_of_powers()
293 # and subalgebra_generated_by() must be the same, and in
295 elt
= assoc_subalg(V
.coordinates(self
.vector()))
297 # This will be in the subalgebra's coordinates...
298 fda_elt
= FiniteDimensionalAlgebraElement(assoc_subalg
, elt
)
299 subalg_inverse
= fda_elt
.inverse()
301 # So we have to convert back...
302 basis
= [ self
.parent(v
) for v
in V
.basis() ]
303 pairs
= zip(subalg_inverse
.vector(), basis
)
304 return self
.parent().linear_combination(pairs
)
307 def is_invertible(self
):
309 Return whether or not this element is invertible.
311 We can't use the superclass method because it relies on
312 the algebra being associative.
314 return not self
.det().is_zero()
317 def is_nilpotent(self
):
319 Return whether or not some power of this element is zero.
321 The superclass method won't work unless we're in an
322 associative algebra, and we aren't. However, we generate
323 an assocoative subalgebra and we're nilpotent there if and
324 only if we're nilpotent here (probably).
328 The identity element is never nilpotent::
330 sage: set_random_seed()
331 sage: random_eja().one().is_nilpotent()
334 The additive identity is always nilpotent::
336 sage: set_random_seed()
337 sage: random_eja().zero().is_nilpotent()
341 # The element we're going to call "is_nilpotent()" on.
342 # Either myself, interpreted as an element of a finite-
343 # dimensional algebra, or an element of an associative
347 if self
.parent().is_associative():
348 elt
= FiniteDimensionalAlgebraElement(self
.parent(), self
)
350 V
= self
.span_of_powers()
351 assoc_subalg
= self
.subalgebra_generated_by()
352 # Mis-design warning: the basis used for span_of_powers()
353 # and subalgebra_generated_by() must be the same, and in
355 elt
= assoc_subalg(V
.coordinates(self
.vector()))
357 # Recursive call, but should work since elt lives in an
358 # associative algebra.
359 return elt
.is_nilpotent()
362 def is_regular(self
):
364 Return whether or not this is a regular element.
368 The identity element always has degree one, but any element
369 linearly-independent from it is regular::
371 sage: J = JordanSpinSimpleEJA(5)
372 sage: J.one().is_regular()
374 sage: e0, e1, e2, e3, e4 = J.gens() # e0 is the identity
375 sage: for x in J.gens():
376 ....: (J.one() + x).is_regular()
384 return self
.degree() == self
.parent().rank()
389 Compute the degree of this element the straightforward way
390 according to the definition; by appending powers to a list
391 and figuring out its dimension (that is, whether or not
392 they're linearly dependent).
396 sage: J = JordanSpinSimpleEJA(4)
397 sage: J.one().degree()
399 sage: e0,e1,e2,e3 = J.gens()
400 sage: (e0 - e1).degree()
403 In the spin factor algebra (of rank two), all elements that
404 aren't multiples of the identity are regular::
406 sage: set_random_seed()
407 sage: n = ZZ.random_element(1,10)
408 sage: J = JordanSpinSimpleEJA(n)
409 sage: x = J.random_element()
410 sage: x == x.coefficient(0)*J.one() or x.degree() == 2
414 return self
.span_of_powers().dimension()
419 Return the matrix that represents left- (or right-)
420 multiplication by this element in the parent algebra.
422 We have to override this because the superclass method
423 returns a matrix that acts on row vectors (that is, on
428 Test the first polarization identity from my notes, Koecher Chapter
429 III, or from Baes (2.3)::
431 sage: set_random_seed()
432 sage: J = random_eja()
433 sage: x = J.random_element()
434 sage: y = J.random_element()
435 sage: Lx = x.matrix()
436 sage: Ly = y.matrix()
437 sage: Lxx = (x*x).matrix()
438 sage: Lxy = (x*y).matrix()
439 sage: bool(2*Lx*Lxy + Ly*Lxx == 2*Lxy*Lx + Lxx*Ly)
442 Test the second polarization identity from my notes or from
445 sage: set_random_seed()
446 sage: J = random_eja()
447 sage: x = J.random_element()
448 sage: y = J.random_element()
449 sage: z = J.random_element()
450 sage: Lx = x.matrix()
451 sage: Ly = y.matrix()
452 sage: Lz = z.matrix()
453 sage: Lzy = (z*y).matrix()
454 sage: Lxy = (x*y).matrix()
455 sage: Lxz = (x*z).matrix()
456 sage: bool(Lx*Lzy + Lz*Lxy + Ly*Lxz == Lzy*Lx + Lxy*Lz + Lxz*Ly)
459 Test the third polarization identity from my notes or from
462 sage: set_random_seed()
463 sage: J = random_eja()
464 sage: u = J.random_element()
465 sage: y = J.random_element()
466 sage: z = J.random_element()
467 sage: Lu = u.matrix()
468 sage: Ly = y.matrix()
469 sage: Lz = z.matrix()
470 sage: Lzy = (z*y).matrix()
471 sage: Luy = (u*y).matrix()
472 sage: Luz = (u*z).matrix()
473 sage: Luyz = (u*(y*z)).matrix()
474 sage: lhs = Lu*Lzy + Lz*Luy + Ly*Luz
475 sage: rhs = Luyz + Ly*Lu*Lz + Lz*Lu*Ly
476 sage: bool(lhs == rhs)
480 fda_elt
= FiniteDimensionalAlgebraElement(self
.parent(), self
)
481 return fda_elt
.matrix().transpose()
484 def minimal_polynomial(self
):
488 sage: set_random_seed()
489 sage: x = random_eja().random_element()
490 sage: x.degree() == x.minimal_polynomial().degree()
495 sage: set_random_seed()
496 sage: x = random_eja().random_element()
497 sage: x.degree() == x.minimal_polynomial().degree()
500 The minimal polynomial and the characteristic polynomial coincide
501 and are known (see Alizadeh, Example 11.11) for all elements of
502 the spin factor algebra that aren't scalar multiples of the
505 sage: set_random_seed()
506 sage: n = ZZ.random_element(2,10)
507 sage: J = JordanSpinSimpleEJA(n)
508 sage: y = J.random_element()
509 sage: while y == y.coefficient(0)*J.one():
510 ....: y = J.random_element()
511 sage: y0 = y.vector()[0]
512 sage: y_bar = y.vector()[1:]
513 sage: actual = y.minimal_polynomial()
514 sage: x = SR.symbol('x', domain='real')
515 sage: expected = x^2 - 2*y0*x + (y0^2 - norm(y_bar)^2)
516 sage: bool(actual == expected)
520 # The element we're going to call "minimal_polynomial()" on.
521 # Either myself, interpreted as an element of a finite-
522 # dimensional algebra, or an element of an associative
526 if self
.parent().is_associative():
527 elt
= FiniteDimensionalAlgebraElement(self
.parent(), self
)
529 V
= self
.span_of_powers()
530 assoc_subalg
= self
.subalgebra_generated_by()
531 # Mis-design warning: the basis used for span_of_powers()
532 # and subalgebra_generated_by() must be the same, and in
534 elt
= assoc_subalg(V
.coordinates(self
.vector()))
536 # Recursive call, but should work since elt lives in an
537 # associative algebra.
538 return elt
.minimal_polynomial()
541 def quadratic_representation(self
, other
=None):
543 Return the quadratic representation of this element.
547 The explicit form in the spin factor algebra is given by
548 Alizadeh's Example 11.12::
550 sage: set_random_seed()
551 sage: n = ZZ.random_element(1,10)
552 sage: J = JordanSpinSimpleEJA(n)
553 sage: x = J.random_element()
554 sage: x_vec = x.vector()
556 sage: x_bar = x_vec[1:]
557 sage: A = matrix(QQ, 1, [x_vec.inner_product(x_vec)])
558 sage: B = 2*x0*x_bar.row()
559 sage: C = 2*x0*x_bar.column()
560 sage: D = identity_matrix(QQ, n-1)
561 sage: D = (x0^2 - x_bar.inner_product(x_bar))*D
562 sage: D = D + 2*x_bar.tensor_product(x_bar)
563 sage: Q = block_matrix(2,2,[A,B,C,D])
564 sage: Q == x.quadratic_representation()
567 Test all of the properties from Theorem 11.2 in Alizadeh::
569 sage: set_random_seed()
570 sage: J = random_eja()
571 sage: x = J.random_element()
572 sage: y = J.random_element()
576 sage: actual = x.quadratic_representation(y)
577 sage: expected = ( (x+y).quadratic_representation()
578 ....: -x.quadratic_representation()
579 ....: -y.quadratic_representation() ) / 2
580 sage: actual == expected
585 sage: alpha = QQ.random_element()
586 sage: actual = (alpha*x).quadratic_representation()
587 sage: expected = (alpha^2)*x.quadratic_representation()
588 sage: actual == expected
593 sage: Qy = y.quadratic_representation()
594 sage: actual = J(Qy*x.vector()).quadratic_representation()
595 sage: expected = Qy*x.quadratic_representation()*Qy
596 sage: actual == expected
601 sage: k = ZZ.random_element(1,10)
602 sage: actual = (x^k).quadratic_representation()
603 sage: expected = (x.quadratic_representation())^k
604 sage: actual == expected
610 elif not other
in self
.parent():
611 raise ArgumentError("'other' must live in the same algebra")
613 return ( self
.matrix()*other
.matrix()
614 + other
.matrix()*self
.matrix()
615 - (self
*other
).matrix() )
618 def span_of_powers(self
):
620 Return the vector space spanned by successive powers of
623 # The dimension of the subalgebra can't be greater than
624 # the big algebra, so just put everything into a list
625 # and let span() get rid of the excess.
626 V
= self
.vector().parent()
627 return V
.span( (self
**d
).vector() for d
in xrange(V
.dimension()) )
630 def subalgebra_generated_by(self
):
632 Return the associative subalgebra of the parent EJA generated
637 sage: set_random_seed()
638 sage: x = random_eja().random_element()
639 sage: x.subalgebra_generated_by().is_associative()
642 Squaring in the subalgebra should be the same thing as
643 squaring in the superalgebra::
645 sage: set_random_seed()
646 sage: x = random_eja().random_element()
647 sage: u = x.subalgebra_generated_by().random_element()
648 sage: u.matrix()*u.vector() == (u**2).vector()
652 # First get the subspace spanned by the powers of myself...
653 V
= self
.span_of_powers()
656 # Now figure out the entries of the right-multiplication
657 # matrix for the successive basis elements b0, b1,... of
660 for b_right
in V
.basis():
661 eja_b_right
= self
.parent()(b_right
)
663 # The first row of the right-multiplication matrix by
664 # b1 is what we get if we apply that matrix to b1. The
665 # second row of the right multiplication matrix by b1
666 # is what we get when we apply that matrix to b2...
668 # IMPORTANT: this assumes that all vectors are COLUMN
669 # vectors, unlike our superclass (which uses row vectors).
670 for b_left
in V
.basis():
671 eja_b_left
= self
.parent()(b_left
)
672 # Multiply in the original EJA, but then get the
673 # coordinates from the subalgebra in terms of its
675 this_row
= V
.coordinates((eja_b_left
*eja_b_right
).vector())
676 b_right_rows
.append(this_row
)
677 b_right_matrix
= matrix(F
, b_right_rows
)
678 mats
.append(b_right_matrix
)
680 # It's an algebra of polynomials in one element, and EJAs
681 # are power-associative.
683 # TODO: choose generator names intelligently.
684 return FiniteDimensionalEuclideanJordanAlgebra(F
, mats
, assume_associative
=True, names
='f')
687 def subalgebra_idempotent(self
):
689 Find an idempotent in the associative subalgebra I generate
690 using Proposition 2.3.5 in Baes.
694 sage: set_random_seed()
696 sage: c = J.random_element().subalgebra_idempotent()
699 sage: J = JordanSpinSimpleEJA(5)
700 sage: c = J.random_element().subalgebra_idempotent()
705 if self
.is_nilpotent():
706 raise ValueError("this only works with non-nilpotent elements!")
708 V
= self
.span_of_powers()
709 J
= self
.subalgebra_generated_by()
710 # Mis-design warning: the basis used for span_of_powers()
711 # and subalgebra_generated_by() must be the same, and in
713 u
= J(V
.coordinates(self
.vector()))
715 # The image of the matrix of left-u^m-multiplication
716 # will be minimal for some natural number s...
718 minimal_dim
= V
.dimension()
719 for i
in xrange(1, V
.dimension()):
720 this_dim
= (u
**i
).matrix().image().dimension()
721 if this_dim
< minimal_dim
:
722 minimal_dim
= this_dim
725 # Now minimal_matrix should correspond to the smallest
726 # non-zero subspace in Baes's (or really, Koecher's)
729 # However, we need to restrict the matrix to work on the
730 # subspace... or do we? Can't we just solve, knowing that
731 # A(c) = u^(s+1) should have a solution in the big space,
734 # Beware, solve_right() means that we're using COLUMN vectors.
735 # Our FiniteDimensionalAlgebraElement superclass uses rows.
738 c_coordinates
= A
.solve_right(u_next
.vector())
740 # Now c_coordinates is the idempotent we want, but it's in
741 # the coordinate system of the subalgebra.
743 # We need the basis for J, but as elements of the parent algebra.
745 basis
= [self
.parent(v
) for v
in V
.basis()]
746 return self
.parent().linear_combination(zip(c_coordinates
, basis
))
751 Return my trace, the sum of my eigenvalues.
755 sage: J = JordanSpinSimpleEJA(3)
756 sage: e0,e1,e2 = J.gens()
757 sage: x = e0 + e1 + e2
762 cs
= self
.characteristic_polynomial().coefficients(sparse
=False)
766 raise ValueError('charpoly had fewer than 2 coefficients')
769 def trace_inner_product(self
, other
):
771 Return the trace inner product of myself and ``other``.
773 if not other
in self
.parent():
774 raise ArgumentError("'other' must live in the same algebra")
776 return (self
*other
).trace()
779 def eja_rn(dimension
, field
=QQ
):
781 Return the Euclidean Jordan Algebra corresponding to the set
782 `R^n` under the Hadamard product.
786 This multiplication table can be verified by hand::
789 sage: e0,e1,e2 = J.gens()
804 # The FiniteDimensionalAlgebra constructor takes a list of
805 # matrices, the ith representing right multiplication by the ith
806 # basis element in the vector space. So if e_1 = (1,0,0), then
807 # right (Hadamard) multiplication of x by e_1 picks out the first
808 # component of x; and likewise for the ith basis element e_i.
809 Qs
= [ matrix(field
, dimension
, dimension
, lambda k
,j
: 1*(k
== j
== i
))
810 for i
in xrange(dimension
) ]
812 return FiniteDimensionalEuclideanJordanAlgebra(field
,Qs
,rank
=dimension
)
818 Return a "random" finite-dimensional Euclidean Jordan Algebra.
822 For now, we choose a random natural number ``n`` (greater than zero)
823 and then give you back one of the following:
825 * The cartesian product of the rational numbers ``n`` times; this is
826 ``QQ^n`` with the Hadamard product.
828 * The Jordan spin algebra on ``QQ^n``.
830 * The ``n``-by-``n`` rational symmetric matrices with the symmetric
833 Later this might be extended to return Cartesian products of the
839 Euclidean Jordan algebra of degree...
842 n
= ZZ
.random_element(1,5)
843 constructor
= choice([eja_rn
,
845 RealSymmetricSimpleEJA
,
846 ComplexHermitianSimpleEJA
])
847 return constructor(n
, field
=QQ
)
851 def _real_symmetric_basis(n
, field
=QQ
):
853 Return a basis for the space of real symmetric n-by-n matrices.
855 # The basis of symmetric matrices, as matrices, in their R^(n-by-n)
859 for j
in xrange(i
+1):
860 Eij
= matrix(field
, n
, lambda k
,l
: k
==i
and l
==j
)
864 # Beware, orthogonal but not normalized!
865 Sij
= Eij
+ Eij
.transpose()
870 def _complex_hermitian_basis(n
, field
=QQ
):
872 Returns a basis for the space of complex Hermitian n-by-n matrices.
876 sage: set_random_seed()
877 sage: n = ZZ.random_element(1,5)
878 sage: all( M.is_symmetric() for M in _complex_hermitian_basis(n) )
882 F
= QuadraticField(-1, 'I')
885 # This is like the symmetric case, but we need to be careful:
887 # * We want conjugate-symmetry, not just symmetry.
888 # * The diagonal will (as a result) be real.
892 for j
in xrange(i
+1):
893 Eij
= matrix(field
, n
, lambda k
,l
: k
==i
and l
==j
)
895 Sij
= _embed_complex_matrix(Eij
)
898 # Beware, orthogonal but not normalized! The second one
899 # has a minus because it's conjugated.
900 Sij_real
= _embed_complex_matrix(Eij
+ Eij
.transpose())
902 Sij_imag
= _embed_complex_matrix(I
*Eij
- I
*Eij
.transpose())
907 def _multiplication_table_from_matrix_basis(basis
):
909 At least three of the five simple Euclidean Jordan algebras have the
910 symmetric multiplication (A,B) |-> (AB + BA)/2, where the
911 multiplication on the right is matrix multiplication. Given a basis
912 for the underlying matrix space, this function returns a
913 multiplication table (obtained by looping through the basis
914 elements) for an algebra of those matrices.
916 # In S^2, for example, we nominally have four coordinates even
917 # though the space is of dimension three only. The vector space V
918 # is supposed to hold the entire long vector, and the subspace W
919 # of V will be spanned by the vectors that arise from symmetric
920 # matrices. Thus for S^2, dim(V) == 4 and dim(W) == 3.
921 field
= basis
[0].base_ring()
922 dimension
= basis
[0].nrows()
925 return vector(field
, m
.list())
928 return matrix(field
, dimension
, v
.list())
930 V
= VectorSpace(field
, dimension
**2)
931 W
= V
.span( mat2vec(s
) for s
in basis
)
933 # Taking the span above reorders our basis (thanks, jerk!) so we
934 # need to put our "matrix basis" in the same order as the
935 # (reordered) vector basis.
936 S
= [ vec2mat(b
) for b
in W
.basis() ]
940 # Brute force the multiplication-by-s matrix by looping
941 # through all elements of the basis and doing the computation
942 # to find out what the corresponding row should be. BEWARE:
943 # these multiplication tables won't be symmetric! It therefore
944 # becomes REALLY IMPORTANT that the underlying algebra
945 # constructor uses ROW vectors and not COLUMN vectors. That's
946 # why we're computing rows here and not columns.
949 this_row
= mat2vec((s
*t
+ t
*s
)/2)
950 Q_rows
.append(W
.coordinates(this_row
))
951 Q
= matrix(field
, W
.dimension(), Q_rows
)
957 def _embed_complex_matrix(M
):
959 Embed the n-by-n complex matrix ``M`` into the space of real
960 matrices of size 2n-by-2n via the map the sends each entry `z = a +
961 bi` to the block matrix ``[[a,b],[-b,a]]``.
965 sage: F = QuadraticField(-1,'i')
966 sage: x1 = F(4 - 2*i)
967 sage: x2 = F(1 + 2*i)
970 sage: M = matrix(F,2,[x1,x2,x3,x4])
971 sage: _embed_complex_matrix(M)
981 raise ArgumentError("the matrix 'M' must be square")
982 field
= M
.base_ring()
987 blocks
.append(matrix(field
, 2, [[a
,-b
],[b
,a
]]))
989 # We can drop the imaginaries here.
990 return block_matrix(field
.base_ring(), n
, blocks
)
993 def _unembed_complex_matrix(M
):
995 The inverse of _embed_complex_matrix().
999 sage: A = matrix(QQ,[ [ 1, 2, 3, 4],
1000 ....: [-2, 1, -4, 3],
1001 ....: [ 9, 10, 11, 12],
1002 ....: [-10, 9, -12, 11] ])
1003 sage: _unembed_complex_matrix(A)
1004 [ -2*i + 1 -4*i + 3]
1005 [ -10*i + 9 -12*i + 11]
1009 raise ArgumentError("the matrix 'M' must be square")
1010 if not n
.mod(2).is_zero():
1011 raise ArgumentError("the matrix 'M' must be a complex embedding")
1013 F
= QuadraticField(-1, 'i')
1016 # Go top-left to bottom-right (reading order), converting every
1017 # 2-by-2 block we see to a single complex element.
1019 for k
in xrange(n
/2):
1020 for j
in xrange(n
/2):
1021 submat
= M
[2*k
:2*k
+2,2*j
:2*j
+2]
1022 if submat
[0,0] != submat
[1,1]:
1023 raise ArgumentError('bad real submatrix')
1024 if submat
[0,1] != -submat
[1,0]:
1025 raise ArgumentError('bad imag submatrix')
1026 z
= submat
[0,0] + submat
[1,0]*i
1029 return matrix(F
, n
/2, elements
)
1032 def RealSymmetricSimpleEJA(n
, field
=QQ
):
1034 The rank-n simple EJA consisting of real symmetric n-by-n
1035 matrices, the usual symmetric Jordan product, and the trace inner
1036 product. It has dimension `(n^2 + n)/2` over the reals.
1040 sage: J = RealSymmetricSimpleEJA(2)
1041 sage: e0, e1, e2 = J.gens()
1051 The degree of this algebra is `(n^2 + n) / 2`::
1053 sage: set_random_seed()
1054 sage: n = ZZ.random_element(1,5)
1055 sage: J = RealSymmetricSimpleEJA(n)
1056 sage: J.degree() == (n^2 + n)/2
1060 S
= _real_symmetric_basis(n
, field
=field
)
1061 Qs
= _multiplication_table_from_matrix_basis(S
)
1063 return FiniteDimensionalEuclideanJordanAlgebra(field
,Qs
,rank
=n
)
1066 def ComplexHermitianSimpleEJA(n
, field
=QQ
):
1068 The rank-n simple EJA consisting of complex Hermitian n-by-n
1069 matrices over the real numbers, the usual symmetric Jordan product,
1070 and the real-part-of-trace inner product. It has dimension `n^2` over
1075 The degree of this algebra is `n^2`::
1077 sage: set_random_seed()
1078 sage: n = ZZ.random_element(1,5)
1079 sage: J = ComplexHermitianSimpleEJA(n)
1080 sage: J.degree() == n^2
1084 S
= _complex_hermitian_basis(n
)
1085 Qs
= _multiplication_table_from_matrix_basis(S
)
1086 return FiniteDimensionalEuclideanJordanAlgebra(field
, Qs
, rank
=n
)
1089 def QuaternionHermitianSimpleEJA(n
):
1091 The rank-n simple EJA consisting of self-adjoint n-by-n quaternion
1092 matrices, the usual symmetric Jordan product, and the
1093 real-part-of-trace inner product. It has dimension `2n^2 - n` over
1098 def OctonionHermitianSimpleEJA(n
):
1100 This shit be crazy. It has dimension 27 over the reals.
1105 def JordanSpinSimpleEJA(n
, field
=QQ
):
1107 The rank-2 simple EJA consisting of real vectors ``x=(x0, x_bar)``
1108 with the usual inner product and jordan product ``x*y =
1109 (<x_bar,y_bar>, x0*y_bar + y0*x_bar)``. It has dimension `n` over
1114 This multiplication table can be verified by hand::
1116 sage: J = JordanSpinSimpleEJA(4)
1117 sage: e0,e1,e2,e3 = J.gens()
1133 In one dimension, this is the reals under multiplication::
1135 sage: J1 = JordanSpinSimpleEJA(1)
1136 sage: J2 = eja_rn(1)
1142 id_matrix
= identity_matrix(field
, n
)
1144 ei
= id_matrix
.column(i
)
1145 Qi
= zero_matrix(field
, n
)
1147 Qi
.set_column(0, ei
)
1148 Qi
+= diagonal_matrix(n
, [ei
[0]]*n
)
1149 # The addition of the diagonal matrix adds an extra ei[0] in the
1150 # upper-left corner of the matrix.
1151 Qi
[0,0] = Qi
[0,0] * ~
field(2)
1154 # The rank of the spin factor algebra is two, UNLESS we're in a
1155 # one-dimensional ambient space (the rank is bounded by the
1156 # ambient dimension).
1157 return FiniteDimensionalEuclideanJordanAlgebra(field
, Qs
, rank
=min(n
,2))