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
.algebras
.quatalg
.quaternion_algebra
import QuaternionAlgebra
9 from sage
.categories
.magmatic_algebras
import MagmaticAlgebras
10 from sage
.combinat
.free_module
import CombinatorialFreeModule
11 from sage
.matrix
.constructor
import matrix
12 from sage
.matrix
.matrix_space
import MatrixSpace
13 from sage
.misc
.cachefunc
import cached_method
14 from sage
.misc
.prandom
import choice
15 from sage
.misc
.table
import table
16 from sage
.modules
.free_module
import FreeModule
, VectorSpace
17 from sage
.rings
.integer_ring
import ZZ
18 from sage
.rings
.number_field
.number_field
import NumberField
, QuadraticField
19 from sage
.rings
.polynomial
.polynomial_ring_constructor
import PolynomialRing
20 from sage
.rings
.rational_field
import QQ
21 from sage
.rings
.real_lazy
import CLF
, RLF
22 from sage
.structure
.element
import is_Matrix
24 from mjo
.eja
.eja_element
import FiniteDimensionalEuclideanJordanAlgebraElement
25 from mjo
.eja
.eja_utils
import _mat2vec
27 class FiniteDimensionalEuclideanJordanAlgebra(CombinatorialFreeModule
):
28 # This is an ugly hack needed to prevent the category framework
29 # from implementing a coercion from our base ring (e.g. the
30 # rationals) into the algebra. First of all -- such a coercion is
31 # nonsense to begin with. But more importantly, it tries to do so
32 # in the category of rings, and since our algebras aren't
33 # associative they generally won't be rings.
34 _no_generic_basering_coercion
= True
46 sage: from mjo.eja.eja_algebra import random_eja
50 By definition, Jordan multiplication commutes::
52 sage: set_random_seed()
53 sage: J = random_eja()
54 sage: x = J.random_element()
55 sage: y = J.random_element()
61 self
._natural
_basis
= natural_basis
63 # TODO: HACK for the charpoly.. needs redesign badly.
64 self
._basis
_normalizers
= None
67 category
= MagmaticAlgebras(field
).FiniteDimensional()
68 category
= category
.WithBasis().Unital()
70 fda
= super(FiniteDimensionalEuclideanJordanAlgebra
, self
)
72 range(len(mult_table
)),
75 self
.print_options(bracket
='')
77 # The multiplication table we're given is necessarily in terms
78 # of vectors, because we don't have an algebra yet for
79 # anything to be an element of. However, it's faster in the
80 # long run to have the multiplication table be in terms of
81 # algebra elements. We do this after calling the superclass
82 # constructor so that from_vector() knows what to do.
83 self
._multiplication
_table
= [ map(lambda x
: self
.from_vector(x
), ls
)
84 for ls
in mult_table
]
87 def _element_constructor_(self
, elt
):
89 Construct an element of this algebra from its natural
92 This gets called only after the parent element _call_ method
93 fails to find a coercion for the argument.
97 sage: from mjo.eja.eja_algebra import (JordanSpinEJA,
98 ....: RealCartesianProductEJA,
99 ....: RealSymmetricEJA)
103 The identity in `S^n` is converted to the identity in the EJA::
105 sage: J = RealSymmetricEJA(3)
106 sage: I = matrix.identity(QQ,3)
107 sage: J(I) == J.one()
110 This skew-symmetric matrix can't be represented in the EJA::
112 sage: J = RealSymmetricEJA(3)
113 sage: A = matrix(QQ,3, lambda i,j: i-j)
115 Traceback (most recent call last):
117 ArithmeticError: vector is not in free module
121 Ensure that we can convert any element of the two non-matrix
122 simple algebras (whose natural representations are their usual
123 vector representations) back and forth faithfully::
125 sage: set_random_seed()
126 sage: J = RealCartesianProductEJA.random_instance()
127 sage: x = J.random_element()
128 sage: J(x.to_vector().column()) == x
130 sage: J = JordanSpinEJA.random_instance()
131 sage: x = J.random_element()
132 sage: J(x.to_vector().column()) == x
137 # The superclass implementation of random_element()
138 # needs to be able to coerce "0" into the algebra.
141 natural_basis
= self
.natural_basis()
142 basis_space
= natural_basis
[0].matrix_space()
143 if elt
not in basis_space
:
144 raise ValueError("not a naturally-represented algebra element")
146 # Thanks for nothing! Matrix spaces aren't vector spaces in
147 # Sage, so we have to figure out its natural-basis coordinates
148 # ourselves. We use the basis space's ring instead of the
149 # element's ring because the basis space might be an algebraic
150 # closure whereas the base ring of the 3-by-3 identity matrix
151 # could be QQ instead of QQbar.
152 V
= VectorSpace(basis_space
.base_ring(), elt
.nrows()*elt
.ncols())
153 W
= V
.span_of_basis( _mat2vec(s
) for s
in natural_basis
)
154 coords
= W
.coordinate_vector(_mat2vec(elt
))
155 return self
.from_vector(coords
)
159 def _max_test_case_size():
161 Return an integer "size" that is an upper bound on the size of
162 this algebra when it is used in a random test
163 case. Unfortunately, the term "size" is quite vague -- when
164 dealing with `R^n` under either the Hadamard or Jordan spin
165 product, the "size" refers to the dimension `n`. When dealing
166 with a matrix algebra (real symmetric or complex/quaternion
167 Hermitian), it refers to the size of the matrix, which is
168 far less than the dimension of the underlying vector space.
170 We default to five in this class, which is safe in `R^n`. The
171 matrix algebra subclasses (or any class where the "size" is
172 interpreted to be far less than the dimension) should override
173 with a smaller number.
180 Return a string representation of ``self``.
184 sage: from mjo.eja.eja_algebra import JordanSpinEJA
188 Ensure that it says what we think it says::
190 sage: JordanSpinEJA(2, field=QQ)
191 Euclidean Jordan algebra of dimension 2 over Rational Field
192 sage: JordanSpinEJA(3, field=RDF)
193 Euclidean Jordan algebra of dimension 3 over Real Double Field
196 fmt
= "Euclidean Jordan algebra of dimension {} over {}"
197 return fmt
.format(self
.dimension(), self
.base_ring())
199 def product_on_basis(self
, i
, j
):
200 return self
._multiplication
_table
[i
][j
]
202 def _a_regular_element(self
):
204 Guess a regular element. Needed to compute the basis for our
205 characteristic polynomial coefficients.
209 sage: from mjo.eja.eja_algebra import random_eja
213 Ensure that this hacky method succeeds for every algebra that we
214 know how to construct::
216 sage: set_random_seed()
217 sage: J = random_eja()
218 sage: J._a_regular_element().is_regular()
223 z
= self
.sum( (i
+1)*gs
[i
] for i
in range(len(gs
)) )
224 if not z
.is_regular():
225 raise ValueError("don't know a regular element")
230 def _charpoly_basis_space(self
):
232 Return the vector space spanned by the basis used in our
233 characteristic polynomial coefficients. This is used not only to
234 compute those coefficients, but also any time we need to
235 evaluate the coefficients (like when we compute the trace or
238 z
= self
._a
_regular
_element
()
239 # Don't use the parent vector space directly here in case this
240 # happens to be a subalgebra. In that case, we would be e.g.
241 # two-dimensional but span_of_basis() would expect three
243 V
= VectorSpace(self
.base_ring(), self
.vector_space().dimension())
244 basis
= [ (z
**k
).to_vector() for k
in range(self
.rank()) ]
245 V1
= V
.span_of_basis( basis
)
246 b
= (V1
.basis() + V1
.complement().basis())
247 return V
.span_of_basis(b
)
252 def _charpoly_coeff(self
, i
):
254 Return the coefficient polynomial "a_{i}" of this algebra's
255 general characteristic polynomial.
257 Having this be a separate cached method lets us compute and
258 store the trace/determinant (a_{r-1} and a_{0} respectively)
259 separate from the entire characteristic polynomial.
261 if self
._basis
_normalizers
is not None:
262 # Must be a matrix class?
263 # WARNING/TODO: this whole mess is mis-designed.
264 n
= self
.natural_basis_space().nrows()
265 field
= self
.base_ring().base_ring() # yeeeeaaaahhh
266 J
= self
.__class
__(n
, field
, False)
267 (_
,x
,_
,_
) = J
._charpoly
_matrix
_system
()
268 p
= J
._charpoly
_coeff
(i
)
269 # p might be missing some vars, have to substitute "optionally"
270 pairs
= zip(x
.base_ring().gens(), self
._basis
_normalizers
)
271 substitutions
= { v: v*c for (v,c) in pairs }
272 return p
.subs(substitutions
)
274 (A_of_x
, x
, xr
, detA
) = self
._charpoly
_matrix
_system
()
275 R
= A_of_x
.base_ring()
277 # Guaranteed by theory
280 # Danger: the in-place modification is done for performance
281 # reasons (reconstructing a matrix with huge polynomial
282 # entries is slow), but I don't know how cached_method works,
283 # so it's highly possible that we're modifying some global
284 # list variable by reference, here. In other words, you
285 # probably shouldn't call this method twice on the same
286 # algebra, at the same time, in two threads
287 Ai_orig
= A_of_x
.column(i
)
288 A_of_x
.set_column(i
,xr
)
289 numerator
= A_of_x
.det()
290 A_of_x
.set_column(i
,Ai_orig
)
292 # We're relying on the theory here to ensure that each a_i is
293 # indeed back in R, and the added negative signs are to make
294 # the whole charpoly expression sum to zero.
295 return R(-numerator
/detA
)
299 def _charpoly_matrix_system(self
):
301 Compute the matrix whose entries A_ij are polynomials in
302 X1,...,XN, the vector ``x`` of variables X1,...,XN, the vector
303 corresponding to `x^r` and the determinent of the matrix A =
304 [A_ij]. In other words, all of the fixed (cachable) data needed
305 to compute the coefficients of the characteristic polynomial.
310 # Turn my vector space into a module so that "vectors" can
311 # have multivatiate polynomial entries.
312 names
= tuple('X' + str(i
) for i
in range(1,n
+1))
313 R
= PolynomialRing(self
.base_ring(), names
)
315 # Using change_ring() on the parent's vector space doesn't work
316 # here because, in a subalgebra, that vector space has a basis
317 # and change_ring() tries to bring the basis along with it. And
318 # that doesn't work unless the new ring is a PID, which it usually
322 # Now let x = (X1,X2,...,Xn) be the vector whose entries are
326 # And figure out the "left multiplication by x" matrix in
329 monomial_matrices
= [ self
.monomial(i
).operator().matrix()
330 for i
in range(n
) ] # don't recompute these!
332 ek
= self
.monomial(k
).to_vector()
334 sum( x
[i
]*(monomial_matrices
[i
]*ek
)
335 for i
in range(n
) ) )
336 Lx
= matrix
.column(R
, lmbx_cols
)
338 # Now we can compute powers of x "symbolically"
339 x_powers
= [self
.one().to_vector(), x
]
340 for d
in range(2, r
+1):
341 x_powers
.append( Lx
*(x_powers
[-1]) )
343 idmat
= matrix
.identity(R
, n
)
345 W
= self
._charpoly
_basis
_space
()
346 W
= W
.change_ring(R
.fraction_field())
348 # Starting with the standard coordinates x = (X1,X2,...,Xn)
349 # and then converting the entries to W-coordinates allows us
350 # to pass in the standard coordinates to the charpoly and get
351 # back the right answer. Specifically, with x = (X1,X2,...,Xn),
354 # W.coordinates(x^2) eval'd at (standard z-coords)
358 # W-coords of (standard coords of x^2 eval'd at std-coords of z)
360 # We want the middle equivalent thing in our matrix, but use
361 # the first equivalent thing instead so that we can pass in
362 # standard coordinates.
363 x_powers
= [ W
.coordinate_vector(xp
) for xp
in x_powers
]
364 l2
= [idmat
.column(k
-1) for k
in range(r
+1, n
+1)]
365 A_of_x
= matrix
.column(R
, n
, (x_powers
[:r
] + l2
))
366 return (A_of_x
, x
, x_powers
[r
], A_of_x
.det())
370 def characteristic_polynomial(self
):
372 Return a characteristic polynomial that works for all elements
375 The resulting polynomial has `n+1` variables, where `n` is the
376 dimension of this algebra. The first `n` variables correspond to
377 the coordinates of an algebra element: when evaluated at the
378 coordinates of an algebra element with respect to a certain
379 basis, the result is a univariate polynomial (in the one
380 remaining variable ``t``), namely the characteristic polynomial
385 sage: from mjo.eja.eja_algebra import JordanSpinEJA
389 The characteristic polynomial in the spin algebra is given in
390 Alizadeh, Example 11.11::
392 sage: J = JordanSpinEJA(3)
393 sage: p = J.characteristic_polynomial(); p
394 X1^2 - X2^2 - X3^2 + (-2*t)*X1 + t^2
395 sage: xvec = J.one().to_vector()
403 # The list of coefficient polynomials a_1, a_2, ..., a_n.
404 a
= [ self
._charpoly
_coeff
(i
) for i
in range(n
) ]
406 # We go to a bit of trouble here to reorder the
407 # indeterminates, so that it's easier to evaluate the
408 # characteristic polynomial at x's coordinates and get back
409 # something in terms of t, which is what we want.
411 S
= PolynomialRing(self
.base_ring(),'t')
413 S
= PolynomialRing(S
, R
.variable_names())
416 # Note: all entries past the rth should be zero. The
417 # coefficient of the highest power (x^r) is 1, but it doesn't
418 # appear in the solution vector which contains coefficients
419 # for the other powers (to make them sum to x^r).
421 a
[r
] = 1 # corresponds to x^r
423 # When the rank is equal to the dimension, trying to
424 # assign a[r] goes out-of-bounds.
425 a
.append(1) # corresponds to x^r
427 return sum( a
[k
]*(t
**k
) for k
in range(len(a
)) )
430 def inner_product(self
, x
, y
):
432 The inner product associated with this Euclidean Jordan algebra.
434 Defaults to the trace inner product, but can be overridden by
435 subclasses if they are sure that the necessary properties are
440 sage: from mjo.eja.eja_algebra import random_eja
444 Our inner product satisfies the Jordan axiom, which is also
445 referred to as "associativity" for a symmetric bilinear form::
447 sage: set_random_seed()
448 sage: J = random_eja()
449 sage: x = J.random_element()
450 sage: y = J.random_element()
451 sage: z = J.random_element()
452 sage: (x*y).inner_product(z) == y.inner_product(x*z)
456 X
= x
.natural_representation()
457 Y
= y
.natural_representation()
458 return self
.natural_inner_product(X
,Y
)
461 def is_trivial(self
):
463 Return whether or not this algebra is trivial.
465 A trivial algebra contains only the zero element.
469 sage: from mjo.eja.eja_algebra import ComplexHermitianEJA
473 sage: J = ComplexHermitianEJA(3)
476 sage: A = J.zero().subalgebra_generated_by()
481 return self
.dimension() == 0
484 def multiplication_table(self
):
486 Return a visual representation of this algebra's multiplication
487 table (on basis elements).
491 sage: from mjo.eja.eja_algebra import JordanSpinEJA
495 sage: J = JordanSpinEJA(4)
496 sage: J.multiplication_table()
497 +----++----+----+----+----+
498 | * || e0 | e1 | e2 | e3 |
499 +====++====+====+====+====+
500 | e0 || e0 | e1 | e2 | e3 |
501 +----++----+----+----+----+
502 | e1 || e1 | e0 | 0 | 0 |
503 +----++----+----+----+----+
504 | e2 || e2 | 0 | e0 | 0 |
505 +----++----+----+----+----+
506 | e3 || e3 | 0 | 0 | e0 |
507 +----++----+----+----+----+
510 M
= list(self
._multiplication
_table
) # copy
511 for i
in range(len(M
)):
512 # M had better be "square"
513 M
[i
] = [self
.monomial(i
)] + M
[i
]
514 M
= [["*"] + list(self
.gens())] + M
515 return table(M
, header_row
=True, header_column
=True, frame
=True)
518 def natural_basis(self
):
520 Return a more-natural representation of this algebra's basis.
522 Every finite-dimensional Euclidean Jordan Algebra is a direct
523 sum of five simple algebras, four of which comprise Hermitian
524 matrices. This method returns the original "natural" basis
525 for our underlying vector space. (Typically, the natural basis
526 is used to construct the multiplication table in the first place.)
528 Note that this will always return a matrix. The standard basis
529 in `R^n` will be returned as `n`-by-`1` column matrices.
533 sage: from mjo.eja.eja_algebra import (JordanSpinEJA,
534 ....: RealSymmetricEJA)
538 sage: J = RealSymmetricEJA(2)
540 Finite family {0: e0, 1: e1, 2: e2}
541 sage: J.natural_basis()
543 [1 0] [ 0 1/2*sqrt2] [0 0]
544 [0 0], [1/2*sqrt2 0], [0 1]
549 sage: J = JordanSpinEJA(2)
551 Finite family {0: e0, 1: e1}
552 sage: J.natural_basis()
559 if self
._natural
_basis
is None:
560 M
= self
.natural_basis_space()
561 return tuple( M(b
.to_vector()) for b
in self
.basis() )
563 return self
._natural
_basis
566 def natural_basis_space(self
):
568 Return the matrix space in which this algebra's natural basis
571 if self
._natural
_basis
is None or len(self
._natural
_basis
) == 0:
572 return MatrixSpace(self
.base_ring(), self
.dimension(), 1)
574 return self
._natural
_basis
[0].matrix_space()
578 def natural_inner_product(X
,Y
):
580 Compute the inner product of two naturally-represented elements.
582 For example in the real symmetric matrix EJA, this will compute
583 the trace inner-product of two n-by-n symmetric matrices. The
584 default should work for the real cartesian product EJA, the
585 Jordan spin EJA, and the real symmetric matrices. The others
586 will have to be overridden.
588 return (X
.conjugate_transpose()*Y
).trace()
594 Return the unit element of this algebra.
598 sage: from mjo.eja.eja_algebra import (RealCartesianProductEJA,
603 sage: J = RealCartesianProductEJA(5)
605 e0 + e1 + e2 + e3 + e4
609 The identity element acts like the identity::
611 sage: set_random_seed()
612 sage: J = random_eja()
613 sage: x = J.random_element()
614 sage: J.one()*x == x and x*J.one() == x
617 The matrix of the unit element's operator is the identity::
619 sage: set_random_seed()
620 sage: J = random_eja()
621 sage: actual = J.one().operator().matrix()
622 sage: expected = matrix.identity(J.base_ring(), J.dimension())
623 sage: actual == expected
627 # We can brute-force compute the matrices of the operators
628 # that correspond to the basis elements of this algebra.
629 # If some linear combination of those basis elements is the
630 # algebra identity, then the same linear combination of
631 # their matrices has to be the identity matrix.
633 # Of course, matrices aren't vectors in sage, so we have to
634 # appeal to the "long vectors" isometry.
635 oper_vecs
= [ _mat2vec(g
.operator().matrix()) for g
in self
.gens() ]
637 # Now we use basis linear algebra to find the coefficients,
638 # of the matrices-as-vectors-linear-combination, which should
639 # work for the original algebra basis too.
640 A
= matrix
.column(self
.base_ring(), oper_vecs
)
642 # We used the isometry on the left-hand side already, but we
643 # still need to do it for the right-hand side. Recall that we
644 # wanted something that summed to the identity matrix.
645 b
= _mat2vec( matrix
.identity(self
.base_ring(), self
.dimension()) )
647 # Now if there's an identity element in the algebra, this should work.
648 coeffs
= A
.solve_right(b
)
649 return self
.linear_combination(zip(self
.gens(), coeffs
))
652 def random_element(self
):
653 # Temporary workaround for https://trac.sagemath.org/ticket/28327
654 if self
.is_trivial():
657 s
= super(FiniteDimensionalEuclideanJordanAlgebra
, self
)
658 return s
.random_element()
662 def random_instance(cls
, field
=QQ
, **kwargs
):
664 Return a random instance of this type of algebra.
666 In subclasses for algebras that we know how to construct, this
667 is a shortcut for constructing test cases and examples.
669 if cls
is FiniteDimensionalEuclideanJordanAlgebra
:
670 # Red flag! But in theory we could do this I guess. The
671 # only finite-dimensional exceptional EJA is the
672 # octononions. So, we could just create an EJA from an
673 # associative matrix algebra (generated by a subset of
674 # elements) with the symmetric product. Or, we could punt
675 # to random_eja() here, override it in our subclasses, and
676 # not worry about it.
677 raise NotImplementedError
679 n
= ZZ
.random_element(1, cls
._max
_test
_case
_size
())
680 return cls(n
, field
, **kwargs
)
685 Return the rank of this EJA.
689 The author knows of no algorithm to compute the rank of an EJA
690 where only the multiplication table is known. In lieu of one, we
691 require the rank to be specified when the algebra is created,
692 and simply pass along that number here.
696 sage: from mjo.eja.eja_algebra import (JordanSpinEJA,
697 ....: RealSymmetricEJA,
698 ....: ComplexHermitianEJA,
699 ....: QuaternionHermitianEJA,
704 The rank of the Jordan spin algebra is always two::
706 sage: JordanSpinEJA(2).rank()
708 sage: JordanSpinEJA(3).rank()
710 sage: JordanSpinEJA(4).rank()
713 The rank of the `n`-by-`n` Hermitian real, complex, or
714 quaternion matrices is `n`::
716 sage: RealSymmetricEJA(2).rank()
718 sage: ComplexHermitianEJA(2).rank()
720 sage: QuaternionHermitianEJA(2).rank()
722 sage: RealSymmetricEJA(5).rank()
724 sage: ComplexHermitianEJA(5).rank()
726 sage: QuaternionHermitianEJA(5).rank()
731 Ensure that every EJA that we know how to construct has a
732 positive integer rank::
734 sage: set_random_seed()
735 sage: r = random_eja().rank()
736 sage: r in ZZ and r > 0
743 def vector_space(self
):
745 Return the vector space that underlies this algebra.
749 sage: from mjo.eja.eja_algebra import RealSymmetricEJA
753 sage: J = RealSymmetricEJA(2)
754 sage: J.vector_space()
755 Vector space of dimension 3 over...
758 return self
.zero().to_vector().parent().ambient_vector_space()
761 Element
= FiniteDimensionalEuclideanJordanAlgebraElement
764 class RealCartesianProductEJA(FiniteDimensionalEuclideanJordanAlgebra
):
766 Return the Euclidean Jordan Algebra corresponding to the set
767 `R^n` under the Hadamard product.
769 Note: this is nothing more than the Cartesian product of ``n``
770 copies of the spin algebra. Once Cartesian product algebras
771 are implemented, this can go.
775 sage: from mjo.eja.eja_algebra import RealCartesianProductEJA
779 This multiplication table can be verified by hand::
781 sage: J = RealCartesianProductEJA(3)
782 sage: e0,e1,e2 = J.gens()
798 We can change the generator prefix::
800 sage: RealCartesianProductEJA(3, prefix='r').gens()
804 def __init__(self
, n
, field
=QQ
, **kwargs
):
805 V
= VectorSpace(field
, n
)
806 mult_table
= [ [ V
.gen(i
)*(i
== j
) for j
in range(n
) ]
809 fdeja
= super(RealCartesianProductEJA
, self
)
810 return fdeja
.__init
__(field
, mult_table
, rank
=n
, **kwargs
)
812 def inner_product(self
, x
, y
):
814 Faster to reimplement than to use natural representations.
818 sage: from mjo.eja.eja_algebra import RealCartesianProductEJA
822 Ensure that this is the usual inner product for the algebras
825 sage: set_random_seed()
826 sage: J = RealCartesianProductEJA.random_instance()
827 sage: x = J.random_element()
828 sage: y = J.random_element()
829 sage: X = x.natural_representation()
830 sage: Y = y.natural_representation()
831 sage: x.inner_product(y) == J.natural_inner_product(X,Y)
835 return x
.to_vector().inner_product(y
.to_vector())
840 Return a "random" finite-dimensional Euclidean Jordan Algebra.
844 For now, we choose a random natural number ``n`` (greater than zero)
845 and then give you back one of the following:
847 * The cartesian product of the rational numbers ``n`` times; this is
848 ``QQ^n`` with the Hadamard product.
850 * The Jordan spin algebra on ``QQ^n``.
852 * The ``n``-by-``n`` rational symmetric matrices with the symmetric
855 * The ``n``-by-``n`` complex-rational Hermitian matrices embedded
856 in the space of ``2n``-by-``2n`` real symmetric matrices.
858 * The ``n``-by-``n`` quaternion-rational Hermitian matrices embedded
859 in the space of ``4n``-by-``4n`` real symmetric matrices.
861 Later this might be extended to return Cartesian products of the
866 sage: from mjo.eja.eja_algebra import random_eja
871 Euclidean Jordan algebra of dimension...
874 classname
= choice([RealCartesianProductEJA
,
878 QuaternionHermitianEJA
])
879 return classname
.random_instance()
886 class MatrixEuclideanJordanAlgebra(FiniteDimensionalEuclideanJordanAlgebra
):
888 def _max_test_case_size():
889 # Play it safe, since this will be squared and the underlying
890 # field can have dimension 4 (quaternions) too.
894 def _denormalized_basis(cls
, n
, field
):
895 raise NotImplementedError
897 def __init__(self
, n
, field
=QQ
, normalize_basis
=True, **kwargs
):
898 S
= self
._denormalized
_basis
(n
, field
)
900 if n
> 1 and normalize_basis
:
901 # We'll need sqrt(2) to normalize the basis, and this
902 # winds up in the multiplication table, so the whole
903 # algebra needs to be over the field extension.
904 R
= PolynomialRing(field
, 'z')
907 if p
.is_irreducible():
908 field
= NumberField(p
, 'sqrt2', embedding
=RLF(2).sqrt())
909 S
= [ s
.change_ring(field
) for s
in S
]
910 self
._basis
_normalizers
= tuple(
911 ~
(self
.natural_inner_product(s
,s
).sqrt()) for s
in S
)
912 S
= tuple( s
*c
for (s
,c
) in zip(S
,self
._basis
_normalizers
) )
914 Qs
= self
.multiplication_table_from_matrix_basis(S
)
916 fdeja
= super(MatrixEuclideanJordanAlgebra
, self
)
917 return fdeja
.__init
__(field
,
925 def multiplication_table_from_matrix_basis(basis
):
927 At least three of the five simple Euclidean Jordan algebras have the
928 symmetric multiplication (A,B) |-> (AB + BA)/2, where the
929 multiplication on the right is matrix multiplication. Given a basis
930 for the underlying matrix space, this function returns a
931 multiplication table (obtained by looping through the basis
932 elements) for an algebra of those matrices.
934 # In S^2, for example, we nominally have four coordinates even
935 # though the space is of dimension three only. The vector space V
936 # is supposed to hold the entire long vector, and the subspace W
937 # of V will be spanned by the vectors that arise from symmetric
938 # matrices. Thus for S^2, dim(V) == 4 and dim(W) == 3.
939 field
= basis
[0].base_ring()
940 dimension
= basis
[0].nrows()
942 V
= VectorSpace(field
, dimension
**2)
943 W
= V
.span_of_basis( _mat2vec(s
) for s
in basis
)
945 mult_table
= [[W
.zero() for j
in range(n
)] for i
in range(n
)]
948 mat_entry
= (basis
[i
]*basis
[j
] + basis
[j
]*basis
[i
])/2
949 mult_table
[i
][j
] = W
.coordinate_vector(_mat2vec(mat_entry
))
957 Embed the matrix ``M`` into a space of real matrices.
959 The matrix ``M`` can have entries in any field at the moment:
960 the real numbers, complex numbers, or quaternions. And although
961 they are not a field, we can probably support octonions at some
962 point, too. This function returns a real matrix that "acts like"
963 the original with respect to matrix multiplication; i.e.
965 real_embed(M*N) = real_embed(M)*real_embed(N)
968 raise NotImplementedError
974 The inverse of :meth:`real_embed`.
976 raise NotImplementedError
980 def natural_inner_product(cls
,X
,Y
):
981 Xu
= cls
.real_unembed(X
)
982 Yu
= cls
.real_unembed(Y
)
988 # Otherwise, try the thing that works for complex numbers; and
989 # if that doesn't work, the thing that works for quaternions.
991 return tr
.vector()[0] # real part, imag part is index 1
992 except AttributeError:
993 # A quaternions doesn't have a vector() method, but does
994 # have coefficient_tuple() method that returns the
995 # coefficients of 1, i, j, and k -- in that order.
996 return tr
.coefficient_tuple()[0]
999 class RealSymmetricEJA(MatrixEuclideanJordanAlgebra
):
1001 The rank-n simple EJA consisting of real symmetric n-by-n
1002 matrices, the usual symmetric Jordan product, and the trace inner
1003 product. It has dimension `(n^2 + n)/2` over the reals.
1007 sage: from mjo.eja.eja_algebra import RealSymmetricEJA
1011 sage: J = RealSymmetricEJA(2)
1012 sage: e0, e1, e2 = J.gens()
1022 The dimension of this algebra is `(n^2 + n) / 2`::
1024 sage: set_random_seed()
1025 sage: n_max = RealSymmetricEJA._max_test_case_size()
1026 sage: n = ZZ.random_element(1, n_max)
1027 sage: J = RealSymmetricEJA(n)
1028 sage: J.dimension() == (n^2 + n)/2
1031 The Jordan multiplication is what we think it is::
1033 sage: set_random_seed()
1034 sage: J = RealSymmetricEJA.random_instance()
1035 sage: x = J.random_element()
1036 sage: y = J.random_element()
1037 sage: actual = (x*y).natural_representation()
1038 sage: X = x.natural_representation()
1039 sage: Y = y.natural_representation()
1040 sage: expected = (X*Y + Y*X)/2
1041 sage: actual == expected
1043 sage: J(expected) == x*y
1046 We can change the generator prefix::
1048 sage: RealSymmetricEJA(3, prefix='q').gens()
1049 (q0, q1, q2, q3, q4, q5)
1051 Our natural basis is normalized with respect to the natural inner
1052 product unless we specify otherwise::
1054 sage: set_random_seed()
1055 sage: J = RealSymmetricEJA.random_instance()
1056 sage: all( b.norm() == 1 for b in J.gens() )
1059 Since our natural basis is normalized with respect to the natural
1060 inner product, and since we know that this algebra is an EJA, any
1061 left-multiplication operator's matrix will be symmetric because
1062 natural->EJA basis representation is an isometry and within the EJA
1063 the operator is self-adjoint by the Jordan axiom::
1065 sage: set_random_seed()
1066 sage: x = RealSymmetricEJA.random_instance().random_element()
1067 sage: x.operator().matrix().is_symmetric()
1072 def _denormalized_basis(cls
, n
, field
):
1074 Return a basis for the space of real symmetric n-by-n matrices.
1078 sage: from mjo.eja.eja_algebra import RealSymmetricEJA
1082 sage: set_random_seed()
1083 sage: n = ZZ.random_element(1,5)
1084 sage: B = RealSymmetricEJA._denormalized_basis(n,QQ)
1085 sage: all( M.is_symmetric() for M in B)
1089 # The basis of symmetric matrices, as matrices, in their R^(n-by-n)
1093 for j
in xrange(i
+1):
1094 Eij
= matrix(field
, n
, lambda k
,l
: k
==i
and l
==j
)
1098 Sij
= Eij
+ Eij
.transpose()
1104 def _max_test_case_size():
1105 return 5 # Dimension 10
1110 Embed the matrix ``M`` into a space of real matrices.
1112 The matrix ``M`` can have entries in any field at the moment:
1113 the real numbers, complex numbers, or quaternions. And although
1114 they are not a field, we can probably support octonions at some
1115 point, too. This function returns a real matrix that "acts like"
1116 the original with respect to matrix multiplication; i.e.
1118 real_embed(M*N) = real_embed(M)*real_embed(N)
1125 def real_unembed(M
):
1127 The inverse of :meth:`real_embed`.
1133 class ComplexMatrixEuclideanJordanAlgebra(MatrixEuclideanJordanAlgebra
):
1137 Embed the n-by-n complex matrix ``M`` into the space of real
1138 matrices of size 2n-by-2n via the map the sends each entry `z = a +
1139 bi` to the block matrix ``[[a,b],[-b,a]]``.
1143 sage: from mjo.eja.eja_algebra import \
1144 ....: ComplexMatrixEuclideanJordanAlgebra
1148 sage: F = QuadraticField(-1, 'i')
1149 sage: x1 = F(4 - 2*i)
1150 sage: x2 = F(1 + 2*i)
1153 sage: M = matrix(F,2,[[x1,x2],[x3,x4]])
1154 sage: ComplexMatrixEuclideanJordanAlgebra.real_embed(M)
1163 Embedding is a homomorphism (isomorphism, in fact)::
1165 sage: set_random_seed()
1166 sage: n_max = ComplexMatrixEuclideanJordanAlgebra._max_test_case_size()
1167 sage: n = ZZ.random_element(n_max)
1168 sage: F = QuadraticField(-1, 'i')
1169 sage: X = random_matrix(F, n)
1170 sage: Y = random_matrix(F, n)
1171 sage: Xe = ComplexMatrixEuclideanJordanAlgebra.real_embed(X)
1172 sage: Ye = ComplexMatrixEuclideanJordanAlgebra.real_embed(Y)
1173 sage: XYe = ComplexMatrixEuclideanJordanAlgebra.real_embed(X*Y)
1180 raise ValueError("the matrix 'M' must be square")
1181 field
= M
.base_ring()
1184 a
= z
.vector()[0] # real part, I guess
1185 b
= z
.vector()[1] # imag part, I guess
1186 blocks
.append(matrix(field
, 2, [[a
,b
],[-b
,a
]]))
1188 # We can drop the imaginaries here.
1189 return matrix
.block(field
.base_ring(), n
, blocks
)
1193 def real_unembed(M
):
1195 The inverse of _embed_complex_matrix().
1199 sage: from mjo.eja.eja_algebra import \
1200 ....: ComplexMatrixEuclideanJordanAlgebra
1204 sage: A = matrix(QQ,[ [ 1, 2, 3, 4],
1205 ....: [-2, 1, -4, 3],
1206 ....: [ 9, 10, 11, 12],
1207 ....: [-10, 9, -12, 11] ])
1208 sage: ComplexMatrixEuclideanJordanAlgebra.real_unembed(A)
1210 [ 10*i + 9 12*i + 11]
1214 Unembedding is the inverse of embedding::
1216 sage: set_random_seed()
1217 sage: F = QuadraticField(-1, 'i')
1218 sage: M = random_matrix(F, 3)
1219 sage: Me = ComplexMatrixEuclideanJordanAlgebra.real_embed(M)
1220 sage: ComplexMatrixEuclideanJordanAlgebra.real_unembed(Me) == M
1226 raise ValueError("the matrix 'M' must be square")
1227 if not n
.mod(2).is_zero():
1228 raise ValueError("the matrix 'M' must be a complex embedding")
1230 field
= M
.base_ring() # This should already have sqrt2
1231 R
= PolynomialRing(field
, 'z')
1233 F
= NumberField(z
**2 + 1,'i', embedding
=CLF(-1).sqrt())
1236 # Go top-left to bottom-right (reading order), converting every
1237 # 2-by-2 block we see to a single complex element.
1239 for k
in xrange(n
/2):
1240 for j
in xrange(n
/2):
1241 submat
= M
[2*k
:2*k
+2,2*j
:2*j
+2]
1242 if submat
[0,0] != submat
[1,1]:
1243 raise ValueError('bad on-diagonal submatrix')
1244 if submat
[0,1] != -submat
[1,0]:
1245 raise ValueError('bad off-diagonal submatrix')
1246 z
= submat
[0,0] + submat
[0,1]*i
1249 return matrix(F
, n
/2, elements
)
1252 class ComplexHermitianEJA(ComplexMatrixEuclideanJordanAlgebra
):
1254 The rank-n simple EJA consisting of complex Hermitian n-by-n
1255 matrices over the real numbers, the usual symmetric Jordan product,
1256 and the real-part-of-trace inner product. It has dimension `n^2` over
1261 sage: from mjo.eja.eja_algebra import ComplexHermitianEJA
1265 The dimension of this algebra is `n^2`::
1267 sage: set_random_seed()
1268 sage: n_max = ComplexHermitianEJA._max_test_case_size()
1269 sage: n = ZZ.random_element(1, n_max)
1270 sage: J = ComplexHermitianEJA(n)
1271 sage: J.dimension() == n^2
1274 The Jordan multiplication is what we think it is::
1276 sage: set_random_seed()
1277 sage: J = ComplexHermitianEJA.random_instance()
1278 sage: x = J.random_element()
1279 sage: y = J.random_element()
1280 sage: actual = (x*y).natural_representation()
1281 sage: X = x.natural_representation()
1282 sage: Y = y.natural_representation()
1283 sage: expected = (X*Y + Y*X)/2
1284 sage: actual == expected
1286 sage: J(expected) == x*y
1289 We can change the generator prefix::
1291 sage: ComplexHermitianEJA(2, prefix='z').gens()
1294 Our natural basis is normalized with respect to the natural inner
1295 product unless we specify otherwise::
1297 sage: set_random_seed()
1298 sage: J = ComplexHermitianEJA.random_instance()
1299 sage: all( b.norm() == 1 for b in J.gens() )
1302 Since our natural basis is normalized with respect to the natural
1303 inner product, and since we know that this algebra is an EJA, any
1304 left-multiplication operator's matrix will be symmetric because
1305 natural->EJA basis representation is an isometry and within the EJA
1306 the operator is self-adjoint by the Jordan axiom::
1308 sage: set_random_seed()
1309 sage: x = ComplexHermitianEJA.random_instance().random_element()
1310 sage: x.operator().matrix().is_symmetric()
1315 def _denormalized_basis(cls
, n
, field
):
1317 Returns a basis for the space of complex Hermitian n-by-n matrices.
1319 Why do we embed these? Basically, because all of numerical linear
1320 algebra assumes that you're working with vectors consisting of `n`
1321 entries from a field and scalars from the same field. There's no way
1322 to tell SageMath that (for example) the vectors contain complex
1323 numbers, while the scalar field is real.
1327 sage: from mjo.eja.eja_algebra import ComplexHermitianEJA
1331 sage: set_random_seed()
1332 sage: n = ZZ.random_element(1,5)
1333 sage: field = QuadraticField(2, 'sqrt2')
1334 sage: B = ComplexHermitianEJA._denormalized_basis(n, field)
1335 sage: all( M.is_symmetric() for M in B)
1339 R
= PolynomialRing(field
, 'z')
1341 F
= NumberField(z
**2 + 1, 'I', embedding
=CLF(-1).sqrt())
1344 # This is like the symmetric case, but we need to be careful:
1346 # * We want conjugate-symmetry, not just symmetry.
1347 # * The diagonal will (as a result) be real.
1351 for j
in xrange(i
+1):
1352 Eij
= matrix(F
, n
, lambda k
,l
: k
==i
and l
==j
)
1354 Sij
= cls
.real_embed(Eij
)
1357 # The second one has a minus because it's conjugated.
1358 Sij_real
= cls
.real_embed(Eij
+ Eij
.transpose())
1360 Sij_imag
= cls
.real_embed(I
*Eij
- I
*Eij
.transpose())
1363 # Since we embedded these, we can drop back to the "field" that we
1364 # started with instead of the complex extension "F".
1365 return tuple( s
.change_ring(field
) for s
in S
)
1369 class QuaternionMatrixEuclideanJordanAlgebra(MatrixEuclideanJordanAlgebra
):
1373 Embed the n-by-n quaternion matrix ``M`` into the space of real
1374 matrices of size 4n-by-4n by first sending each quaternion entry `z
1375 = a + bi + cj + dk` to the block-complex matrix ``[[a + bi,
1376 c+di],[-c + di, a-bi]]`, and then embedding those into a real
1381 sage: from mjo.eja.eja_algebra import \
1382 ....: QuaternionMatrixEuclideanJordanAlgebra
1386 sage: Q = QuaternionAlgebra(QQ,-1,-1)
1387 sage: i,j,k = Q.gens()
1388 sage: x = 1 + 2*i + 3*j + 4*k
1389 sage: M = matrix(Q, 1, [[x]])
1390 sage: QuaternionMatrixEuclideanJordanAlgebra.real_embed(M)
1396 Embedding is a homomorphism (isomorphism, in fact)::
1398 sage: set_random_seed()
1399 sage: n_max = QuaternionMatrixEuclideanJordanAlgebra._max_test_case_size()
1400 sage: n = ZZ.random_element(n_max)
1401 sage: Q = QuaternionAlgebra(QQ,-1,-1)
1402 sage: X = random_matrix(Q, n)
1403 sage: Y = random_matrix(Q, n)
1404 sage: Xe = QuaternionMatrixEuclideanJordanAlgebra.real_embed(X)
1405 sage: Ye = QuaternionMatrixEuclideanJordanAlgebra.real_embed(Y)
1406 sage: XYe = QuaternionMatrixEuclideanJordanAlgebra.real_embed(X*Y)
1411 quaternions
= M
.base_ring()
1414 raise ValueError("the matrix 'M' must be square")
1416 F
= QuadraticField(-1, 'i')
1421 t
= z
.coefficient_tuple()
1426 cplxM
= matrix(F
, 2, [[ a
+ b
*i
, c
+ d
*i
],
1427 [-c
+ d
*i
, a
- b
*i
]])
1428 realM
= ComplexMatrixEuclideanJordanAlgebra
.real_embed(cplxM
)
1429 blocks
.append(realM
)
1431 # We should have real entries by now, so use the realest field
1432 # we've got for the return value.
1433 return matrix
.block(quaternions
.base_ring(), n
, blocks
)
1438 def real_unembed(M
):
1440 The inverse of _embed_quaternion_matrix().
1444 sage: from mjo.eja.eja_algebra import \
1445 ....: QuaternionMatrixEuclideanJordanAlgebra
1449 sage: M = matrix(QQ, [[ 1, 2, 3, 4],
1450 ....: [-2, 1, -4, 3],
1451 ....: [-3, 4, 1, -2],
1452 ....: [-4, -3, 2, 1]])
1453 sage: QuaternionMatrixEuclideanJordanAlgebra.real_unembed(M)
1454 [1 + 2*i + 3*j + 4*k]
1458 Unembedding is the inverse of embedding::
1460 sage: set_random_seed()
1461 sage: Q = QuaternionAlgebra(QQ, -1, -1)
1462 sage: M = random_matrix(Q, 3)
1463 sage: Me = QuaternionMatrixEuclideanJordanAlgebra.real_embed(M)
1464 sage: QuaternionMatrixEuclideanJordanAlgebra.real_unembed(Me) == M
1470 raise ValueError("the matrix 'M' must be square")
1471 if not n
.mod(4).is_zero():
1472 raise ValueError("the matrix 'M' must be a complex embedding")
1474 # Use the base ring of the matrix to ensure that its entries can be
1475 # multiplied by elements of the quaternion algebra.
1476 field
= M
.base_ring()
1477 Q
= QuaternionAlgebra(field
,-1,-1)
1480 # Go top-left to bottom-right (reading order), converting every
1481 # 4-by-4 block we see to a 2-by-2 complex block, to a 1-by-1
1484 for l
in xrange(n
/4):
1485 for m
in xrange(n
/4):
1486 submat
= ComplexMatrixEuclideanJordanAlgebra
.real_unembed(
1487 M
[4*l
:4*l
+4,4*m
:4*m
+4] )
1488 if submat
[0,0] != submat
[1,1].conjugate():
1489 raise ValueError('bad on-diagonal submatrix')
1490 if submat
[0,1] != -submat
[1,0].conjugate():
1491 raise ValueError('bad off-diagonal submatrix')
1492 z
= submat
[0,0].vector()[0] # real part
1493 z
+= submat
[0,0].vector()[1]*i
# imag part
1494 z
+= submat
[0,1].vector()[0]*j
# real part
1495 z
+= submat
[0,1].vector()[1]*k
# imag part
1498 return matrix(Q
, n
/4, elements
)
1502 class QuaternionHermitianEJA(QuaternionMatrixEuclideanJordanAlgebra
):
1504 The rank-n simple EJA consisting of self-adjoint n-by-n quaternion
1505 matrices, the usual symmetric Jordan product, and the
1506 real-part-of-trace inner product. It has dimension `2n^2 - n` over
1511 sage: from mjo.eja.eja_algebra import QuaternionHermitianEJA
1515 The dimension of this algebra is `2*n^2 - n`::
1517 sage: set_random_seed()
1518 sage: n_max = QuaternionHermitianEJA._max_test_case_size()
1519 sage: n = ZZ.random_element(1, n_max)
1520 sage: J = QuaternionHermitianEJA(n)
1521 sage: J.dimension() == 2*(n^2) - n
1524 The Jordan multiplication is what we think it is::
1526 sage: set_random_seed()
1527 sage: J = QuaternionHermitianEJA.random_instance()
1528 sage: x = J.random_element()
1529 sage: y = J.random_element()
1530 sage: actual = (x*y).natural_representation()
1531 sage: X = x.natural_representation()
1532 sage: Y = y.natural_representation()
1533 sage: expected = (X*Y + Y*X)/2
1534 sage: actual == expected
1536 sage: J(expected) == x*y
1539 We can change the generator prefix::
1541 sage: QuaternionHermitianEJA(2, prefix='a').gens()
1542 (a0, a1, a2, a3, a4, a5)
1544 Our natural basis is normalized with respect to the natural inner
1545 product unless we specify otherwise::
1547 sage: set_random_seed()
1548 sage: J = QuaternionHermitianEJA.random_instance()
1549 sage: all( b.norm() == 1 for b in J.gens() )
1552 Since our natural basis is normalized with respect to the natural
1553 inner product, and since we know that this algebra is an EJA, any
1554 left-multiplication operator's matrix will be symmetric because
1555 natural->EJA basis representation is an isometry and within the EJA
1556 the operator is self-adjoint by the Jordan axiom::
1558 sage: set_random_seed()
1559 sage: x = QuaternionHermitianEJA.random_instance().random_element()
1560 sage: x.operator().matrix().is_symmetric()
1565 def _denormalized_basis(cls
, n
, field
):
1567 Returns a basis for the space of quaternion Hermitian n-by-n matrices.
1569 Why do we embed these? Basically, because all of numerical
1570 linear algebra assumes that you're working with vectors consisting
1571 of `n` entries from a field and scalars from the same field. There's
1572 no way to tell SageMath that (for example) the vectors contain
1573 complex numbers, while the scalar field is real.
1577 sage: from mjo.eja.eja_algebra import QuaternionHermitianEJA
1581 sage: set_random_seed()
1582 sage: n = ZZ.random_element(1,5)
1583 sage: B = QuaternionHermitianEJA._denormalized_basis(n,QQ)
1584 sage: all( M.is_symmetric() for M in B )
1588 Q
= QuaternionAlgebra(QQ
,-1,-1)
1591 # This is like the symmetric case, but we need to be careful:
1593 # * We want conjugate-symmetry, not just symmetry.
1594 # * The diagonal will (as a result) be real.
1598 for j
in xrange(i
+1):
1599 Eij
= matrix(Q
, n
, lambda k
,l
: k
==i
and l
==j
)
1601 Sij
= cls
.real_embed(Eij
)
1604 # The second, third, and fourth ones have a minus
1605 # because they're conjugated.
1606 Sij_real
= cls
.real_embed(Eij
+ Eij
.transpose())
1608 Sij_I
= cls
.real_embed(I
*Eij
- I
*Eij
.transpose())
1610 Sij_J
= cls
.real_embed(J
*Eij
- J
*Eij
.transpose())
1612 Sij_K
= cls
.real_embed(K
*Eij
- K
*Eij
.transpose())
1618 class JordanSpinEJA(FiniteDimensionalEuclideanJordanAlgebra
):
1620 The rank-2 simple EJA consisting of real vectors ``x=(x0, x_bar)``
1621 with the usual inner product and jordan product ``x*y =
1622 (<x_bar,y_bar>, x0*y_bar + y0*x_bar)``. It has dimension `n` over
1627 sage: from mjo.eja.eja_algebra import JordanSpinEJA
1631 This multiplication table can be verified by hand::
1633 sage: J = JordanSpinEJA(4)
1634 sage: e0,e1,e2,e3 = J.gens()
1650 We can change the generator prefix::
1652 sage: JordanSpinEJA(2, prefix='B').gens()
1656 def __init__(self
, n
, field
=QQ
, **kwargs
):
1657 V
= VectorSpace(field
, n
)
1658 mult_table
= [[V
.zero() for j
in range(n
)] for i
in range(n
)]
1668 z0
= x
.inner_product(y
)
1669 zbar
= y0
*xbar
+ x0
*ybar
1670 z
= V([z0
] + zbar
.list())
1671 mult_table
[i
][j
] = z
1673 # The rank of the spin algebra is two, unless we're in a
1674 # one-dimensional ambient space (because the rank is bounded by
1675 # the ambient dimension).
1676 fdeja
= super(JordanSpinEJA
, self
)
1677 return fdeja
.__init
__(field
, mult_table
, rank
=min(n
,2), **kwargs
)
1679 def inner_product(self
, x
, y
):
1681 Faster to reimplement than to use natural representations.
1685 sage: from mjo.eja.eja_algebra import JordanSpinEJA
1689 Ensure that this is the usual inner product for the algebras
1692 sage: set_random_seed()
1693 sage: J = JordanSpinEJA.random_instance()
1694 sage: x = J.random_element()
1695 sage: y = J.random_element()
1696 sage: X = x.natural_representation()
1697 sage: Y = y.natural_representation()
1698 sage: x.inner_product(y) == J.natural_inner_product(X,Y)
1702 return x
.to_vector().inner_product(y
.to_vector())