X-Git-Url: http://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=mjo%2Feja%2Feuclidean_jordan_algebra.py;h=1426d5e16be4b6acc7c68a4494e2c6f1c4d61819;hb=4156fccce1265f500fe432b0f5567e43fbbc23d6;hp=d6235d33ee2edd77f24d1b304e8d4d80b4342d9f;hpb=5f2deba7b079cfe5a0a290f810e569bfb480d186;p=sage.d.git diff --git a/mjo/eja/euclidean_jordan_algebra.py b/mjo/eja/euclidean_jordan_algebra.py index d6235d3..1426d5e 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 """ @@ -153,6 +187,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. @@ -243,7 +367,7 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): 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 @@ -261,6 +385,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,7 +466,7 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): 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(): @@ -323,7 +501,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,7 +510,8 @@ 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: set_random_seed() + sage: n = ZZ.random_element(1,10) sage: J = JordanSpinSimpleEJA(n) sage: x = J.random_element() sage: x_vec = x.vector() @@ -348,8 +527,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): @@ -576,7 +802,7 @@ def random_eja(): Euclidean Jordan algebra of degree... """ - n = ZZ.random_element(1,5).abs() + n = ZZ.random_element(1,5) constructor = choice([eja_rn, JordanSpinSimpleEJA, RealSymmetricSimpleEJA, @@ -611,7 +837,7 @@ def _complex_hermitian_basis(n, field=QQ): TESTS:: sage: set_random_seed() - sage: n = ZZ.random_element(1,5).abs() + sage: n = ZZ.random_element(1,5) sage: all( M.is_symmetric() for M in _complex_hermitian_basis(n) ) True @@ -788,7 +1014,7 @@ def RealSymmetricSimpleEJA(n, field=QQ): The degree of this algebra is `(n^2 + n) / 2`:: sage: set_random_seed() - sage: n = ZZ.random_element(1,5).abs() + sage: n = ZZ.random_element(1,5) sage: J = RealSymmetricSimpleEJA(n) sage: J.degree() == (n^2 + n)/2 True @@ -812,7 +1038,7 @@ def ComplexHermitianSimpleEJA(n, field=QQ): The degree of this algebra is `n^2`:: sage: set_random_seed() - sage: n = ZZ.random_element(1,5).abs() + sage: n = ZZ.random_element(1,5) sage: J = ComplexHermitianSimpleEJA(n) sage: J.degree() == n^2 True