Small language fixes; for brevity move one example to tests

Author: jukkakohonen

src/sage/combinat/integer_vectors_mod_permgroup.py

@@ -53,26 +53,24 @@ class IntegerVectorsModPermutationGroup(UniqueRepresentation):
         v = \max_{\text{lex order}} \{g \cdot v | g \in G \}
 
     The action of `G` is on position. This means for example that the
-    simple transposition `s_1 = (1, 2)` swaps the first and the second entries
-    of any integer vector `v = [a_1, a_2, a_3, \dots , a_n]`
+    simple transposition `s_1 = (1, 2)` swaps the first and the second
+    entries of any integer vector `v = [a_1, a_2, a_3, \dots , a_n]`
 
     .. MATH::
 
         s_1 \cdot v = [a_2, a_1, a_3, \dots , a_n]
 
-    This functions returns a parent which contains a single integer
-    vector by orbit under the action of the permutation group `G`. The
-    approach chosen here is to keep the maximal integer vector for the
-    lexicographic order in each orbit. Such maximal vector will be
-    called canonical integer vector under the action of the
-    permutation group `G`.
+    This function returns a parent which contains, from each orbit
+    orbit under the action of the permutation group `G`, a single
+    canonical vector.  The canonical vector is the one that is maximal
+    within the orbit according to lexicographic order.
 
     INPUT:
 
     - ``G`` - a permutation group
     - ``sum`` - (default: None) - a nonnegative integer
     - ``max_part`` - (default: None) - a nonnegative integer setting the
-      maximum of entries of elements
+      maximum value for every element
     - ``sgs`` - (default: None) - a strong generating system of the
       group `G`. If you do not provide it, it will be calculated at the
       creation of the parent
@@ -118,7 +116,7 @@ class IntegerVectorsModPermutationGroup(UniqueRepresentation):
 
     The method
     :meth:`~sage.combinat.integer_vectors_mod_permgroup.IntegerVectorsModPermutationGroup_All.is_canonical`
-    tests if any integer vector is maximal in its orbit. This method
+    tests if an integer vector is maximal in its orbit. This method
     is also used in the containment test::
 
         sage: I = IntegerVectorsModPermutationGroup(PermutationGroup([[(1,2,3,4)]]))
@@ -137,7 +135,7 @@ class IntegerVectorsModPermutationGroup(UniqueRepresentation):
         sage: I.is_canonical('bla')
         Traceback (most recent call last):
         ...
-        AssertionError: bla should be a list or a integer vector
+        AssertionError: bla should be a list or an integer vector
 
     If you give a value to the extra argument ``sum``, the set returned
     will be a finite set containing only canonical vectors whose entries
@@ -185,23 +183,23 @@ class IntegerVectorsModPermutationGroup(UniqueRepresentation):
 
             sgs = tuple(tuple(s) for s in G.strong_generating_system())
 
-        and provide it as the optional `sgs` argument to the
+        and provide it as the optional ``sgs`` argument to the
         constructor.
 
     TESTS:
 
     Let us check that canonical integer vectors of the symmetric group
-    are just sorted list of integers::
+    are just nonincreasing lists of integers::
 
         sage: I = IntegerVectorsModPermutationGroup(SymmetricGroup(5))  # long time
         sage: p = iter(I)                                               # long time
         sage: for i in range(100):                                      # long time
         ....:     v = list(next(p))
         ....:     assert sorted(v, reverse=True) == v
 
-    We now check that there is as much of canonical vectors under the
-    symmetric group `S_n` whose entries sum to `d` than partitions of
-    `d` of at most `n` parts::
+    We now check that there are as many canonical vectors under the
+    symmetric group `S_n` whose entries sum to `d` as there are
+    partitions of `d` of at most `n` parts::
 
         sage: I = IntegerVectorsModPermutationGroup(SymmetricGroup(5))  # long time
         sage: for i in range(10):                                       # long time
@@ -481,7 +479,7 @@ def is_canonical(self, v, check=True):
             False
         """
         if check:
-            assert isinstance(v, (ClonableIntArray, list)), '%s should be a list or a integer vector' % v
+            assert isinstance(v, (ClonableIntArray, list)), '%s should be a list or an integer vector' % v
             assert (self.n == len(v)), '%s should be of length %s' % (v, self.n)
             for p in v:
                 assert (p == NN(p)), 'Elements of %s should be integers' % v
@@ -879,17 +877,12 @@ def cardinality(self):
             21
 
         With two interchangeable elements, the smaller one
-        ranges from zero to `sum//2`::
+        ranges from zero to ``sum//2``::
 
             sage: G = PermutationGroup([(1,2)])
             sage: IntegerVectorsModPermutationGroup(G, 1000).cardinality()
             501
 
-            sage: G = PermutationGroup([(1,2,3)])
-            sage: I = IntegerVectorsModPermutationGroup(G, sum=10, max_part=5)
-            sage: I.cardinality()
-            7
-
         Binary vectors up to full symmetry are first some ones and
         then some zeros::
 
@@ -919,6 +912,13 @@ def cardinality(self):
             sage: V.cardinality()
             0
 
+        The case when both ``sum`` and ``max_part`` are specified::
+
+            sage: G = PermutationGroup([(1,2,3)])
+            sage: I = IntegerVectorsModPermutationGroup(G, sum=10, max_part=5)
+            sage: I.cardinality()
+            7
+
         All permutation groups of degree 4::
 
             sage: for G in SymmetricGroup(4).subgroups():
@@ -1032,7 +1032,7 @@ def is_canonical(self, v, check=True):
             True
         """
         if check:
-            assert isinstance(v, (ClonableIntArray, list)), '%s should be a list or a integer vector' % v
+            assert isinstance(v, (ClonableIntArray, list)), '%s should be a list or an integer vector' % v
             assert (self.n == len(v)), '%s should be of length %s' % (v, self.n)
             for p in v:
                 assert (p == NN(p)), 'Elements of %s should be integers' % v
@@ -1214,7 +1214,7 @@ class Element(ClonableIntArray):
             sage: v = I.element_class(I, [3,2,0,0])
             Traceback (most recent call last):
             ...
-            AssertionError: [3, 2, 0, 0] should be a integer vector of sum 4
+            AssertionError: [3, 2, 0, 0] should be an integer vector of sum 4
         """
 
         def check(self):
@@ -1234,7 +1234,7 @@ def check(self):
                 AssertionError
             """
             if self.parent()._sum is not None:
-                assert sum(self) == self.parent()._sum, '%s should be a integer vector of sum %s' % (self, self.parent()._sum)
+                assert sum(self) == self.parent()._sum, '%s should be an integer vector of sum %s' % (self, self.parent()._sum)
             if self.parent()._max_part >= 0:
                 assert max(self) <= self.parent()._max_part, 'Entries of %s must be inferior to %s' % (self, self.parent()._max_part)
             assert self.parent().is_canonical(self)