cone/rearrangement.py: fix the test for propriety.

[sage.d.git] / mjo / cone / rearrangement.py

diff --git a/mjo/cone/rearrangement.py b/mjo/cone/rearrangement.py
index b868dd854a5e4945594d860a869e150e01870401..fd792c4b481351a37ab3a0d73227120109de1dc1 100644 (file)
--- a/mjo/cone/rearrangement.py
+++ b/mjo/cone/rearrangement.py
@@ -69,7 +69,7 @@ def rearrangement_cone(p,n):
 
         sage: all( rearrangement_cone(p,n).is_proper()
         ....:              for n in xrange(10)
-        ....:              for p in xrange(n) )
+        ....:              for p in xrange(1, n) )
         True
 
     The Lyapunov rank of the rearrangement cone of order ``p`` in ``n``
@@ -95,68 +95,54 @@ def rearrangement_cone(p,n):
         sage: all( K.contains(P*r) for r in K )
         True
 
-    """
-
-    def d(j):
-        v = [1]*n    # Create the list of all ones...
-        v[j] = 1 - p # Now "fix" the ``j``th entry.
-        return v
-
-    V = VectorSpace(QQ, n)
-    G = V.basis() + [ d(j) for j in xrange(n) ]
-    return Cone(G)
+    The smallest ``p`` components of every element of the rearrangement
+    cone should sum to a nonnegative number (this tests that the
+    generators really are what we think they are)::
 
+        sage: set_random_seed()
+        sage: def _has_rearrangement_property(v,p):
+        ....:     return sum( sorted(v)[0:p] ) >= 0
+        sage: all( _has_rearrangement_property(
+        ....:      rearrangement_cone(p,n).random_element(),
+        ....:      p
+        ....:    )
+        ....:    for n in xrange(2, 10)
+        ....:    for p in xrange(1, n-1)
+        ....: )
+        True
 
-def has_rearrangement_property(v, p):
-    r"""
-    Test if the vector ``v`` has the "rearrangement property."
-
-    The rearrangement cone of order ``p`` in `n` dimensions has its
-    members vectors of length `n`. The "rearrangement property,"
-    satisfied by its elements, is to have its smallest ``p`` components
-    sum to a nonnegative number.
-
-    We believe that we have a description of the extreme vectors of the
-    rearrangement cone: see ``rearrangement_cone()``. This function is
-    used to test that conic combinations of those extreme vectors are in
-    fact elements of the rearrangement cone. We can't test all conic
-    combinations, obviously, but we can test a random one.
-
-    To become more sure of the result, generate a bunch of vectors with
-    ``random_element()`` and test them with this function.
-
-    INPUT:
-
-    - ``v`` -- An element of a cone suspected of being the rearrangement
-               cone of order ``p``.
-
-    - ``p`` -- The suspected order of the rearrangement cone.
-
-    OUTPUT:
-
-    If ``v`` has the rearrangement property (that is, if its smallest ``p``
-    components sum to a nonnegative number), ``True`` is returned. Otherwise
-    ``False`` is returned.
+    The rearrangenent cone of order ``p`` is contained in the
+    rearrangement cone of order ``p + 1``::
 
-    SETUP::
+        sage: set_random_seed()
+        sage: n = ZZ.random_element(2,10)
+        sage: p = ZZ.random_element(1,n)
+        sage: K1 = rearrangement_cone(p,n)
+        sage: K2 = rearrangement_cone(p+1,n)
+        sage: all( x in K2 for x in K1 )
+        True
 
-        sage: from mjo.cone.rearrangement import (has_rearrangement_property,
-        ....:                                     rearrangement_cone)
+    The order ``p`` should be between ``1`` and ``n``, inclusive::
 
-    EXAMPLES:
+        sage: rearrangement_cone(0,3)
+        Traceback (most recent call last):
+        ...
+        ValueError: order p=0 should be between 1 and n=3, inclusive
+        sage: rearrangement_cone(5,3)
+        Traceback (most recent call last):
+        ...
+        ValueError: order p=5 should be between 1 and n=3, inclusive
 
-    Every element of a rearrangement cone should have the property::
+    """
+    if p < 1 or p > n:
+        raise ValueError('order p=%d should be between 1 and n=%d, inclusive'
+                         %
+                         (p,n))
 
-        sage: set_random_seed()
-        sage: all( has_rearrangement_property(
-        ....:        rearrangement_cone(p,n).random_element(),
-        ....:        p
-        ....:      )
-        ....:      for n in xrange(2, 10)
-        ....:      for p in xrange(1, n-1)
-        ....: )
-        True
+    def d(j):
+        v = [1]*n    # Create the list of all ones...
+        v[j] = 1 - p # Now "fix" the ``j``th entry.
+        return v
 
-    """
-    components = sorted(v)[0:p]
-    return sum(components) >= 0
+    G = identity_matrix(ZZ,n).rows() + [ d(j) for j in xrange(n) ]
+    return Cone(G)