.. index:: single: partitions_protocol .. _partitions_protocol/0:

.. rst-class:: right

protocol

`partitions_protocol`

Protocol for set partition operations over lists.

| Availability: | logtalk_load(partitions(loader))

| Author: Paulo Moura | Version: 1:0:0 | Date: 2026-05-12

| Compilation flags: | static

| Dependencies: | (none)

| Remarks: | (none)

| Inherited public predicates: | (none)

.. contents:: :local: :backlinks: top

Public predicates

.. index:: partitions/2 .. _partitions_protocol/0::partitions/2:

partitions/2 ^^^^^^^^^^^^^^^^

Generates all set partitions of a list using default order. Partitions are represented as lists of non-empty blocks. The empty list has one partition, represented by the empty list of blocks.

| Compilation flags: | static

| Template: | partitions(List,Partitions) | Mode and number of proofs: | partitions(+list,-list) - one

.. index:: partition/2 .. _partitions_protocol/0::partition/2:

partition/2 ^^^^^^^^^^^^^^^

True iff the second argument is a set partition of a list using default order.

| Compilation flags: | static

| Template: | partition(List,Partition) | Mode and number of proofs: | partition(+list,-list) - one_or_more

.. index:: partitions/3 .. _partitions_protocol/0::partitions/3:

partitions/3 ^^^^^^^^^^^^^^^^

Generates either all set partitions with the given order (when the second argument is default or lexicographic) or all set partitions with an exact number of blocks using default order (when the first argument is an integer).

| Compilation flags: | static

.. index:: partition/3 .. _partitions_protocol/0::partition/3:

partition/3 ^^^^^^^^^^^^^^^

True iff the third argument is a set partition generated either in the given order or with the given exact number of blocks using default order.

| Compilation flags: | static

.. index:: partitions/4 .. _partitions_protocol/0::partitions/4:

partitions/4 ^^^^^^^^^^^^^^^^

Generates all set partitions with an exact number of blocks and the given order: default or lexicographic.

| Compilation flags: | static

| Template: | partitions(K,List,Order,Partitions) | Mode and number of proofs: | partitions(+integer,+list,+atom,-list) - one

.. index:: partition/4 .. _partitions_protocol/0::partition/4:

partition/4 ^^^^^^^^^^^^^^^

True iff the fourth argument is a set partition with an exact number of blocks and the given order: default or lexicographic.

| Compilation flags: | static

| Template: | partition(K,List,Order,Partition) | Mode and number of proofs: | partition(+integer,+list,+atom,-list) - one_or_more

.. index:: distinct_partitions/2 .. _partitions_protocol/0::distinct_partitions/2:

distinct_partitions/2 ^^^^^^^^^^^^^^^^^^^^^^^^^

Generates all distinct set partitions of a list (deduplicating equal-valued partitions after canonicalizing block order) using default order.

| Compilation flags: | static

| Template: | distinct_partitions(List,Partitions) | Mode and number of proofs: | distinct_partitions(+list,-list) - one

.. index:: distinct_partition/2 .. _partitions_protocol/0::distinct_partition/2:

distinct_partition/2 ^^^^^^^^^^^^^^^^^^^^^^^^

True iff the second argument is a distinct set partition of a list using default order.

| Compilation flags: | static

| Template: | distinct_partition(List,Partition) | Mode and number of proofs: | distinct_partition(+list,-list) - one_or_more

.. index:: distinct_partitions/3 .. _partitions_protocol/0::distinct_partitions/3:

distinct_partitions/3 ^^^^^^^^^^^^^^^^^^^^^^^^^

Generates either all distinct set partitions with the given order (when the second argument is default or lexicographic) or all distinct set partitions with an exact number of blocks using default order (when the first argument is an integer).

| Compilation flags: | static

.. index:: distinct_partition/3 .. _partitions_protocol/0::distinct_partition/3:

distinct_partition/3 ^^^^^^^^^^^^^^^^^^^^^^^^

True iff the third argument is a distinct set partition generated either in the given order or with the given exact number of blocks using default order.

| Compilation flags: | static

| Template: | distinct_partition(ListOrK,OrderOrList,Partition) | Mode and number of proofs: | distinct_partition(+list,+atom,-list) - one_or_more | distinct_partition(+integer,+list,-list) - one_or_more

.. index:: distinct_partitions/4 .. _partitions_protocol/0::distinct_partitions/4:

distinct_partitions/4 ^^^^^^^^^^^^^^^^^^^^^^^^^

Generates all distinct set partitions with an exact number of blocks and the given order: default or lexicographic.

| Compilation flags: | static

| Template: | distinct_partitions(K,List,Order,Partitions) | Mode and number of proofs: | distinct_partitions(+integer,+list,+atom,-list) - one

.. index:: distinct_partition/4 .. _partitions_protocol/0::distinct_partition/4:

distinct_partition/4 ^^^^^^^^^^^^^^^^^^^^^^^^

True iff the fourth argument is a distinct set partition with an exact number of blocks and the given order: default or lexicographic.

| Compilation flags: | static

| Template: | distinct_partition(K,List,Order,Partition) | Mode and number of proofs: | distinct_partition(+integer,+list,+atom,-list) - one_or_more

.. index:: count_partitions/2 .. _partitions_protocol/0::count_partitions/2:

count_partitions/2 ^^^^^^^^^^^^^^^^^^^^^^

Counts the number of set partitions of a list.

| Compilation flags: | static

| Template: | count_partitions(List,Count) | Mode and number of proofs: | count_partitions(+list,-integer) - one

.. index:: nth_partition/3 .. _partitions_protocol/0::nth_partition/3:

nth_partition/3 ^^^^^^^^^^^^^^^^^^^

Returns the set partition at a given zero-based index using default order.

| Compilation flags: | static

| Template: | nth_partition(List,Index,Partition) | Mode and number of proofs: | nth_partition(+list,+integer,-list) - zero_or_one

.. index:: nth_partition/4 .. _partitions_protocol/0::nth_partition/4:

nth_partition/4 ^^^^^^^^^^^^^^^^^^^

Returns either the set partition at a given zero-based index in the given order (when the second argument is default or lexicographic) or the set partition with an exact number of blocks at a given zero-based index using default order (when the first argument is an integer).

| Compilation flags: | static

| Template: | nth_partition(ListOrK,OrderOrList,Index,Partition) | Mode and number of proofs: | nth_partition(+list,+atom,+integer,-list) - zero_or_one | nth_partition(+integer,+list,+integer,-list) - zero_or_one

.. index:: nth_partition/5 .. _partitions_protocol/0::nth_partition/5:

nth_partition/5 ^^^^^^^^^^^^^^^^^^^

Returns the set partition with an exact number of blocks at a given zero-based index in the given order: default or lexicographic.

| Compilation flags: | static

| Template: | nth_partition(K,List,Order,Index,Partition) | Mode and number of proofs: | nth_partition(+integer,+list,+atom,+integer,-list) - zero_or_one

.. index:: partition_index/3 .. _partitions_protocol/0::partition_index/3:

partition_index/3 ^^^^^^^^^^^^^^^^^^^^^

Returns the zero-based index of a set partition using default order.

| Compilation flags: | static

| Template: | partition_index(List,Partition,Index) | Mode and number of proofs: | partition_index(+list,+list,-integer) - zero_or_one

.. index:: partition_index/4 .. _partitions_protocol/0::partition_index/4:

partition_index/4 ^^^^^^^^^^^^^^^^^^^^^

Returns either the zero-based index of a set partition in the given order (when the second argument is default or lexicographic) or the zero-based index of a set partition with an exact number of blocks using default order (when the first argument is an integer).

| Compilation flags: | static

| Template: | partition_index(ListOrK,OrderOrList,Partition,Index) | Mode and number of proofs: | partition_index(+list,+atom,+list,-integer) - zero_or_one | partition_index(+integer,+list,+list,-integer) - zero_or_one

.. index:: partition_index/5 .. _partitions_protocol/0::partition_index/5:

partition_index/5 ^^^^^^^^^^^^^^^^^^^^^

Returns the zero-based index of a set partition with an exact number of blocks in the given order: default or lexicographic.

| Compilation flags: | static

| Template: | partition_index(K,List,Order,Partition,Index) | Mode and number of proofs: | partition_index(+integer,+list,+atom,+list,-integer) - zero_or_one

.. index:: count_partitions/3 .. _partitions_protocol/0::count_partitions/3:

count_partitions/3 ^^^^^^^^^^^^^^^^^^^^^^

Counts the number of set partitions of a list with an exact number of blocks.

| Compilation flags: | static

| Template: | count_partitions(K,List,Count) | Mode and number of proofs: | count_partitions(+integer,+list,-integer) - zero_or_one

