]> gitweb.michael.orlitzky.com - sage.d.git/commitdiff
eja: put element methods in alphabetical order.
authorMichael Orlitzky <michael@orlitzky.com>
Sat, 29 Jun 2019 14:08:56 +0000 (10:08 -0400)
committerMichael Orlitzky <michael@orlitzky.com>
Mon, 29 Jul 2019 03:19:01 +0000 (23:19 -0400)
mjo/eja/euclidean_jordan_algebra.py

index 60a7ba1ede07bac242eb9aef6bcf9b722340c595..1281a029a8f5c4557d9d35ee50342caecdc51054 100644 (file)
@@ -126,6 +126,65 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra):
                 return A.element_class(A, (self.matrix()**(n-1))*self.vector())
 
 
+        def characteristic_polynomial(self):
+            return self.matrix().characteristic_polynomial()
+
+
+        def is_nilpotent(self):
+            """
+            Return whether or not some power of this element is zero.
+
+            The superclass method won't work unless we're in an
+            associative algebra, and we aren't. However, we generate
+            an assocoative subalgebra and we're nilpotent there if and
+            only if we're nilpotent here (probably).
+
+            TESTS:
+
+            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()
+                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()
+                True
+
+            """
+            # The element we're going to call "is_nilpotent()" on.
+            # Either myself, interpreted as an element of a finite-
+            # dimensional algebra, or an element of an associative
+            # subalgebra.
+            elt = None
+
+            if self.parent().is_associative():
+                elt = FiniteDimensionalAlgebraElement(self.parent(), self)
+            else:
+                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()))
+
+            # Recursive call, but should work since elt lives in an
+            # associative algebra.
+            return elt.is_nilpotent()
+
+
         def is_regular(self):
             """
             Return whether or not this is a regular element.
@@ -150,17 +209,6 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra):
             """
             return self.degree() == self.parent().rank()
 
-        def span_of_powers(self):
-            """
-            Return the vector space spanned by successive powers of
-            this element.
-            """
-            # The dimension of the subalgebra can't be greater than
-            # the big algebra, so just put everything into a list
-            # and let span() get rid of the excess.
-            V = self.vector().parent()
-            return V.span( (self**d).vector() for d in xrange(V.dimension()) )
-
 
         def degree(self):
             """
@@ -205,69 +253,6 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra):
             return fda_elt.matrix().transpose()
 
 
-        def subalgebra_generated_by(self):
-            """
-            Return the associative subalgebra of the parent EJA generated
-            by this element.
-
-            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.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: u = x.subalgebra_generated_by().random_element()
-                sage: u.matrix()*u.vector() == (u**2).vector()
-                True
-
-            """
-            # First get the subspace spanned by the powers of myself...
-            V = self.span_of_powers()
-            F = self.base_ring()
-
-            # Now figure out the entries of the right-multiplication
-            # matrix for the successive basis elements b0, b1,... of
-            # that subspace.
-            mats = []
-            for b_right in V.basis():
-                eja_b_right = self.parent()(b_right)
-                b_right_rows = []
-                # The first row of the right-multiplication matrix by
-                # b1 is what we get if we apply that matrix to b1. The
-                # second row of the right multiplication matrix by b1
-                # is what we get when we apply that matrix to b2...
-                #
-                # IMPORTANT: this assumes that all vectors are COLUMN
-                # vectors, unlike our superclass (which uses row vectors).
-                for b_left in V.basis():
-                    eja_b_left = self.parent()(b_left)
-                    # Multiply in the original EJA, but then get the
-                    # coordinates from the subalgebra in terms of its
-                    # basis.
-                    this_row = V.coordinates((eja_b_left*eja_b_right).vector())
-                    b_right_rows.append(this_row)
-                b_right_matrix = matrix(F, b_right_rows)
-                mats.append(b_right_matrix)
-
-            # It's an algebra of polynomials in one element, and EJAs
-            # are power-associative.
-            #
-            # TODO: choose generator names intelligently.
-            return FiniteDimensionalEuclideanJordanAlgebra(F, mats, assume_associative=True, names='f')
-
-
         def minimal_polynomial(self):
             """
             EXAMPLES::
