[Top] [Up] [Previous] [Next] [Index]

# 17 Combinatorics

### Sections

1. Combinatorial Numbers
2. Combinations, Arrangements and Tuples
3. Fibonacci and Lucas Sequences
4. Permanent of a Matrix

This chapter describes the functions that deal with combinatorics. We mainly concentrate on two areas. One is about selections, that is the ways one can select elements from a set. The other is about partitions, that is the ways one can partition a set into the union of pairwise disjoint subsets.

## 17.1 Combinatorial Numbers

- `Factorial(` n`) F`

  returns the factorial n! of the positive integer n, which is defined as the product 1 ·2 ·3 …n.

  n! is the number of permutations of a set of n elements. 1/n! is the coefficient of xn in the formal series ex, which is the generating function for factorial.

      gap> List( [0..10], Factorial );
      [ 1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800 ]
      gap> Factorial( 30 );
      265252859812191058636308480000000

  `PermutationsList` (see PermutationsList) computes the set of all permutations of a list.

- `Binomial(` n`,` k`) F`

  returns the binomial coefficient

  |   | n k |   |

  of integers n and k, which is defined as n! / (k! (n−k)!) (see Factorial). We define

  |   | 0 0 |   | = 1, |   | n k |   | = 0

  if k < 0 or n < k, and

  |   | n k |   | = (−1)k |   | −n+k−1 k |   |

  if n < 0, which is consistent with the equivalent definition

  |   | n k |   | = |   | n−1 k |   | + |   | n−1 k−1 |   | ·

  |   | n k |   |

  is the number of combinations with k elements, i.e., the number of subsets with k elements, of a set with n elements.

  |   | n k |   |

  is the coefficient of the term xk of the polynomial (x + 1)n, which is the generating function for

  |   | n · |   | ,

  hence the name.

      gap> List( [0..4], k->Binomial( 4, k ) );  # Knuth calls this the trademark of Binomial
      [ 1, 4, 6, 4, 1 ]
      gap> List( [0..6], n->List( [0..6], k->Binomial( n, k ) ) );;
      gap> PrintArray( last );  # the lower triangle is called Pascal's triangle
      [ [   1,   0,   0,   0,   0,   0,   0 ],
        [   1,   1,   0,   0,   0,   0,   0 ],
        [   1,   2,   1,   0,   0,   0,   0 ],
        [   1,   3,   3,   1,   0,   0,   0 ],
        [   1,   4,   6,   4,   1,   0,   0 ],
        [   1,   5,  10,  10,   5,   1,   0 ],
        [   1,   6,  15,  20,  15,   6,   1 ] ]
      gap> Binomial( 50, 10 );
      10272278170

  `NrCombinations` (see Combinations) is the generalization of `Binomial` for multisets. `Combinations` (see Combinations) computes the set of all combinations of a multiset.

- `Bell(` n`) F`

  returns the Bell number B(n). The Bell numbers are defined by B(0)=1 and the recurrence

  B(n+1) = | n ∑ k=0 |  |   | n k |   | B(k)

  .

  B(n) is the number of ways to partition a set of n elements into pairwise disjoint nonempty subsets (see PartitionsSet). This implies of course that B(n) = ∑k=0nS2(n,k) (see Stirling2). B(n)/n! is the coefficient of xn in the formal series eex−1, which is the generating function for B(n).

      gap> List( [0..6], n -> Bell( n ) );
      [ 1, 1, 2, 5, 15, 52, 203 ]
      gap> Bell( 14 );
      190899322

- `Bernoulli(` n`) F`

  returns the n-th Bernoulli number Bn, which is defined by B0 = 1 and

  Bn = − | n−1 ∑ k=0 |  |   | n+1 k |   | Bk/(n+1)

  .

  Bn/n! is the coefficient of xn in the power series of x/ex−1. Except for B1=−1/2 the Bernoulli numbers for odd indices are zero.

      gap> Bernoulli( 4 );
      -1/30
      gap> Bernoulli( 10 );
      5/66
      gap> Bernoulli( 12 );  # there is no simple pattern in Bernoulli numbers
      -691/2730
      gap> Bernoulli( 50 );  # and they grow fairly fast
      495057205241079648212477525/66

