- sage: set_random_seed()
- sage: n = ZZ.random_element(1,10)
- sage: J = JordanSpinEJA(n)
- sage: x = J.random_element()
- sage: while not x.is_invertible():
- ....: x = J.random_element()
- sage: x_vec = x.vector()
- sage: x0 = x_vec[0]
- sage: x_bar = x_vec[1:]
- sage: coeff = ~(x0^2 - x_bar.inner_product(x_bar))
- sage: inv_vec = x_vec.parent()([x0] + (-x_bar).list())
- sage: x_inverse = coeff*inv_vec
- sage: x.inverse() == J(x_inverse)
- True
-
- TESTS:
-
- The identity element is its own inverse::
-
- sage: set_random_seed()
- sage: J = random_eja()
- sage: J.one().inverse() == J.one()
- True
-
- If an element has an inverse, it acts like one::
-
- sage: set_random_seed()
- sage: J = random_eja()
- sage: x = J.random_element()
- sage: (not x.is_invertible()) or (x.inverse()*x == J.one())
- True
-
- The inverse of the inverse is what we started with::
-
- sage: set_random_seed()
- sage: J = random_eja()
- sage: x = J.random_element()
- sage: (not x.is_invertible()) or (x.inverse().inverse() == x)
- True
-
- The zero element is never invertible::
-
- sage: set_random_seed()
- sage: J = random_eja().zero().inverse()
- Traceback (most recent call last):
- ...
- ValueError: element is not invertible
-
- """
- if not self.is_invertible():
- raise ValueError("element is not invertible")
-
- return (~self.quadratic_representation())(self)
-
-
- def is_invertible(self):
- """
- Return whether or not this element is invertible.
-
- ALGORITHM:
-
- The usual way to do this is to check if the determinant is
- zero, but we need the characteristic polynomial for the
- determinant. The minimal polynomial is a lot easier to get,
- so we use Corollary 2 in Chapter V of Koecher to check
- whether or not the paren't algebra's zero element is a root
- of this element's minimal polynomial.
-
- Beware that we can't use the superclass method, because it
- relies on the algebra being associative.
-
- SETUP::
-
- sage: from mjo.eja.eja_algebra import random_eja
-
- TESTS:
-
- The identity element is always invertible::
-
- sage: set_random_seed()
- sage: J = random_eja()
- sage: J.one().is_invertible()
- True
-
- The zero element is never invertible::
-
- sage: set_random_seed()
- sage: J = random_eja()
- sage: J.zero().is_invertible()
- False
-
- """
- zero = self.parent().zero()
- p = self.minimal_polynomial()
- return not (p(zero) == zero)
-
-
- def is_nilpotent(self):
- """
- Return whether or not some power of this element is zero.
-
- The superclass method won't work unless we're in an
- associative algebra, and we aren't. However, we generate
- an assocoative subalgebra and we're nilpotent there if and
- only if we're nilpotent here (probably).
-
- SETUP::
-
- sage: from mjo.eja.eja_algebra import random_eja
-
- TESTS:
-
- The identity element is never nilpotent::
-
- sage: set_random_seed()
- sage: random_eja().one().is_nilpotent()
- False
-
- The additive identity is always nilpotent::
-
- sage: set_random_seed()
- sage: random_eja().zero().is_nilpotent()
- True
-
- """
- # The element we're going to call "is_nilpotent()" on.
- # Either myself, interpreted as an element of a finite-
- # dimensional algebra, or an element of an associative
- # subalgebra.
- elt = None
-
- if self.parent().is_associative():
- elt = FiniteDimensionalAlgebraElement(self.parent(), self)
- else:
- V = self.span_of_powers()
- assoc_subalg = self.subalgebra_generated_by()
- # Mis-design warning: the basis used for span_of_powers()
- # and subalgebra_generated_by() must be the same, and in
- # the same order!
- elt = assoc_subalg(V.coordinates(self.vector()))
-
- # Recursive call, but should work since elt lives in an
- # associative algebra.
- return elt.is_nilpotent()
-
-
- def is_regular(self):
- """
- Return whether or not this is a regular element.
-
- SETUP::
-
- sage: from mjo.eja.eja_algebra import JordanSpinEJA
-
- EXAMPLES:
-
- The identity element always has degree one, but any element
- linearly-independent from it is regular::
-
- sage: J = JordanSpinEJA(5)
- sage: J.one().is_regular()
- False
- sage: e0, e1, e2, e3, e4 = J.gens() # e0 is the identity
- sage: for x in J.gens():
- ....: (J.one() + x).is_regular()
- False
- True
- True
- True
- True
-
- """
- return self.degree() == self.parent().rank()
-
-
- def degree(self):
- """
- Compute the degree of this element the straightforward way
- according to the definition; by appending powers to a list
- and figuring out its dimension (that is, whether or not
- they're linearly dependent).
-
- SETUP::
-
- sage: from mjo.eja.eja_algebra import JordanSpinEJA
-
- EXAMPLES::
-
- sage: J = JordanSpinEJA(4)
- sage: J.one().degree()
- 1
- sage: e0,e1,e2,e3 = J.gens()
- sage: (e0 - e1).degree()
- 2
-
- In the spin factor algebra (of rank two), all elements that
- aren't multiples of the identity are regular::
-
- sage: set_random_seed()
- sage: n = ZZ.random_element(1,10)
- sage: J = JordanSpinEJA(n)
- sage: x = J.random_element()
- sage: x == x.coefficient(0)*J.one() or x.degree() == 2
- True
-
- """
- return self.span_of_powers().dimension()
-
-
- def left_matrix(self):
- """
- Our parent class defines ``left_matrix`` and ``matrix``
- methods whose names are misleading. We don't want them.
- """
- raise NotImplementedError("use operator().matrix() instead")
-
- matrix = left_matrix
-
-
- def minimal_polynomial(self):
- """
- Return the minimal polynomial of this element,
- as a function of the variable `t`.
-
- ALGORITHM:
-
- We restrict ourselves to the associative subalgebra
- generated by this element, and then return the minimal
- polynomial of this element's operator matrix (in that
- subalgebra). This works by Baes Proposition 2.3.16.
-
- SETUP::
-
- sage: from mjo.eja.eja_algebra import (JordanSpinEJA,
- ....: random_eja)
-
- TESTS:
-
- The minimal polynomial of the identity and zero elements are
- always the same::
-
- sage: set_random_seed()
- sage: J = random_eja()
- sage: J.one().minimal_polynomial()
- t - 1
- sage: J.zero().minimal_polynomial()
- t
-
- The degree of an element is (by one definition) the degree
- of its minimal polynomial::
-
- sage: set_random_seed()
- sage: x = random_eja().random_element()
- sage: x.degree() == x.minimal_polynomial().degree()
- True
-
- The minimal polynomial and the characteristic polynomial coincide
- and are known (see Alizadeh, Example 11.11) for all elements of
- the spin factor algebra that aren't scalar multiples of the
- identity::
-
- sage: set_random_seed()
- sage: n = ZZ.random_element(2,10)
- sage: J = JordanSpinEJA(n)
- sage: y = J.random_element()
- sage: while y == y.coefficient(0)*J.one():
- ....: y = J.random_element()
- sage: y0 = y.vector()[0]
- sage: y_bar = y.vector()[1:]
- sage: actual = y.minimal_polynomial()
- sage: t = PolynomialRing(J.base_ring(),'t').gen(0)
- sage: expected = t^2 - 2*y0*t + (y0^2 - norm(y_bar)^2)
- sage: bool(actual == expected)
- True
-
- The minimal polynomial should always kill its element::
-
- sage: set_random_seed()
- sage: x = random_eja().random_element()
- sage: p = x.minimal_polynomial()
- sage: x.apply_univariate_polynomial(p)
- 0
-
- """
- V = self.span_of_powers()
- assoc_subalg = self.subalgebra_generated_by()
- # Mis-design warning: the basis used for span_of_powers()
- # and subalgebra_generated_by() must be the same, and in
- # the same order!
- elt = assoc_subalg(V.coordinates(self.vector()))
- return elt.operator().minimal_polynomial()
-
-
-
- def natural_representation(self):
- """
- Return a more-natural representation of this element.
-
- Every finite-dimensional Euclidean Jordan Algebra is a
- direct sum of five simple algebras, four of which comprise
- Hermitian matrices. This method returns the original
- "natural" representation of this element as a Hermitian
- matrix, if it has one. If not, you get the usual representation.
-
- SETUP::
-
- sage: from mjo.eja.eja_algebra import (ComplexHermitianEJA,
- ....: QuaternionHermitianEJA)
-
- EXAMPLES::
-
- sage: J = ComplexHermitianEJA(3)
- sage: J.one()
- e0 + e5 + e8
- sage: J.one().natural_representation()
- [1 0 0 0 0 0]
- [0 1 0 0 0 0]
- [0 0 1 0 0 0]
- [0 0 0 1 0 0]
- [0 0 0 0 1 0]
- [0 0 0 0 0 1]
-
- ::
-
- sage: J = QuaternionHermitianEJA(3)
- sage: J.one()
- e0 + e9 + e14
- sage: J.one().natural_representation()
- [1 0 0 0 0 0 0 0 0 0 0 0]
- [0 1 0 0 0 0 0 0 0 0 0 0]
- [0 0 1 0 0 0 0 0 0 0 0 0]
- [0 0 0 1 0 0 0 0 0 0 0 0]
- [0 0 0 0 1 0 0 0 0 0 0 0]
- [0 0 0 0 0 1 0 0 0 0 0 0]
- [0 0 0 0 0 0 1 0 0 0 0 0]
- [0 0 0 0 0 0 0 1 0 0 0 0]
- [0 0 0 0 0 0 0 0 1 0 0 0]
- [0 0 0 0 0 0 0 0 0 1 0 0]
- [0 0 0 0 0 0 0 0 0 0 1 0]
- [0 0 0 0 0 0 0 0 0 0 0 1]
-
- """
- B = self.parent().natural_basis()
- W = B[0].matrix_space()
- return W.linear_combination(zip(self.vector(), B))
-
-
- def operator(self):
- """
- Return the left-multiplication-by-this-element
- operator on the ambient algebra.
-
- SETUP::
-
- sage: from mjo.eja.eja_algebra import random_eja
-
- TESTS::
-
- sage: set_random_seed()
- sage: J = random_eja()
- sage: x = J.random_element()
- sage: y = J.random_element()
- sage: x.operator()(y) == x*y
- True
- sage: y.operator()(x) == x*y
- True
-
- """
- P = self.parent()
- fda_elt = FiniteDimensionalAlgebraElement(P, self)
- return FiniteDimensionalEuclideanJordanAlgebraOperator(
- P,
- P,
- fda_elt.matrix().transpose() )
-
-
- def quadratic_representation(self, other=None):
- """
- Return the quadratic representation of this element.
-
- SETUP::
-
- sage: from mjo.eja.eja_algebra import (JordanSpinEJA,
- ....: random_eja)
-
- EXAMPLES:
-
- The explicit form in the spin factor algebra is given by
- Alizadeh's Example 11.12::
-
- sage: set_random_seed()
- sage: n = ZZ.random_element(1,10)
- sage: J = JordanSpinEJA(n)
- sage: x = J.random_element()
- sage: x_vec = x.vector()
- sage: x0 = x_vec[0]
- sage: x_bar = x_vec[1:]
- sage: A = matrix(QQ, 1, [x_vec.inner_product(x_vec)])
- sage: B = 2*x0*x_bar.row()
- sage: C = 2*x0*x_bar.column()
- sage: D = matrix.identity(QQ, n-1)
- sage: D = (x0^2 - x_bar.inner_product(x_bar))*D
- sage: D = D + 2*x_bar.tensor_product(x_bar)
- sage: Q = matrix.block(2,2,[A,B,C,D])
- sage: Q == x.quadratic_representation().matrix()
- True
-
- Test all of the properties from Theorem 11.2 in Alizadeh::
-
- sage: set_random_seed()
- sage: J = random_eja()
- sage: x = J.random_element()
- sage: y = J.random_element()
- sage: Lx = x.operator()
- sage: Lxx = (x*x).operator()
- sage: Qx = x.quadratic_representation()
- sage: Qy = y.quadratic_representation()
- sage: Qxy = x.quadratic_representation(y)
- sage: Qex = J.one().quadratic_representation(x)
- sage: n = ZZ.random_element(10)
- sage: Qxn = (x^n).quadratic_representation()
-
- Property 1:
-
- sage: 2*Qxy == (x+y).quadratic_representation() - Qx - Qy
- True
-
- Property 2 (multiply on the right for :trac:`28272`):
-
- sage: alpha = QQ.random_element()
- sage: (alpha*x).quadratic_representation() == Qx*(alpha^2)
- True
-
- Property 3:
-
- sage: not x.is_invertible() or ( Qx(x.inverse()) == x )
- True
-
- sage: not x.is_invertible() or (
- ....: ~Qx
- ....: ==
- ....: x.inverse().quadratic_representation() )
- True
-
- sage: Qxy(J.one()) == x*y
- True
-
- Property 4:
-
- sage: not x.is_invertible() or (
- ....: x.quadratic_representation(x.inverse())*Qx
- ....: == Qx*x.quadratic_representation(x.inverse()) )
- True
-
- sage: not x.is_invertible() or (
- ....: x.quadratic_representation(x.inverse())*Qx
- ....: ==
- ....: 2*x.operator()*Qex - Qx )
- True
-
- sage: 2*x.operator()*Qex - Qx == Lxx
- True
-
- Property 5:
-
- sage: Qy(x).quadratic_representation() == Qy*Qx*Qy
- True
-
- Property 6:
-
- sage: Qxn == (Qx)^n
- True
-
- Property 7:
-
- sage: not x.is_invertible() or (
- ....: Qx*x.inverse().operator() == Lx )
- True
-
- Property 8:
-
- sage: not x.operator_commutes_with(y) or (
- ....: Qx(y)^n == Qxn(y^n) )
- True
-
- """
- if other is None:
- other=self
- elif not other in self.parent():
- raise TypeError("'other' must live in the same algebra")
-
- L = self.operator()
- M = other.operator()
- return ( L*M + M*L - (self*other).operator() )
-
-
- def span_of_powers(self):
- """
- Return the vector space spanned by successive powers of
- this element.
- """
- # The dimension of the subalgebra can't be greater than
- # the big algebra, so just put everything into a list
- # and let span() get rid of the excess.
- #
- # We do the extra ambient_vector_space() in case we're messing
- # with polynomials and the direct parent is a module.
- V = self.parent().vector_space()
- return V.span( (self**d).vector() for d in xrange(V.dimension()) )
-
-
- def subalgebra_generated_by(self):
- """
- Return the associative subalgebra of the parent EJA generated
- by this element.
-
- SETUP::
-
- sage: from mjo.eja.eja_algebra import random_eja
-
- TESTS::
-
- sage: set_random_seed()
- sage: x = random_eja().random_element()
- sage: x.subalgebra_generated_by().is_associative()
- True
-
- Squaring in the subalgebra should work the same as in
- the superalgebra::
-
- sage: set_random_seed()
- sage: x = random_eja().random_element()
- sage: u = x.subalgebra_generated_by().random_element()
- sage: u.operator()(u) == u^2
- True
-
- """
- # First get the subspace spanned by the powers of myself...
- V = self.span_of_powers()
- F = self.base_ring()
-
- # Now figure out the entries of the right-multiplication
- # matrix for the successive basis elements b0, b1,... of
- # that subspace.
- mats = []
- for b_right in V.basis():
- eja_b_right = self.parent()(b_right)
- b_right_rows = []
- # The first row of the right-multiplication matrix by
- # b1 is what we get if we apply that matrix to b1. The
- # second row of the right multiplication matrix by b1
- # is what we get when we apply that matrix to b2...
- #
- # IMPORTANT: this assumes that all vectors are COLUMN
- # vectors, unlike our superclass (which uses row vectors).
- for b_left in V.basis():
- eja_b_left = self.parent()(b_left)
- # Multiply in the original EJA, but then get the
- # coordinates from the subalgebra in terms of its
- # basis.
- this_row = V.coordinates((eja_b_left*eja_b_right).vector())
- b_right_rows.append(this_row)
- b_right_matrix = matrix(F, b_right_rows)
- mats.append(b_right_matrix)
-
- # It's an algebra of polynomials in one element, and EJAs
- # are power-associative.
- #
- # TODO: choose generator names intelligently.
- #
- # The rank is the highest possible degree of a minimal polynomial,
- # and is bounded above by the dimension. We know in this case that
- # there's an element whose minimal polynomial has the same degree
- # as the space's dimension, so that must be its rank too.
- return FiniteDimensionalEuclideanJordanAlgebra(
- F,
- mats,
- V.dimension(),
- assume_associative=True,
- names='f')
-
-
- def subalgebra_idempotent(self):
- """
- Find an idempotent in the associative subalgebra I generate
- using Proposition 2.3.5 in Baes.
-
- SETUP::
-
- sage: from mjo.eja.eja_algebra import random_eja
-
- TESTS::
-
- sage: set_random_seed()
- sage: J = random_eja()
- sage: x = J.random_element()
- sage: while x.is_nilpotent():
- ....: x = J.random_element()
- sage: c = x.subalgebra_idempotent()
- sage: c^2 == c
- True
-
- """
- if self.is_nilpotent():
- raise ValueError("this only works with non-nilpotent elements!")
-
- V = self.span_of_powers()
- J = self.subalgebra_generated_by()
- # Mis-design warning: the basis used for span_of_powers()
- # and subalgebra_generated_by() must be the same, and in
- # the same order!
- u = J(V.coordinates(self.vector()))
-
- # The image of the matrix of left-u^m-multiplication
- # will be minimal for some natural number s...
- s = 0
- minimal_dim = V.dimension()
- for i in xrange(1, V.dimension()):
- this_dim = (u**i).operator().matrix().image().dimension()
- if this_dim < minimal_dim:
- minimal_dim = this_dim
- s = i
-
- # Now minimal_matrix should correspond to the smallest
- # non-zero subspace in Baes's (or really, Koecher's)
- # proposition.
- #
- # However, we need to restrict the matrix to work on the
- # 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_coordinates = A.solve_right(u_next.vector())
-
- # Now c_coordinates is the idempotent we want, but it's in
- # the coordinate system of the subalgebra.
- #
- # We need the basis for J, but as elements of the parent algebra.
- #
- basis = [self.parent(v) for v in V.basis()]
- return self.parent().linear_combination(zip(c_coordinates, basis))
-
-
- def trace(self):
- """
- Return my trace, the sum of my eigenvalues.
-
- SETUP::
-
- sage: from mjo.eja.eja_algebra import (JordanSpinEJA,
- ....: RealCartesianProductEJA,
- ....: random_eja)
-
- EXAMPLES::
-
- sage: J = JordanSpinEJA(3)
- sage: x = sum(J.gens())
- sage: x.trace()
- 2
-
- ::
-
- sage: J = RealCartesianProductEJA(5)
- sage: J.one().trace()
- 5
-
- TESTS:
-
- The trace of an element is a real number::
-
- sage: set_random_seed()
- sage: J = random_eja()
- sage: J.random_element().trace() in J.base_ring()
- True
-
- """
- P = self.parent()
- r = P.rank()
- p = P._charpoly_coeff(r-1)
- # The _charpoly_coeff function already adds the factor of
- # -1 to ensure that _charpoly_coeff(r-1) is really what
- # appears in front of t^{r-1} in the charpoly. However,
- # we want the negative of THAT for the trace.
- return -p(*self.vector())
-
-
- def trace_inner_product(self, other):
- """
- Return the trace inner product of myself and ``other``.
-
- SETUP::
-
- sage: from mjo.eja.eja_algebra import random_eja
-
- TESTS:
-
- The trace inner product is commutative::
-
- sage: set_random_seed()
- sage: J = random_eja()
- sage: x = J.random_element(); y = J.random_element()
- sage: x.trace_inner_product(y) == y.trace_inner_product(x)
- True
-
- The trace inner product is bilinear::
-
- sage: set_random_seed()
- sage: J = random_eja()
- sage: x = J.random_element()
- sage: y = J.random_element()
- sage: z = J.random_element()
- sage: a = QQ.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) )
- sage: actual == expected
- True
- sage: actual = x.trace_inner_product(a*(y+z))
- sage: expected = ( a*x.trace_inner_product(y) +
- ....: a*x.trace_inner_product(z) )
- sage: actual == expected
- True
-
- The trace inner product satisfies the compatibility
- condition in the definition of a Euclidean Jordan algebra::
-
- sage: set_random_seed()
- sage: J = random_eja()
- sage: x = J.random_element()
- sage: y = J.random_element()
- sage: z = J.random_element()
- sage: (x*y).trace_inner_product(z) == y.trace_inner_product(x*z)
- True
-
- """
- if not other in self.parent():
- raise TypeError("'other' must live in the same algebra")
-
- return (self*other).trace()