X-Git-Url: http://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=mjo%2Feja%2Feja_element.py;h=235047a153f0594bf450987ae2988a5873d92f36;hb=ec4c9a49813109790d461da06d4f64219fa4bf8c;hp=2c425ca320a5c04e6defee044bd0deb01e76dda4;hpb=99952b3ef2ad157d820f1dbd946d329987383464;p=sage.d.git diff --git a/mjo/eja/eja_element.py b/mjo/eja/eja_element.py index 2c425ca..235047a 100644 --- a/mjo/eja/eja_element.py +++ b/mjo/eja/eja_element.py @@ -375,7 +375,8 @@ class FiniteDimensionalEJAElement(IndexedFreeModuleElement): Ensure that the determinant is multiplicative on an associative subalgebra as in Faraut and Korányi's Proposition II.2.2:: - sage: J = random_eja().random_element().subalgebra_generated_by() + sage: x0 = random_eja().random_element() + sage: J = x0.subalgebra_generated_by(orthonormalize=False) sage: x,y = J.random_elements(2) sage: (x*y).det() == x.det()*y.det() True @@ -484,10 +485,12 @@ class FiniteDimensionalEJAElement(IndexedFreeModuleElement): of an element is the inverse of its left-multiplication operator applied to the algebra's identity, when that inverse exists:: - sage: J = random_eja() - sage: x = J.random_element() - sage: (not x.operator().is_invertible()) or ( - ....: x.operator().inverse()(J.one()) == x.inverse() ) + sage: J = random_eja() # long time + sage: x = J.random_element() # long time + sage: (not x.operator().is_invertible()) or ( # long time + ....: x.operator().inverse()(J.one()) # long time + ....: == # long time + ....: x.inverse() ) # long time True Check that the fast (cached) and slow algorithms give the same @@ -504,15 +507,18 @@ class FiniteDimensionalEJAElement(IndexedFreeModuleElement): True """ not_invertible_msg = "element is not invertible" - if self.parent()._charpoly_coefficients.is_in_cache(): + + algebra = self.parent() + if algebra._charpoly_coefficients.is_in_cache(): # We can invert using our charpoly if it will be fast to # compute. If the coefficients are cached, our rank had # better be too! if self.det().is_zero(): raise ZeroDivisionError(not_invertible_msg) - r = self.parent().rank() + r = algebra.rank() a = self.characteristic_polynomial().coefficients(sparse=False) - return (-1)**(r+1)*sum(a[i+1]*self**i for i in range(r))/self.det() + return (-1)**(r+1)*algebra.sum(a[i+1]*self**i + for i in range(r))/self.det() try: inv = (~self.quadratic_representation())(self) @@ -789,7 +795,23 @@ class FiniteDimensionalEJAElement(IndexedFreeModuleElement): ALGORITHM: - ......... + First we handle the special cases where the algebra is + trivial, this element is zero, or the dimension of the algebra + is one and this element is not zero. With those out of the + way, we may assume that ``self`` is nonzero, the algebra is + nontrivial, and that the dimension of the algebra is at least + two. + + Beginning with the algebra's unit element (power zero), we add + successive (basis representations of) powers of this element + to a matrix, row-reducing at each step. After row-reducing, we + check the rank of the matrix. If adding a row and row-reducing + does not increase the rank of the matrix at any point, the row + we've just added lives in the span of the previous ones; thus + the corresponding power of ``self`` lives in the span of its + lesser powers. When that happens, the degree of the minimal + polynomial is the rank of the matrix; if it never happens, the + degree must be the dimension of the entire space. SETUP:: @@ -832,7 +854,6 @@ class FiniteDimensionalEJAElement(IndexedFreeModuleElement): sage: x = random_eja().random_element() sage: x.degree() == x.minimal_polynomial().degree() True - """ n = self.parent().dimension() @@ -976,9 +997,9 @@ class FiniteDimensionalEJAElement(IndexedFreeModuleElement): The minimal polynomial should always kill its element:: - sage: x = random_eja().random_element() - sage: p = x.minimal_polynomial() - sage: x.apply_univariate_polynomial(p) + sage: x = random_eja().random_element() # long time + sage: p = x.minimal_polynomial() # long time + sage: x.apply_univariate_polynomial(p) # long time 0 The minimal polynomial is invariant under a change of basis, @@ -1371,7 +1392,7 @@ class FiniteDimensionalEJAElement(IndexedFreeModuleElement): This subalgebra, being composed of only powers, is associative:: sage: x0 = random_eja().random_element() - sage: A = x0.subalgebra_generated_by() + sage: A = x0.subalgebra_generated_by(orthonormalize=False) sage: x,y,z = A.random_elements(3) sage: (x*y)*z == x*(y*z) True @@ -1380,7 +1401,7 @@ class FiniteDimensionalEJAElement(IndexedFreeModuleElement): the superalgebra:: sage: x = random_eja().random_element() - sage: A = x.subalgebra_generated_by() + sage: A = x.subalgebra_generated_by(orthonormalize=False) sage: A(x^2) == A(x)*A(x) True @@ -1419,7 +1440,7 @@ class FiniteDimensionalEJAElement(IndexedFreeModuleElement): where there are non-nilpotent elements, or that we get the dumb solution in the trivial algebra:: - sage: J = random_eja() + sage: J = random_eja(field=QQ, orthonormalize=False) sage: x = J.random_element() sage: while x.is_nilpotent() and not J.is_trivial(): ....: x = J.random_element() @@ -1434,7 +1455,10 @@ class FiniteDimensionalEJAElement(IndexedFreeModuleElement): if self.is_nilpotent(): raise ValueError("this only works with non-nilpotent elements!") - J = self.subalgebra_generated_by() + # The subalgebra is transient (we return an element of the + # superalgebra, i.e. this algebra) so why bother + # orthonormalizing? + J = self.subalgebra_generated_by(orthonormalize=False) u = J(self) # The image of the matrix of left-u^m-multiplication @@ -1455,14 +1479,12 @@ class FiniteDimensionalEJAElement(IndexedFreeModuleElement): # 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 = J.from_vector(A.solve_right(u_next.to_vector())) - # Now c is the idempotent we want, but it still lives in the subalgebra. + # Now c is the idempotent we want, but it still lives in + # the subalgebra. return c.superalgebra_element() @@ -1536,6 +1558,102 @@ class FiniteDimensionalEJAElement(IndexedFreeModuleElement): # we want the negative of THAT for the trace. return -p(*self.to_vector()) + def operator_inner_product(self, other): + r""" + Return the operator inner product of myself and ``other``. + + The "operator inner product," whose name is not standard, is + defined be the usual linear-algebraic trace of the + ``(x*y).operator()``. + + Proposition III.1.5 in Faraut and Korányi shows that on any + Euclidean Jordan algebra, this is another associative inner + product under which the cone of squares is symmetric. + + This *probably* works even if the basis hasn't been + orthonormalized because the eigenvalues of the corresponding + matrix don't change when the basis does (they're preserved by + any similarity transformation). + + SETUP:: + + sage: from mjo.eja.eja_algebra import (JordanSpinEJA, + ....: RealSymmetricEJA, + ....: ComplexHermitianEJA, + ....: random_eja) + + EXAMPLES: + + Proposition III.4.2 of Faraut and Korányi shows that on a + simple algebra of rank `r` and dimension `n`, this inner + product is `n/r` times the canonical + :meth:`trace_inner_product`:: + + sage: J = JordanSpinEJA(4, field=QQ) + sage: x,y = J.random_elements(2) + sage: n = J.dimension() + sage: r = J.rank() + sage: actual = x.operator_inner_product(y) + sage: expected = (n/r)*x.trace_inner_product(y) + sage: actual == expected + True + + :: + + sage: J = RealSymmetricEJA(3) + sage: x,y = J.random_elements(2) + sage: n = J.dimension() + sage: r = J.rank() + sage: actual = x.operator_inner_product(y) + sage: expected = (n/r)*x.trace_inner_product(y) + sage: actual == expected + True + + :: + + sage: J = ComplexHermitianEJA(3, field=QQ, orthonormalize=False) + sage: x,y = J.random_elements(2) + sage: n = J.dimension() + sage: r = J.rank() + sage: actual = x.operator_inner_product(y) + sage: expected = (n/r)*x.trace_inner_product(y) + sage: actual == expected + True + + TESTS: + + The operator inner product is commutative, bilinear, and + associative:: + + sage: J = random_eja() + sage: x,y,z = J.random_elements(3) + sage: # commutative + sage: x.operator_inner_product(y) == y.operator_inner_product(x) + True + sage: # bilinear + sage: a = J.base_ring().random_element() + sage: actual = (a*(x+z)).operator_inner_product(y) + sage: expected = ( a*x.operator_inner_product(y) + + ....: a*z.operator_inner_product(y) ) + sage: actual == expected + True + sage: actual = x.operator_inner_product(a*(y+z)) + sage: expected = ( a*x.operator_inner_product(y) + + ....: a*x.operator_inner_product(z) ) + sage: actual == expected + True + sage: # associative + sage: actual = (x*y).operator_inner_product(z) + sage: expected = y.operator_inner_product(x*z) + sage: actual == expected + True + + """ + if not other in self.parent(): + raise TypeError("'other' must live in the same algebra") + + return (self*other).operator().matrix().trace() + def trace_inner_product(self, other): """ @@ -1555,7 +1673,7 @@ class FiniteDimensionalEJAElement(IndexedFreeModuleElement): sage: x.trace_inner_product(y) == y.trace_inner_product(x) True sage: # bilinear - sage: a = J.base_ring().random_element(); + sage: a = J.base_ring().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) )