- `Stirling1(` n`,` k`) F`

  returns the Stirling number of the first kind S1(n,k) of the integers n and k. Stirling numbers of the first kind are defined by S1(0,0) = 1, S1(n,0) = S1(0,k) = 0 if n, k ≠ 0 and the recurrence S1(n,k) = (n−1) S1(n−1,k) + S1(n−1,k−1).

  S1(n,k) is the number of permutations of n points with k cycles. Stirling numbers of the first kind appear as coefficients in the series

  n! |   | x n |   | = | n ∑ k=0 | S1(n,k) xk

  which is the generating function for Stirling numbers of the first kind. Note the similarity to

  xn = | n ∑ k=0 | S2(n,k) k! |   | x k |   |

  (see Stirling2). Also the definition of S1 implies S1(n,k) = S2(−k,−n) if n,k < 0. There are many formulae relating Stirling numbers of the first kind to Stirling numbers of the second kind, Bell numbers, and Binomial coefficients.

      gap> List( [0..4], k -> Stirling1( 4, k ) );  # Knuth calls this the trademark of S_1
      [ 0, 6, 11, 6, 1 ]
      gap> List( [0..6], n->List( [0..6], k->Stirling1( n, k ) ) );;
      gap> # note the similarity with Pascal's triangle for the Binomial numbers
      gap> PrintArray( last );
      [ [    1,    0,    0,    0,    0,    0,    0 ],
        [    0,    1,    0,    0,    0,    0,    0 ],
        [    0,    1,    1,    0,    0,    0,    0 ],
        [    0,    2,    3,    1,    0,    0,    0 ],
        [    0,    6,   11,    6,    1,    0,    0 ],
        [    0,   24,   50,   35,   10,    1,    0 ],
        [    0,  120,  274,  225,   85,   15,    1 ] ]
      gap> Stirling1(50,10);
      101623020926367490059043797119309944043405505380503665627365376

- `Stirling2(` n`,` k`) F`

  returns the Stirling number of the second kind S2(n,k) of the integers n and k. Stirling numbers of the second kind are defined by S2(0,0) = 1, S2(n,0) = S2(0,k) = 0 if n, k ≠ 0 and the recurrence S2(n,k) = k S2(n−1,k) + S2(n−1,k−1).

  S2(n,k) is the number of ways to partition a set of n elements into k pairwise disjoint nonempty subsets (see PartitionsSet). Stirling numbers of the second kind appear as coefficients in the expansion of

  xn = | n ∑ k=0 | S2(n,k) k! |   | x k |   |

  . Note the similarity to

  n! |   | x n |   | = | n ∑ k=0 | S1(n,k) xk

  (see Stirling1). Also the definition of S2 implies S2(n,k) = S1(−k,−n) if n,k < 0. There are many formulae relating Stirling numbers of the second kind to Stirling numbers of the first kind, Bell numbers, and Binomial coefficients.

      gap> List( [0..4], k->Stirling2( 4, k ) );  # Knuth calls this the trademark of S_2
      [ 0, 1, 7, 6, 1 ]
      gap> List( [0..6], n->List( [0..6], k->Stirling2( n, k ) ) );;
      gap> # note the similarity with Pascal's triangle for the Binomial numbers
      gap> PrintArray( last );
      [ [   1,   0,   0,   0,   0,   0,   0 ],
        [   0,   1,   0,   0,   0,   0,   0 ],
        [   0,   1,   1,   0,   0,   0,   0 ],
        [   0,   1,   3,   1,   0,   0,   0 ],
        [   0,   1,   7,   6,   1,   0,   0 ],
        [   0,   1,  15,  25,  10,   1,   0 ],
        [   0,   1,  31,  90,  65,  15,   1 ] ]
      gap> Stirling2( 50, 10 );
      26154716515862881292012777396577993781727011

  ## 17.2 Combinations, Arrangements and Tuples