.. index:: count_distinct_partitions/2 .. _partitions_protocol/0::count_distinct_partitions/2:

count_distinct_partitions/2 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Counts the number of distinct set partitions of a list (deduplicating equal-valued partitions).

| Compilation flags: | static

| Template: | count_distinct_partitions(List,Count) | Mode and number of proofs: | count_distinct_partitions(+list,-integer) - one

.. index:: nth_distinct_partition/3 .. _partitions_protocol/0::nth_distinct_partition/3:

nth_distinct_partition/3 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Returns the distinct set partition at a given zero-based index using default order.

| Compilation flags: | static

| Template: | nth_distinct_partition(List,Index,Partition) | Mode and number of proofs: | nth_distinct_partition(+list,+integer,-list) - zero_or_one

.. index:: nth_distinct_partition/4 .. _partitions_protocol/0::nth_distinct_partition/4:

nth_distinct_partition/4 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Returns either the distinct set partition at a given zero-based index in the given order (when the second argument is default or lexicographic) or the distinct set partition with an exact number of blocks at a given zero-based index using default order (when the first argument is an integer).

| Compilation flags: | static

| Template: | nth_distinct_partition(ListOrK,OrderOrList,Index,Partition) | Mode and number of proofs: | nth_distinct_partition(+list,+atom,+integer,-list) - zero_or_one | nth_distinct_partition(+integer,+list,+integer,-list) - zero_or_one

.. index:: nth_distinct_partition/5 .. _partitions_protocol/0::nth_distinct_partition/5:

nth_distinct_partition/5 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Returns the distinct set partition with an exact number of blocks at a given zero-based index in the given order: default or lexicographic.

| Compilation flags: | static

| Template: | nth_distinct_partition(K,List,Order,Index,Partition) | Mode and number of proofs: | nth_distinct_partition(+integer,+list,+atom,+integer,-list) - zero_or_one

.. index:: distinct_partition_index/3 .. _partitions_protocol/0::distinct_partition_index/3:

distinct_partition_index/3 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Returns the zero-based index of a distinct set partition using default order.

| Compilation flags: | static

| Template: | distinct_partition_index(List,Partition,Index) | Mode and number of proofs: | distinct_partition_index(+list,+list,-integer) - zero_or_one

.. index:: distinct_partition_index/4 .. _partitions_protocol/0::distinct_partition_index/4:

distinct_partition_index/4 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Returns either the zero-based index of a distinct set partition in the given order (when the second argument is default or lexicographic) or the zero-based index of a distinct set partition with an exact number of blocks using default order (when the first argument is an integer).

| Compilation flags: | static

| Template: | distinct_partition_index(ListOrK,OrderOrList,Partition,Index) | Mode and number of proofs: | distinct_partition_index(+list,+atom,+list,-integer) - zero_or_one | distinct_partition_index(+integer,+list,+list,-integer) - zero_or_one

.. index:: distinct_partition_index/5 .. _partitions_protocol/0::distinct_partition_index/5:

distinct_partition_index/5 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Returns the zero-based index of a distinct set partition with an exact number of blocks in the given order: default or lexicographic.

| Compilation flags: | static

| Template: | distinct_partition_index(K,List,Order,Partition,Index) | Mode and number of proofs: | distinct_partition_index(+integer,+list,+atom,+list,-integer) - zero_or_one

.. index:: count_distinct_partitions/3 .. _partitions_protocol/0::count_distinct_partitions/3:

count_distinct_partitions/3 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Counts the number of distinct set partitions of a list with an exact number of blocks.

| Compilation flags: | static

| Template: | count_distinct_partitions(K,List,Count) | Mode and number of proofs: | count_distinct_partitions(+integer,+list,-integer) - zero_or_one

.. index:: random_partition/2 .. _partitions_protocol/0::random_partition/2:

random_partition/2 ^^^^^^^^^^^^^^^^^^^^^^

Returns a random set partition of a list.

| Compilation flags: | static

| Template: | random_partition(List,Partition) | Mode and number of proofs: | random_partition(+list,-list) - one

.. index:: random_partition/3 .. _partitions_protocol/0::random_partition/3:

random_partition/3 ^^^^^^^^^^^^^^^^^^^^^^

Returns a random set partition of a list with an exact number of blocks.

| Compilation flags: | static

| Template: | random_partition(K,List,Partition) | Mode and number of proofs: | random_partition(+integer,+list,-list) - zero_or_one

