doc/info/combinatorics.texi

   1 @menu
   2 * Introduction to combinatorics::
   3 * Functions and Variables for Combinatorics::
   4 @end menu
   5
   6 @node Introduction to combinatorics, Functions and Variables for Combinatorics, Package combinatorics, Package combinatorics
   7 @section Package combinatorics
   8
   9 The @code{combinatorics} package provides several functions to work with
  10 permutations and to permute elements of a list. The permutations of
  11 degree @emph{n} are all the @emph{n}! possible orderings of the first
  12 @emph{n} positive integers, 1, 2, @dots{}, @emph{n}. The functions in this
  13 packages expect a permutation to be represented by a list of those
  14 integers.
  15
  16 Cycles are represented as a list of two or more integers @emph{i_1},
  17 @emph{i_2}, @dots{}, @emph{i_m}, all different. Such a list represents a permutation
  18 where the integer @emph{i_2} appears in the @emph{i_1}th position, the
  19 integer @emph{i_3} appears in the @emph{i_2}th position and so on, until
  20 the integer @emph{i_1}, which appears in the @emph{i_m}th position.
  21
  22 For instance, [4, 2, 1, 3] is one of the 24 permutations of degree four,
  23 which can also be represented by the cycle [1, 4, 3]. The functions
  24 where cycles are used to represent permutations also require the
  25 order of the permutation to avoid ambiguity. For instance, the same
  26 cycle [1, 4, 3] could refer to the permutation of order 6: [4, 2, 1, 3, 5,
  27 6]. A product of cycles must be represented by a list of cycles; the
  28 cycles at the end of the list are applied first. For example, [[2,
  29 4], [1, 3, 6, 5]] is equivalent to the permutation [3, 4, 6, 2, 1, 5].
  30
  31 A cycle can be written in several ways. for instance, [1, 3, 6, 5], [3,
  32 6, 5, 1] and [6, 5, 1, 3] are all equivalent. The canonical form used in
  33 the package is the one that places the lowest index in the first
  34 place. A cycle with only two indices is also called a transposition and
  35 if the two indices are consecutive, it is called an adjacent
  36 transposition.
  37
  38 To run an interactive tutorial, use the command @code{demo
  39 (combinatorics)}. Since this is an additional package, it must be loaded
  40 with the command @code{load("combinatorics")}.
  41
  42
  43 @opencatbox{Categories:}
  44 @category{Share packages}
  45 @category{Package combinatorics}
  46 @closecatbox
  47
  48 @node Functions and Variables for Combinatorics,  , Introduction to combinatorics, Package combinatorics
  49 @section Functions and Variables for Combinatorics
  50
  51 @anchor{apply_cycles}
  52 @deffn {Function} apply_cycles (@var{cl},@var{l})
  53
  54 Permutes the list or set @var{l} applying to it the list of cycles
  55 @var{cl}. The cycles at the end of the list are applied first and the
  56 first cycle in the list @var{cl} is the last one to be applied.
  57
  58 See also @mrefdot{permute}
  59
  60 Example:
  61
  62 @c ===beg===
  63 @c load("combinatorics")$
  64 @c lis1:[a,b*c^2,4,z,x/y,1/2,ff23(x),0];
  65 @c apply_cycles ([[1, 6], [2, 6, 5, 7]], lis1);
  66 @c ===end===
  67 @example
  68 (%i1) load("combinatorics")$
  69 @group
  70 (%i2) lis1:[a,b*c^2,4,z,x/y,1/2,ff23(x),0];
  71                         2        x  1
  72 (%o2)            [a, b c , 4, z, -, -, ff23(x), 0]
  73                                  y  2
  74 @end group
  75 @group
  76 (%i3) apply_cycles ([[1, 6], [2, 6, 5, 7]], lis1);
  77                   x  1                       2
  78 (%o3)            [-, -, 4, z, ff23(x), a, b c , 0]
  79                   y  2
  80 @end group
  81 @end example
  82
  83 @opencatbox{Categories:}
  84 @category{Package combinatorics}
  85 @closecatbox
  86
  87 @end deffn
  88
  89 @anchor{cyclep}
  90 @deffn {Function} cyclep (@var{c}, @var{n})
  91
  92 Returns true if @var{c} is a valid cycle of order @var{n} namely, a list
  93 of non-repeated positive integers less or equal to @var{n}. Otherwise,
  94 it returns false.
  95
  96 See also @mrefdot{permp}
  97
  98 Examples:
  99
 100 @c ===beg===
 101 @c load("combinatorics")$
 102 @c cyclep ([-2,3,4], 5);
 103 @c cyclep ([2,3,4,2], 5);
 104 @c cyclep ([6,3,4], 5);
 105 @c cyclep ([6,3,4], 6);
 106 @c ===end===
 107 @example
 108 (%i1) load("combinatorics")$
 109 @group
 110 (%i2) cyclep ([-2,3,4], 5);
 111 (%o2)                          false
 112 @end group
 113 @group
 114 (%i3) cyclep ([2,3,4,2], 5);
 115 (%o3)                          false
 116 @end group
 117 @group
 118 (%i4) cyclep ([6,3,4], 5);
 119 (%o4)                          false
 120 @end group
 121 @group
 122 (%i5) cyclep ([6,3,4], 6);
 123 (%o5)                          true
 124 @end group
 125 @end example
 126
 127 @opencatbox{Categories:}
 128 @category{Package combinatorics}
 129 @closecatbox
 130
 131 @end deffn
 132
 133 @anchor{perm_cycles}
 134 @deffn {Function} perm_cycles (@var{p})
 135
 136 Returns permutation @var{p} as a product of cycles. The cycles are
 137 written in a canonical form, in which the lowest index in the cycle is
 138 placed in the first position.
 139
 140 See also @mrefdot{perm_decomp}
 141
 142 Example:
 143
 144 @c ===beg===
 145 @c load("combinatorics")$
 146 @c perm_cycles ([4, 6, 3, 1, 7, 5, 2, 8]);
 147 @c ===end===
 148 @example
 149 (%i1) load("combinatorics")$
 150 @group
 151 (%i2) perm_cycles ([4, 6, 3, 1, 7, 5, 2, 8]);
 152 (%o2)                 [[1, 4], [2, 6, 5, 7]]
 153 @end group
 154 @end example
 155
 156 @opencatbox{Categories:}
 157 @category{Package combinatorics}
 158 @closecatbox
 159
 160 @end deffn
 161
 162 @anchor{perm_decomp}
 163 @deffn {Function} perm_decomp (@var{p})
 164
 165 Returns the minimum set of adjacent transpositions whose product equals
 166 the given permutation @var{p}.
 167
 168 See also @mrefdot{perm_cycles}
 169
 170 Example:
 171
 172 @c ===beg===
 173 @c load("combinatorics")$
 174 @c perm_decomp ([4, 6, 3, 1, 7, 5, 2, 8]);
 175 @c ===end===
 176 @example
 177 (%i1) load("combinatorics")$
 178 @group
 179 (%i2) perm_decomp ([4, 6, 3, 1, 7, 5, 2, 8]);
 180 (%o2) [[6, 7], [5, 6], [6, 7], [3, 4], [4, 5], [2, 3], [3, 4],
 181                             [4, 5], [5, 6], [1, 2], [2, 3], [3, 4]]
 182 @end group
 183 @end example
 184
 185 @opencatbox{Categories:}
 186 @category{Package combinatorics}
 187 @closecatbox
 188
 189 @end deffn
 190
 191 @anchor{perm_inverse}
 192 @deffn {Function} perm_inverse (@var{p})
 193
 194 Returns the inverse of a permutation of @var{p}, namely, a permutation
 195 @var{q} such that the products @var{pq} and @var{qp} are equal to the
 196 identity permutation: [1, 2, 3, @dots{}, @var{n}], where @var{n} is the
 197 length of @var{p}.
 198
 199 See also @mrefdot{permult}
 200
 201 Example:
 202
 203 @c ===beg===
 204 @c load("combinatorics")$
 205 @c perm_inverse ([4, 6, 3, 1, 7, 5, 2, 8]);
 206 @c ===end===
 207 @example
 208 (%i1) load("combinatorics")$
 209 @group
 210 (%i2) perm_inverse ([4, 6, 3, 1, 7, 5, 2, 8]);
 211 (%o2)                [4, 7, 3, 1, 6, 2, 5, 8]
 212 @end group
 213 @end example
 214
 215 @opencatbox{Categories:}
 216 @category{Package combinatorics}
 217 @closecatbox
 218
 219 @end deffn
 220
 221 @anchor{perm_length}
 222 @deffn {Function} perm_length (@var{p})
 223
 224 Determines the minimum number of adjacent transpositions necessary to
 225 write permutation @var{p} as a product of adjacent transpositions. An
 226 adjacent transposition is a cycle with only two numbers, which are
 227 consecutive integers.
 228
 229 See also @mrefdot{perm_decomp}
 230
 231 Example:
 232
 233 @c ===beg===
 234 @c load("combinatorics")$
 235 @c perm_length ([4, 6, 3, 1, 7, 5, 2, 8]);
 236 @c ===end===
 237 @example
 238 (%i1) load("combinatorics")$
 239 @group
 240 (%i2) perm_length ([4, 6, 3, 1, 7, 5, 2, 8]);
 241 (%o2)                           12
 242 @end group
 243 @end example
 244
 245 @opencatbox{Categories:}
 246 @category{Package combinatorics}
 247 @closecatbox
 248
 249 @end deffn
 250
 251 @anchor{perm_lex_next}
 252 @deffn {Function} perm_lex_next (@var{p})
 253
 254 Returns the permutation that comes after the given permutation @var{p},
 255 in the sequence of permutations in lexicographic order.
 256
 257 Example:
 258
 259 @c ===beg===
 260 @c load("combinatorics")$
 261 @c perm_lex_next ([4, 6, 3, 1, 7, 5, 2, 8]);
 262 @c ===end===
 263 @example
 264 (%i1) load("combinatorics")$
 265 @group
 266 (%i2) perm_lex_next ([4, 6, 3, 1, 7, 5, 2, 8]);
 267 (%o2)                [4, 6, 3, 1, 7, 5, 8, 2]
 268 @end group
 269 @end example
 270
 271 @opencatbox{Categories:}
 272 @category{Package combinatorics}
 273 @closecatbox
 274
 275 @end deffn
 276
 277 @anchor{perm_lex_rank}
 278 @deffn {Function} perm_lex_rank (@var{p})
 279
 280 Finds the position of permutation @var{p}, an integer from 1 to the
 281 degree @var{n} of the permutation, in the sequence of permutations in
 282 lexicographic order.
 283
 284 See also @mref{perm_lex_unrank} and @mrefdot{perms_lex}
 285
 286 Example:
 287
 288 @c ===beg===
 289 @c load("combinatorics")$
 290 @c perm_lex_rank ([4, 6, 3, 1, 7, 5, 2, 8]);
 291 @c ===end===
 292 @example
 293 (%i1) load("combinatorics")$
 294 @group
 295 (%i2) perm_lex_rank ([4, 6, 3, 1, 7, 5, 2, 8]);
 296 (%o2)                          18255
 297 @end group
 298 @end example
 299
 300 @opencatbox{Categories:}
 301 @category{Package combinatorics}
 302 @closecatbox
 303
 304 @end deffn
 305
 306 @anchor{perm_lex_unrank}
 307 @deffn {Function} perm_lex_unrank (@var{n}, @var{i})
 308
 309 Returns the @emph{n}-degree permutation at position @var{i} (from 1 to
 310 @emph{n}!) in the lexicographic ordering of permutations.
 311
 312 See also @mref{perm_lex_rank} and @mrefdot{perms_lex}
 313
 314 Example:
 315
 316 @c ===beg===
 317 @c load("combinatorics")$
 318 @c perm_lex_unrank (8, 18255);
 319 @c ===end===
 320 @example
 321 (%i1) load("combinatorics")$
 322 @group
 323 (%i2) perm_lex_unrank (8, 18255);
 324 (%o2)                [4, 6, 3, 1, 7, 5, 2, 8]
 325 @end group
 326 @end example
 327
 328 @opencatbox{Categories:}
 329 @category{Package combinatorics}
 330 @closecatbox
 331
 332 @end deffn
 333
 334 @anchor{perm_next}
 335 @deffn {Function} perm_next (@var{p})
 336
 337 Returns the permutation that comes after the given permutation @var{p},
 338 in the sequence of permutations in Trotter-Johnson order.
 339
 340 See also @mrefdot{perms}
 341
 342 Example:
 343
 344 @c ===beg===
 345 @c load("combinatorics")$
 346 @c perm_next ([4, 6, 3, 1, 7, 5, 2, 8]);
 347 @c ===end===
 348 @example
 349 (%i1) load("combinatorics")$
 350 @group
 351 (%i2) perm_next ([4, 6, 3, 1, 7, 5, 2, 8]);
 352 (%o2)                [4, 6, 3, 1, 7, 5, 8, 2]
 353 @end group
 354 @end example
 355
 356 @opencatbox{Categories:}
 357 @category{Package combinatorics}
 358 @closecatbox
 359
 360 @end deffn
 361
 362 @anchor{perm_parity}
 363 @deffn {Function} perm_parity (@var{p})
 364
 365 Finds the parity of permutation @var{p}: 0 if the minimum number of
 366 adjacent transpositions necessary to write permutation @var{p} as a
 367 product of adjacent transpositions is even, or 1 if that number is odd.
 368
 369 See also @mrefdot{perm_decomp}
 370
 371 Example:
 372
 373 @c ===beg===
 374 @c load("combinatorics")$
 375 @c perm_parity ([4, 6, 3, 1, 7, 5, 2, 8]);
 376 @c ===end===
 377 @example
 378 (%i1) load("combinatorics")$
 379 @group
 380 (%i2) perm_parity ([4, 6, 3, 1, 7, 5, 2, 8]);
 381 (%o2)                            0
 382 @end group
 383 @end example
 384
 385 @opencatbox{Categories:}
 386 @category{Package combinatorics}
 387 @closecatbox
 388
 389 @end deffn
 390
 391 @anchor{perm_rank}
 392 @deffn {Function} perm_rank (@var{p})
 393
 394 Finds the position of permutation @var{p}, an integer from 1 to the
 395 degree @var{n} of the permutation, in the sequence of permutations in
 396 Trotter-Johnson order.
 397
 398 See also @mref{perm_unrank} and @mrefdot{perms}
 399
 400 Example:
 401
 402 @c ===beg===
 403 @c load("combinatorics")$
 404 @c perm_rank ([4, 6, 3, 1, 7, 5, 2, 8]);
 405 @c ===end===
 406 @example
 407 (%i1) load("combinatorics")$
 408 @group
 409 (%i2) perm_rank ([4, 6, 3, 1, 7, 5, 2, 8]);
 410 (%o2)                          19729
 411 @end group
 412 @end example
 413
 414 @opencatbox{Categories:}
 415 @category{Package combinatorics}
 416 @closecatbox
 417
 418 @end deffn
 419
 420 @anchor{perm_undecomp}
 421 @deffn {Function} perm_undecomp (@var{cl}, @var{n})
 422
 423 Converts the list of cycles @var{cl} of degree @var{n} into an @var{n}
 424 degree permutation, equal to their product.
 425
 426 See also @mrefdot{perm_decomp}
 427
 428 Example:
 429
 430 @c ===beg===
 431 @c load("combinatorics")$
 432 @c perm_undecomp ([[1,6],[2,6,5,7]], 8);
 433 @c ===end===
 434 @example
 435 (%i1) load("combinatorics")$
 436 @group
 437 (%i2) perm_undecomp ([[1,6],[2,6,5,7]], 8);
 438 (%o2)                [5, 6, 3, 4, 7, 1, 2, 8]
 439 @end group
 440 @end example
 441
 442 @opencatbox{Categories:}
 443 @category{Package combinatorics}
 444 @closecatbox
 445
 446 @end deffn
 447
 448 @anchor{perm_unrank}
 449 @deffn {Function} perm_unrank (@var{n}, @var{i})
 450
 451 Returns the @emph{n}-degree permutation at position @var{i} (from 1 to
 452 @emph{n}!) in the Trotter-Johnson ordering of permutations.
 453
 454 See also @mref{perm_rank} and @mrefdot{perms}
 455
 456 Example:
 457
 458 @c ===beg===
 459 @c load("combinatorics")$
 460 @c perm_unrank (8, 19729);
 461 @c ===end===
 462 @example
 463 (%i1) load("combinatorics")$
 464 @group
 465 (%i2) perm_unrank (8, 19729);
 466 (%o2)                [4, 6, 3, 1, 7, 5, 2, 8]
 467 @end group
 468 @end example
 469
 470 @opencatbox{Categories:}
 471 @category{Package combinatorics}
 472 @closecatbox
 473
 474 @end deffn
 475
 476 @anchor{permp}
 477 @deffn {Function} permp (@var{p})
 478
 479 Returns true if @var{p} is a valid permutation namely, a list of length
 480 @var{n}, whose elements are all the positive integers from 1 to @var{n},
 481 without repetitions. Otherwise, it returns false.
 482
 483 Examples:
 484
 485 @c ===beg===
 486 @c load("combinatorics")$
 487 @c permp ([2,0,3,1]);
 488 @c permp ([2,1,4,3]);
 489 @c ===end===
 490 @example
 491 (%i1) load("combinatorics")$
 492 @group
 493 (%i2) permp ([2,0,3,1]);
 494 (%o2)                          false
 495 @end group
 496 @group
 497 (%i3) permp ([2,1,4,3]);
 498 (%o3)                          true
 499 @end group
 500 @end example
 501
 502 @opencatbox{Categories:}
 503 @category{Package combinatorics}
 504 @closecatbox
 505
 506 @end deffn
 507
 508 @anchor{perms}
 509 @deffn {Function} perms @
 510 @fname{perms} (@var{n}) @
 511 @fname{perms} (@var{n}, @var{i}) @
 512 @fname{perms} (@var{n}, @var{i}, @var{j})
 513
 514 @code{perms(@var{n})} returns a list of all
 515 @emph{n}-degree permutations in the so-called Trotter-Johnson order.
 516
 517 @code{perms(@var{n}, @var{i})} returns the @emph{n}-degree
 518 permutation which is at the @emph{i}th position (from 1 to @emph{n}!) in
 519 the Trotter-Johnson ordering of the permutations.
 520
 521 @code{perms(@var{n}, @var{i}, @var{j})} returns a list of the @emph{n}-degree
 522 permutations between positions @var{i} and @var{j} in the Trotter-Johnson
 523 ordering of the permutations.
 524
 525 The sequence of permutations in Trotter-Johnson order starts with the
 526 identity permutation and each consecutive permutation can be obtained
 527 from the previous one a by single adjacent transposition.
 528
 529 See also @mref{perm_next}, @mref{perm_rank} and @mrefdot{perm_unrank}
 530
 531 Examples:
 532
 533 @c ===beg===
 534 @c load("combinatorics")$
 535 @c perms (4);
 536 @c perms (4, 12);
 537 @c perms (4, 12, 14);
 538 @c ===end===
 539 @example
 540 (%i1) load("combinatorics")$
 541 @group
 542 (%i2) perms (4);
 543 (%o2) [[1, 2, 3, 4], [1, 2, 4, 3], [1, 4, 2, 3], [4, 1, 2, 3],
 544 [4, 1, 3, 2], [1, 4, 3, 2], [1, 3, 4, 2], [1, 3, 2, 4],
 545 [3, 1, 2, 4], [3, 1, 4, 2], [3, 4, 1, 2], [4, 3, 1, 2],
 546 [4, 3, 2, 1], [3, 4, 2, 1], [3, 2, 4, 1], [3, 2, 1, 4],
 547 [2, 3, 1, 4], [2, 3, 4, 1], [2, 4, 3, 1], [4, 2, 3, 1],
 548 [4, 2, 1, 3], [2, 4, 1, 3], [2, 1, 4, 3], [2, 1, 3, 4]]
 549 @end group
 550 @group
 551 (%i3) perms (4, 12);
 552 (%o3)                     [[4, 3, 1, 2]]
 553 @end group
 554 @group
 555 (%i4) perms (4, 12, 14);
 556 (%o4)       [[4, 3, 1, 2], [4, 3, 2, 1], [3, 4, 2, 1]]
 557 @end group
 558 @end example
 559
 560 @opencatbox{Categories:}
 561 @category{Package combinatorics}
 562 @closecatbox
 563
 564 @end deffn
 565
 566 @anchor{perms_lex}
 567 @deffn {Function} perms_lex @
 568 @fname{perms_lex} (@var{n}) @
 569 @fname{perms_lex} (@var{n}, @var{i}) @
 570 @fname{perms_lex} (@var{n}, @var{i}, @var{j})
 571
 572 @code{perms_lex(@var{n})} returns a list of all
 573 @emph{n}-degree permutations in the so-called lexicographic order.
 574
 575 @code{perms_lex(@var{n}, @var{i})} returns the @emph{n}-degree
 576 permutation which is at the @emph{i}th position (from 1 to @emph{n}!) in
 577 the lexicographic ordering of the permutations.
 578
 579 @code{perms_lex(@var{n}, @var{i}, @var{j})} returns a list of the @emph{n}-degree
 580 permutations between positions @var{i} and @var{j} in the lexicographic
 581 ordering of the permutations.
 582
 583 The sequence of permutations in lexicographic order starts with all the
 584 permutations with the lowest index, 1, followed by all permutations
 585 starting with the following index, 2, and so on. The permutations
 586 starting by an index @emph{i} are the permutations of the first @emph{n}
 587 integers different from @emph{i} and they are also placed in
 588 lexicographic order, where the permutations with the lowest of those
 589 integers are placed first and so on.
 590
 591 See also @mref{perm_lex_next}, @mref{perm_lex_rank} and
 592 @mrefdot{perm_lex_unrank}
 593
 594 Examples:
 595
 596 @c ===beg===
 597 @c load("combinatorics")$
 598 @c perms_lex (4);
 599 @c perms_lex (4, 12);
 600 @c perms_lex (4, 12, 14);
 601 @c ===end===
 602 @example
 603 (%i1) load("combinatorics")$
 604 @group
 605 (%i2) perms_lex (4);
 606 (%o2) [[1, 2, 3, 4], [1, 2, 4, 3], [1, 3, 2, 4], [1, 3, 4, 2],
 607 [1, 4, 2, 3], [1, 4, 3, 2], [2, 1, 3, 4], [2, 1, 4, 3],
 608 [2, 3, 1, 4], [2, 3, 4, 1], [2, 4, 1, 3], [2, 4, 3, 1],
 609 [3, 1, 2, 4], [3, 1, 4, 2], [3, 2, 1, 4], [3, 2, 4, 1],
 610 [3, 4, 1, 2], [3, 4, 2, 1], [4, 1, 2, 3], [4, 1, 3, 2],
 611 [4, 2, 1, 3], [4, 2, 3, 1], [4, 3, 1, 2], [4, 3, 2, 1]]
 612 @end group
 613 @group
 614 (%i3) perms_lex (4, 12);
 615 (%o3)                     [[2, 4, 3, 1]]
 616 @end group
 617 @group
 618 (%i4) perms_lex (4, 12, 14);
 619 (%o4)       [[2, 4, 3, 1], [3, 1, 2, 4], [3, 1, 4, 2]]
 620 @end group
 621 @end example
 622
 623 @opencatbox{Categories:}
 624 @category{Package combinatorics}
 625 @closecatbox
 626
 627 @end deffn
 628
 629 @anchor{permult}
 630 @deffn {Function} permult (@var{p_1}, @dots{}, @var{p_m})
 631
 632 Returns the product of two or more permutations @var{p_1}, @dots{}, @var{p_m}.
 633
 634 Example:
 635
 636 @c ===beg===
 637 @c load("combinatorics")$
 638 @c permult ([2,3,1], [3,1,2], [2,1,3]);
 639 @c ===end===
 640 @example
 641 (%i1) load("combinatorics")$
 642 @group
 643 (%i2) permult ([2,3,1], [3,1,2], [2,1,3]);
 644 (%o2)                        [2, 1, 3]
 645 @end group
 646 @end example
 647
 648 @opencatbox{Categories:}
 649 @category{Package combinatorics}
 650 @closecatbox
 651
 652 @end deffn
 653
 654 @anchor{permute}
 655 @deffn {Function} permute (@var{p}, @var{l})
 656
 657 Applies the permutation @var{p} to the elements of the list (or set)
 658 @var{l}.
 659
 660 Example:
 661
 662 @c ===beg===
 663 @c load("combinatorics")$
 664 @c lis1: [a,b*c^2,4,z,x/y,1/2,ff23(x),0];
 665 @c permute ([4, 6, 3, 1, 7, 5, 2, 8], lis1);
 666 @c ===end===
 667 @example
 668 (%i1) load("combinatorics")$
 669 @group
 670 (%i2) lis1: [a,b*c^2,4,z,x/y,1/2,ff23(x),0];
 671                         2        x  1
 672 (%o2)            [a, b c , 4, z, -, -, ff23(x), 0]
 673                                  y  2
 674 @end group
 675 @group
 676 (%i3) permute ([4, 6, 3, 1, 7, 5, 2, 8], lis1);
 677                      1                 x     2
 678 (%o3)            [z, -, 4, a, ff23(x), -, b c , 0]
 679                      2                 y
 680 @end group
 681 @end example
 682
 683 @opencatbox{Categories:}
 684 @category{Package combinatorics}
 685 @closecatbox
 686
 687 @end deffn
 688
 689 @anchor{random_perm}
 690 @deffn {Function} random_perm (@var{n})
 691
 692 Returns a random permutation of degree @var{n}.
 693
 694 See also @mrefdot{random_permutation}
 695
 696 Example:
 697
 698 @c ===beg===
 699 @c load("combinatorics")$
 700 @c random_perm (7);
 701 @c ===end===
 702 @example
 703 (%i1) load("combinatorics")$
 704 @group
 705 (%i2) random_perm (7);
 706 (%o2)                  [6, 3, 4, 7, 5, 1, 2]
 707 @end group
 708 @end example
 709
 710 @opencatbox{Categories:}
 711 @category{Package combinatorics}
 712 @closecatbox
 713
 714 @end deffn
 715