- `Combinations(` mset`[,` k`] ) F`

  returns the set of all combinations of the multiset mset (a list of objects which may contain the same object several times) with k elements; if k is not given it returns all combinations of mset.

  A combination of mset is an unordered selection without repetitions and is represented by a sorted sublist of mset. If mset is a proper set, there are

  |   | |mset| k |   |

  (see Binomial) combinations with k elements, and the set of all combinations is just the powerset of mset, which contains all subsets of mset and has cardinality 2|mset|.

- `NrCombinations(` mset`[,` k`] ) F`

  returns the number of `Combinations(`mset`,`k`)`.

      gap> Combinations( [1,2,2,3] );
      [ [  ], [ 1 ], [ 1, 2 ], [ 1, 2, 2 ], [ 1, 2, 2, 3 ], [ 1, 2, 3 ], [ 1, 3 ],
        [ 2 ], [ 2, 2 ], [ 2, 2, 3 ], [ 2, 3 ], [ 3 ] ]
      gap> NrCombinations( [1..52], 5 );  # number of different hands in a game of poker
      2598960

  The function `Arrangements` (see Arrangements) computes ordered selections without repetitions, `UnorderedTuples` (see UnorderedTuples) computes unordered selections with repetitions and `Tuples` (see Tuples) computes ordered selections with repetitions.

- `Arrangements(` mset`[,` k`] ) F`

  returns the set of arrangements of the multiset mset that contain k elements. If k is not given it returns all arrangements of mset.

  An arrangement of mset is an ordered selection without repetitions and is represented by a list that contains only elements from mset, but maybe in a different order. If mset is a proper set there are |mset|! / (|mset|−k)! (see Factorial) arrangements with k elements.

- `NrArrangements(` mset`[,` k`] ) F`

  returns the number of `Arrangements(`mset`,`k`)`.

  As an example of arrangements of a multiset, think of the game Scrabble. Suppose you have the six characters of the word `settle` and you have to make a four letter word. Then the possibilities are given by

      gap> Arrangements( ["s","e","t","t","l","e"], 4 );
      [ [ "e", "e", "l", "s" ], [ "e", "e", "l", "t" ], [ "e", "e", "s", "l" ],
        [ "e", "e", "s", "t" ], [ "e", "e", "t", "l" ], [ "e", "e", "t", "s" ],
        ... 93 more possibilities ...
        [ "t", "t", "l", "s" ], [ "t", "t", "s", "e" ], [ "t", "t", "s", "l" ] ]

  Can you find the five proper English words, where `lets` does not count? Note that the fact that the list returned by `Arrangements` is a proper set means in this example that the possibilities are listed in the same order as they appear in the dictionary.

      gap> NrArrangements( ["s","e","t","t","l","e"] );
      523

  The function `Combinations` (see Combinations) computes unordered selections without repetitions, `UnorderedTuples` (see UnorderedTuples) computes unordered selections with repetitions and `Tuples` (see Tuples) computes ordered selections with repetitions.

- `UnorderedTuples(` set`,` k`) F`

  returns the set of all unordered tuples of length k of the set set.

  An unordered tuple of length k of set is a unordered selection with repetitions of set and is represented by a sorted list of length k containing elements from set. There are

  |   | |set|+k−1 k |   |

  (see Binomial) such unordered tuples.

  Note that the fact that `UnorderedTuples` returns a set implies that the last index runs fastest. That means the first tuple contains the smallest element from set k times, the second tuple contains the smallest element of set at all positions except at the last positions, where it contains the second smallest element from set and so on.