.. index:: sample_partitions/3 .. _partitions_protocol/0::sample_partitions/3:

sample_partitions/3 ^^^^^^^^^^^^^^^^^^^^^^^

Returns SampleCount random set partitions of a list, sampled with replacement.

| Compilation flags: | static

| Template: | sample_partitions(List,SampleCount,Samples) | Mode and number of proofs: | sample_partitions(+list,+integer,-list) - zero_or_one

.. index:: sample_partitions/4 .. _partitions_protocol/0::sample_partitions/4:

sample_partitions/4 ^^^^^^^^^^^^^^^^^^^^^^^

Returns SampleCount random set partitions of a list with an exact number of blocks, sampled with replacement.

| Compilation flags: | static

| Template: | sample_partitions(K,List,SampleCount,Samples) | Mode and number of proofs: | sample_partitions(+integer,+list,+integer,-list) - zero_or_one

.. index:: random_distinct_partition/2 .. _partitions_protocol/0::random_distinct_partition/2:

random_distinct_partition/2 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Returns a random distinct set partition of a list (deduplicating equal-valued partitions).

| Compilation flags: | static

| Template: | random_distinct_partition(List,Partition) | Mode and number of proofs: | random_distinct_partition(+list,-list) - one

.. index:: random_distinct_partition/3 .. _partitions_protocol/0::random_distinct_partition/3:

random_distinct_partition/3 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Returns a random distinct set partition of a list with an exact number of blocks (deduplicating equal-valued partitions).

| Compilation flags: | static

| Template: | random_distinct_partition(K,List,Partition) | Mode and number of proofs: | random_distinct_partition(+integer,+list,-list) - zero_or_one

.. index:: sample_distinct_partitions/3 .. _partitions_protocol/0::sample_distinct_partitions/3:

sample_distinct_partitions/3 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Returns SampleCount random distinct set partitions of a list, sampled with replacement after deduplicating equal-valued partitions.

| Compilation flags: | static

| Template: | sample_distinct_partitions(List,SampleCount,Samples) | Mode and number of proofs: | sample_distinct_partitions(+list,+integer,-list) - zero_or_one

.. index:: sample_distinct_partitions/4 .. _partitions_protocol/0::sample_distinct_partitions/4:

sample_distinct_partitions/4 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Returns SampleCount random distinct set partitions of a list with an exact number of blocks, sampled with replacement after deduplicating equal-valued partitions.

| Compilation flags: | static

| Template: | sample_distinct_partitions(K,List,SampleCount,Samples) | Mode and number of proofs: | sample_distinct_partitions(+integer,+list,+integer,-list) - zero_or_one

.. index:: next_partition/3 .. _partitions_protocol/0::next_partition/3:

next_partition/3 ^^^^^^^^^^^^^^^^^^^^

Returns the next distinct set partition value in lexicographic order induced by the first argument.

| Compilation flags: | static

| Template: | next_partition(List,Partition,Next) | Mode and number of proofs: | next_partition(+list,+list,-list) - zero_or_one

.. index:: next_partition/4 .. _partitions_protocol/0::next_partition/4:

next_partition/4 ^^^^^^^^^^^^^^^^^^^^

Returns the next distinct set partition value with an exact number of blocks in lexicographic order induced by the second argument.

| Compilation flags: | static

| Template: | next_partition(K,List,Partition,Next) | Mode and number of proofs: | next_partition(+integer,+list,+list,-list) - zero_or_one

.. index:: previous_partition/3 .. _partitions_protocol/0::previous_partition/3:

previous_partition/3 ^^^^^^^^^^^^^^^^^^^^^^^^

Returns the previous distinct set partition value in lexicographic order induced by the first argument.

| Compilation flags: | static

| Template: | previous_partition(List,Partition,Previous) | Mode and number of proofs: | previous_partition(+list,+list,-list) - zero_or_one

.. index:: previous_partition/4 .. _partitions_protocol/0::previous_partition/4:

previous_partition/4 ^^^^^^^^^^^^^^^^^^^^^^^^

Returns the previous distinct set partition value with an exact number of blocks in lexicographic order induced by the second argument.

| Compilation flags: | static

| Template: | previous_partition(K,List,Partition,Previous) | Mode and number of proofs: | previous_partition(+integer,+list,+list,-list) - zero_or_one

Protected predicates

(none)

Private predicates

(none)

Operators

(none)