names='e',
assume_associative=False,
category=None,
- rank=None):
+ rank=None,
+ natural_basis=None):
n = len(mult_table)
mult_table = [b.base_extend(field) for b in mult_table]
for b in mult_table:
assume_associative=assume_associative,
names=names,
category=cat,
- rank=rank)
+ rank=rank,
+ natural_basis=natural_basis)
def __init__(self, field,
names='e',
assume_associative=False,
category=None,
- rank=None):
+ rank=None,
+ natural_basis=None):
+ """
+ EXAMPLES:
+
+ By definition, Jordan multiplication commutes::
+
+ sage: set_random_seed()
+ sage: J = random_eja()
+ sage: x = J.random_element()
+ sage: y = J.random_element()
+ sage: x*y == y*x
+ True
+
+ """
self._rank = rank
+ self._natural_basis = natural_basis
fda = super(FiniteDimensionalEuclideanJordanAlgebra, self)
fda.__init__(field,
mult_table,
fmt = "Euclidean Jordan algebra of degree {} over {}"
return fmt.format(self.degree(), self.base_ring())
+
+ def natural_basis(self):
+ """
+ Return a more-natural representation of this algebra's basis.
+
+ 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" basis
+ for our underlying vector space. (Typically, the natural basis
+ is used to construct the multiplication table in the first place.)
+
+ Note that this will always return a matrix. The standard basis
+ in `R^n` will be returned as `n`-by-`1` column matrices.
+
+ EXAMPLES::
+
+ sage: J = RealSymmetricSimpleEJA(2)
+ sage: J.basis()
+ Family (e0, e1, e2)
+ sage: J.natural_basis()
+ (
+ [1 0] [0 1] [0 0]
+ [0 0], [1 0], [0 1]
+ )
+
+ ::
+
+ sage: J = JordanSpinSimpleEJA(2)
+ sage: J.basis()
+ Family (e0, e1)
+ sage: J.natural_basis()
+ (
+ [1] [0]
+ [0], [1]
+ )
+
+ """
+ if self._natural_basis is None:
+ return tuple( b.vector().column() for b in self.basis() )
+ else:
+ return self._natural_basis
+
+
def rank(self):
"""
Return the rank of this EJA.
instead of column vectors! We, on the other hand, assume column
vectors everywhere.
- EXAMPLES:
+ EXAMPLES::
+
+ sage: set_random_seed()
+ sage: x = random_eja().random_element()
+ sage: x.operator_matrix()*x.vector() == (x^2).vector()
+ True
+
+ A few examples of power-associativity::
sage: set_random_seed()
sage: x = random_eja().random_element()
- sage: x.matrix()*x.vector() == (x**2).vector()
+ sage: x*(x*x)*(x*x) == x^5
+ True
+ sage: (x*x)*(x*x*x) == x^5
+ True
+
+ We also know that powers operator-commute (Koecher, Chapter
+ III, Corollary 1)::
+
+ sage: set_random_seed()
+ sage: x = random_eja().random_element()
+ sage: m = ZZ.random_element(0,10)
+ sage: n = ZZ.random_element(0,10)
+ sage: Lxm = (x^m).operator_matrix()
+ sage: Lxn = (x^n).operator_matrix()
+ sage: Lxm*Lxn == Lxn*Lxm
True
"""
elif n == 1:
return self
else:
- return A.element_class(A, (self.matrix()**(n-1))*self.vector())
+ return A( (self.operator_matrix()**(n-1))*self.vector() )
def characteristic_polynomial(self):
raise NotImplementedError('irregular element')
+ def operator_commutes_with(self, other):
+ """
+ Return whether or not this element operator-commutes
+ with ``other``.
+
+ EXAMPLES:
+
+ The definition of a Jordan algebra says that any element
+ operator-commutes with its square::
+
+ sage: set_random_seed()
+ sage: x = random_eja().random_element()
+ sage: x.operator_commutes_with(x^2)
+ True
+
+ TESTS:
+
+ Test Lemma 1 from Chapter III of Koecher::
+
+ sage: set_random_seed()
+ sage: J = random_eja()
+ sage: u = J.random_element()
+ sage: v = J.random_element()
+ sage: lhs = u.operator_commutes_with(u*v)
+ sage: rhs = v.operator_commutes_with(u^2)
+ sage: lhs == rhs
+ True
+
+ """
+ if not other in self.parent():
+ raise ArgumentError("'other' must live in the same algebra")
+
+ A = self.operator_matrix()
+ B = other.operator_matrix()
+ return (A*B == B*A)
+
+
def det(self):
"""
Return my determinant, the product of my eigenvalues.
raise ValueError('charpoly had no coefficients')
+ def inverse(self):
+ """
+ Return the Jordan-multiplicative inverse of this element.
+
+ We can't use the superclass method because it relies on the
+ algebra being associative.
+
+ EXAMPLES:
+
+ The inverse in the spin factor algebra is given in Alizadeh's
+ Example 11.11::
+
+ sage: set_random_seed()
+ sage: n = ZZ.random_element(1,10)
+ sage: J = JordanSpinSimpleEJA(n)
+ sage: x = J.random_element()
+ sage: while x.is_zero():
+ ....: x = J.random_element()
+ sage: x_vec = x.vector()
+ sage: x0 = x_vec[0]
+ sage: x_bar = x_vec[1:]
+ sage: coeff = 1/(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. TODO: this
+ can be a lot less ugly once ``is_invertible`` doesn't crash
+ on irregular elements::
+
+ sage: set_random_seed()
+ sage: J = random_eja()
+ sage: x = J.random_element()
+ sage: try:
+ ....: x.inverse()*x == J.one()
+ ....: except:
+ ....: True
+ True
+
+ """
+ if self.parent().is_associative():
+ elt = FiniteDimensionalAlgebraElement(self.parent(), self)
+ return elt.inverse()
+
+ # TODO: we can do better once the call to is_invertible()
+ # doesn't crash on irregular elements.
+ #if not self.is_invertible():
+ # raise ArgumentError('element is not invertible')
+
+ # We do this a little different than the usual recursive
+ # call to a finite-dimensional algebra element, because we
+ # wind up with an inverse that lives in the subalgebra and
+ # we need information about the parent to convert it back.
+ 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()))
+
+ # This will be in the subalgebra's coordinates...
+ fda_elt = FiniteDimensionalAlgebraElement(assoc_subalg, elt)
+ subalg_inverse = fda_elt.inverse()
+
+ # So we have to convert back...
+ basis = [ self.parent(v) for v in V.basis() ]
+ pairs = zip(subalg_inverse.vector(), basis)
+ return self.parent().linear_combination(pairs)
+
+
+ def is_invertible(self):
+ """
+ Return whether or not this element is invertible.
+
+ We can't use the superclass method because it relies on
+ the algebra being associative.
+ """
+ return not self.det().is_zero()
+
+
def is_nilpotent(self):
"""
Return whether or not some power of this element is zero.
aren't multiples of the identity are regular::
sage: set_random_seed()
- sage: n = ZZ.random_element(1,10).abs()
+ sage: n = ZZ.random_element(1,10)
sage: J = JordanSpinSimpleEJA(n)
sage: x = J.random_element()
sage: x == x.coefficient(0)*J.one() or x.degree() == 2
return self.span_of_powers().dimension()
- def matrix(self):
- """
- Return the matrix that represents left- (or right-)
- multiplication by this element in the parent algebra.
-
- We have to override this because the superclass method
- returns a matrix that acts on row vectors (that is, on
- the right).
- """
- fda_elt = FiniteDimensionalAlgebraElement(self.parent(), self)
- return fda_elt.matrix().transpose()
-
-
def minimal_polynomial(self):
"""
EXAMPLES::
identity::
sage: set_random_seed()
- sage: n = ZZ.random_element(2,10).abs()
+ sage: n = ZZ.random_element(2,10)
sage: J = JordanSpinSimpleEJA(n)
sage: y = J.random_element()
sage: while y == y.coefficient(0)*J.one():
return elt.minimal_polynomial()
- def quadratic_representation(self):
+ 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.
+
+ EXAMPLES::
+
+ sage: J = ComplexHermitianSimpleEJA(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]
+
+ """
+ B = self.parent().natural_basis()
+ W = B[0].matrix_space()
+ return W.linear_combination(zip(self.vector(), B))
+
+
+ def operator_matrix(self):
+ """
+ Return the matrix that represents left- (or right-)
+ multiplication by this element in the parent algebra.
+
+ We have to override this because the superclass method
+ returns a matrix that acts on row vectors (that is, on
+ the right).
+
+ EXAMPLES:
+
+ Test the first polarization identity from my notes, Koecher Chapter
+ III, or from Baes (2.3)::
+
+ sage: set_random_seed()
+ sage: J = random_eja()
+ sage: x = J.random_element()
+ sage: y = J.random_element()
+ sage: Lx = x.operator_matrix()
+ sage: Ly = y.operator_matrix()
+ sage: Lxx = (x*x).operator_matrix()
+ sage: Lxy = (x*y).operator_matrix()
+ sage: bool(2*Lx*Lxy + Ly*Lxx == 2*Lxy*Lx + Lxx*Ly)
+ True
+
+ Test the second polarization identity from my notes or from
+ Baes (2.4)::
+
+ sage: set_random_seed()
+ sage: J = random_eja()
+ sage: x = J.random_element()
+ sage: y = J.random_element()
+ sage: z = J.random_element()
+ sage: Lx = x.operator_matrix()
+ sage: Ly = y.operator_matrix()
+ sage: Lz = z.operator_matrix()
+ sage: Lzy = (z*y).operator_matrix()
+ sage: Lxy = (x*y).operator_matrix()
+ sage: Lxz = (x*z).operator_matrix()
+ sage: bool(Lx*Lzy + Lz*Lxy + Ly*Lxz == Lzy*Lx + Lxy*Lz + Lxz*Ly)
+ True
+
+ Test the third polarization identity from my notes or from
+ Baes (2.5)::
+
+ sage: set_random_seed()
+ sage: J = random_eja()
+ sage: u = J.random_element()
+ sage: y = J.random_element()
+ sage: z = J.random_element()
+ sage: Lu = u.operator_matrix()
+ sage: Ly = y.operator_matrix()
+ sage: Lz = z.operator_matrix()
+ sage: Lzy = (z*y).operator_matrix()
+ sage: Luy = (u*y).operator_matrix()
+ sage: Luz = (u*z).operator_matrix()
+ sage: Luyz = (u*(y*z)).operator_matrix()
+ sage: lhs = Lu*Lzy + Lz*Luy + Ly*Luz
+ sage: rhs = Luyz + Ly*Lu*Lz + Lz*Lu*Ly
+ sage: bool(lhs == rhs)
+ True
+
+ """
+ fda_elt = FiniteDimensionalAlgebraElement(self.parent(), self)
+ return fda_elt.matrix().transpose()
+
+
+ def quadratic_representation(self, other=None):
"""
Return the quadratic representation of this element.
The explicit form in the spin factor algebra is given by
Alizadeh's Example 11.12::
- sage: n = ZZ.random_element(1,10).abs()
+ sage: set_random_seed()
+ sage: n = ZZ.random_element(1,10)
sage: J = JordanSpinSimpleEJA(n)
sage: x = J.random_element()
sage: x_vec = x.vector()
sage: Q == x.quadratic_representation()
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()
+
+ Property 1:
+
+ sage: actual = x.quadratic_representation(y)
+ sage: expected = ( (x+y).quadratic_representation()
+ ....: -x.quadratic_representation()
+ ....: -y.quadratic_representation() ) / 2
+ sage: actual == expected
+ True
+
+ Property 2:
+
+ sage: alpha = QQ.random_element()
+ sage: actual = (alpha*x).quadratic_representation()
+ sage: expected = (alpha^2)*x.quadratic_representation()
+ sage: actual == expected
+ True
+
+ Property 5:
+
+ sage: Qy = y.quadratic_representation()
+ sage: actual = J(Qy*x.vector()).quadratic_representation()
+ sage: expected = Qy*x.quadratic_representation()*Qy
+ sage: actual == expected
+ True
+
+ Property 6:
+
+ sage: k = ZZ.random_element(1,10)
+ sage: actual = (x^k).quadratic_representation()
+ sage: expected = (x.quadratic_representation())^k
+ sage: actual == expected
+ True
+
"""
- return 2*(self.matrix()**2) - (self**2).matrix()
+ if other is None:
+ other=self
+ elif not other in self.parent():
+ raise ArgumentError("'other' must live in the same algebra")
+
+ L = self.operator_matrix()
+ M = other.operator_matrix()
+ return ( L*M + M*L - (self*other).operator_matrix() )
def span_of_powers(self):
sage: set_random_seed()
sage: x = random_eja().random_element()
sage: u = x.subalgebra_generated_by().random_element()
- sage: u.matrix()*u.vector() == (u**2).vector()
+ sage: u.operator_matrix()*u.vector() == (u**2).vector()
True
"""
s = 0
minimal_dim = V.dimension()
for i in xrange(1, V.dimension()):
- this_dim = (u**i).matrix().image().dimension()
+ this_dim = (u**i).operator_matrix().image().dimension()
if this_dim < minimal_dim:
minimal_dim = this_dim
s = i
# Beware, solve_right() means that we're using COLUMN vectors.
# Our FiniteDimensionalAlgebraElement superclass uses rows.
u_next = u**(s+1)
- A = u_next.matrix()
+ 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
Euclidean Jordan algebra of degree...
"""
- n = ZZ.random_element(1,5).abs()
+ n = ZZ.random_element(1,5)
constructor = choice([eja_rn,
JordanSpinSimpleEJA,
RealSymmetricSimpleEJA,
# Beware, orthogonal but not normalized!
Sij = Eij + Eij.transpose()
S.append(Sij)
- return S
+ return tuple(S)
+
+
+def _complex_hermitian_basis(n, field=QQ):
+ """
+ Returns a basis for the space of complex Hermitian n-by-n matrices.
+
+ TESTS::
+
+ sage: set_random_seed()
+ sage: n = ZZ.random_element(1,5)
+ sage: all( M.is_symmetric() for M in _complex_hermitian_basis(n) )
+ True
+
+ """
+ F = QuadraticField(-1, 'I')
+ I = F.gen()
+
+ # This is like the symmetric case, but we need to be careful:
+ #
+ # * We want conjugate-symmetry, not just symmetry.
+ # * The diagonal will (as a result) be real.
+ #
+ S = []
+ for i in xrange(n):
+ for j in xrange(i+1):
+ Eij = matrix(field, n, lambda k,l: k==i and l==j)
+ if i == j:
+ Sij = _embed_complex_matrix(Eij)
+ S.append(Sij)
+ else:
+ # Beware, orthogonal but not normalized! The second one
+ # has a minus because it's conjugated.
+ Sij_real = _embed_complex_matrix(Eij + Eij.transpose())
+ S.append(Sij_real)
+ Sij_imag = _embed_complex_matrix(I*Eij - I*Eij.transpose())
+ S.append(Sij_imag)
+ return tuple(S)
def _multiplication_table_from_matrix_basis(basis):
multiplication on the right is matrix multiplication. Given a basis
for the underlying matrix space, this function returns a
multiplication table (obtained by looping through the basis
- elements) for an algebra of those matrices.
+ elements) for an algebra of those matrices. A reordered copy
+ of the basis is also returned to work around the fact that
+ the ``span()`` in this function will change the order of the basis
+ from what we think it is, to... something else.
"""
# In S^2, for example, we nominally have four coordinates even
# though the space is of dimension three only. The vector space V
# Taking the span above reorders our basis (thanks, jerk!) so we
# need to put our "matrix basis" in the same order as the
# (reordered) vector basis.
- S = [ vec2mat(b) for b in W.basis() ]
+ S = tuple( vec2mat(b) for b in W.basis() )
Qs = []
for s in S:
Q = matrix(field, W.dimension(), Q_rows)
Qs.append(Q)
- return Qs
+ return (Qs, S)
def _embed_complex_matrix(M):
e0 + e2
sage: e2*e2
e2
+
+ TESTS:
+
+ The degree of this algebra is `(n^2 + n) / 2`::
+
+ sage: set_random_seed()
+ sage: n = ZZ.random_element(1,5)
+ sage: J = RealSymmetricSimpleEJA(n)
+ sage: J.degree() == (n^2 + n)/2
+ True
+
"""
S = _real_symmetric_basis(n, field=field)
- Qs = _multiplication_table_from_matrix_basis(S)
+ (Qs, T) = _multiplication_table_from_matrix_basis(S)
- return FiniteDimensionalEuclideanJordanAlgebra(field,Qs,rank=n)
+ return FiniteDimensionalEuclideanJordanAlgebra(field,
+ Qs,
+ rank=n,
+ natural_basis=T)
def ComplexHermitianSimpleEJA(n, field=QQ):
"""
The rank-n simple EJA consisting of complex Hermitian n-by-n
matrices over the real numbers, the usual symmetric Jordan product,
- and the real-part-of-trace inner product. It has dimension `n^2 over
+ and the real-part-of-trace inner product. It has dimension `n^2` over
the reals.
+
+ TESTS:
+
+ The degree of this algebra is `n^2`::
+
+ sage: set_random_seed()
+ sage: n = ZZ.random_element(1,5)
+ sage: J = ComplexHermitianSimpleEJA(n)
+ sage: J.degree() == n^2
+ True
+
"""
- F = QuadraticField(-1, 'i')
- i = F.gen()
- S = _real_symmetric_basis(n, field=F)
- T = []
- for s in S:
- T.append(s)
- T.append(i*s)
- embed_T = [ _embed_complex_matrix(t) for t in T ]
- Qs = _multiplication_table_from_matrix_basis(embed_T)
- return FiniteDimensionalEuclideanJordanAlgebra(field, Qs, rank=n)
+ S = _complex_hermitian_basis(n)
+ (Qs, T) = _multiplication_table_from_matrix_basis(S)
+ return FiniteDimensionalEuclideanJordanAlgebra(field,
+ Qs,
+ rank=n,
+ natural_basis=T)
+
def QuaternionHermitianSimpleEJA(n):
"""
projects / sage.d.git / blobdiff