- `NrUnorderedTuples(` set`,` k`) F`

  returns the number of `UnorderedTuples(`set`,`k`)`.

  As an example for unordered tuples think of a poker-like game played with 5 dice. Then each possible hand corresponds to an unordered five-tuple from the set [1..6]

      gap> NrUnorderedTuples( [1..6], 5 );
      252
      gap> UnorderedTuples( [1..6], 5 );
      [ [ 1, 1, 1, 1, 1 ], [ 1, 1, 1, 1, 2 ], [ 1, 1, 1, 1, 3 ], [ 1, 1, 1, 1, 4 ],
        [ 1, 1, 1, 1, 5 ], [ 1, 1, 1, 1, 6 ], [ 1, 1, 1, 2, 2 ], [ 1, 1, 1, 2, 3 ],
        ... 100 more tuples ...
        [ 1, 3, 5, 5, 6 ], [ 1, 3, 5, 6, 6 ], [ 1, 3, 6, 6, 6 ], [ 1, 4, 4, 4, 4 ],
        ... 100 more tuples ...
        [ 3, 3, 5, 5, 5 ], [ 3, 3, 5, 5, 6 ], [ 3, 3, 5, 6, 6 ], [ 3, 3, 6, 6, 6 ],
        ... 32 more tuples ...
        [ 5, 5, 5, 6, 6 ], [ 5, 5, 6, 6, 6 ], [ 5, 6, 6, 6, 6 ], [ 6, 6, 6, 6, 6 ] ]

  The function `Combinations` (see Combinations) computes unordered selections without repetitions, `Arrangements` (see Arrangements) computes ordered selections without repetitions and `Tuples` (see Tuples) computes ordered selections with repetitions.

- `Tuples(` set`,` k`) F`

  returns the set of all ordered tuples of length k of the set set.

  An ordered tuple of length k of set is an ordered selection with repetition and is represented by a list of length k containing elements of set. There are |set|k such ordered tuples.

  Note that the fact that `Tuples` returns a set implies that the last index runs fastest. That means the first tuple contains the smallest element from set k times, the second tuple contains the smallest element of set at all positions except at the last positions, where it contains the second smallest element from set and so on.

- `NrTuples(` set`,` k`) F`

  returns the number of `Tuples(`set`,`k`)`.

      gap> Tuples( [1,2,3], 2 );
      [ [ 1, 1 ], [ 1, 2 ], [ 1, 3 ], [ 2, 1 ], [ 2, 2 ], [ 2, 3 ], [ 3, 1 ],
        [ 3, 2 ], [ 3, 3 ] ]
      gap> NrTuples( [1..10], 5 );
      100000

  `Tuples(`set`,`k`)` can also be viewed as the k-fold cartesian product of set (see Cartesian).

  The function `Combinations` (see Combinations) computes unordered selections without repetitions, `Arrangements` (see Arrangements) computes ordered selections without repetitions, and finally the function `UnorderedTuples` (see UnorderedTuples) computes unordered selections with repetitions.

- `PermutationsList(` mset`) F`

  `PermutationsList` returns the set of permutations of the multiset mset.

  A permutation is represented by a list that contains exactly the same elements as mset, but possibly in different order. If mset is a proper set there are |mset| ! (see Factorial) such permutations. Otherwise if the first elements appears k1 times, the second element appears k2 times and so on, the number of permutations is |mset|! / (k1! k2! …), which is sometimes called multinomial coefficient.

- `NrPermutationsList(` mset`) F`

  returns the number of `PermutationsList(`mset`)`.

      gap> PermutationsList( [1,2,3] );
      [ [ 1, 2, 3 ], [ 1, 3, 2 ], [ 2, 1, 3 ], [ 2, 3, 1 ], [ 3, 1, 2 ],
        [ 3, 2, 1 ] ]
      gap> PermutationsList( [1,1,2,2] );
      [ [ 1, 1, 2, 2 ], [ 1, 2, 1, 2 ], [ 1, 2, 2, 1 ], [ 2, 1, 1, 2 ],
        [ 2, 1, 2, 1 ], [ 2, 2, 1, 1 ] ]
      gap> NrPermutationsList( [1,2,2,3,3,3,4,4,4,4] );
      12600

  The function `Arrangements` (see Arrangements) is the generalization of `PermutationsList` that allows you to specify the size of the permutations. `Derangements` (see Derangements) computes permutations that have no fixpoints.

