X-Git-Url: http://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=mjo%2Feja%2Feuclidean_jordan_algebra.py;h=4713ff0859876b5832e6e5e9551f632444c6a138;hb=8ee3c1ac3dd5a2b08f91cfd4c700d87f617196e6;hp=16ce256f244e96d7875bda4e3a27d005ae4b3c40;hpb=3734e050b5508ec030478c497ddb8a6cd8d53327;p=sage.d.git diff --git a/mjo/eja/euclidean_jordan_algebra.py b/mjo/eja/euclidean_jordan_algebra.py index 16ce256..4713ff0 100644 --- a/mjo/eja/euclidean_jordan_algebra.py +++ b/mjo/eja/euclidean_jordan_algebra.py @@ -52,6 +52,19 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): assume_associative=False, category=None, rank=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 fda = super(FiniteDimensionalEuclideanJordanAlgebra, self) fda.__init__(field, @@ -95,11 +108,32 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): 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.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*(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: x.matrix()*x.vector() == (x**2).vector() + sage: m = ZZ.random_element(0,10) + sage: n = ZZ.random_element(0,10) + sage: Lxm = (x^m).matrix() + sage: Lxn = (x^n).matrix() + sage: Lxm*Lxn == Lxn*Lxm True """ @@ -127,18 +161,55 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): 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.matrix() + B = other.matrix() + return (A*B == B*A) + + def det(self): """ Return my determinant, the product of my eigenvalues. 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() @@ -153,6 +224,96 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): 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. @@ -207,7 +368,7 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): 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 @@ -232,7 +393,7 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): EXAMPLES:: - sage: J = eja_ln(4) + sage: J = JordanSpinSimpleEJA(4) sage: J.one().degree() 1 sage: e0,e1,e2,e3 = J.gens() @@ -243,8 +404,8 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): aren't multiples of the identity are regular:: sage: set_random_seed() - sage: n = ZZ.random_element(1,10).abs() - sage: J = eja_ln(n) + 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 True @@ -261,6 +422,60 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): 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.matrix() + sage: Ly = y.matrix() + sage: Lxx = (x*x).matrix() + sage: Lxy = (x*y).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.matrix() + sage: Ly = y.matrix() + sage: Lz = z.matrix() + sage: Lzy = (z*y).matrix() + sage: Lxy = (x*y).matrix() + sage: Lxz = (x*z).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.matrix() + sage: Ly = y.matrix() + sage: Lz = z.matrix() + sage: Lzy = (z*y).matrix() + sage: Luy = (u*y).matrix() + sage: Luz = (u*z).matrix() + sage: Luyz = (u*(y*z)).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() @@ -288,8 +503,8 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): identity:: sage: set_random_seed() - sage: n = ZZ.random_element(2,10).abs() - sage: J = eja_ln(n) + sage: n = ZZ.random_element(2,10) + sage: J = JordanSpinSimpleEJA(n) sage: y = J.random_element() sage: while y == y.coefficient(0)*J.one(): ....: y = J.random_element() @@ -323,7 +538,7 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): return elt.minimal_polynomial() - def quadratic_representation(self): + def quadratic_representation(self, other=None): """ Return the quadratic representation of this element. @@ -332,8 +547,9 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): 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 = eja_ln(n) + 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: x0 = x_vec[0] @@ -348,8 +564,55 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): 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") + + return ( self.matrix()*other.matrix() + + other.matrix()*self.matrix() + - (self*other).matrix() ) def span_of_powers(self): @@ -433,7 +696,7 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): 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 @@ -489,7 +752,7 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): EXAMPLES:: - sage: J = eja_ln(3) + sage: J = JordanSpinSimpleEJA(3) sage: e0,e1,e2 = J.gens() sage: x = e0 + e1 + e2 sage: x.trace() @@ -549,82 +812,6 @@ def eja_rn(dimension, field=QQ): return FiniteDimensionalEuclideanJordanAlgebra(field,Qs,rank=dimension) -def eja_ln(dimension, field=QQ): - """ - Return the Jordan algebra corresponding to the Lorentz "ice cream" - cone of the given ``dimension``. - - EXAMPLES: - - This multiplication table can be verified by hand:: - - 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 - - In one dimension, this is the reals under multiplication:: - - sage: J1 = eja_ln(1) - sage: J2 = eja_rn(1) - sage: J1 == J2 - True - - """ - 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) - - # 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) - - -def eja_sn(dimension, field=QQ): - """ - Return the simple Jordan algebra of ``dimension``-by-``dimension`` - symmetric matrices over ``field``. - - 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 - - """ - S = _real_symmetric_basis(dimension, field=field) - Qs = _multiplication_table_from_matrix_basis(S) - - return FiniteDimensionalEuclideanJordanAlgebra(field,Qs,rank=dimension) - def random_eja(): """ @@ -652,9 +839,12 @@ def random_eja(): Euclidean Jordan algebra of degree... """ - n = ZZ.random_element(1,10).abs() - constructor = choice([eja_rn, eja_ln, eja_sn]) - return constructor(dimension=n, field=QQ) + n = ZZ.random_element(1,5) + constructor = choice([eja_rn, + JordanSpinSimpleEJA, + RealSymmetricSimpleEJA, + ComplexHermitianSimpleEJA]) + return constructor(n, field=QQ) @@ -677,6 +867,43 @@ def _real_symmetric_basis(n, field=QQ): 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) + 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 @@ -709,7 +936,7 @@ def _multiplication_table_from_matrix_basis(basis): S = [ vec2mat(b) for b in W.basis() ] Qs = [] - for s in basis: + for s in S: # Brute force the multiplication-by-s matrix by looping # through all elements of the basis and doing the computation # to find out what the corresponding row should be. BEWARE: @@ -718,31 +945,146 @@ def _multiplication_table_from_matrix_basis(basis): # constructor uses ROW vectors and not COLUMN vectors. That's # why we're computing rows here and not columns. Q_rows = [] - for t in basis: + 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 Qs -def RealSymmetricSimpleEJA(n): +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) + sage: J = RealSymmetricSimpleEJA(n) + sage: J.degree() == (n^2 + n)/2 + True + """ - pass + S = _real_symmetric_basis(n, field=field) + Qs = _multiplication_table_from_matrix_basis(S) + + return FiniteDimensionalEuclideanJordanAlgebra(field,Qs,rank=n) + -def ComplexHermitianSimpleEJA(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 + 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 + """ - pass + S = _complex_hermitian_basis(n) + Qs = _multiplication_table_from_matrix_basis(S) + return FiniteDimensionalEuclideanJordanAlgebra(field, Qs, rank=n) + def QuaternionHermitianSimpleEJA(n): """ @@ -760,11 +1102,56 @@ def OctonionHermitianSimpleEJA(n): n = 3 pass -def JordanSpinSimpleEJA(n): +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 = (, 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 + """ - pass + 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))