Revision history [back]

I took a look to the code of the VectorPartitions and there was a line that i could not understand immediately...

@staticmethod
def __classcall_private__(cls, vec, min=None, parts=None, distinct=False, is_repeatable=None):
    r"""
    Create the class of vector partitions of ``vec`` where all parts
    are greater than or equal to the vector ``min``.

    EXAMPLES::

        sage: VP1 = VectorPartitions([2, 1])
        sage: VP2 = VectorPartitions((2, 1), min = [0, 1])
        sage: VP1 is VP2
        True
    """
    if min is None:
        min = find_min(vec)  # tuple([0 for v in vec[:-1]]+[1])
    if parts is None:
        parts = list(IntegerVectorsIterator(vec, min=min))
    if [0]*len(vec) in parts:
        parts.remove([0]*len(vec))
    if min in parts:
        min_index = parts.index(min)
        parts = parts[min_index:]
    parts = list(parts)
    for part_index in range(len(parts)):
        parts[part_index] = tuple(parts[part_index])
    return super().__classcall__(cls, tuple(vec), tuple(min), tuple(parts), distinct, is_repeatable)

The line that was somehow strange was the one where the code wants to work with the minimal vector [0, ... , 0, 1]... So i tried to use my min, to overwrite...

Let us compare:

sage: a, b, c = (0, 1), (1, 0), (1, 1)
sage: 
sage: for p in Permutations((a,b,c)):
....:     print(p, '--->', list(VectorPartitions([2, 2], parts=p)))
....: 
[(0, 1), (1, 0), (1, 1)] ---> [[[0, 1], [0, 1], [1, 0], [1, 0]], [[0, 1], [1, 0], [1, 1]], [[1, 1], [1, 1]]]
[(0, 1), (1, 1), (1, 0)] ---> [[[0, 1], [0, 1], [1, 0], [1, 0]], [[0, 1], [1, 0], [1, 1]], [[1, 1], [1, 1]]]
[(1, 0), (0, 1), (1, 1)] ---> [[[0, 1], [1, 0], [1, 1]], [[1, 1], [1, 1]]]
[(1, 0), (1, 1), (0, 1)] ---> []
[(1, 1), (0, 1), (1, 0)] ---> [[[0, 1], [1, 0], [1, 1]], [[0, 1], [0, 1], [1, 0], [1, 0]]]
[(1, 1), (1, 0), (0, 1)] ---> []
sage:

Yes, against my wish. We get a correct answer only when the parts are lexicographically sorted. Or we declare our min:

sage: for p in Permutations((a,b,c)):
....:     print(p, '--->', list(VectorPartitions([2, 2], parts=p, min=[0, 0])))
....: 
[(0, 1), (1, 0), (1, 1)] ---> [[[0, 1], [0, 1], [1, 0], [1, 0]], [[0, 1], [1, 0], [1, 1]], [[1, 1], [1, 1]]]
[(0, 1), (1, 1), (1, 0)] ---> [[[0, 1], [0, 1], [1, 0], [1, 0]], [[0, 1], [1, 0], [1, 1]], [[1, 1], [1, 1]]]
[(1, 0), (0, 1), (1, 1)] ---> [[[0, 1], [0, 1], [1, 0], [1, 0]], [[0, 1], [1, 0], [1, 1]], [[1, 1], [1, 1]]]
[(1, 0), (1, 1), (0, 1)] ---> [[[0, 1], [0, 1], [1, 0], [1, 0]], [[0, 1], [1, 0], [1, 1]], [[1, 1], [1, 1]]]
[(1, 1), (0, 1), (1, 0)] ---> [[[1, 1], [1, 1]], [[0, 1], [1, 0], [1, 1]], [[0, 1], [0, 1], [1, 0], [1, 0]]]
[(1, 1), (1, 0), (0, 1)] ---> [[[1, 1], [1, 1]], [[0, 1], [1, 0], [1, 1]], [[0, 1], [0, 1], [1, 0], [1, 0]]]
sage:

(Tuples are used in order to have quickly the permutations.) (I did not try other cases... Hope it works, it is late in the night here...)