- `Derangements(` list`) F`

  returns the set of all derangements of the list list.

  A derangement is a fixpointfree permutation of list and is represented by a list that contains exactly the same elements as list, but in such an order that the derangement has at no position the same element as list. If the list list contains no element twice there are exactly |list|! (1/2! − 1/3! + 1/4! − …+ (−1)n/n!) derangements.

  Note that the ratio `NrPermutationsList([1..n])/NrDerangements([1..n])`, which is n! / (n! (1/2! − 1/3! + 1/4! − …+ (−1)n/n!)) is an approximation for the base of the natural logarithm e = 2.7182818285…, which is correct to about n digits.

- `NrDerangements(` list`) F`

  returns the number of `Derangements(`list`)`.

  As an example of derangements suppose that you have to send four different letters to four different people. Then a derangement corresponds to a way to send those letters such that no letter reaches the intended person.

      gap> Derangements( [1,2,3,4] );
      [ [ 2, 1, 4, 3 ], [ 2, 3, 4, 1 ], [ 2, 4, 1, 3 ], [ 3, 1, 4, 2 ],
        [ 3, 4, 1, 2 ], [ 3, 4, 2, 1 ], [ 4, 1, 2, 3 ], [ 4, 3, 1, 2 ],
        [ 4, 3, 2, 1 ] ]
      gap> NrDerangements( [1..10] );
      1334961
      gap> Int( 10^7*NrPermutationsList([1..10])/last );
      27182816
      gap> Derangements( [1,1,2,2,3,3] );
      [ [ 2, 2, 3, 3, 1, 1 ], [ 2, 3, 1, 3, 1, 2 ], [ 2, 3, 1, 3, 2, 1 ],
        [ 2, 3, 3, 1, 1, 2 ], [ 2, 3, 3, 1, 2, 1 ], [ 3, 2, 1, 3, 1, 2 ],
        [ 3, 2, 1, 3, 2, 1 ], [ 3, 2, 3, 1, 1, 2 ], [ 3, 2, 3, 1, 2, 1 ],
        [ 3, 3, 1, 1, 2, 2 ] ]
      gap> NrDerangements( [1,2,2,3,3,3,4,4,4,4] );
      338

  The function `PermutationsList` (see PermutationsList) computes all permutations of a list.

- `PartitionsSet(` set`[,` k`] ) F`

  returns the set of all unordered partitions of the set set into k pairwise disjoint nonempty sets. If k is not given it returns all unordered partitions of set for all k.

  An unordered partition of set is a set of pairwise disjoint nonempty sets with union set and is represented by a sorted list of such sets. There are B( |set| ) (see Bell) partitions of the set set and S2( |set|, k ) (see Stirling2) partitions with k elements.

- `NrPartitionsSet(` set`[,` k`] ) F`

  returns the number of `PartitionsSet(`set`,`k`)`.

      gap> PartitionsSet( [1,2,3] );
      [ [ [ 1 ], [ 2 ], [ 3 ] ], [ [ 1 ], [ 2, 3 ] ], [ [ 1, 2 ], [ 3 ] ],
        [ [ 1, 2, 3 ] ], [ [ 1, 3 ], [ 2 ] ] ]
      gap> PartitionsSet( [1,2,3,4], 2 );
      [ [ [ 1 ], [ 2, 3, 4 ] ], [ [ 1, 2 ], [ 3, 4 ] ], [ [ 1, 2, 3 ], [ 4 ] ],
        [ [ 1, 2, 4 ], [ 3 ] ], [ [ 1, 3 ], [ 2, 4 ] ], [ [ 1, 3, 4 ], [ 2 ] ],
        [ [ 1, 4 ], [ 2, 3 ] ] ]
      gap> NrPartitionsSet( [1..6] );
      203
      gap> NrPartitionsSet( [1..10], 3 );
      9330

  Note that `PartitionsSet` does currently not support multisets and that there is currently no ordered counterpart.

