Test the second polarization identity from my notes or from
Baes (2.4)::
- sage: x,y,z = random_eja().random_elements(3)
- sage: Lx = x.operator()
- sage: Ly = y.operator()
- sage: Lz = z.operator()
- sage: Lzy = (z*y).operator()
- sage: Lxy = (x*y).operator()
- sage: Lxz = (x*z).operator()
- sage: bool(Lx*Lzy + Lz*Lxy + Ly*Lxz == Lzy*Lx + Lxy*Lz + Lxz*Ly)
+ sage: x,y,z = random_eja().random_elements(3) # long time
+ sage: Lx = x.operator() # long time
+ sage: Ly = y.operator() # long time
+ sage: Lz = z.operator() # long time
+ sage: Lzy = (z*y).operator() # long time
+ sage: Lxy = (x*y).operator() # long time
+ sage: Lxz = (x*z).operator() # long time
+ sage: lhs = Lx*Lzy + Lz*Lxy + Ly*Lxz # long time
+ sage: rhs = Lzy*Lx + Lxy*Lz + Lxz*Ly # long time
+ sage: bool(lhs == rhs) # long time
True
Test the third polarization identity from my notes or from
Baes (2.5)::
- sage: u,y,z = random_eja().random_elements(3)
- sage: Lu = u.operator()
- sage: Ly = y.operator()
- sage: Lz = z.operator()
- sage: Lzy = (z*y).operator()
- sage: Luy = (u*y).operator()
- sage: Luz = (u*z).operator()
- sage: Luyz = (u*(y*z)).operator()
- sage: lhs = Lu*Lzy + Lz*Luy + Ly*Luz
- sage: rhs = Luyz + Ly*Lu*Lz + Lz*Lu*Ly
- sage: bool(lhs == rhs)
+ sage: u,y,z = random_eja().random_elements(3) # long time
+ sage: Lu = u.operator() # long time
+ sage: Ly = y.operator() # long time
+ sage: Lz = z.operator() # long time
+ sage: Lzy = (z*y).operator() # long time
+ sage: Luy = (u*y).operator() # long time
+ sage: Luz = (u*z).operator() # long time
+ sage: Luyz = (u*(y*z)).operator() # long time
+ sage: lhs = Lu*Lzy + Lz*Luy + Ly*Luz # long time
+ sage: rhs = Luyz + Ly*Lu*Lz + Lz*Lu*Ly # long time
+ sage: bool(lhs == rhs) # long time
True
"""
Ensure that the determinant is multiplicative on an associative
subalgebra as in Faraut and Korányi's Proposition II.2.2::
- sage: J = random_eja().random_element().subalgebra_generated_by()
+ sage: x0 = random_eja().random_element()
+ sage: J = x0.subalgebra_generated_by(orthonormalize=False)
sage: x,y = J.random_elements(2)
sage: (x*y).det() == x.det()*y.det()
True
of an element is the inverse of its left-multiplication operator
applied to the algebra's identity, when that inverse exists::
- sage: J = random_eja()
- sage: x = J.random_element()
- sage: (not x.operator().is_invertible()) or (
- ....: x.operator().inverse()(J.one()) == x.inverse() )
+ sage: J = random_eja() # long time
+ sage: x = J.random_element() # long time
+ sage: (not x.operator().is_invertible()) or ( # long time
+ ....: x.operator().inverse()(J.one()) # long time
+ ....: == # long time
+ ....: x.inverse() ) # long time
True
Check that the fast (cached) and slow algorithms give the same
True
"""
not_invertible_msg = "element is not invertible"
- if self.parent()._charpoly_coefficients.is_in_cache():
+
+ algebra = self.parent()
+ if algebra._charpoly_coefficients.is_in_cache():
# We can invert using our charpoly if it will be fast to
# compute. If the coefficients are cached, our rank had
# better be too!
if self.det().is_zero():
raise ZeroDivisionError(not_invertible_msg)
- r = self.parent().rank()
+ r = algebra.rank()
a = self.characteristic_polynomial().coefficients(sparse=False)
- return (-1)**(r+1)*sum(a[i+1]*self**i for i in range(r))/self.det()
+ return (-1)**(r+1)*algebra.sum(a[i+1]*self**i
+ for i in range(r))/self.det()
try:
inv = (~self.quadratic_representation())(self)
ALGORITHM:
- .........
+ First we handle the special cases where the algebra is
+ trivial, this element is zero, or the dimension of the algebra
+ is one and this element is not zero. With those out of the
+ way, we may assume that ``self`` is nonzero, the algebra is
+ nontrivial, and that the dimension of the algebra is at least
+ two.
+
+ Beginning with the algebra's unit element (power zero), we add
+ successive (basis representations of) powers of this element
+ to a matrix, row-reducing at each step. After row-reducing, we
+ check the rank of the matrix. If adding a row and row-reducing
+ does not increase the rank of the matrix at any point, the row
+ we've just added lives in the span of the previous ones; thus
+ the corresponding power of ``self`` lives in the span of its
+ lesser powers. When that happens, the degree of the minimal
+ polynomial is the rank of the matrix; if it never happens, the
+ degree must be the dimension of the entire space.
SETUP::
sage: x = random_eja().random_element()
sage: x.degree() == x.minimal_polynomial().degree()
True
-
"""
n = self.parent().dimension()
The minimal polynomial should always kill its element::
- sage: x = random_eja().random_element()
- sage: p = x.minimal_polynomial()
- sage: x.apply_univariate_polynomial(p)
+ sage: x = random_eja().random_element() # long time
+ sage: p = x.minimal_polynomial() # long time
+ sage: x.apply_univariate_polynomial(p) # long time
0
The minimal polynomial is invariant under a change of basis,
This subalgebra, being composed of only powers, is associative::
sage: x0 = random_eja().random_element()
- sage: A = x0.subalgebra_generated_by()
+ sage: A = x0.subalgebra_generated_by(orthonormalize=False)
sage: x,y,z = A.random_elements(3)
sage: (x*y)*z == x*(y*z)
True
the superalgebra::
sage: x = random_eja().random_element()
- sage: A = x.subalgebra_generated_by()
+ sage: A = x.subalgebra_generated_by(orthonormalize=False)
sage: A(x^2) == A(x)*A(x)
True
where there are non-nilpotent elements, or that we get the dumb
solution in the trivial algebra::
- sage: J = random_eja()
+ sage: J = random_eja(field=QQ, orthonormalize=False)
sage: x = J.random_element()
sage: while x.is_nilpotent() and not J.is_trivial():
....: x = J.random_element()
if self.is_nilpotent():
raise ValueError("this only works with non-nilpotent elements!")
- J = self.subalgebra_generated_by()
+ # The subalgebra is transient (we return an element of the
+ # superalgebra, i.e. this algebra) so why bother
+ # orthonormalizing?
+ J = self.subalgebra_generated_by(orthonormalize=False)
u = J(self)
# The image of the matrix of left-u^m-multiplication
# subspace... or do we? Can't we just solve, knowing that
# A(c) = u^(s+1) should have a solution in the big space,
# too?
- #
- # Beware, solve_right() means that we're using COLUMN vectors.
- # Our FiniteDimensionalAlgebraElement superclass uses rows.
u_next = u**(s+1)
A = u_next.operator().matrix()
c = J.from_vector(A.solve_right(u_next.to_vector()))
- # Now c is the idempotent we want, but it still lives in the subalgebra.
+ # Now c is the idempotent we want, but it still lives in
+ # the subalgebra.
return c.superalgebra_element()
sage: (alpha*x + y).trace() == alpha*x.trace() + y.trace()
True
+ The trace of a square is nonnegative::
+
+ sage: x = random_eja().random_element()
+ sage: (x*x).trace() >= 0
+ True
+
"""
P = self.parent()
r = P.rank()
# we want the negative of THAT for the trace.
return -p(*self.to_vector())
+ def operator_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 *probably* 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_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_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_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: x.operator_inner_product(y) == y.operator_inner_product(x)
+ True
+ sage: # bilinear
+ sage: a = J.base_ring().random_element()
+ sage: actual = (a*(x+z)).operator_inner_product(y)
+ sage: expected = ( a*x.operator_inner_product(y) +
+ ....: a*z.operator_inner_product(y) )
+ sage: actual == expected
+ True
+ sage: actual = x.operator_inner_product(a*(y+z))
+ sage: expected = ( a*x.operator_inner_product(y) +
+ ....: a*x.operator_inner_product(z) )
+ sage: actual == expected
+ True
+ sage: # associative
+ sage: actual = (x*y).operator_inner_product(z)
+ sage: expected = y.operator_inner_product(x*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 trace_inner_product(self, other):
"""
sage: x.trace_inner_product(y) == y.trace_inner_product(x)
True
sage: # bilinear
- sage: a = J.base_ring().random_element();
+ sage: a = J.base_ring().random_element()
sage: actual = (a*(x+z)).trace_inner_product(y)
sage: expected = ( a*x.trace_inner_product(y) +
....: a*z.trace_inner_product(y) )