+
+
+ def operator_trace_inner_product(self, other):
+ r"""
+ Return the operator inner product of myself and ``other``.
+
+ The "operator inner product," whose name is not standard, is
+ defined be the usual linear-algebraic trace of the
+ ``(x*y).operator()``.
+
+ Proposition III.1.5 in Faraut and Korányi shows that on any
+ Euclidean Jordan algebra, this is another associative inner
+ product under which the cone of squares is symmetric.
+
+ This works even if the basis hasn't been orthonormalized
+ because the eigenvalues of the corresponding matrix don't
+ change when the basis does (they're preserved by any
+ similarity transformation).
+
+ SETUP::
+
+ sage: from mjo.eja.eja_algebra import (JordanSpinEJA,
+ ....: RealSymmetricEJA,
+ ....: ComplexHermitianEJA,
+ ....: random_eja)
+
+ EXAMPLES:
+
+ Proposition III.4.2 of Faraut and Korányi shows that on a
+ simple algebra of rank `r` and dimension `n`, this inner
+ product is `n/r` times the canonical
+ :meth:`trace_inner_product`::
+
+ sage: J = JordanSpinEJA(4, field=QQ)
+ sage: x,y = J.random_elements(2)
+ sage: n = J.dimension()
+ sage: r = J.rank()
+ sage: actual = x.operator_trace_inner_product(y)
+ sage: expected = (n/r)*x.trace_inner_product(y)
+ sage: actual == expected
+ True
+
+ ::
+
+ sage: J = RealSymmetricEJA(3)
+ sage: x,y = J.random_elements(2)
+ sage: n = J.dimension()
+ sage: r = J.rank()
+ sage: actual = x.operator_trace_inner_product(y)
+ sage: expected = (n/r)*x.trace_inner_product(y)
+ sage: actual == expected
+ True
+
+ ::
+
+ sage: J = ComplexHermitianEJA(3, field=QQ, orthonormalize=False)
+ sage: x,y = J.random_elements(2)
+ sage: n = J.dimension()
+ sage: r = J.rank()
+ sage: actual = x.operator_trace_inner_product(y)
+ sage: expected = (n/r)*x.trace_inner_product(y)
+ sage: actual == expected
+ True
+
+ TESTS:
+
+ The operator inner product is commutative, bilinear, and
+ associative::
+
+ sage: J = random_eja()
+ sage: x,y,z = J.random_elements(3)
+ sage: # commutative
+ sage: actual = x.operator_trace_inner_product(y)
+ sage: expected = y.operator_trace_inner_product(x)
+ sage: actual == expected
+ True
+ sage: # bilinear
+ sage: a = J.base_ring().random_element()
+ sage: actual = (a*(x+z)).operator_trace_inner_product(y)
+ sage: expected = ( a*x.operator_trace_inner_product(y) +
+ ....: a*z.operator_trace_inner_product(y) )
+ sage: actual == expected
+ True
+ sage: actual = x.operator_trace_inner_product(a*(y+z))
+ sage: expected = ( a*x.operator_trace_inner_product(y) +
+ ....: a*x.operator_trace_inner_product(z) )
+ sage: actual == expected
+ True
+ sage: # associative
+ sage: actual = (x*y).operator_trace_inner_product(z)
+ sage: expected = y.operator_trace_inner_product(x*z)
+ sage: actual == expected
+ True
+
+ Despite the fact that the implementation uses a matrix representation,
+ the answer is independent of the basis used::
+
+ sage: J = RealSymmetricEJA(3, field=QQ, orthonormalize=False)
+ sage: V = RealSymmetricEJA(3)
+ sage: x,y = J.random_elements(2)
+ sage: w = V(x.to_matrix())
+ sage: z = V(y.to_matrix())
+ sage: expected = x.operator_trace_inner_product(y)
+ sage: actual = w.operator_trace_inner_product(z)
+ sage: actual == expected
+ True
+
+ """
+ if not other in self.parent():
+ raise TypeError("'other' must live in the same algebra")
+
+ return (self*other).operator().matrix().trace()
+
+
+ def operator_trace_norm(self):
+ """
+ The norm of this element with respect to
+ :meth:`operator_trace_inner_product`.
+
+ SETUP::
+
+ sage: from mjo.eja.eja_algebra import (JordanSpinEJA,
+ ....: HadamardEJA)
+
+ EXAMPLES:
+
+ On a simple algebra, this will differ from :meth:`trace_norm`
+ by the scalar factor ``(n/r).sqrt()``, where `n` is the
+ dimension of the algebra and `r` its rank. This follows from
+ the corresponding result (Proposition III.4.2 of Faraut and
+ Korányi) for the trace inner product::
+
+ sage: J = HadamardEJA(2)
+ sage: x = sum(J.gens())
+ sage: x.operator_trace_norm()
+ 1.414213562373095?
+
+ ::
+
+ sage: J = JordanSpinEJA(4)
+ sage: x = sum(J.gens())
+ sage: x.operator_trace_norm()
+ 4
+
+ """
+ return self.operator_trace_inner_product(self).sqrt()
+
+
+class CartesianProductParentEJAElement(EJAElement):
+ r"""
+ An intermediate class for elements that have a Cartesian
+ product as their parent algebra.
+
+ This is needed because the ``to_matrix`` method (which gives you a
+ representation from the superalgebra) needs to do special stuff
+ for Cartesian products. Specifically, an EJA subalgebra of a
+ Cartesian product EJA will not itself be a Cartesian product (it
+ has its own basis) -- but we want ``to_matrix()`` to be able to
+ give us a Cartesian product representation.
+ """
+ def to_matrix(self):
+ # An override is necessary to call our custom _scale().
+ B = self.parent().matrix_basis()
+ W = self.parent().matrix_space()
+
+ # Aaaaand linear combinations don't work in Cartesian
+ # product spaces, even though they provide a method with
+ # that name. This is hidden in a subclass because the
+ # _scale() function is slow.
+ pairs = zip(B, self.to_vector())
+ return W.sum( _scale(b, alpha) for (b,alpha) in pairs )
+
+class CartesianProductEJAElement(CartesianProductParentEJAElement):
+ def det(self):
+ r"""
+ Compute the determinant of this product-element using the
+ determianants of its factors.
+
+ This result Follows from the spectral decomposition of (say)
+ the pair `(x,y)` in terms of the Jordan frame `\left\{ (c_1,
+ 0),(c_2, 0),...,(0,d_1),(0,d_2),... \right\}.
+ """
+ from sage.misc.misc_c import prod
+ return prod( f.det() for f in self.cartesian_factors() )