- `Partitions(` n`[,` k`] ) F`

  returns the set of all (unordered) partitions of the positive integer n into sums with k summands. If k is not given it returns all unordered partitions of set for all k.

  An unordered partition is an unordered sum n = p1+p2 +…+ pk of positive integers and is represented by the list p = [p1,p2,…,pk], in nonincreasing order, i.e., p1 > =p2 > = … > =pk. We write p |- n. There are approximately eπ√{2/3 n} / 4 √3 n such partitions.

  It is possible to associate with every partition of the integer n a conjugacy class of permutations in the symmetric group on n points and vice versa. Therefore p(n) : = `NrPartitions`(n) is the number of conjugacy classes of the symmetric group on n points.

  Ramanujan found the identities p(5i+4) = 0 mod 5, p(7i+5) = 0 mod 7 and p(11i+6) = 0 mod 11 and many other fascinating things about the number of partitions.

  Do not call `Partitions` with an n much larger than 40, in which case there are 37338 partitions, since the list will simply become too large.

- `NrPartitions(` n`[,` k`] ) F`

  returns the number of `Partitions(`set`,`k`)`.

      gap> Partitions( 7 );
      [ [ 1, 1, 1, 1, 1, 1, 1 ], [ 2, 1, 1, 1, 1, 1 ], [ 2, 2, 1, 1, 1 ],
        [ 2, 2, 2, 1 ], [ 3, 1, 1, 1, 1 ], [ 3, 2, 1, 1 ], [ 3, 2, 2 ],
        [ 3, 3, 1 ], [ 4, 1, 1, 1 ], [ 4, 2, 1 ], [ 4, 3 ], [ 5, 1, 1 ], [ 5, 2 ],
        [ 6, 1 ], [ 7 ] ]
      gap> Partitions( 8, 3 );
      [ [ 3, 3, 2 ], [ 4, 2, 2 ], [ 4, 3, 1 ], [ 5, 2, 1 ], [ 6, 1, 1 ] ]
      gap> NrPartitions( 7 );
      15
      gap> NrPartitions( 100 );
      190569292

  The function `OrderedPartitions` (see OrderedPartitions) is the ordered counterpart of `Partitions`.

- `OrderedPartitions(` n`[,` k`] ) F`

  returns the set of all ordered partitions of the positive integer n into sums with k summands. If k is not given it returns all ordered partitions of set for all k.

  An ordered partition is an ordered sum n = p1 + p2 +…+ pk of positive integers and is represented by the list [ p1, p2,…, pk ]. There are totally 2n−1 ordered partitions and

  |   | n−1 k−1 |   |

  (see Binomial) ordered partitions with k summands.

  Do not call `OrderedPartitions` with an n much larger than 15, the list will simply become too large.

- `NrOrderedPartitions(` n`[,` k`] ) F`

  returns the number of `OrderedPartitions(`set`,`k`)`.

      gap> OrderedPartitions( 5 );
      [ [ 1, 1, 1, 1, 1 ], [ 1, 1, 1, 2 ], [ 1, 1, 2, 1 ], [ 1, 1, 3 ],
        [ 1, 2, 1, 1 ], [ 1, 2, 2 ], [ 1, 3, 1 ], [ 1, 4 ], [ 2, 1, 1, 1 ],
        [ 2, 1, 2 ], [ 2, 2, 1 ], [ 2, 3 ], [ 3, 1, 1 ], [ 3, 2 ], [ 4, 1 ], [ 5 ] ]
      gap> OrderedPartitions( 6, 3 );
      [ [ 1, 1, 4 ], [ 1, 2, 3 ], [ 1, 3, 2 ], [ 1, 4, 1 ], [ 2, 1, 3 ],
        [ 2, 2, 2 ], [ 2, 3, 1 ], [ 3, 1, 2 ], [ 3, 2, 1 ], [ 4, 1, 1 ] ]
      gap> NrOrderedPartitions(20);
      524288

  The function `Partitions` (see Partitions) is the unordered counterpart of `OrderedPartitions`.

