class_docstr: Has methods to ``enumerate`` and ``count`` the partitions of a multiset.
  
  This implements a refactored and extended version of Knuth's algorithm
  7.1.2.5M [AOCP]_."
  
  The enumeration methods of this class are generators and return
  data structures which can be interpreted by the same visitor
  functions used for the output of ``multiset_partitions_taocp``.
  
  Examples
  ========
  
  >>> from sympy.utilities.enumerative import MultisetPartitionTraverser
  >>> m = MultisetPartitionTraverser()
  >>> m.count_partitions([4,4,4,2])
  127750
  >>> m.count_partitions([3,3,3])
  686
  
  See Also
  ========
  
  multiset_partitions_taocp
  sympy.utilities.iterables.multiset_partitions
  
  References
  ==========
  
  .. [AOCP] Algorithm 7.1.2.5M in Volume 4A, Combinatoral Algorithms,
         Part 1, of The Art of Computer Programming, by Donald Knuth.
  
  .. [Factorisatio] On a Problem of Oppenheim concerning
         "Factorisatio Numerorum" E. R. Canfield, Paul Erdos, Carl
         Pomerance, JOURNAL OF NUMBER THEORY, Vol. 17, No. 1. August
         1983.  See section 7 for a description of an algorithm
         similar to Knuth's.
  
  .. [Yorgey] Generating Multiset Partitions, Brent Yorgey, The
         Monad.Reader, Issue 8, September 2007.
docstr: Decrements part, while respecting size constraint.
  
  A part can have no children which are of sufficient size (as
  indicated by ``lb``) unless that part has sufficient
  unallocated multiplicity.  When enforcing the size constraint,
  this method will decrement the part (if necessary) by an
  amount needed to ensure sufficient unallocated multiplicity.
  
  Returns True iff the part was successfully decremented.
  
  Parameters
  ==========
  
  part
      part to be decremented (topmost part on the stack)
  
  amt
      Can only take values 0 or 1.  A value of 1 means that the
      part must be decremented, and then the size constraint is
      enforced.  A value of 0 means just to enforce the ``lb``
      size constraint.
  
  lb
      The partitions produced by the calling enumeration must
      have more parts than this value.
docstr_tok: ["Decrements","part",",","while","respecting","size","constraint",".","A","part","can","have","no","children","which","are","of","sufficient","size","(","as","indicated","by","``","lb","``",")","unless","that","part","has","sufficient","unallocated","multiplicity",".","When","enforcing","the","size","constraint",",","this","method","will","decrement","the","part","(","if","necessary",")","by","an","amount","needed","to","ensure","sufficient","unallocated","multiplicity",".","Returns","True","iff","the","part","was","successfully","decremented",".","Parameters","==========","part","part","to","be","decremented","(","topmost","part","on","the","stack",")","amt","Can","only","take","values","0","or","1",".","A","value","of","1","means","that","the","part","must","be","decremented",",","and","then","the","size","constraint","is","enforced",".","A","value","of","0","means","just","to","enforce","the","``","lb","``","size","constraint",".","lb","The","partitions","produced","by","the","calling","enumeration","must","have","more","parts","than","this","value","."]
code: def decrement_part_large(self, part, amt, lb):
      """Decrements part, while respecting size constraint.
  
      A part can have no children which are of sufficient size (as
      indicated by ``lb``) unless that part has sufficient
      unallocated multiplicity.  When enforcing the size constraint,
      this method will decrement the part (if necessary) by an
      amount needed to ensure sufficient unallocated multiplicity.
  
      Returns True iff the part was successfully decremented.
  
      Parameters
      ==========
  
      part
          part to be decremented (topmost part on the stack)
  
      amt
          Can only take values 0 or 1.  A value of 1 means that the
          part must be decremented, and then the size constraint is
          enforced.  A value of 0 means just to enforce the ``lb``
          size constraint.
  
      lb
          The partitions produced by the calling enumeration must
          have more parts than this value.
  
      """
  
      if amt == 1:
          # In this case we always need to decrement, *before*
          # enforcing the "sufficient unallocated multiplicity"
          # constraint.  Easiest for this is just to call the
          # regular decrement method.
          if not self.decrement_part(part):
              return False
  
      # Next, perform any needed additional decrementing to respect
      # "sufficient unallocated multiplicity" (or fail if this is
      # not possible).
      min_unalloc = lb - self.lpart
      if min_unalloc <= 0:
          return True
      total_mult = sum(pc.u for pc in part)
      total_alloc = sum(pc.v for pc in part)
      if total_mult <= min_unalloc:
          return False
  
      deficit = min_unalloc - (total_mult - total_alloc)
      if deficit <= 0:
          return True
  
      for i in range(len(part) - 1, -1, -1):
          if i == 0:
              if part[0].v > deficit:
                  part[0].v -= deficit
                  return True
              else:
                  return (
                      False  # This shouldn't happen, due to above check
                  )
          else:
              if part[i].v >= deficit:
                  part[i].v -= deficit
                  return True
              else:
                  deficit -= part[i].v
                  part[i].v = 0
  
label_desc: Use image node_id 6 for calling the MultisetPartitionTraverser obj's underlying member method code with example usage: obj.decrement_part_large(part, amt, lb) and returns: True, False, True, False, True, False, True