class Element(FiniteDimensionalAlgebraElement):
"""
An element of a Euclidean Jordan algebra.
-
- Since EJAs are commutative, the "right multiplication" matrix is
- also the left multiplication matrix and must be symmetric::
-
- sage: set_random_seed()
- sage: n = ZZ.random_element(1,10).abs()
- sage: J = eja_rn(5)
- sage: J.random_element().matrix().is_symmetric()
- True
- sage: J = eja_ln(5)
- sage: J.random_element().matrix().is_symmetric()
- True
-
"""
def __pow__(self, n):
EXAMPLES:
sage: set_random_seed()
- sage: J = eja_ln(5)
- sage: x = J.random_element()
+ sage: x = random_eja().random_element()
sage: x.matrix()*x.vector() == (x**2).vector()
True
EXAMPLES::
- sage: J = eja_ln(2)
+ sage: J = JordanSpinSimpleEJA(2)
sage: e0,e1 = J.gens()
sage: x = e0 + e1
sage: x.det()
0
- sage: J = eja_ln(3)
+ sage: J = JordanSpinSimpleEJA(3)
sage: e0,e1,e2 = J.gens()
sage: x = e0 + e1 + e2
sage: x.det()
The identity element is never nilpotent::
sage: set_random_seed()
- sage: n = ZZ.random_element(2,10).abs()
- sage: J = eja_rn(n)
- sage: J.one().is_nilpotent()
- False
- sage: J = eja_ln(n)
- sage: J.one().is_nilpotent()
+ sage: random_eja().one().is_nilpotent()
False
The additive identity is always nilpotent::
sage: set_random_seed()
- sage: n = ZZ.random_element(2,10).abs()
- sage: J = eja_rn(n)
- sage: J.zero().is_nilpotent()
- True
- sage: J = eja_ln(n)
- sage: J.zero().is_nilpotent()
+ sage: random_eja().zero().is_nilpotent()
True
"""
The identity element always has degree one, but any element
linearly-independent from it is regular::
- sage: J = eja_ln(5)
+ sage: J = JordanSpinSimpleEJA(5)
sage: J.one().is_regular()
False
sage: e0, e1, e2, e3, e4 = J.gens() # e0 is the identity
EXAMPLES::
- sage: J = eja_ln(4)
+ sage: J = JordanSpinSimpleEJA(4)
sage: J.one().degree()
1
sage: e0,e1,e2,e3 = J.gens()
sage: set_random_seed()
sage: n = ZZ.random_element(1,10).abs()
- sage: J = eja_ln(n)
+ sage: J = JordanSpinSimpleEJA(n)
sage: x = J.random_element()
sage: x == x.coefficient(0)*J.one() or x.degree() == 2
True
EXAMPLES::
sage: set_random_seed()
- sage: n = ZZ.random_element(1,10).abs()
- sage: J = eja_rn(n)
- sage: x = J.random_element()
+ sage: x = random_eja().random_element()
sage: x.degree() == x.minimal_polynomial().degree()
True
::
sage: set_random_seed()
- sage: n = ZZ.random_element(1,10).abs()
- sage: J = eja_ln(n)
- sage: x = J.random_element()
+ sage: x = random_eja().random_element()
sage: x.degree() == x.minimal_polynomial().degree()
True
sage: set_random_seed()
sage: n = ZZ.random_element(2,10).abs()
- sage: J = eja_ln(n)
+ sage: J = JordanSpinSimpleEJA(n)
sage: y = J.random_element()
sage: while y == y.coefficient(0)*J.one():
....: y = J.random_element()
return elt.minimal_polynomial()
+ def quadratic_representation(self):
+ """
+ Return the quadratic representation of this element.
+
+ EXAMPLES:
+
+ 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: J = JordanSpinSimpleEJA(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 = identity_matrix(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 = block_matrix(2,2,[A,B,C,D])
+ sage: Q == x.quadratic_representation()
+ True
+
+ """
+ return 2*(self.matrix()**2) - (self**2).matrix()
+
+
def span_of_powers(self):
"""
Return the vector space spanned by successive powers of
TESTS::
sage: set_random_seed()
- sage: n = ZZ.random_element(1,10).abs()
- sage: J = eja_rn(n)
- sage: x = J.random_element()
- sage: x.subalgebra_generated_by().is_associative()
- True
- sage: J = eja_ln(n)
- sage: x = J.random_element()
+ sage: x = random_eja().random_element()
sage: x.subalgebra_generated_by().is_associative()
True
Squaring in the subalgebra should be the same thing as
squaring in the superalgebra::
- sage: J = eja_ln(5)
- sage: x = J.random_element()
+ 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()
True
sage: c = J.random_element().subalgebra_idempotent()
sage: c^2 == c
True
- sage: J = eja_ln(5)
+ sage: J = JordanSpinSimpleEJA(5)
sage: c = J.random_element().subalgebra_idempotent()
sage: c^2 == c
True
EXAMPLES::
- sage: J = eja_ln(3)
+ sage: J = JordanSpinSimpleEJA(3)
sage: e0,e1,e2 = J.gens()
sage: x = e0 + e1 + e2
sage: x.trace()
raise ValueError('charpoly had fewer than 2 coefficients')
+ def trace_inner_product(self, other):
+ """
+ Return the trace inner product of myself and ``other``.
+ """
+ if not other in self.parent():
+ raise ArgumentError("'other' must live in the same algebra")
+
+ return (self*other).trace()
+
+
def eja_rn(dimension, field=QQ):
"""
Return the Euclidean Jordan Algebra corresponding to the set
return FiniteDimensionalEuclideanJordanAlgebra(field,Qs,rank=dimension)
-def eja_ln(dimension, field=QQ):
+
+def random_eja():
"""
- Return the Jordan algebra corresponding to the Lorentz "ice cream"
- cone of the given ``dimension``.
+ Return a "random" finite-dimensional Euclidean Jordan Algebra.
- EXAMPLES:
+ ALGORITHM:
- This multiplication table can be verified by hand::
+ For now, we choose a random natural number ``n`` (greater than zero)
+ and then give you back one of the following:
- sage: J = eja_ln(4)
- sage: e0,e1,e2,e3 = J.gens()
- sage: e0*e0
- e0
- sage: e0*e1
- e1
- sage: e0*e2
- e2
- sage: e0*e3
- e3
- sage: e1*e2
- 0
- sage: e1*e3
- 0
- sage: e2*e3
- 0
+ * The cartesian product of the rational numbers ``n`` times; this is
+ ``QQ^n`` with the Hadamard product.
- In one dimension, this is the reals under multiplication::
+ * The Jordan spin algebra on ``QQ^n``.
- sage: J1 = eja_ln(1)
- sage: J2 = eja_rn(1)
- sage: J1 == J2
- True
+ * The ``n``-by-``n`` rational symmetric matrices with the symmetric
+ product.
- """
- Qs = []
- id_matrix = identity_matrix(field,dimension)
- for i in xrange(dimension):
- ei = id_matrix.column(i)
- Qi = zero_matrix(field,dimension)
- Qi.set_row(0, ei)
- Qi.set_column(0, ei)
- Qi += diagonal_matrix(dimension, [ei[0]]*dimension)
- # The addition of the diagonal matrix adds an extra ei[0] in the
- # upper-left corner of the matrix.
- Qi[0,0] = Qi[0,0] * ~field(2)
- Qs.append(Qi)
+ Later this might be extended to return Cartesian products of the
+ EJAs above.
- # The rank of the spin factor algebra is two, UNLESS we're in a
- # one-dimensional ambient space (the rank is bounded by the
- # ambient dimension).
- rank = min(dimension,2)
- return FiniteDimensionalEuclideanJordanAlgebra(field,Qs,rank=rank)
+ TESTS::
+ sage: random_eja()
+ Euclidean Jordan algebra of degree...
-def eja_sn(dimension, field=QQ):
"""
- Return the simple Jordan algebra of ``dimension``-by-``dimension``
- symmetric matrices over ``field``.
+ n = ZZ.random_element(1,5).abs()
+ constructor = choice([eja_rn,
+ JordanSpinSimpleEJA,
+ RealSymmetricSimpleEJA,
+ ComplexHermitianSimpleEJA])
+ return constructor(n, field=QQ)
- EXAMPLES::
- sage: J = eja_sn(2)
- sage: e0, e1, e2 = J.gens()
- sage: e0*e0
- e0
- sage: e1*e1
- e0 + e2
- sage: e2*e2
- e2
+def _real_symmetric_basis(n, field=QQ):
+ """
+ Return a basis for the space of real symmetric n-by-n matrices.
"""
- Qs = []
-
- # In S^2, for example, we nominally have four coordinates even
- # though the space is of dimension three only. The vector space V
- # is supposed to hold the entire long vector, and the subspace W
- # of V will be spanned by the vectors that arise from symmetric
- # matrices. Thus for S^2, dim(V) == 4 and dim(W) == 3.
- V = VectorSpace(field, dimension**2)
-
# The basis of symmetric matrices, as matrices, in their R^(n-by-n)
# coordinates.
S = []
-
- for i in xrange(dimension):
+ for i in xrange(n):
for j in xrange(i+1):
- Eij = matrix(field, dimension, lambda k,l: k==i and l==j)
+ Eij = matrix(field, n, lambda k,l: k==i and l==j)
if i == j:
Sij = Eij
else:
+ # Beware, orthogonal but not normalized!
Sij = Eij + Eij.transpose()
S.append(Sij)
+ return 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).abs()
+ 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 S
+
+
+def _multiplication_table_from_matrix_basis(basis):
+ """
+ At least three of the five simple Euclidean Jordan algebras have the
+ symmetric multiplication (A,B) |-> (AB + BA)/2, where the
+ 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.
+ """
+ # In S^2, for example, we nominally have four coordinates even
+ # though the space is of dimension three only. The vector space V
+ # is supposed to hold the entire long vector, and the subspace W
+ # of V will be spanned by the vectors that arise from symmetric
+ # matrices. Thus for S^2, dim(V) == 4 and dim(W) == 3.
+ field = basis[0].base_ring()
+ dimension = basis[0].nrows()
def mat2vec(m):
return vector(field, m.list())
- W = V.span( mat2vec(s) for s in S )
+ def vec2mat(v):
+ return matrix(field, dimension, v.list())
+ V = VectorSpace(field, dimension**2)
+ W = V.span( mat2vec(s) for s in basis )
+
+ # 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() ]
+
+ Qs = []
for s in S:
# Brute force the multiplication-by-s matrix by looping
# through all elements of the basis and doing the computation
for t in S:
this_row = mat2vec((s*t + t*s)/2)
Q_rows.append(W.coordinates(this_row))
- Q = matrix(field,Q_rows)
+ Q = matrix(field, W.dimension(), Q_rows)
Qs.append(Q)
- return FiniteDimensionalEuclideanJordanAlgebra(field,Qs,rank=dimension)
+ return Qs
+
+
+def _embed_complex_matrix(M):
+ """
+ Embed the n-by-n complex matrix ``M`` into the space of real
+ matrices of size 2n-by-2n via the map the sends each entry `z = a +
+ bi` to the block matrix ``[[a,b],[-b,a]]``.
+
+ EXAMPLES::
+
+ sage: F = QuadraticField(-1,'i')
+ sage: x1 = F(4 - 2*i)
+ sage: x2 = F(1 + 2*i)
+ sage: x3 = F(-i)
+ sage: x4 = F(6)
+ sage: M = matrix(F,2,[x1,x2,x3,x4])
+ sage: _embed_complex_matrix(M)
+ [ 4 2| 1 -2]
+ [-2 4| 2 1]
+ [-----+-----]
+ [ 0 1| 6 0]
+ [-1 0| 0 6]
+
+ """
+ n = M.nrows()
+ if M.ncols() != n:
+ raise ArgumentError("the matrix 'M' must be square")
+ field = M.base_ring()
+ blocks = []
+ for z in M.list():
+ a = z.real()
+ b = z.imag()
+ blocks.append(matrix(field, 2, [[a,-b],[b,a]]))
+
+ # We can drop the imaginaries here.
+ return block_matrix(field.base_ring(), n, blocks)
+
+
+def _unembed_complex_matrix(M):
+ """
+ The inverse of _embed_complex_matrix().
+
+ EXAMPLES::
+
+ sage: A = matrix(QQ,[ [ 1, 2, 3, 4],
+ ....: [-2, 1, -4, 3],
+ ....: [ 9, 10, 11, 12],
+ ....: [-10, 9, -12, 11] ])
+ sage: _unembed_complex_matrix(A)
+ [ -2*i + 1 -4*i + 3]
+ [ -10*i + 9 -12*i + 11]
+ """
+ n = ZZ(M.nrows())
+ if M.ncols() != n:
+ raise ArgumentError("the matrix 'M' must be square")
+ if not n.mod(2).is_zero():
+ raise ArgumentError("the matrix 'M' must be a complex embedding")
+
+ F = QuadraticField(-1, 'i')
+ i = F.gen()
+
+ # Go top-left to bottom-right (reading order), converting every
+ # 2-by-2 block we see to a single complex element.
+ elements = []
+ for k in xrange(n/2):
+ for j in xrange(n/2):
+ submat = M[2*k:2*k+2,2*j:2*j+2]
+ if submat[0,0] != submat[1,1]:
+ raise ArgumentError('bad real submatrix')
+ if submat[0,1] != -submat[1,0]:
+ raise ArgumentError('bad imag submatrix')
+ z = submat[0,0] + submat[1,0]*i
+ elements.append(z)
+
+ return matrix(F, n/2, elements)
+
+
+def RealSymmetricSimpleEJA(n, field=QQ):
+ """
+ The rank-n simple EJA consisting of real symmetric n-by-n
+ matrices, the usual symmetric Jordan product, and the trace inner
+ product. It has dimension `(n^2 + n)/2` over the reals.
+
+ EXAMPLES::
+
+ sage: J = RealSymmetricSimpleEJA(2)
+ sage: e0, e1, e2 = J.gens()
+ sage: e0*e0
+ e0
+ sage: e1*e1
+ 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).abs()
+ 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)
+
+ return FiniteDimensionalEuclideanJordanAlgebra(field,Qs,rank=n)
+
+
+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
+ the reals.
+
+ TESTS:
+
+ The degree of this algebra is `n^2`::
+
+ sage: set_random_seed()
+ sage: n = ZZ.random_element(1,5).abs()
+ sage: J = ComplexHermitianSimpleEJA(n)
+ sage: J.degree() == n^2
+ True
+
+ """
+ S = _complex_hermitian_basis(n)
+ Qs = _multiplication_table_from_matrix_basis(S)
+ return FiniteDimensionalEuclideanJordanAlgebra(field, Qs, rank=n)
+
+
+def QuaternionHermitianSimpleEJA(n):
+ """
+ The rank-n simple EJA consisting of self-adjoint n-by-n quaternion
+ matrices, the usual symmetric Jordan product, and the
+ real-part-of-trace inner product. It has dimension `2n^2 - n` over
+ the reals.
+ """
+ pass
+
+def OctonionHermitianSimpleEJA(n):
+ """
+ This shit be crazy. It has dimension 27 over the reals.
+ """
+ n = 3
+ pass
+
+def JordanSpinSimpleEJA(n, field=QQ):
+ """
+ The rank-2 simple EJA consisting of real vectors ``x=(x0, x_bar)``
+ with the usual inner product and jordan product ``x*y =
+ (<x_bar,y_bar>, x0*y_bar + y0*x_bar)``. It has dimension `n` over
+ the reals.
+
+ EXAMPLES:
+
+ This multiplication table can be verified by hand::
+
+ sage: J = JordanSpinSimpleEJA(4)
+ sage: e0,e1,e2,e3 = J.gens()
+ sage: e0*e0
+ e0
+ sage: e0*e1
+ e1
+ sage: e0*e2
+ e2
+ sage: e0*e3
+ e3
+ sage: e1*e2
+ 0
+ sage: e1*e3
+ 0
+ sage: e2*e3
+ 0
+
+ In one dimension, this is the reals under multiplication::
+
+ sage: J1 = JordanSpinSimpleEJA(1)
+ sage: J2 = eja_rn(1)
+ sage: J1 == J2
+ True
+
+ """
+ Qs = []
+ id_matrix = identity_matrix(field, n)
+ for i in xrange(n):
+ ei = id_matrix.column(i)
+ Qi = zero_matrix(field, n)
+ Qi.set_row(0, ei)
+ Qi.set_column(0, ei)
+ Qi += diagonal_matrix(n, [ei[0]]*n)
+ # The addition of the diagonal matrix adds an extra ei[0] in the
+ # upper-left corner of the matrix.
+ Qi[0,0] = Qi[0,0] * ~field(2)
+ Qs.append(Qi)
+
+ # The rank of the spin factor algebra is two, UNLESS we're in a
+ # one-dimensional ambient space (the rank is bounded by the
+ # ambient dimension).
+ return FiniteDimensionalEuclideanJordanAlgebra(field, Qs, rank=min(n,2))
projects / sage.d.git / blobdiff