- `PartitionsGreatestLE(` n`,` m`) F`

  returns the set of all (unordered) partitions of the integer n having parts less or equal to the integer m.

- `PartitionsGreatestEQ(` n`,` m`) F`

  returns the set of all (unordered) partitions of the integer n having greatest part equal to the integer m.

- `RestrictedPartitions(` n`,` set`[,` k`] ) F`

  In the first form `RestrictedPartitions` returns the set of all restricted partitions of the positive integer n into sums with k summands with the summands of the partition coming from the set set. If k is not given all restricted partitions for all k are returned.

  A restricted partition is like an ordinary partition (see Partitions) an unordered sum n = p1+p2+…+pk of positive integers and is represented by the list p = [p1,p2,…,pk], in nonincreasing order. The difference is that here the pi must be elements from the set set, while for ordinary partitions they may be elements from `[1..n]`.

- `NrRestrictedPartitions(` n`,` set`[,` k`] ) F`

  returns the number of `RestrictedPartitions(`n`,`set`,`k`)`.

      gap> RestrictedPartitions( 8, [1,3,5,7] );
      [ [ 1, 1, 1, 1, 1, 1, 1, 1 ], [ 3, 1, 1, 1, 1, 1 ], [ 3, 3, 1, 1 ],
        [ 5, 1, 1, 1 ], [ 5, 3 ], [ 7, 1 ] ]
      gap> NrRestrictedPartitions(50,[1,2,5,10,20,50]);
      451

  The last example tells us that there are 451 ways to return 50 pence change using 1,2,5,10,20 and 50 pence coins.

- `SignPartition(` pi`) F`

  returns the sign of a permutation with cycle structure pi.

  This function actually describes a homomorphism from the symmetric group Sn into the cyclic group of order 2, whose kernel is exactly the alternating group An (see SignPerm). Partitions of sign 1 are called even partitions while partitions of sign −1 are called odd.

      gap> SignPartition([6,5,4,3,2,1]);
      -1

- `AssociatedPartition(` pi`) F`

  `AssociatedPartition` returns the associated partition of the partition pi which is obtained by transposing the corresponding Young diagram.

      gap> AssociatedPartition([4,2,1]);
      [ 3, 2, 1, 1 ]
      gap> AssociatedPartition([6]);
      [ 1, 1, 1, 1, 1, 1 ]

- `PowerPartition(` pi`,` k`) F`

  `PowerPartition` returns the partition corresponding to the k-th power of a permutation with cycle structure pi.

  Each part l of pi is replaced by d = gcd(l, k) parts l/d. So if pi is a partition of n then pi k also is a partition of n. `PowerPartition` describes the powermap of symmetric groups.

      gap> PowerPartition([6,5,4,3,2,1], 3);
      [ 5, 4, 2, 2, 2, 2, 1, 1, 1, 1 ]

- `PartitionTuples(` n`,` r`) F`

  `PartitionTuples` returns the list of all r-tuples of partitions which together form a partition of n.

  r--tuples of partitions describe the classes and the characters of wreath products of groups with r conjugacy classes with the symmetric group Sn.

- `NrPartitionTuples(` n`,` r`) F`

  returns the number of `PartitionTuples(` n`,` r`)`.

      gap> PartitionTuples(3, 2);
      [ [ [ 1, 1, 1 ], [  ] ], [ [ 1, 1 ], [ 1 ] ], [ [ 1 ], [ 1, 1 ] ],
        [ [  ], [ 1, 1, 1 ] ], [ [ 2, 1 ], [  ] ], [ [ 1 ], [ 2 ] ],
        [ [ 2 ], [ 1 ] ], [ [  ], [ 2, 1 ] ], [ [ 3 ], [  ] ], [ [  ], [ 3 ] ] ]

  ## 17.3 Fibonacci and Lucas Sequences

