protocol

permutations_protocol

Protocol for permutations operations over lists.

Availability:
logtalk_load(permutations(loader))
Author: Paulo Moura
Version: 1:0:0
Date: 2026-02-26
Compilation flags:
static
Dependencies:
(none)
Remarks:
(none)
Inherited public predicates:
(none)

Public predicates

permutations/2

Generates all permutations of a list.

Compilation flags:
static
Template:
permutations(List,Permutations)
Mode and number of proofs:
permutations(+list,-list) - one

permutation/2

True iff the second argument is a permutation of the first argument.

Compilation flags:
static
Template:
permutation(List,Permutation)
Mode and number of proofs:
permutation(+list,-list) - one_or_more

permutations/3

Generates all permutations with the given order: default, lexicographic, or shortlex.

Compilation flags:
static
Template:
permutations(List,Order,Permutations)
Mode and number of proofs:
permutations(+list,+atom,-list) - one

permutation/3

True iff the third argument is a permutation with the given order: default, lexicographic, or shortlex.

Compilation flags:
static
Template:
permutation(List,Order,Permutation)
Mode and number of proofs:
permutation(+list,+atom,-list) - one_or_more

distinct_permutations/2

Generates all distinct permutations of a list (deduplicating repeated values in the input list).

Compilation flags:
static
Template:
distinct_permutations(List,Permutations)
Mode and number of proofs:
distinct_permutations(+list,-list) - one

distinct_permutation/2

True iff the second argument is a distinct permutation of the first argument.

Compilation flags:
static
Template:
distinct_permutation(List,Permutation)
Mode and number of proofs:
distinct_permutation(+list,-list) - one_or_more

distinct_permutations/3

Generates all distinct permutations with the given order: default, lexicographic, or shortlex.

Compilation flags:
static
Template:
distinct_permutations(List,Order,Permutations)
Mode and number of proofs:
distinct_permutations(+list,+atom,-list) - one

distinct_permutation/3

True iff the third argument is a distinct permutation with the given order: default, lexicographic, or shortlex.

Compilation flags:
static
Template:
distinct_permutation(List,Order,Permutation)
Mode and number of proofs:
distinct_permutation(+list,+atom,-list) - one_or_more

k_permutations/3

Generates all K-permutations (ordered selections) of a list.

Compilation flags:
static
Template:
k_permutations(K,List,Permutations)
Mode and number of proofs:
k_permutations(+integer,+list,-list) - one

k_permutation/3

True iff the third argument is a K-permutation (ordered selection) of a list.

Compilation flags:
static
Template:
k_permutation(K,List,Permutation)
Mode and number of proofs:
k_permutation(+integer,+list,-list) - one_or_more

k_permutations/4

Generates all K-permutations with the given order: default, lexicographic, or shortlex.

Compilation flags:
static
Template:
k_permutations(K,List,Order,Permutations)
Mode and number of proofs:
k_permutations(+integer,+list,+atom,-list) - one

k_permutation/4

True iff the fourth argument is a K-permutation with the given order: default, lexicographic, or shortlex.

Compilation flags:
static
Template:
k_permutation(K,List,Order,Permutation)
Mode and number of proofs:
k_permutation(+integer,+list,+atom,-list) - one_or_more

cartesian_product/3

Generates all K-element tuples from a list with replacement where order matters.

Compilation flags:
static
Template:
cartesian_product(K,List,Tuples)
Mode and number of proofs:
cartesian_product(+integer,+list,-list) - one

derangements/2

Generates all derangements of a list.

Compilation flags:
static
Template:
derangements(List,Derangements)
Mode and number of proofs:
derangements(+list,-list) - one

derangement/2

True iff the second argument is a derangement of the first argument.

Compilation flags:
static
Template:
derangement(List,Derangement)
Mode and number of proofs:
derangement(+list,-list) - one_or_more

next_permutation/2

Returns the next permutation in lexicographic order.

Compilation flags:
static
Template:
next_permutation(Permutation,Next)
Mode and number of proofs:
next_permutation(+list,-list) - zero_or_one

previous_permutation/2

Returns the previous permutation in lexicographic order.

Compilation flags:
static
Template:
previous_permutation(Permutation,Previous)
Mode and number of proofs:
previous_permutation(+list,-list) - zero_or_one

nth_permutation/3

Returns the permutation at a given zero-based index.

Compilation flags:
static
Template:
nth_permutation(List,Index,Permutation)
Mode and number of proofs:
nth_permutation(+list,+integer,-list) - zero_or_one

permutation_index/3

Returns the zero-based index of a permutation.

Compilation flags:
static
Template:
permutation_index(List,Permutation,Index)
Mode and number of proofs:
permutation_index(+list,+list,-integer) - zero_or_one

count_permutations/2

Counts the number of permutations of a list.

Compilation flags:
static
Template:
count_permutations(List,Count)
Mode and number of proofs:
count_permutations(+list,-integer) - one

random_permutation/2

Returns a random permutation of a list.

Compilation flags:
static
Template:
random_permutation(List,Permutation)
Mode and number of proofs:
random_permutation(+list,-list) - one

Protected predicates

(none)

Private predicates

(none)

Operators

(none)