@@ -329,59 +314,79 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra):
             return elt.minimal_polynomial()
 
 
-        def is_nilpotent(self):
+        def span_of_powers(self):
             """
-            Return whether or not some power of this element is zero.
+            Return the vector space spanned by successive powers of
+            this element.
+            """
+            # The dimension of the subalgebra can't be greater than
+            # the big algebra, so just put everything into a list
+            # and let span() get rid of the excess.
+            V = self.vector().parent()
+            return V.span( (self**d).vector() for d in xrange(V.dimension()) )
 
-            The superclass method won't work unless we're in an
-            associative algebra, and we aren't. However, we generate
-            an assocoative subalgebra and we're nilpotent there if and
-            only if we're nilpotent here (probably).
 
-            TESTS:
+        def subalgebra_generated_by(self):
+            """
+            Return the associative subalgebra of the parent EJA generated
+            by this element.
 
-            The identity element is never nilpotent::
+            TESTS::
 
                 sage: set_random_seed()
-                sage: n = ZZ.random_element(2,10).abs()
+                sage: n = ZZ.random_element(1,10).abs()
                 sage: J = eja_rn(n)
-                sage: J.one().is_nilpotent()
-                False
+                sage: x = J.random_element()
+                sage: x.subalgebra_generated_by().is_associative()
+                True
                 sage: J = eja_ln(n)
-                sage: J.one().is_nilpotent()
-                False
+                sage: x = J.random_element()
+                sage: x.subalgebra_generated_by().is_associative()
+                True
 
-            The additive identity is always nilpotent::
+            Squaring in the subalgebra should be the same thing as
+            squaring in the superalgebra::
 
-                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: J = eja_ln(5)
+                sage: x = J.random_element()
+                sage: u = x.subalgebra_generated_by().random_element()
+                sage: u.matrix()*u.vector() == (u**2).vector()
                 True
 
             """
-            # The element we're going to call "is_nilpotent()" on.
-            # Either myself, interpreted as an element of a finite-
-            # dimensional algebra, or an element of an associative
-            # subalgebra.
-            elt = None
+            # First get the subspace spanned by the powers of myself...
+            V = self.span_of_powers()
+            F = self.base_ring()
 
-            if self.parent().is_associative():
-                elt = FiniteDimensionalAlgebraElement(self.parent(), self)
-            else:
-                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()))
+            # Now figure out the entries of the right-multiplication
+            # matrix for the successive basis elements b0, b1,... of
+            # that subspace.
+            mats = []
+            for b_right in V.basis():
+                eja_b_right = self.parent()(b_right)
+                b_right_rows = []
+                # The first row of the right-multiplication matrix by
+                # b1 is what we get if we apply that matrix to b1. The
+                # second row of the right multiplication matrix by b1
+                # is what we get when we apply that matrix to b2...
+                #
+                # IMPORTANT: this assumes that all vectors are COLUMN
+                # vectors, unlike our superclass (which uses row vectors).
+                for b_left in V.basis():
+                    eja_b_left = self.parent()(b_left)
+                    # Multiply in the original EJA, but then get the
+                    # coordinates from the subalgebra in terms of its
+                    # basis.
+                    this_row = V.coordinates((eja_b_left*eja_b_right).vector())
+                    b_right_rows.append(this_row)
+                b_right_matrix = matrix(F, b_right_rows)
+                mats.append(b_right_matrix)
 
-            # Recursive call, but should work since elt lives in an
-            # associative algebra.
-            return elt.is_nilpotent()
+            # It's an algebra of polynomials in one element, and EJAs
+            # are power-associative.
+            #
+            # TODO: choose generator names intelligently.
+            return FiniteDimensionalEuclideanJordanAlgebra(F, mats, assume_associative=True, names='f')
 
 
         def subalgebra_idempotent(self):
@@ -447,10 +452,6 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra):
 
 
 
-        def characteristic_polynomial(self):
-            return self.matrix().characteristic_polynomial()
-
-
 def eja_rn(dimension, field=QQ):
     """
     Return the Euclidean Jordan Algebra corresponding to the set