- `Fibonacci(` n`) F`

  returns the nth number of the Fibonacci sequence. The Fibonacci sequence Fn is defined by the initial conditions F1=F2=1 and the recurrence relation Fn+2 = Fn+1 + Fn. For negative n we define Fn = (−1)n+1 F−n, which is consistent with the recurrence relation.

  Using generating functions one can prove that Fn = φn − 1/φn, where φ is (√5 + 1)/2, i.e., one root of x2 − x − 1 = 0. Fibonacci numbers have the property Gcd( Fm, Fn ) = FGcd(m,n). But a pair of Fibonacci numbers requires more division steps in Euclid's algorithm (see Gcd) than any other pair of integers of the same size. `Fibonacci(`k`)` is the special case `Lucas(1,-1,`k`)[1]` (see Lucas).

      gap> Fibonacci( 10 );
      55
      gap> Fibonacci( 35 );
      9227465
      gap> Fibonacci( -10 );
      -55

- `Lucas(` P`,` Q`,` k`) F`

  returns the k-th values of the Lucas sequence with parameters P and Q, which must be integers, as a list of three integers.

  Let α, β be the two roots of x2 − P x + Q then we define Lucas( P, Q, k )[1] = Uk = (αk − βk) / (α− β) and Lucas( P, Q, k )[2] = Vk = (αk + βk) and as a convenience Lucas( P, Q, k )[3] = Qk.

  The following recurrence relations are easily derived from the definition U0 = 0, U1 = 1, Uk = P Uk−1 − Q Uk−2 and V0 = 2, V1 = P, Vk = P Vk−1 − Q Vk−2. Those relations are actually used to define `Lucas` if α = β.

  Also the more complex relations used in `Lucas` can be easily derived U2k = Uk Vk, U2k+1 = (P U2k + V2k) / 2 and V2k = Vk2 − 2 Qk, V2k+1 = ((P2−4Q) U2k + P V2k) / 2.

  `Fibonacci(`k`)` (see Fibonacci) is simply `Lucas(1,-1,`k`)[1]`. In an abuse of notation, the sequence `Lucas(1,-1,`k`)[2]` is sometimes called the Lucas sequence.

      gap> List( [0..10], i -> Lucas(1,-2,i)[1] );     # 2^k - (-1)^k)/3
      [ 0, 1, 1, 3, 5, 11, 21, 43, 85, 171, 341 ]
      gap> List( [0..10], i -> Lucas(1,-2,i)[2] );     # 2^k + (-1)^k
      [ 2, 1, 5, 7, 17, 31, 65, 127, 257, 511, 1025 ]
      gap> List( [0..10], i -> Lucas(1,-1,i)[1] );     # Fibonacci sequence
      [ 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55 ]
      gap> List( [0..10], i -> Lucas(2,1,i)[1] );      # the roots are equal
      [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]

  ## 17.4 Permanent of a Matrix

- `Permanent(` mat`) F`

  returns the permanent of the matrix mat. The permanent is defined by ∑p ∈ Symm(n)∏i=1nmat[i][ip].

  Note the similarity of the definition of the permanent to the definition of the determinant (see DeterminantMat). In fact the only difference is the missing sign of the permutation. However the permanent is quite unlike the determinant, for example it is not multilinear or alternating. It has however important combinatorial properties.

      gap> Permanent( [[0,1,1,1],
      >      [1,0,1,1],
      >      [1,1,0,1],
      >      [1,1,1,0]] );  # inefficient way to compute `NrDerangements([1..4])'
      9
      gap> Permanent( [[1,1,0,1,0,0,0],
      >      [0,1,1,0,1,0,0],
      >      [0,0,1,1,0,1,0],
      >      [0,0,0,1,1,0,1],
      >      [1,0,0,0,1,1,0],
      >      [0,1,0,0,0,1,1],
      >      [1,0,1,0,0,0,1]] );  # 24 permutations fit the projective plane of order 2
      24

  [Top] [Up] [Previous] [Next] [Index]

  GAP 4 manual
  May 2005