The cl-permutation Reference Manual

Next: , Previous: , Up: (dir)   [Contents][Index]

The cl-permutation Reference Manual

This is the cl-permutation Reference Manual, generated automatically by Declt version 4.0 beta 2 "William Riker" on Tue Nov 15 05:01:51 2022 GMT+0.

Table of Contents


1 Introduction

CL-PERMUTATION

A library for operating on permutations and permutation groups.

Creating Permutations

Permutations are represented by the structure PERM, which is read-only/immutable at the API boundary. A permutation of size N is essentially a sequence of numbers from 1 to N. One-based permutations were chosen because that is the dominating convention in mathematics. All we lose, essentially, is direct compatibility with array indexing, and one fixnum worth of space. (Internally, the permutations are stored in an array of size N+1, where the zeroth element is always zero).

A permutation can be created via MAKE-PERM:

PERM> (make-perm 1 2 3)
#<PERM 1 2 3>

The permutation will be checked for validity.

PERM> (make-perm 1 2 5)
Given permutation must contain the numbers 1 to 3
   [Condition of type SIMPLE-ERROR]

One can also create permutations with LIST-TO-PERM, which converts a list to a permutation. The companion function PERM-TO-LIST does the opposite operation, but it's not recommended to use list representations of permutations.

One can also create permutations with VECTOR-TO-PERM, which is analogous to LIST-TO-PERM, except it works for vectors. The reverse is PERM-TO-VECTOR.

Lastly, there is an experimental reader macro for permutations, which are created at read time. To enable the syntax, use

(enable-perm-reader)

and then one may type

#[3 1 2 4 5]

for permutations instead.

Permutation Operations

There is a slew of permutation operations:

Permutation Generation

There are ways of efficiently generating all permutations of a given length incrementally. Instead of generating all permutations at once in memory -- which takes O(n*n!) space -- we generate permutations on the fly.

The first way is to iterate over the permutations using a DOLIST-style macro called DOPERMS.

PERM> (let ((i 1))
        (doperms (p 3)
          (format t "~D: ~A~%" i p)
          (incf i)))
1: #<PERM 1 2 3>
2: #<PERM 1 3 2>
3: #<PERM 3 1 2>
4: #<PERM 3 2 1>
5: #<PERM 2 3 1>
6: #<PERM 2 1 3>

The other way is to produce a generator object (a closure, in fact) which generates the permutations. Simply FUNCALL the object to receive the next permutation. When they're all exhausted, the closure will return NIL.

PERM> (defparameter S3 (make-perm-generator 3))
S3
PERM> (defparameter S2 (make-perm-generator 2))
S2
PERM> (list (funcall S2) (funcall S3))
(#<PERM 1 2> #<PERM 1 2 3>)
PERM> (list (funcall S2) (funcall S3))
(#<PERM 2 1> #<PERM 1 3 2>)
PERM> (list (funcall S2) (funcall S3))
(NIL #<PERM 3 1 2>)
PERM> (list (funcall S2) (funcall S3))
(NIL #<PERM 3 2 1>)
PERM> (list (funcall S2) (funcall S3))
(NIL #<PERM 2 3 1>)

Cycle Operations

There's also a number of operations for cycles. Cycles are represented by the CYCLE structure. We can convert to and from cycle representation using TO-CYCLES and FROM-CYCLES. Cycles created by TO-CYCLES are automatically canonicalized with CANONICALIZE-CYCLES. Canonicalization is defined as:

Cycles that have not been canonicalized are printed with an asterisk '*'. We can observe this by explicitly disabling cycle canonicalization:

PERM> (make-cycle 3 1)
#<CYCLE (1 3)>                ; no asterisk
PERM> (let ((*canonicalize-cycle-on-creation* nil))
        (make-cycle 3 1))
#<CYCLE (3 1)*>               ; asterisk

An example use of TO-CYCLES is as follows:

PERM> (let ((r (random-perm 10)))
        (values r (to-cycles r)))
#<PERM 7 4 8 5 2 10 3 9 1 6>
(#<CYCLE (6 10)> #<CYCLE (2 4 5)> #<CYCLE (1 7 3 8 9)>)

FROM-CYCLES allows the specification of the permutation's length. For example:

PERM> (from-cycles (list (make-cycle 1 3 2)))
#<PERM 3 1 2>
PERM> (from-cycles (list (make-cycle 1 3 2)) 5)
#<PERM 3 1 2 4 5>

Lastly, there is a (mostly useless) function CYCLES-TO-ONE-LINE which converts cycles to one-line notation. That is, the cycles

(1 2 3)(4 5)

gets converted to the permutation

12345.

For example,

PERM> (cycles-to-one-line (list (make-cycle 1 2 3)
                                (make-cycle 4 5)))
#<PERM 1 2 3 4 5>

If one takes a permutation which has been canonically decomposed into cycles, then interestingly, there exists a bijection between one-line notation and the cycle decomposition.

Combinatorial Specifications

A "combinatorial specification" describes a space of combinatorial objects. They have a nice property that they all can be mapped to and from integers sharply. See the section "Ranking and Unranking Combinatorial Specifications".

Currently, only objects of linear structure exist. All of them are represented as subclasses of COMBINATORIAL-SPEC. They are as follows.

RADIX-SPEC: Base-B Non-Negative Integers

These are a representation of a base-B non-negative integer, for a base B > 1. They are handled by the RADIX-SPEC class. Within CL-PERMUTATION, the digits are written left-to-right to correspond with natural vector index ordering. A RADIX-SPEC can be made with MAKE-RADIX-SPEC. Here is the enumeration of all two-digit trinary numbers:

PERM> (print-objects-of-spec (make-radix-spec 3 2))
0 ==> #(0 0) ==> 0
1 ==> #(1 0) ==> 1
2 ==> #(2 0) ==> 2
3 ==> #(0 1) ==> 3
4 ==> #(1 1) ==> 4
5 ==> #(2 1) ==> 5
6 ==> #(0 2) ==> 6
7 ==> #(1 2) ==> 7
8 ==> #(2 2) ==> 8

MIXED-RADIX-SPEC: Non-Negative Mixed-Radix Integers

A mixed-radix integer is a generalization of a base-B integer. The digits in a mixed-radix numeral correspond to different bases. Mixed-radix specifications can be made with VECTOR-TO-MIXED-RADIX-SPEC. For example, the following are all numerals of radix (2, 3, 1):

PERM> (print-objects-of-spec (vector-to-mixed-radix-spec #(2 3 1)))
0 ==> #(0 0 0) ==> 0
1 ==> #(1 0 0) ==> 1
2 ==> #(0 1 0) ==> 2
3 ==> #(1 1 0) ==> 3
4 ==> #(0 2 0) ==> 4
5 ==> #(1 2 0) ==> 5

Notice again we use vector index ordering.

PERM-SPEC: Permutations

The space of permutations of length N (also known as S_N) can be represented. These are represented by the PERM-SPEC class.

PERM> (print-objects-of-spec (make-perm-spec 3))
0 ==> #(0 1 2) ==> 0
1 ==> #(0 2 1) ==> 1
2 ==> #(1 0 2) ==> 2
3 ==> #(1 2 0) ==> 3
4 ==> #(2 0 1) ==> 4
5 ==> #(2 1 0) ==> 5

Currently, actual PERM objects are not generated (see below about ranking/unranking). However, one can easily convert between the two.

COMBINATION-SPEC: Combinations

Combinations represent the selection of M objects from a collection of N objects. These are represented by a vector containing M 1's and N 0's. The class that manages this is a COMBINATION-SPEC. For example, all combinations of 2 objects of a total of 4 can be listed by the following:

PERM> (print-objects-of-spec (make-combination-spec 4 2))
0 ==> #(0 0 1 1) ==> 0
1 ==> #(0 1 0 1) ==> 1
2 ==> #(1 0 0 1) ==> 2
3 ==> #(0 1 1 0) ==> 3
4 ==> #(1 0 1 0) ==> 4
5 ==> #(1 1 0 0) ==> 5

WORD-SPEC: Words

A word is similar to a permutation except that it may have repeated, indistinct elements. These are represented by a WORD-SPEC. It can be created by supplying a sample word to the function VECTOR-TO-WORD-SPEC. For example, all words of the form 1123 can be listed as follows:

PERM> (print-objects-of-spec (vector-to-word-spec #(1 1 2 3)))
0 ==> #(1 1 2 3) ==> 0
1 ==> #(1 1 3 2) ==> 1
2 ==> #(1 2 1 3) ==> 2
3 ==> #(1 2 3 1) ==> 3
4 ==> #(1 3 1 2) ==> 4
5 ==> #(1 3 2 1) ==> 5
6 ==> #(2 1 1 3) ==> 6
7 ==> #(2 1 3 1) ==> 7
8 ==> #(2 3 1 1) ==> 8
9 ==> #(3 1 1 2) ==> 9
10 ==> #(3 1 2 1) ==> 10
11 ==> #(3 2 1 1) ==> 11

Ranking and Unranking Combinatorial Specifications

Each combinatorial specification represents a finite space of N > 0 objects. N is called the "cardinality" of the specification and can be computed with the CARDINALITY method.

> (cardinality (make-perm-spec 3))
6
> (cardinality (vector-to-word-spec #(1 1 2 3)))
12

The cardinality is computed only once for a combinatorial specification and is then cached for fast access.

Obviously, every object in a particular finite combinatorial space can be bijected to and from integers below the cardinality of that space. CL-PERMUTATION provides fast and efficient mechanisms for computing one such bijection for each combinatorial specification. Mapping from an object to an integer is called "ranking" and mapping from an integer back to an object is called "unranking".

When a lexicographic ordering makes sense, there will be 1-to-1 correspondence with the ordering on integers. In other words for objects X1 and X2 and their ranks R1 and R2, X1 lex< X2 iff R1 < R2.

The method UNRANK takes a combinatorial specification and an integer, and maps it to the corresponding object representation (usually a vector). It takes an optional keyword argument :SET which acts as a destination of the unranked object (for efficiency purposes).

The method RANK takes a combinatorial specification and an object produced by UNRANK (again, usually a sensible vector) and returns the integer (the "rank") of that object. PRINT-OBJECTS-OF-SPEC, as used above, prints the rank of every object in a combinatorial space.

One can map over all objects and ranks by using MAP-SPEC, which takes a binary function (rank and object) as well as a combinatorial specification, and applies that function to each object and their rank.

Permutation Groups

There is initial support for permutation groups at the moment. Permutation groups are represented by the structure PERM-GROUP.

We can create a permutation group from its generators via GENERATE-PERM-GROUP. A shorthand syntax is provided which, instead of taking a list of PERM objects, takes a list of lists representing perms. This shorthand is GROUP-FROM. For example, the following two are the same group:

PERM> (generate-perm-group (list (make-perm 1 3 2 4)
                                 (make-perm 3 2 4 1)))
#<PERM-GROUP of 2 generators>
PERM> (group-from '((1 3 2 4)
                    (3 2 4 1)))
#<PERM-GROUP of 2 generators>

We can generate a permutation group from a list of cycles as well. The above is equivalent to

PERM> (group-from-cycles (list (list (make-cycle 2 3))
                               (list (make-cycle 1 3 4)))
                         4) 
#<PERM-GROUP of 2 generators>

Once we have generated a group, we can do some operations on it.

For example, let's define the group for 3x3 Rubik's cubes. A cube has six moves: we can turn the front, back, left, right, top, and bottom. Label each sticker with a number like so:

                     +--------------+
                     |              |
                     |  1    2    3 |
                     |              |
                     |  4   up    5 |
                     |              |
                     |  6    7    8 |
                     |              |
      +--------------+--------------+--------------+--------------+
      |              |              |              |              |
      |  9   10   11 | 17   18   19 | 25   26   27 | 33   34   35 |
      |              |              |              |              |
      | 12  left  13 | 20 front  21 | 28 right  29 | 36  back  37 |
      |              |              |              |              |
      | 14   15   16 | 22   23   24 | 30   31   32 | 38   39   40 |
      |              |              |              |              |
      +--------------+--------------+--------------+--------------+
                     |              |
                     | 41   42   43 |
                     |              |
                     | 44  down  45 |
                     |              |
                     | 46   47   48 |
                     |              |
                     +--------------+

Each turn corresponds to a permutation of stickers. I'll do the hard work of specifying them:

(defparameter rubik-3x3
  (group-from
   '((3 5 8 2 7 1 4 6 33 34 35 12 13 14 15 16 9 10 11 20 21 22 23 24 17 
      18 19 28 29 30 31 32 25 26 27 36 37 38 39 40 41 42 43 44 45 46 47 48)
     (17 2 3 20 5 22 7 8 11 13 16 10 15 9 12 14 41 18 19 44 21 46 23 24 
      25 26 27 28 29 30 31 32 33 34 6 36 4 38 39 1 40 42 43 37 45 35 47 48) 
     (1 2 3 4 5 25 28 30 9 10 8 12 7 14 15 6 19 21 24 18 23 17 20 22 43 
      26 27 42 29 41 31 32 33 34 35 36 37 38 39 40 11 13 16 44 45 46 47 48) 
     (1 2 38 4 36 6 7 33 9 10 11 12 13 14 15 16 17 18 3 20 5 22 23 8 27 
      29 32 26 31 25 28 30 48 34 35 45 37 43 39 40 41 42 19 44 21 46 47 24) 
     (14 12 9 4 5 6 7 8 46 10 11 47 13 48 15 16 17 18 19 20 21 22 23 24
      25 26 1 28 2 30 31 3 35 37 40 34 39 33 36 38 41 42 43 44 45 32 29 27) 
     (1 2 3 4 5 6 7 8 9 10 11 12 13 22 23 24 17 18 19 20 21 30 31 32 25
      26 27 28 29 38 39 40 33 34 35 36 37 14 15 16 43 45 48 42 47 41 44 46))))

Now we have our group:

PERM> rubik-3x3
#<PERM-GROUP of 6 generators>

Let's query the group's order:

PERM> (group-order rubik-3x3)
43252003274489856000

A lot of positions! Let's generate a random cube:

PERM> (random-group-element rubik-3x3)
#<PERM 1 20 24 39 12 40 29 41 9 47 46 21 45 11 34 8 14 36 22 31 44 25 10 48
       16 37 43 15 26 32 7 33 30 13 35 5 28 27 23 17 19 4 38 2 18 6 42 3>

And as cycles...

PERM> (to-cycles *)
(#<CYCLE (35)>
 #<CYCLE (30 32 33)>
 #<CYCLE (27 43 38)>
 #<CYCLE (9)>
 #<CYCLE (8 41 19 22 25 16)>
 #<CYCLE (6 40 17 14 11 46)>
 #<CYCLE (4 39 23 10 47 42)>
 #<CYCLE (3 24 48)>
 #<CYCLE (2 20 31 7 29 26 37 28 15 34 13 45 18 36 5 12 21 44)>
 #<CYCLE (1)>)

Let's check if flipping an edge piece is valid:

PERM> (group-element-p (from-cycles (list (make-cycle 7 18)) 48) rubik-3x3)
NIL

No it's not. How about four edge pieces?

PERM> (group-element-p (from-cycles (list (make-cycle 7 18)
                                          (make-cycle 2 34)
                                          (make-cycle 4 10)
                                          (make-cycle 5 26))
                                    48)
                       rubik-3x3)
T

As can be seen, the few operations we have are powerful in studying finite groups.


2 Systems

The main system appears first, followed by any subsystem dependency.


Previous: , Up: Systems   [Contents][Index]

2.1 cl-permutation

A library for operating on permutations and permutation groups.

Author

Robert Smith <robert@stylewarning.com>

License

BSD 3-clause (See LICENSE)

Dependencies
  • alexandria (system).
  • iterate (system).
  • cl-algebraic-data-type (system).
  • closer-mop (system).
  • uiop (system).
  • bordeaux-fft (system).
Source

cl-permutation.asd.

Child Components

3 Files

Files are sorted by type and then listed depth-first from the systems components trees.


Previous: , Up: Files   [Contents][Index]

3.1 Lisp


Next: , Previous: , Up: Lisp   [Contents][Index]

3.1.1 cl-permutation/cl-permutation.asd

Source

cl-permutation.asd.

Parent Component

cl-permutation (system).

ASDF Systems

cl-permutation.


3.1.2 cl-permutation/package.lisp

Source

cl-permutation.asd.

Parent Component

cl-permutation (system).

Packages

cl-permutation.


3.1.3 cl-permutation/utilities.lisp

Dependency

package.lisp (file).

Source

cl-permutation.asd.

Parent Component

cl-permutation (system).

Internals

3.1.4 cl-permutation/permutation.lisp

Dependency

utilities.lisp (file).

Source

cl-permutation.asd.

Parent Component

cl-permutation (system).

Public Interface
Internals

3.1.5 cl-permutation/bruhat.lisp

Dependency

permutation.lisp (file).

Source

cl-permutation.asd.

Parent Component

cl-permutation (system).

Public Interface

3.1.6 cl-permutation/permutation-generation.lisp

Dependency

bruhat.lisp (file).

Source

cl-permutation.asd.

Parent Component

cl-permutation (system).

Public Interface
Internals

3.1.7 cl-permutation/group.lisp

Dependency

permutation-generation.lisp (file).

Source

cl-permutation.asd.

Parent Component

cl-permutation (system).

Public Interface

3.1.8 cl-permutation/free-group.lisp

Dependency

group.lisp (file).

Source

cl-permutation.asd.

Parent Component

cl-permutation (system).

Public Interface
Internals

3.1.9 cl-permutation/straight-line-program.lisp

Dependency

free-group.lisp (file).

Source

cl-permutation.asd.

Parent Component

cl-permutation (system).

Public Interface
Internals

3.1.10 cl-permutation/permutation-group.lisp

Dependency

straight-line-program.lisp (file).

Source

cl-permutation.asd.

Parent Component

cl-permutation (system).

Public Interface
Internals

3.1.11 cl-permutation/minkwitz.lisp

Dependency

permutation-group.lisp (file).

Source

cl-permutation.asd.

Parent Component

cl-permutation (system).

Public Interface
Internals

3.1.12 cl-permutation/homomorphism.lisp

Dependency

minkwitz.lisp (file).

Source

cl-permutation.asd.

Parent Component

cl-permutation (system).

Public Interface
Internals

3.1.13 cl-permutation/orbit.lisp

Dependency

homomorphism.lisp (file).

Source

cl-permutation.asd.

Parent Component

cl-permutation (system).

Public Interface

3.1.14 cl-permutation/do-group-elements.lisp

Dependency

orbit.lisp (file).

Source

cl-permutation.asd.

Parent Component

cl-permutation (system).

Public Interface
Internals

3.1.15 cl-permutation/block.lisp

Dependency

do-group-elements.lisp (file).

Source

cl-permutation.asd.

Parent Component

cl-permutation (system).

Public Interface
Internals

3.1.16 cl-permutation/combinatorial-ranking.lisp

Dependency

block.lisp (file).

Source

cl-permutation.asd.

Parent Component

cl-permutation (system).

Public Interface
Internals

3.1.17 cl-permutation/find-subgroups.lisp

Dependency

combinatorial-ranking.lisp (file).

Source

cl-permutation.asd.

Parent Component

cl-permutation (system).

Internals

3.1.18 cl-permutation/god.lisp

Dependency

find-subgroups.lisp (file).

Source

cl-permutation.asd.

Parent Component

cl-permutation (system).

Internals

3.1.19 cl-permutation/extra-functions.lisp

Dependency

god.lisp (file).

Source

cl-permutation.asd.

Parent Component

cl-permutation (system).

Internals

4 Packages

Packages are listed by definition order.


Previous: , Up: Packages   [Contents][Index]

4.1 cl-permutation

Source

package.lisp.

Nickname

perm

Use List

common-lisp.

Public Interface
Internals

5 Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.


Next: , Previous: , Up: Definitions   [Contents][Index]

5.1 Public Interface


Next: , Previous: , Up: Public Interface   [Contents][Index]

5.1.1 Special variables

Special Variable: *canonicalize-cycle-on-creation*
Package

cl-permutation.

Source

permutation.lisp.


5.1.2 Macros

Macro: do-group-elements ((var group &optional return) &body body)

Iterate through all of the elements of the group GROUP, binding each element to VAR and executing BODY. Optionally return a value specified by RETURN.

Package

cl-permutation.

Source

do-group-elements.lisp.

Macro: doperms ((x n &optional result) &body body)

Iterate over all permutations of size N, optionally returning RESULT.

Package

cl-permutation.

Source

permutation-generation.lisp.


5.1.3 Ordinary functions

Function: bruhat< (w v)

Does W precede V in the Bruhat sense?

We say that W precedes V in the Bruhat sense if there’s a transposition S with V = WS and the length of V is one less the length of W.

Package

cl-permutation.

Source

bruhat.lisp.

Function: bruhat<= (w v)

Does W precede V in the Bruhat sense, or are they equal?

Package

cl-permutation.

Source

bruhat.lisp.

Function: canonicalize-cycle (cycle)

Rotate a cycle CYCLE so its least value is syntactically first.

Package

cl-permutation.

Source

permutation.lisp.

Function: canonicalize-cycles (cycles)

Canonicalize each cycle in the list of cycles CYCLES, then canonicalize the list of cycles in descending value of the first position of the cycle.

Package

cl-permutation.

Source

permutation.lisp.

Function: compose-slp (slp1 slp2)

Compose two SLPs SLP1 and SLP2.

Package

cl-permutation.

Source

straight-line-program.lisp.

Function: cycle-identity-p (cycle)

Is the cycle CYCLE representative of an identity permutation?

Package

cl-permutation.

Source

permutation.lisp.

Function: cycle-length (cycle)

Compute the length of the cycle CYCLE.

Package

cl-permutation.

Source

permutation.lisp.

Function: cycle-ref (cycle n)

Compute the Nth element of the cycle CYCLE. Treat the cycle as if it is circular (so indexes greater than the cycle length or less than zero will wrap around).

Package

cl-permutation.

Source

permutation.lisp.

Function: cycle-type (perm)

Compute the cycle type of a perm PERM.

The cycle type is a partition of the perm’s size, and is equal to the lengths of the cycles in descending order of the perm’s cycle decomposition.

Package

cl-permutation.

Source

permutation.lisp.

Function: cycles-to-one-line (cycles)

Convert CYCLES to one-line notation. This is the same as flattening the cycles.

Note: This is not the same as FROM-CYCLES.

Package

cl-permutation.

Source

permutation.lisp.

Function: enable-perm-reader ()

Enable the use of #[...] for perms.

Package

cl-permutation.

Source

permutation.lisp.

Function: evaluate-slp (group ctx slp &key homomorphism)

Within a group GROUP, and given the context CTX and the straight line program SLP, compute its evaluation (the value of the SLP in the target group).

If HOMOMORPHISM is provided, then the image of each SLP-ELEMENT will be computed. The image of the homomorphism should be GROUP.

Package

cl-permutation.

Source

straight-line-program.lisp.

Function: find-conjugator (x y)

Find an element that conjugates X to Y. In other words, find the permutation C such that

Y = C X C^-1.

Package

cl-permutation.

Source

permutation.lisp.

Function: find-minimal-block-system-containing (perm-group alphas)

Find the minimal blocks of the permutation group PERM-GROUP which contain the list of points ALPHAS.

Returns a list of lists. Each sub-list represents a block. Each block is an image of one another under the generators of the group.

Package

cl-permutation.

Source

block.lisp.

Function: find-non-trivial-block-system (group)

Find a non-trivial block system of the permutation group GROUP.

GROUP must be transitive in order for this to produce truly non-trivial block systems.

Package

cl-permutation.

Source

block.lisp.

Function: free-group-identity-p (x)

Is X an identity element of a free group?

Package

cl-permutation.

Source

free-group.lisp.

Function: from-cycles (cycles &optional size)

Convert a cycle representation of a permutation CYCLES to the standard representation.

SIZE is ignored if it is less than the maximum point within the cycles.

Package

cl-permutation.

Source

permutation.lisp.

Function: generate-perm-group (generators)

Generate a permutation group generated by the list of permutations GENERATORS.

Package

cl-permutation.

Source

permutation-group.lisp.

Function: generator-decomposition (g group &key return-original-generators)

Given an element g ∈ GROUP, factorize it into a sequence of generators, represented as a list of elements in the homomorphic FREE-GROUP.

If RETURN-ORIGINAL-GENERATORS is true, return the group’s original generators as permutations.

This is also called "factorization".

Package

cl-permutation.

Source

minkwitz.lisp.

Function: group-degree (group &key true)

What is the degree of the group GROUP?

If TRUE is a true-value, then the true degree will be returned (i.e., the maximum non-fixed point index). For example, consider

G = <(1 3 2 4 5)>

then

(group-degree G :true nil) ==> 5 [default]
(group-degree G :true t) ==> 3.

Package

cl-permutation.

Source

permutation-group.lisp.

Function: group-element-p (perm group)

Decide if the permutation PERM is an element of the group GROUP.

Package

cl-permutation.

Source

permutation-group.lisp.

Function: group-element-rank-functions (group)

Generate two functions as values:

1. A function to map elements of the permutation group GROUP to integers [0, 2^|GROUP| - 1].

2. The inverse of the above function.

Package

cl-permutation.

Source

do-group-elements.lisp.

Function: group-from (generators-as-lists)

Generate a permutation group from a list of generators, which are represented as lists.

Package

cl-permutation.

Source

permutation-group.lisp.

Function: group-from-cycles (generators-as-cycles size)

Generate a permutation group from a list of generators, which are represented as cycles.

Package

cl-permutation.

Source

permutation-group.lisp.

Function: group-from-orbit (original-group orbit)

Produce a group by having the group ORIGINAL-GROUP act on the orbit ORBIT of that group.

As a second value, the homomorphism will be returned.

Package

cl-permutation.

Source

orbit.lisp.

Function: group-identity (group)

Return the identity element of the group GROUP.

Package

cl-permutation.

Source

permutation-group.lisp.

Function: group-orbits (group)

Compute the orbits of the group GROUP. This will be a list of arrays of points.

Package

cl-permutation.

Source

orbit.lisp.

Function: group-order (group)

Compute the order of the permutation group GROUP.

Package

cl-permutation.

Source

permutation-group.lisp.

Function: homomorphism-induced-perm-group (group hom)

Given a group GROUP, and a homomorphism HOM mapping elements of that group to permutations,compute the homomorphism-induced group.

Package

cl-permutation.

Source

homomorphism.lisp.

Function: invert-slp (slp)

Invert the SLP SLP.

Package

cl-permutation.

Source

straight-line-program.lisp.

Function: list-to-perm (list)

Construct a perm from a list LIST.

Package

cl-permutation.

Source

permutation.lisp.

Function: make-combination-spec (n m)

Make a COMBINATION-SPEC representing the space of objects representing M items being chosen out of N total.

Package

cl-permutation.

Source

combinatorial-ranking.lisp.

Function: make-cycle (&rest elements)

Create a new cycle with the elements ELEMENTS.

Package

cl-permutation.

Source

permutation.lisp.

Function: make-free-group (num-generators)

Make a free group that contains NUM-GENERATORS generators.

Package

cl-permutation.

Source

free-group.lisp.

Function: make-free-group-element (g &rest elements)

Make an element of the free group G where ELEMENTS are either integer generators of G, or other elements created by this function.

Package

cl-permutation.

Source

free-group.lisp.

Function: make-perm (&rest elements)

Construct a permutation from the numbers ELEMENTS.

Package

cl-permutation.

Source

permutation.lisp.

Function: make-perm-generator (n)

Create a generator that generates permutations of size N.

Package

cl-permutation.

Source

permutation-generation.lisp.

Function: make-perm-spec (n)

Make a PERM-SPEC representing the set of permutations S_n.

Package

cl-permutation.

Source

combinatorial-ranking.lisp.

Function: make-radix-spec (radix size)

Make a RADIX-SPEC representing all numbers between 0 and RADIX^SIZE - 1.

Package

cl-permutation.

Source

combinatorial-ranking.lisp.

Function: map-spec (f spec)

Call the function F across all elements described by SPEC.

F should be a binary function whose first argument represents the rank of object passed as the second argument.

Package

cl-permutation.

Source

combinatorial-ranking.lisp.

Function: naive-generator-decomposition (perm group &key return-original-generators)

Compute the generator decomposition of the permutation PERM of the group GROUP. By default, return a sequence of free generators.

If RETURN-ORIGINAL-GENERATORS is true, return the group’s original generators as permutations.

Note: The result is likely very long and inefficient.

Package

cl-permutation.

Source

permutation-group.lisp.

Function: normal-subgroup-p (group subgroup)

Is the group SUBGROUP a normal subgroup of GROUP?

Package

cl-permutation.

Source

permutation-group.lisp.

Function: orbit-group-homomorphism (original-group orbit)

Compute a homomorphism between elements of the permutation group ORIGINAL-GROUP to the naturally induced group of an orbit ORBIT of ORIGINAL-GROUP.

Package

cl-permutation.

Source

orbit.lisp.

Function: orbit-length (n perm)

Compute the length of the orbit of the element N in the permutation PERM.

Package

cl-permutation.

Source

permutation.lisp.

Function: orbit-of (n perm)

Compute the orbit of the element N in the permutation PERM. Return a cycle representing the orbit of N.

Package

cl-permutation.

Source

permutation.lisp.

Function: perm-compose (p1 p2)

Compose the permutations P1 and P2: x |-> P1(P2(x)).

Example: If P1 = 2 |-> 3 and P2 = 1 |-> 2 then (perm-compose P1 P2) = 1 |-> 3.

Package

cl-permutation.

Source

permutation.lisp.

Function: perm-compose-flipped (p1 p2)

Compose the permutatons P1 and P2: x |-> P2(P1(x)). This is equivalent to (PERM-COMPOSE P2 P1).

Package

cl-permutation.

Source

permutation.lisp.

Function: perm-conjugate (p c)

Conjugate the permutation P by C. This is C P C^-1.

Package

cl-permutation.

Source

permutation.lisp.

Function: perm-eval (perm n)

Evaluate the permutation PERM at index N.

Package

cl-permutation.

Source

permutation.lisp.

Function: perm-eval* (perm n)

Evaluate the permutation PERM at index N. If N is larger than the size of the permutation, return the fixed point.

Package

cl-permutation.

Source

permutation.lisp.

Function: perm-evaluator (perm)

Return an evaluation function for the permutation PERM (a la PERM-EVAL).

Package

cl-permutation.

Source

permutation.lisp.

Function: perm-evaluator* (perm)

Return an evaluation function for the permutation PERM (a la PERM-EVAL*).

Package

cl-permutation.

Source

permutation.lisp.

Function: perm-even-p (perm)

Is PERM an even permutation?

Package

cl-permutation.

Source

permutation.lisp.

Function: perm-expt (perm n)

Raise a permutation PERM to the Nth power. If N is negative, then the inverse will be raised to the -Nth power.

Package

cl-permutation.

Source

permutation.lisp.

Function: perm-fixpoints (perm &optional n)

Return a list of the fixed points in PERM less than or equal to N, which is the perm’s size by default.

Package

cl-permutation.

Source

permutation.lisp.

Function: perm-identity (n)

The identity permutation of size N.

Package

cl-permutation.

Source

permutation.lisp.

Function: perm-identity-p (perm)

Is the permutation PERM an identity permutation?

Package

cl-permutation.

Source

permutation.lisp.

Function: perm-inverse (perm)

Find the inverse of the permutation PERM.

Package

cl-permutation.

Source

permutation.lisp.

Function: perm-inverse-eval (perm n)

Evaluate the inverse of the permutation PERM at index N.

Package

cl-permutation.

Source

permutation.lisp.

Function: perm-inverse-eval* (perm n)

Evaluate the inverse of the permutation PERM at index N. If N is larger than the size of the permutation, return the fixed point.

Package

cl-permutation.

Source

permutation.lisp.

Function: perm-last-non-fixpoint (perm)

Find the last non-fixed point of the perm PERM. If it exists, return the index A and the point B as two values. These satisfy

(PERM-EVAL PERM A) = B

If a fixed point doesn’t exist, return NIL.

Package

cl-permutation.

Source

permutation.lisp.

Function: perm-length (perm)

Count the number of inversions in the permutation PERM.

Package

cl-permutation.

Source

permutation.lisp.

Function: perm-odd-p (perm)

Is PERM an odd permutation?

Package

cl-permutation.

Source

permutation.lisp.

Function: perm-order (perm)

Compute the order of a permutation PERM. This is the non-negative power required to exponentiate it to identity.

Package

cl-permutation.

Source

permutation.lisp.

Function: perm-point-fixed-p (perm k)

Is K fixed in the perm PERM?

Package

cl-permutation.

Source

permutation.lisp.

Function: perm-ref (perm n)

Compute the zero-based index of PERM at N.

Package

cl-permutation.

Source

permutation.lisp.

Function: perm-sign (perm)

The sign of a permutation PERM.

Package

cl-permutation.

Source

permutation.lisp.

Function: perm-size (perm)

The size of a permutation PERM.

Package

cl-permutation.

Source

permutation.lisp.

Function: perm-to-list (perm)

Convert a permutation PERM to a list representation.

Package

cl-permutation.

Source

permutation.lisp.

Function: perm-to-vector (perm)

Convert a permutation PERM to a vector.

Package

cl-permutation.

Source

permutation.lisp.

Function: perm-transpose-entries (perm a b)

Transpose the entries A and B in PERM.

Package

cl-permutation.

Source

permutation.lisp.

Function: perm-transpose-indexes (perm a b)

Transpose the indexes A and B in PERM.

Package

cl-permutation.

Source

permutation.lisp.

Function: perm= (perm other-perm)

Are PERM and OTHER-PERM mathematically equal? (Note: Different sized perms are considered unequal. See PERM=* for extended equality.)

Package

cl-permutation.

Source

permutation.lisp.

Function: perm=* (perm other-perm)

Are PERM and OTHER-PERM mathematically equal when viewed as functions on naturals? (Note: For inequality on different sized perms, see PERM=.)

Package

cl-permutation.

Source

permutation.lisp.

Function: permute (perm a &key type)

Permute the sequence A according to PERM. Retun an object of the same kind as A by default unless TYPE is specified.

Package

cl-permutation.

Source

permutation.lisp.

Function: primitive-group-p (group)

Is the perm group GROUP primitive?

Package

cl-permutation.

Source

block.lisp.

Function: print-objects-of-spec (spec &optional stream)

Given the combinatorial specification SPEC, enumerate all possible objects represented by that specification, printing them to the stream STREAM.

Package

cl-permutation.

Source

combinatorial-ranking.lisp.

Function: random-group-element (group)

Generate a random element of the group GROUP.

Package

cl-permutation.

Source

permutation-group.lisp.

Function: random-perm (n &optional parity)

Make a random permutation of size N. PARITY specifies the parity of the permutation:

* :ANY for any permutation
* :EVEN for only even permutations
* :ODD for only odd permutations

Package

cl-permutation.

Source

permutation.lisp.

Function: rotate-cycle (cycle &optional n)

Rotate the elements of a cycle CYCLE syntactically counterclockwise/left, a total of N times. When N is negative, rotate in the opposite direction. Return a fresh cycle.

Package

cl-permutation.

Source

permutation.lisp.

Function: same-group-p (group1 group2)

Are the groups GROUP1 and GROUP2 the same (i.e., have the same permutation elements)?

Package

cl-permutation.

Source

permutation-group.lisp.

Function: slp-composition (%0 %1)
Package

cl-permutation.

Source

straight-line-program.lisp.

Function: slp-element (%0)
Package

cl-permutation.

Source

straight-line-program.lisp.

Function: slp-inversion (%0)
Package

cl-permutation.

Source

straight-line-program.lisp.

Function: slp-symbol (%0)
Package

cl-permutation.

Source

straight-line-program.lisp.

Function: subdirect-factors (group)

Compute "subdirect factors" of the group GROUP.

These are groups whose direct product has GROUP as a subgroup.

As a second value, return the corresponding list of homomorphisms between GROUP and the subdirect factors.

Package

cl-permutation.

Source

orbit.lisp.

Function: subgroup-p (group subgroup)

Is the group SUBGROUP a subgroup of GROUP?

Package

cl-permutation.

Source

permutation-group.lisp.

Function: symbol-assignment (ctx symbol)

Within the context CTX and the symbol SYMBOL, look up its representation. Return NIL if it does not exist.

Package

cl-permutation.

Source

straight-line-program.lisp.

Function: (setf symbol-assignment) (ctx symbol)

Assign to the symbol SYMBOL the representation REPRESENTATION within the context CTX.

Package

cl-permutation.

Source

straight-line-program.lisp.

Function: to-cycles (perm &key canonicalizep)

Convert a permutation PERM in its standard representation to its cycle representation.

Package

cl-permutation.

Source

permutation.lisp.

Function: transversal-decomposition (perm group &key remove-identities)

Decompose the permutation PERM into transversal sigmas of the group GROUP.

Package

cl-permutation.

Source

permutation-group.lisp.

Function: vector-to-mixed-radix-spec (radix)

Make a MIXED-RADIX-SPEC representing all mixed-radix numbers specified by the vector RADIX.

Package

cl-permutation.

Source

combinatorial-ranking.lisp.

Function: vector-to-perm (word)

Convert a vector VECTOR to a permutation. VECTOR must represent a valid elements of a permutation.

Package

cl-permutation.

Source

permutation.lisp.

Function: vector-to-word-spec (word)

WORD should be a vector containing 1, 2, ..., N, possibly with repeated elements.

Package

cl-permutation.

Source

combinatorial-ranking.lisp.


5.1.4 Generic functions

Generic Function: cardinality (spec)

Compute the cardinality of SPEC. This represents the total number of elements described by the spec.

Package

cl-permutation.

Source

combinatorial-ranking.lisp.

Methods
Method: cardinality ((spec word-spec))
Method: cardinality ((spec combination-spec))
Method: cardinality ((spec perm-spec))
Method: cardinality ((spec mixed-radix-spec))
Method: cardinality ((spec radix-spec))
Method: cardinality :around ((spec combinatorial-spec))
Generic Function: compose (g a b)

Compose two elements A and B within the group G.

Package

cl-permutation.

Source

group.lisp.

Methods
Method: compose ((g perm-group) a b)
Source

permutation-group.lisp.

Method: compose ((g free-group) a b)
Source

free-group.lisp.

Method: compose ((g free-group) a (b (eql 0)))
Source

free-group.lisp.

Method: compose ((g free-group) a (b null))
Source

free-group.lisp.

Method: compose ((g free-group) (a (eql 0)) b)
Source

free-group.lisp.

Method: compose ((g free-group) (a null) b)
Source

free-group.lisp.

Generic Function: generators (g)

Return a list of the generators of G.

Package

cl-permutation.

Source

group.lisp.

Methods
Method: generators ((g perm-group))
Source

permutation-group.lisp.

Method: generators ((g free-group))
Source

free-group.lisp.

Generic Reader: homomorphism-image (hom)

Image group of the homomorphism HOM.

Package

cl-permutation.

Source

homomorphism.lisp.

Methods
Reader Method: homomorphism-image ((generator-homomorphism generator-homomorphism))

Image of the homomorphism.

Target Slot

to-group.

Reader Method: homomorphism-image ((function-homomorphism function-homomorphism))

Image of the homomorphism.

Target Slot

to-group.

Generic Reader: homomorphism-preimage (hom)

Preimage group of the homomorphism HOM.

Package

cl-permutation.

Source

homomorphism.lisp.

Methods
Reader Method: homomorphism-preimage ((generator-homomorphism generator-homomorphism))

Preimage of the homomorphism.

Target Slot

from-group.

Reader Method: homomorphism-preimage ((function-homomorphism function-homomorphism))

Preimage of the homomorphism.

Target Slot

from-group.

Generic Function: identity-element (g)

Return the identity element of the group G.

Package

cl-permutation.

Source

group.lisp.

Methods
Method: identity-element ((g perm-group))
Source

permutation-group.lisp.

Method: identity-element ((g free-group))
Source

free-group.lisp.

Generic Function: image (homomorphism object)

Compute the image of object OBJECT with respect to the homomorphism HOMOMORPHISM.

Package

cl-permutation.

Source

homomorphism.lisp.

Methods
Method: image ((hom generator-homomorphism) (elt perm))

Given a homomorphism HOM, compute the image of ELT.

Method: image ((hom function-homomorphism) obj)
Method: image ((hom function) object)
Generic Function: inverse (g a)

Compute the inverse of A within the group G.

Package

cl-permutation.

Source

group.lisp.

Methods
Method: inverse ((g perm-group) a)
Source

permutation-group.lisp.

Method: inverse ((g free-group) a)
Source

free-group.lisp.

Generic Function: num-generators (g)

Return the number of generators of the group G.

Package

cl-permutation.

Source

group.lisp.

Methods
Method: num-generators ((g perm-group))
Source

permutation-group.lisp.

Method: num-generators ((g free-group))
Source

free-group.lisp.

Generic Reader: radix (object)
Package

cl-permutation.

Methods
Reader Method: radix ((mixed-radix-spec mixed-radix-spec))

automatically generated reader method

Source

combinatorial-ranking.lisp.

Target Slot

radix.

Reader Method: radix ((radix-spec radix-spec))

automatically generated reader method

Source

combinatorial-ranking.lisp.

Target Slot

radix.

Generic Function: rank (spec set)

Rank the set SET to an integer according to the spec SPEC.

Package

cl-permutation.

Source

combinatorial-ranking.lisp.

Methods
Method: rank ((spec word-spec) set)
Method: rank ((spec combination-spec) set)
Method: rank ((spec perm-spec) set)
Method: rank ((spec mixed-radix-spec) set)
Method: rank ((spec radix-spec) set)
Generic Reader: size (object)
Package

cl-permutation.

Methods
Reader Method: size ((combinatorial-spec combinatorial-spec))

automatically generated reader method

Source

combinatorial-ranking.lisp.

Target Slot

size.

Generic Function: unrank (spec idx &key set)

Unrank the integer rank IDX according to SPEC. If SET is provided, such a vector will be filled. Otherwise, one will be allocated. (Beware: SET must be a vector of an appropriate size.)

Package

cl-permutation.

Source

combinatorial-ranking.lisp.

Methods
Method: unrank ((spec word-spec) (idx integer) &key set)
Method: unrank ((spec combination-spec) (idx integer) &key set)
Method: unrank ((spec perm-spec) (idx integer) &key set)
Method: unrank ((spec mixed-radix-spec) (idx integer) &key set)
Method: unrank ((spec radix-spec) (idx integer) &key set)

5.1.5 Standalone methods

Method: initialize-instance :after ((hom homomorphism) &key)
Source

homomorphism.lisp.

Method: make-load-form ((object-0 slp-element) &optional environment-3)
Source

straight-line-program.lisp.

Method: make-load-form ((object-0 slp-inversion) &optional environment-3)
Source

straight-line-program.lisp.

Method: make-load-form ((object-0 slp-symbol) &optional environment-3)
Source

straight-line-program.lisp.

Method: make-load-form ((object-0 slp-composition) &optional environment-3)
Source

straight-line-program.lisp.

Method: print-object ((object cycle) stream)
Source

permutation.lisp.

Method: print-object ((object slp-element) stream)
Source

straight-line-program.lisp.

Method: print-object ((object perm) stream)
Source

permutation.lisp.

Method: print-object ((group perm-group) stream)
Source

permutation-group.lisp.

Method: print-object ((object slp-inversion) stream)
Source

straight-line-program.lisp.

Method: print-object ((object slp-symbol) stream)
Source

straight-line-program.lisp.

Method: print-object ((object slp-composition) stream)
Source

straight-line-program.lisp.

Method: print-object ((object djs) stream)
Source

block.lisp.

Method: print-object ((object djs-rep) stream)
Source

block.lisp.

Method: print-object ((obj minkwitz-table) stream)
Source

minkwitz.lisp.


5.1.6 Structures

Structure: cycle
Package

cl-permutation.

Source

permutation.lisp.

Direct superclasses

structure-object.

Direct methods

print-object.

Direct slots
Slot: canonicalized
Type

boolean

Readers

cycle-canonicalized.

Writers

(setf cycle-canonicalized).

Slot: rep
Type

(vector cl-permutation:cycle-element)

Initform

#()

Readers

cycle-rep.

Writers

(setf cycle-rep).

Structure: perm
Package

cl-permutation.

Source

permutation.lisp.

Direct superclasses

structure-object.

Direct methods
Direct slots
Slot: rep
Type

cl-permutation::raw-perm

Initform

(cl-permutation::iota-vector 1)

Readers

perm.rep.

Writers

This slot is read-only.

Structure: slp
Package

cl-permutation.

Source

straight-line-program.lisp.

Direct superclasses

algebraic-data-type.

Direct subclasses
Structure: slp-composition
Package

cl-permutation.

Source

straight-line-program.lisp.

Direct superclasses

slp.

Direct methods
Direct slots
Slot: %0
Package

cl-algebraic-data-type.

Type

cl-permutation:slp

Initform

(error "unspecified field.")

Readers

slp-composition%0.

Writers

This slot is read-only.

Slot: %1
Package

cl-algebraic-data-type.

Type

cl-permutation:slp

Initform

(error "unspecified field.")

Readers

slp-composition%1.

Writers

This slot is read-only.

Structure: slp-element
Package

cl-permutation.

Source

straight-line-program.lisp.

Direct superclasses

slp.

Direct methods
Direct slots
Slot: %0
Package

cl-algebraic-data-type.

Initform

(error "unspecified field.")

Readers

slp-element%0.

Writers

This slot is read-only.

Structure: slp-inversion
Package

cl-permutation.

Source

straight-line-program.lisp.

Direct superclasses

slp.

Direct methods
Direct slots
Slot: %0
Package

cl-algebraic-data-type.

Type

cl-permutation:slp

Initform

(error "unspecified field.")

Readers

slp-inversion%0.

Writers

This slot is read-only.

Structure: slp-symbol
Package

cl-permutation.

Source

straight-line-program.lisp.

Direct superclasses

slp.

Direct methods
Direct slots
Slot: %0
Package

cl-algebraic-data-type.

Type

symbol

Initform

(error "unspecified field.")

Readers

slp-symbol%0.

Writers

This slot is read-only.


Next: , Previous: , Up: Public Interface   [Contents][Index]

5.1.7 Classes

Class: combination-spec

Representation of a sequence

Package

cl-permutation.

Source

combinatorial-ranking.lisp.

Direct superclasses

combinatorial-spec.

Direct methods
Direct slots
Slot: zero-count
Initargs

:zero-count

Readers

comb.zero-count.

Writers

This slot is read-only.

Class: combinatorial-spec

Abstract class representing linear sequences of objects of size SIZE.

Package

cl-permutation.

Source

combinatorial-ranking.lisp.

Direct subclasses
Direct methods
Direct slots
Slot: cardinality-cache
Type

(or null unsigned-byte)

Readers

cardinality-cache.

Writers

(setf cardinality-cache).

Slot: size
Initargs

:size

Readers

size.

Writers

This slot is read-only.

Class: free-group

Representation of a free group whose symbols are:

* identity element: 0
* generators: 1 .. N
* inverse generators: -N .. -1

Elements of the group are either individual integers or lists thereof. The lists represent compositions of generators. The BNF grammar looks something like:

<free group generator> := 1 | 2 | ... | N
<free group atom> := <free group generator>
| 0
| -<free group generator>
<free group element> := <free group atom>
| ( <free group atom>* )

An empty list corresponds to an empty composition, which is identity (0).

Package

cl-permutation.

Source

free-group.lisp.

Direct methods
Direct slots
Slot: num-generators
Initargs

:num-generators

Readers

free-group-num-generators.

Writers

This slot is read-only.

Class: function-homomorphism

Simple class which wraps homomorphic functions, associating them with the preimage and image of the function.

Package

cl-permutation.

Source

homomorphism.lisp.

Direct superclasses

homomorphism.

Direct methods
Direct slots
Slot: from-group

Preimage of the homomorphism.

Initargs

:from-group

Readers

homomorphism-preimage.

Writers

This slot is read-only.

Slot: to-group

Image of the homomorphism.

Initargs

:to-group

Readers

homomorphism-image.

Writers

This slot is read-only.

Slot: function

Homomorphism function.

Package

common-lisp.

Initargs

:function

Readers

homomorphism-function.

Writers

This slot is read-only.

Class: generator-homomorphism

A perm group homomorphism constructed from images of its genertators.

This class is FUNCALLable.

Package

cl-permutation.

Source

homomorphism.lisp.

Direct superclasses

homomorphism.

Direct methods
Direct slots
Slot: from-group

Preimage of the homomorphism.

Initargs

:from-group

Readers

homomorphism-preimage.

Writers

This slot is read-only.

Slot: to-group

Image of the homomorphism.

Initargs

:to-group

Readers

homomorphism-image.

Writers

This slot is read-only.

Slot: generator-map

A unary function mapping generators of FROM-GROUP to objects of the resulting group TO-GROUP.

Initargs

:generator-map

Readers

homomorphism-generator-map.

Writers

This slot is read-only.

Class: mixed-radix-spec

Representation of a mixed-radix number of size SIZE with mixed radix RADIX.

Package

cl-permutation.

Source

combinatorial-ranking.lisp.

Direct superclasses

combinatorial-spec.

Direct methods
Direct slots
Slot: radix
Initargs

:radix

Readers

radix.

Writers

This slot is read-only.

Class: perm-group

Representation of a permutation group generated by a finite number of generators.

Package

cl-permutation.

Source

permutation-group.lisp.

Direct methods
Direct slots
Slot: element-size

The size of the elements of the group. This is a non-negative integer and may be larger than the true degree of the group.

Initargs

:element-size

Readers

perm-group.element-size.

Writers

(setf perm-group.element-size).

Slot: generators

A list of generators of the group.

Initargs

:generators

Readers

perm-group.generators.

Writers

(setf perm-group.generators).

Slot: strong-generators

The strong generating set of the group. This is a vector mapping integers to lists of generators which generate the i’th stabilizer.

Initargs

:strong-generators

Readers

perm-group.strong-generators.

Writers

(setf perm-group.strong-generators).

Slot: transversal-system

The transversal system of the group. This is a vector mapping integers K to a table of sigmas SIGMA_K. Every permutation in the group can be represented by a product of permutations SIGMA_K * ... * SIGMA_2 * SIGMA_1.

Initargs

:transversal-system

Readers

perm-group.transversal-system.

Writers

(setf perm-group.transversal-system).

Slot: free-group

A free group corresponding to the given permutation group.

Initargs

:free-group

Readers

perm-group.free-group.

Writers

(setf perm-group.free-group).

Slot: factorization-generators

A vector whose length is the same length as the base of the group, whose values are vectors of free-group elements that are coset representatives of the stabilizer G^(i+1)/G^(i). This collection of generators is *also* a strong generating set. This is optionally computed with #’COMPUTE-FACTORIZATION-GENERATORS.

Initargs

:factorization-generators

Readers

perm-group.factorization-generators.

Writers

(setf perm-group.factorization-generators).

Slot: slp-context

SLPs corresponding to all sigmas and strong generators.

Initargs

:slp-context

Readers

perm-group.slp-context.

Writers

(setf perm-group.slp-context).

Class: perm-spec

Representation of a perm of size SIZE. Canonically this is a permutation of the set {1, ..., SIZE}. (Though it’s possible to rank the permutation of any subset of numbers.)

Package

cl-permutation.

Source

combinatorial-ranking.lisp.

Direct superclasses

combinatorial-spec.

Direct methods
Class: radix-spec

Representation of a sequence of numbers of length SIZE whose elements are between 0 and RADIX - 1.

Package

cl-permutation.

Source

combinatorial-ranking.lisp.

Direct superclasses

combinatorial-spec.

Direct methods
Direct slots
Slot: radix
Initargs

:radix

Readers

radix.

Writers

This slot is read-only.

Class: slp-context

Represents a context (e.g., symbol assignments) in which an SLP can be evaluated.

Package

cl-permutation.

Source

straight-line-program.lisp.

Direct methods
Direct slots
Slot: symbol-table

A mapping between symbols and their representation as SLPs.

Initform

(make-hash-table :test (quote eq))

Readers

symbol-table.

Writers

(setf symbol-table).

Class: word-spec

Representation of a word of elements 1 to TYPES.

Package

cl-permutation.

Source

combinatorial-ranking.lisp.

Direct superclasses

combinatorial-spec.

Direct methods
Direct slots
Slot: types

Non-negative integer representing the number of distinct elements within the word. Note that this will include the additional zero type, even though there are never any zero elements.

Initargs

:types

Readers

word.types.

Writers

This slot is read-only.

Slot: type-counts

Vector of non-negative integers representing the count of each individual element type. (The sum of this vector should equal TYPES.)

Initargs

:type-counts

Readers

word.type-counts.

Writers

This slot is read-only.


Previous: , Up: Public Interface   [Contents][Index]

5.1.8 Types

Type: cycle-element ()

An element of a cycle.

Package

cl-permutation.

Source

permutation.lisp.

Type: perm-element ()

An element of a perm.

Package

cl-permutation.

Source

permutation.lisp.


5.2 Internals


Next: , Previous: , Up: Internals   [Contents][Index]

5.2.1 Special variables

Special Variable: *context*

Special variable used to hold the context being built up for a group.

Package

cl-permutation.

Source

permutation-group.lisp.

Special Variable: *perm-group-verbose*
Package

cl-permutation.

Source

permutation-group.lisp.

Special Variable: *print-with-perm-syntax*

Print permutations with special permutation syntax?

Package

cl-permutation.

Source

permutation.lisp.

Special Variable: *taus*

Special variable used to hold a mapping between permutation objects (by EQ) to a symbol (one generated by #’TAU-SYMBOL) which is referred to by the SLP context.

Package

cl-permutation.

Source

permutation-group.lisp.


5.2.2 Ordinary functions

Function: %djs-and-rep-printer (s stream depth)
Package

cl-permutation.

Source

block.lisp.

Function: %make-coord (&key order rank)
Package

cl-permutation.

Source

block.lisp.

Function: %make-cycle (&key canonicalized rep)
Package

cl-permutation.

Source

permutation.lisp.

Function: %make-djs (&key representative value)
Package

cl-permutation.

Source

block.lisp.

Function: %make-djs-rep (&key djs)
Package

cl-permutation.

Source

block.lisp.

Function: %make-perm (&key rep)
Package

cl-permutation.

Source

permutation.lisp.

Function: %make-queue (&key elements last)
Package

cl-permutation.

Source

utilities.lisp.

Function: %make-system (base orbit-lengths)
Package

cl-permutation.

Source

minkwitz.lisp.

Function: %perm-compose-into/equal ()
Package

cl-permutation.

Source

permutation.lisp.

Function: %perm-compose-into/unequal ()
Package

cl-permutation.

Source

permutation.lisp.

Function: %perm-compose-upto (p1 p2 n)
Package

cl-permutation.

Source

permutation.lisp.

Function: %system-size (ν)
Package

cl-permutation.

Source

minkwitz.lisp.

Function: %word-generator (num-generators)

Return a lambda function taking a non-negative integer N and returning the Nth word in a sequence which enumerates all words of NUM-GENERATORS generators.

Package

cl-permutation.

Source

free-group.lisp.

Function: abs> (x y)
Package

cl-permutation.

Source

permutation-generation.lisp.

Function: add-generator (perm sgs trans k slp)
Package

cl-permutation.

Source

permutation-group.lisp.

Function: allocate-perm-vector (n)

Allocate a vector compatible with a size-N permutation.

Package

cl-permutation.

Source

permutation.lisp.

Function: array-for-spec (spec &key initial-element)
Package

cl-permutation.

Source

combinatorial-ranking.lisp.

Function: assert-valid-permutation-elements (elements)

Verify (via assertions) that the elements

Package

cl-permutation.

Source

permutation.lisp.

Function: atkinson (ω gs)

M. D. Atkinson’s original algorithm as specified in his original paper "An Algorithm for Finding Blocks of a Permutation Group", with very light modifications.

Given a point ω and a list of generators GS, return an array F whose size is max deg(gs), and whose elements are specified as follows:

If a point p appears in F, then the minimal block containing p is the list of all positions of p in F.

Package

cl-permutation.

Source

block.lisp.

Function: binomial-coefficient-or-zero (n k)

If N < K, return 0, otherwise return the binomial coefficient.

Package

cl-permutation.

Source

combinatorial-ranking.lisp.

Function: block-coordinate-transformation-p (object)
Package

cl-permutation.

Source

block.lisp.

Function: block-slot (subsys blk)

In which slot is BLK found in the block subsystem BLOCK-SUBSYSTEM?

Package

cl-permutation.

Source

block.lisp.

Reader: block-subsystem-base-block (instance)
Writer: (setf block-subsystem-base-block) (instance)
Package

cl-permutation.

Source

block.lisp.

Target Slot

base-block.

Reader: block-subsystem-block-size (instance)
Writer: (setf block-subsystem-block-size) (instance)
Package

cl-permutation.

Source

block.lisp.

Target Slot

block-size.

Reader: block-subsystem-group (instance)
Writer: (setf block-subsystem-group) (instance)
Package

cl-permutation.

Source

block.lisp.

Target Slot

group.

Function: block-subsystem-interblock-group (subsys)

Compute the interblock group of a block subsystem SUBSYS.

Package

cl-permutation.

Source

block.lisp.

Function: block-subsystem-interblock-group-homomorphism (subsys)

Given a block subsystem SUBSYS, compute a homomorphism to its interblock group.

Package

cl-permutation.

Source

block.lisp.

Function: block-subsystem-intrablock-group (subsys)
Package

cl-permutation.

Source

block.lisp.

Function: block-subsystem-intrablock-group-generators (subsys)

Compute (possibly redundant) generators of the intrablock group, along with the computed reference frames.

Package

cl-permutation.

Source

block.lisp.

Reader: block-subsystem-orbit (instance)
Writer: (setf block-subsystem-orbit) (instance)
Package

cl-permutation.

Source

block.lisp.

Target Slot

orbit.

Function: block-subsystem-p (object)
Package

cl-permutation.

Source

block.lisp.

Reader: block-subsystem-size (instance)
Writer: (setf block-subsystem-size) (instance)
Package

cl-permutation.

Source

block.lisp.

Target Slot

size.

Function: canonicalize-raw-block-subsystems (bss)

Take a raw list of block systems BSS and canonicalize them.

Package

cl-permutation.

Source

block.lisp.

Function: check-cycle-elements (elements)

Ensure that the elements ELEMENTS are those of a valid cycle.

Package

cl-permutation.

Source

permutation.lisp.

Function: clear-membership-set (set)
Package

cl-permutation.

Source

utilities.lisp.

Function: commutesp (a b)

Do the permutations A and B commute?

Package

cl-permutation.

Source

permutation.lisp.

Function: compute-factorization-generators (group)

Modify the permutation group PERM-GROUP so that it is capable of factorizing elements into generators.

Package

cl-permutation.

Source

minkwitz.lisp.

Function: compute-god-table (group &key target generators rank-cardinality rank-element verbose)
Package

cl-permutation.

Source

god.lisp.

Function: contains-1-to-n (elements)

Check that ELEMENTS contains the integers between 1 and the length of the sequence, inclusive.

Package

cl-permutation.

Source

permutation.lisp.

Reader: coord.order (instance)
Writer: (setf coord.order) (instance)
Package

cl-permutation.

Source

block.lisp.

Target Slot

order.

Reader: coord.rank (instance)
Writer: (setf coord.rank) (instance)
Package

cl-permutation.

Source

block.lisp.

Target Slot

rank.

Function: copy-block-coordinate-transformation (instance)
Package

cl-permutation.

Source

block.lisp.

Function: copy-block-subsystem (instance)
Package

cl-permutation.

Source

block.lisp.

Function: copy-cycle (instance)
Package

cl-permutation.

Source

permutation.lisp.

Function: copy-djs (instance)
Package

cl-permutation.

Source

block.lisp.

Function: copy-djs-rep (instance)
Package

cl-permutation.

Source

block.lisp.

Function: copy-god-table-entry (instance)
Package

cl-permutation.

Source

god.lisp.

Function: copy-perm (instance)
Package

cl-permutation.

Source

permutation.lisp.

Function: copy-queue (instance)
Package

cl-permutation.

Source

utilities.lisp.

Reader: cycle-canonicalized (instance)
Writer: (setf cycle-canonicalized) (instance)
Package

cl-permutation.

Source

permutation.lisp.

Target Slot

canonicalized.

Function: cycle-p (object)
Package

cl-permutation.

Source

permutation.lisp.

Reader: cycle-rep (instance)
Writer: (setf cycle-rep) (instance)
Package

cl-permutation.

Source

permutation.lisp.

Target Slot

rep.

Function: dequeue (queue)

Remove and return an element from the queue QUEUE.

Package

cl-permutation.

Source

utilities.lisp.

Function: djs (value)

Construct a fresh DJS node.

Package

cl-permutation.

Source

block.lisp.

Function: djs-change-representative (djs)

Change the representative of DJS to point to itself.

Package

cl-permutation.

Source

block.lisp.

Function: djs-find (d)

Find the canonical DJS node of which the DJS node D is a part.

Package

cl-permutation.

Source

block.lisp.

Function: djs-p (object)
Package

cl-permutation.

Source

block.lisp.

Reader: djs-rep-djs (instance)
Writer: (setf djs-rep-djs) (instance)
Package

cl-permutation.

Source

block.lisp.

Target Slot

djs.

Function: djs-rep-p (object)
Package

cl-permutation.

Source

block.lisp.

Reader: djs-representative (instance)
Writer: (setf djs-representative) (instance)
Package

cl-permutation.

Source

block.lisp.

Target Slot

representative.

Function: djs-union (a b)

Link together the DJS nodes A and B.

The representative of the union will be that of B.

Package

cl-permutation.

Source

block.lisp.

Reader: djs-value (instance)
Writer: (setf djs-value) (instance)
Package

cl-permutation.

Source

block.lisp.

Target Slot

value.

Function: enqueue (queue obj)

Add an element OBJ to the end of the queue QUEUE.

Package

cl-permutation.

Source

utilities.lisp.

Function: entry (seen word)
Package

cl-permutation.

Source

minkwitz.lisp.

Reader: entry-seen (instance)
Writer: (setf entry-seen) (instance)
Package

cl-permutation.

Source

minkwitz.lisp.

Target Slot

seen.

Reader: entry-word (instance)
Package

cl-permutation.

Source

minkwitz.lisp.

Target Slot

word.

Function: exists-mobile-p (perm len)
Package

cl-permutation.

Source

permutation-generation.lisp.

Function: free-group->perm-group-homomorphism (free-group perm-group)

Construct a homomorphism from the perm group PERM-GROUP’s free group to elements of the perm group itself.

Package

cl-permutation.

Source

permutation-group.lisp.

Function: free-group-element-valid-p (g element)

Given the free group G and some purported element ELEMENT, return a boolean indicating whether it is a valid element of G.

Package

cl-permutation.

Source

free-group.lisp.

Function: free-group-generator-to-perm-group-generator (perm-group free-group-generator)

Convert the free group generator FREE-GROUP-GENERATOR to a generator within the perm group PERM-GROUP.

Package

cl-permutation.

Source

permutation-group.lisp.

Function: generate-minkwitz-table (group &key min-rounds improve-every improve-max-tries initial-length-limit growth-factor simplifier word-generator)

Generate a MINKWITZ-TABLE suitable for decomposing elements of GROUP into its generators (+ inverses).

The arguments are:

GROUP: A permutation group.

MIN-ROUNDS: The *minimum* number of words to search. (Setting this number larger implies more time will be spent searching for short generators.)

IMPROVE-EVERY: A positive fixnum indicating the number of words that should be searched for before an improvement step occurs. ("Improvement" can be quite time-consuming for groups whose stabilizers have a large number of generators—roughly quadratic. On the other hand, improving too infrequently may cause the table to take a long time to fill.)

IMPROVE-MAX-TRIES (optional): The maximum number of new element pairs should be used to improve the table during improvement. (Lowering this number to say 10000 might make table generation faster at the expense of shorter words.)

INITIAL-LENGTH-LIMIT: The algorithm prunes sequences which are too long (especially after composition). What should be the initial limit of the length be? (Setting this too low means that the table will take longer to fill. Setting it too high means that longer words will be stored earlier. It is a little counterintuitive, but sometimes storing longer words earlier can lead to shorter lengths overall.)

GROWTH-FACTOR: After every IMPROVE-EVERY rounds, by what factor should the length limit be grown? (If this number is too small, then the table will take longer to fill up, but it will more aggressively search for shorter words. If this number is too large, the length limit is meaningless.)

SIMPLIFIER: A function mapping words to words. Should simplify the words. (IDENTITY is a valid simplifier.) (Default is a group-aware word simplifier taking into account generator orders and commutation relations.)

WORD-GENERATOR: A function taking a count and a length and produces a word. (These arguments need not be respected in any way.) By default, this will be set to a word generator that scans through all words in a breadth-first order. (Note that the simplifier will *not* be used automatically, unless the default generator is used.)

Package

cl-permutation.

Source

minkwitz.lisp.

Function: generator-exponent-set (g)

Return a combinatorial specification suitable for searching for subgroups of the group G.

The specification specifies vectors of exponents to the group’s generators, which may be used to generate some subgroups of the group.

Package

cl-permutation.

Source

find-subgroups.lisp.

Function: generator-orders (g)

Return the orders of each generator of the group G.

Package

cl-permutation.

Source

find-subgroups.lisp.

Reader: god-table-entry-came-from (instance)
Writer: (setf god-table-entry-came-from) (instance)
Package

cl-permutation.

Source

god.lisp.

Target Slot

came-from.

Reader: god-table-entry-depth (instance)
Writer: (setf god-table-entry-depth) (instance)
Package

cl-permutation.

Source

god.lisp.

Target Slot

depth.

Reader: god-table-entry-move (instance)
Writer: (setf god-table-entry-move) (instance)
Package

cl-permutation.

Source

god.lisp.

Target Slot

move.

Function: god-table-entry-p (object)
Package

cl-permutation.

Source

god.lisp.

Reader: god-table-entry-transition (instance)
Writer: (setf god-table-entry-transition) (instance)
Package

cl-permutation.

Source

god.lisp.

Target Slot

transition.

Function: group-block-subsystems (group)

Return a list of block subsystems of the group GROUP.

Package

cl-permutation.

Source

block.lisp.

Function: group-bsgs (perm-group)

Retrieve a base and associated strong generating set (BSGS) as two values respectively for the permutation group PERM-GROUP.

Package

cl-permutation.

Source

permutation-group.lisp.

Function: group-element-from-signature (group signature)
Package

cl-permutation.

Source

do-group-elements.lisp.

Function: group-radix (group)

Compute the radix of the group GROUP.

Package

cl-permutation.

Source

do-group-elements.lisp.

Function: intrablock-coordinate-function (subsys)
Package

cl-permutation.

Source

block.lisp.

Function: iota (n)

Generate a list of numbers between 0 and N-1.

Package

cl-permutation.

Source

utilities.lisp.

Function: iota+1 (n)

Generate a list of numbers between 1 and N.

Package

cl-permutation.

Source

utilities.lisp.

Function: iota-vector (n)

Generate the equivalent of (COERCE (IOTA N) ’VECTOR).

Package

cl-permutation.

Source

utilities.lisp.

Function: last-to-position (size new-pos)

Create a permutation that will permute the last element of a permutation of size SIZE to the position NEW-POS.

Package

cl-permutation.

Source

extra-functions.lisp.

Function: list-minimum (list)

Find the minimum element of the list via CL:MIN.

Package

cl-permutation.

Source

utilities.lisp.

Function: list-to-queue (list)

Convert the list LIST into a queue. Note: LIST may be modified.

Package

cl-permutation.

Source

utilities.lisp.

Function: make-block-subsystem (&key group base-block size block-size orbit)
Package

cl-permutation.

Source

block.lisp.

Function: make-god-table-entry (&key move came-from depth transition)
Package

cl-permutation.

Source

god.lisp.

Function: make-membership-set (size)
Package

cl-permutation.

Source

utilities.lisp.

Function: make-queue ()

Create a new empty queue.

Package

cl-permutation.

Source

utilities.lisp.

Function: make-sgs (n)

Make a strong generating set of size N.

Package

cl-permutation.

Source

permutation-group.lisp.

Function: make-sigma-table (k &optional identity)

Make a representation of sigma_K, initialized witk sigma_KK = identity.

The optional argument IDENTITY allows the caller to provide the identity permutation for sigma_kk.

This is represented as an alist mapping J to permutations sigma_KJ.

Package

cl-permutation.

Source

permutation-group.lisp.

Function: make-subsystem-transformations (subsys)
Package

cl-permutation.

Source

block.lisp.

Function: make-transversal (n)

Make a transversal of size N.

Package

cl-permutation.

Source

permutation-group.lisp.

Function: map-cycle-mappings (f cycle &key omit-last)

Apply a binary function F to all pairs (a_i, b_i) such that the cycle is the composition of a_i |-> b_i.

If OMIT-LAST is T, then the last mapping will be omitted. For example, for the cycle (P1 P2 ... Pn), the mapping Pn |-> P1 will be excluded.

Package

cl-permutation.

Source

permutation.lisp.

Function: map-exponent-subgroups (f group)

Map the unary function F across all exponent subgroups of the group GROUP.

Package

cl-permutation.

Source

find-subgroups.lisp.

Function: map-into-perm (function perm-spec)
Package

cl-permutation.

Source

permutation-generation.lisp.

Function: map-orbit (f n perm)

Given a unary function F, apply it to each element of the orbit of N within the perm PERM.

Package

cl-permutation.

Source

permutation.lisp.

Function: map-suitable-subgroups (f group)

Map the unary function F across all suitable subgroups of the group GROUP.

Package

cl-permutation.

Source

find-subgroups.lisp.

Function: mark-entry-as-seen (x)
Package

cl-permutation.

Source

minkwitz.lisp.

Function: maximum (list &key key)

Compute the maximum of LIST, optionally via the function KEY.

Package

cl-permutation.

Source

utilities.lisp.

Function: membership-set-count (set)
Package

cl-permutation.

Source

utilities.lisp.

Function: membership-set-nunion (set-a set-b)
Package

cl-permutation.

Source

utilities.lisp.

Function: membership-sets-intersect-p (set-a set-b)
Package

cl-permutation.

Source

utilities.lisp.

Function: minkwitz-table-distribution (m)

what is the distribution of word lengths for a given Minkwitz table M? Return a vector V such that (AREF V L) gives the proportion of decompositions that are length L.

Package

cl-permutation.

Source

minkwitz.lisp.

Function: minkwitz-table-num-words (m)

How many words are represented by the Minkwitz table M?

Package

cl-permutation.

Source

minkwitz.lisp.

Function: mobilep (idx perm &optional len)
Package

cl-permutation.

Source

permutation-generation.lisp.

Function: new-entry (x)
Package

cl-permutation.

Source

minkwitz.lisp.

Function: next-perm (perm len)
Package

cl-permutation.

Source

permutation-generation.lisp.

Function: nshuffle (vector &key parity start)

Shuffle the permutation vector VECTOR with specified parity PARITY. PARITY may be

* :ANY for any permutation
* :EVEN for only even permutations
* :ODD for only odd permutations

START specifies the starting index where elements should be shuffled.

Package

cl-permutation.

Source

utilities.lisp.

Function: partition-if (f seq)

Given a predicate F, partition SEQ into two sublists, the first of which has elements that satisfy F, the second which do not.

Package

cl-permutation.

Source

utilities.lisp.

Function: perm-eject (perm)

Remove the largest element of a permutation.

Package

cl-permutation.

Source

extra-functions.lisp.

Function: perm-extend (perm &optional n)

Extend a permutation PERM

Package

cl-permutation.

Source

extra-functions.lisp.

Function: perm-inject (perm inject-to)

For a permutation PERM of size N, inject N+1 to the position INJECT-TO.

Package

cl-permutation.

Source

extra-functions.lisp.

Function: perm-p (object)
Package

cl-permutation.

Source

permutation.lisp.

Function: perm-reader (stream char n)
Package

cl-permutation.

Source

permutation.lisp.

Reader: perm.rep (instance)
Package

cl-permutation.

Source

permutation.lisp.

Target Slot

rep.

Function: permuter (from to &key test)

Compute a permutation P such that (PERMUTE P FROM) == TO.

Package

cl-permutation.

Source

permutation.lisp.

Function: print-cycle (cycle stream depth)

Printer for cycles.

An asterisk in printed syntax denotes that the cycle has not been canonicalized (though it may be already be canonical).

Package

cl-permutation.

Source

permutation.lisp.

Function: print-perm (perm stream depth)

Printer for perms.

Package

cl-permutation.

Source

permutation.lisp.

Function: product (seq &key key)

Compute the product of the items in SEQ, optionally via the function KEY.

Package

cl-permutation.

Source

utilities.lisp.

Reader: queue-elements (instance)
Writer: (setf queue-elements) (instance)
Package

cl-permutation.

Source

utilities.lisp.

Target Slot

elements.

Function: queue-empty-p (queue)

Is the queue QUEUE empty?

Package

cl-permutation.

Source

utilities.lisp.

Reader: queue-last (instance)
Writer: (setf queue-last) (instance)
Package

cl-permutation.

Source

utilities.lisp.

Target Slot

last.

Function: queuep (object)
Package

cl-permutation.

Source

utilities.lisp.

Function: random-between (a b)

Generate a random integer between A and B, inclusive.

Package

cl-permutation.

Source

utilities.lisp.

Function: random-element (seq)

Select a random element from the sequence SEQ.

Package

cl-permutation.

Source

utilities.lisp.

Function: random-word-generator (n)
Package

cl-permutation.

Source

free-group.lisp.

Function: raw-block-subsystems (group &key canonicalize)

Compute all minimal, disjoint block subsystems of the group GROUP.

Returns a list of block systems.

Package

cl-permutation.

Source

block.lisp.

Function: reduce-over-trans-decomposition (f initial-value perm trans &optional k)

Reduce F over the transversal decomposition of PERM within the transversal system TRANS. Return two values:

1. The result of folding over, or NIL if no decomposition exists.
2. NIL iff no decomposition exists.

F is a function of three arguments:

ACCUM: The "accumulator" argument. INITIAL-VALUE is the initial value of this argument.
K, J : Two arguments representing the sigma.

N.B.! The sigma_kj are visited in "right-to-left" compositional order. That is, if S1, S2, ..., Sk are visited sequentially, then PERM is the composition Sk * ... * S2 * S1.

Package

cl-permutation.

Source

permutation-group.lisp.

Function: reverse-direction (idx perm)
Package

cl-permutation.

Source

permutation-generation.lisp.

Function: rotate-vector! (vec n)

Rotate the vector VEC a total of N elements left/counterclockwise in-place. If N is negative, rotate in the opposite direction.

Package

cl-permutation.

Source

permutation.lisp.

Function: sgs-ref (sgs k)
Package

cl-permutation.

Source

permutation-group.lisp.

Function: (setf sgs-ref) (sgs k)
Package

cl-permutation.

Source

permutation-group.lisp.

Function: sigma (trans k j)

Retrieve sigma_kj for the transversal system TRANS, or NIL if it doesn’t exist.

Package

cl-permutation.

Source

permutation-group.lisp.

Function: (setf sigma) (trans k j)
Package

cl-permutation.

Source

permutation-group.lisp.

Function: sigma-symbol (k j)

Return a symbol representing sigma_kj. This is used for perms that are added to the transversal system during group construction.

Package

cl-permutation.

Source

permutation-group.lisp.

Function: sign (x)

Return the sign of X.

Package

cl-permutation.

Source

utilities.lisp.

Function: singletonp (x)

Does X contain one element?

Package

cl-permutation.

Source

utilities.lisp.

Reader: slp-composition%0 (instance)
Package

cl-permutation.

Source

straight-line-program.lisp.

Target Slot

%0.

Reader: slp-composition%1 (instance)
Package

cl-permutation.

Source

straight-line-program.lisp.

Target Slot

%1.

Reader: slp-element%0 (instance)
Package

cl-permutation.

Source

straight-line-program.lisp.

Target Slot

%0.

Reader: slp-inversion%0 (instance)
Package

cl-permutation.

Source

straight-line-program.lisp.

Target Slot

%0.

Reader: slp-symbol%0 (instance)
Package

cl-permutation.

Source

straight-line-program.lisp.

Target Slot

%0.

Function: solve-and-verify (group solver element &key move-printer)
Package

cl-permutation.

Source

block.lisp.

Function: stabilizer-orbits (group)

Compute a list of orbits corresponding to the BSGS of GROUP. In particular, calculate { i ↦ G⁽ⁱ⁾bᵢ₊₁ }.

Package

cl-permutation.

Source

minkwitz.lisp.

Function: subgroup-from-exponent-vector (g v)

Generate a subgroup of the group G given the exponent vector V (which was possibly generated by some combinatorial spec, perhaps via #’GENERATOR-EXPONENT-SET).

Package

cl-permutation.

Source

find-subgroups.lisp.

Function: subsystem-solver (group &key verbose)
Package

cl-permutation.

Source

block.lisp.

Function: suitable-subgroup-p (g)

Is the group G (which is presumably a subgroup of some other group) suitable for further computation?

Package

cl-permutation.

Source

find-subgroups.lisp.

Function: tau-symbol ()

Return a freshly made symbol for tau.

Package

cl-permutation.

Source

permutation-group.lisp.

Function: trans-decomposition (perm trans &optional k)

Decompose PERM into a list of sigmas within the transversal system TRANS. The composition of the sigmas equals the original perm up to K.

The sigma (SIGMA K J) is represented by the cons cell (K . J).

Package

cl-permutation.

Source

permutation-group.lisp.

Function: trans-element-p (perm trans &optional k)
Package

cl-permutation.

Source

permutation-group.lisp.

Function: transversal-ref (trans k)

Get the Kth element of the transversal TRANS. This is representative of all sigma_k.

Package

cl-permutation.

Source

permutation-group.lisp.

Function: (setf transversal-ref) (trans k)
Package

cl-permutation.

Source

permutation-group.lisp.

Function: trivial-block-system-p (bs)

Is the block system BS a trivial block system?

Package

cl-permutation.

Source

block.lisp.

Function: unsafe/perm-eval (perm n)
Package

cl-permutation.

Source

permutation.lisp.

Function: update-transversal (perm sgs trans k slp)
Package

cl-permutation.

Source

permutation-group.lisp.

Function: upper-bound-decomposition-length (m)

What is the maximum length of a decomposition using the Minkwitz table M?

Package

cl-permutation.

Source

minkwitz.lisp.

Function: verbose ()
Package

cl-permutation.

Source

block.lisp.

Function: word-generator (group)

Return a lambda function taking a non-negative integer N and returning the Nth word in a sequence which enumerates all words of the free group GROUP.

Package

cl-permutation.

Source

free-group.lisp.

Function: word-length (w)

What is the length of the word W?

Package

cl-permutation.

Source

free-group.lisp.

Function: word-simplifier (orders commuting)

Let:

ORDERS: A vector of orders of each generator, or NIL if unknown/infinite.

COMMUTING: a vector of length N+1 where the Jth element is a list of all commuting generators of J

Then return a unary function which takes elements of G and returns simplified versions of them.

Package

cl-permutation.

Source

free-group.lisp.

Function: word-simplifier-for-perm-group (g)

Construct a simplifier for the permutation group G according to its free group.

Package

cl-permutation.

Source

permutation-group.lisp.

Function: zero-array (length)

Make an array of zeroes of length LENGTH.

Package

cl-permutation.

Source

combinatorial-ranking.lisp.


Next: , Previous: , Up: Internals   [Contents][Index]

5.2.3 Generic functions

Generic Reader: cardinality-cache (object)
Package

cl-permutation.

Methods
Reader Method: cardinality-cache ((combinatorial-spec combinatorial-spec))

automatically generated reader method

Source

combinatorial-ranking.lisp.

Target Slot

cardinality-cache.

Generic Writer: (setf cardinality-cache) (object)
Package

cl-permutation.

Methods
Writer Method: (setf cardinality-cache) ((combinatorial-spec combinatorial-spec))

automatically generated writer method

Source

combinatorial-ranking.lisp.

Target Slot

cardinality-cache.

Generic Reader: comb.zero-count (object)
Package

cl-permutation.

Methods
Reader Method: comb.zero-count ((combination-spec combination-spec))

automatically generated reader method

Source

combinatorial-ranking.lisp.

Target Slot

zero-count.

Generic Reader: free-group-num-generators (object)
Package

cl-permutation.

Methods
Reader Method: free-group-num-generators ((free-group free-group))

automatically generated reader method

Source

free-group.lisp.

Target Slot

num-generators.

Generic Reader: god-table-generators (object)
Package

cl-permutation.

Methods
Reader Method: god-table-generators ((god-table god-table))

automatically generated reader method

Source

god.lisp.

Target Slot

generators.

Generic Reader: god-table-group (object)
Package

cl-permutation.

Methods
Reader Method: god-table-group ((god-table god-table))

automatically generated reader method

Source

god.lisp.

Target Slot

group.

Generic Reader: god-table-target (object)
Package

cl-permutation.

Methods
Reader Method: god-table-target ((god-table god-table))

automatically generated reader method

Source

god.lisp.

Target Slot

target.

Generic Reader: god-table-vector (object)
Package

cl-permutation.

Methods
Reader Method: god-table-vector ((god-table god-table))

automatically generated reader method

Source

god.lisp.

Target Slot

table.

Generic Reader: homomorphism-function (object)
Package

cl-permutation.

Methods
Reader Method: homomorphism-function ((function-homomorphism function-homomorphism))

Homomorphism function.

Source

homomorphism.lisp.

Target Slot

function.

Generic Reader: homomorphism-generator-map (object)
Package

cl-permutation.

Methods
Reader Method: homomorphism-generator-map ((generator-homomorphism generator-homomorphism))

A unary function mapping generators of FROM-GROUP to objects of the resulting group TO-GROUP.

Source

homomorphism.lisp.

Target Slot

generator-map.

Generic Reader: minkwitz-table-group (object)
Package

cl-permutation.

Methods
Reader Method: minkwitz-table-group ((minkwitz-table minkwitz-table))

The group for which this table is valid.

Source

minkwitz.lisp.

Target Slot

group.

Generic Reader: minkwitz-table-num-rounds (object)
Package

cl-permutation.

Methods
Reader Method: minkwitz-table-num-rounds ((minkwitz-table minkwitz-table))

The total number of words searched to get this table.

Source

minkwitz.lisp.

Target Slot

num-rounds.

Generic Reader: minkwitz-table-simplifier (object)
Package

cl-permutation.

Methods
Reader Method: minkwitz-table-simplifier ((minkwitz-table minkwitz-table))

The simplification function that was used during the generation of the table. (See GENERATE-MINKWITZ-TABLE.)

Source

minkwitz.lisp.

Target Slot

simplifier.

Generic Reader: minkwitz-table-system (object)
Package

cl-permutation.

Methods
Reader Method: minkwitz-table-system ((minkwitz-table minkwitz-table))

The transversal system storing strong generators as short words.

Specifically, this is a SIMPLE-VECTOR of HASH-TABLEs. The Nth element of this vector corresponds to the Nth stabilizer group of GROUP, ordered according to the group’s base. The table is a partial map ω ↦ π such that π(ω) = b, where b is the base point.

Source

minkwitz.lisp.

Target Slot

system.

Generic Reader: minkwitz-table-word-generator (object)
Package

cl-permutation.

Methods
Reader Method: minkwitz-table-word-generator ((minkwitz-table minkwitz-table))

The word-generating function that was used during the creation of this table. (See GENERATE-MINKWITZ-TABLE.)

Source

minkwitz.lisp.

Target Slot

word-generator.

Generic Reader: perm-group.element-size (object)
Generic Writer: (setf perm-group.element-size) (object)
Package

cl-permutation.

Methods
Reader Method: perm-group.element-size ((perm-group perm-group))
Writer Method: (setf perm-group.element-size) ((perm-group perm-group))

The size of the elements of the group. This is a non-negative integer and may be larger than the true degree of the group.

Source

permutation-group.lisp.

Target Slot

element-size.

Generic Reader: perm-group.factorization-generators (object)
Generic Writer: (setf perm-group.factorization-generators) (object)
Package

cl-permutation.

Methods
Reader Method: perm-group.factorization-generators ((perm-group perm-group))
Writer Method: (setf perm-group.factorization-generators) ((perm-group perm-group))

A vector whose length is the same length as the base of the group, whose values are vectors of free-group elements that are coset representatives of the stabilizer G^(i+1)/G^(i). This collection of generators is *also* a strong generating set. This is optionally computed with #’COMPUTE-FACTORIZATION-GENERATORS.

Source

permutation-group.lisp.

Target Slot

factorization-generators.

Generic Reader: perm-group.free-group (object)
Generic Writer: (setf perm-group.free-group) (object)
Package

cl-permutation.

Methods
Reader Method: perm-group.free-group ((perm-group perm-group))
Writer Method: (setf perm-group.free-group) ((perm-group perm-group))

A free group corresponding to the given permutation group.

Source

permutation-group.lisp.

Target Slot

free-group.

Generic Reader: perm-group.generators (object)
Generic Writer: (setf perm-group.generators) (object)
Package

cl-permutation.

Methods
Reader Method: perm-group.generators ((perm-group perm-group))
Writer Method: (setf perm-group.generators) ((perm-group perm-group))

A list of generators of the group.

Source

permutation-group.lisp.

Target Slot

generators.

Generic Reader: perm-group.slp-context (object)
Generic Writer: (setf perm-group.slp-context) (object)
Package

cl-permutation.

Methods
Reader Method: perm-group.slp-context ((perm-group perm-group))
Writer Method: (setf perm-group.slp-context) ((perm-group perm-group))

SLPs corresponding to all sigmas and strong generators.

Source

permutation-group.lisp.

Target Slot

slp-context.

Generic Reader: perm-group.strong-generators (object)
Generic Writer: (setf perm-group.strong-generators) (object)
Package

cl-permutation.

Methods
Reader Method: perm-group.strong-generators ((perm-group perm-group))
Writer Method: (setf perm-group.strong-generators) ((perm-group perm-group))

The strong generating set of the group. This is a vector mapping integers to lists of generators which generate the i’th stabilizer.

Source

permutation-group.lisp.

Target Slot

strong-generators.

Generic Reader: perm-group.transversal-system (object)
Generic Writer: (setf perm-group.transversal-system) (object)
Package

cl-permutation.

Methods
Reader Method: perm-group.transversal-system ((perm-group perm-group))
Writer Method: (setf perm-group.transversal-system) ((perm-group perm-group))

The transversal system of the group. This is a vector mapping integers K to a table of sigmas SIGMA_K. Every permutation in the group can be represented by a product of permutations SIGMA_K * ... * SIGMA_2 * SIGMA_1.

Source

permutation-group.lisp.

Target Slot

transversal-system.

Generic Function: reconstruct-perm (god-table perm)
Package

cl-permutation.

Source

god.lisp.

Methods
Method: reconstruct-perm ((table god-table) perm)
Generic Reader: symbol-table (object)
Generic Writer: (setf symbol-table) (object)
Package

cl-permutation.

Methods
Reader Method: symbol-table ((slp-context slp-context))
Writer Method: (setf symbol-table) ((slp-context slp-context))

A mapping between symbols and their representation as SLPs.

Source

straight-line-program.lisp.

Target Slot

symbol-table.

Generic Reader: word.type-counts (object)
Package

cl-permutation.

Methods
Reader Method: word.type-counts ((word-spec word-spec))

Vector of non-negative integers representing the count of each individual element type. (The sum of this vector should equal TYPES.)

Source

combinatorial-ranking.lisp.

Target Slot

type-counts.

Generic Reader: word.types (object)
Package

cl-permutation.

Methods
Reader Method: word.types ((word-spec word-spec))

Non-negative integer representing the number of distinct elements within the word. Note that this will include the additional zero type, even though there are never any zero elements.

Source

combinatorial-ranking.lisp.

Target Slot

types.


Next: , Previous: , Up: Internals   [Contents][Index]

5.2.4 Structures

Structure: block-coordinate-transformation
Package

cl-permutation.

Source

block.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: order
Readers

coord.order.

Writers

(setf coord.order).

Slot: rank
Readers

coord.rank.

Writers

(setf coord.rank).

Structure: block-subsystem

Representation of a block subsystem of a group. A "block subsystem" is a G-orbit of a block.

Package

cl-permutation.

Source

block.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: group
Readers

block-subsystem-group.

Writers

(setf block-subsystem-group).

Slot: base-block
Readers

block-subsystem-base-block.

Writers

(setf block-subsystem-base-block).

Slot: size
Readers

block-subsystem-size.

Writers

(setf block-subsystem-size).

Slot: block-size
Readers

block-subsystem-block-size.

Writers

(setf block-subsystem-block-size).

Slot: orbit
Readers

block-subsystem-orbit.

Writers

(setf block-subsystem-orbit).

Structure: djs

Representation of a disjoint-set data structure. Each node has a representative element denoted by REPRESENTATIVE, which points to a DJS-REP node representing the canonical element of that disjoint-set.

Package

cl-permutation.

Source

block.lisp.

Direct superclasses

structure-object.

Direct methods

print-object.

Direct slots
Slot: representative
Type

(or null cl-permutation::djs-rep)

Readers

djs-representative.

Writers

(setf djs-representative).

Slot: value
Readers

djs-value.

Writers

(setf djs-value).

Structure: djs-rep

Pointer to the representative element of a DJS.

Package

cl-permutation.

Source

block.lisp.

Direct superclasses

structure-object.

Direct methods

print-object.

Direct slots
Slot: djs
Type

cl-permutation::djs

Readers

djs-rep-djs.

Writers

(setf djs-rep-djs).

Structure: entry

Representation of an entry in a Minkwitz table.

Package

cl-permutation.

Source

minkwitz.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: seen
Type

boolean

Initform

t

Readers

entry-seen.

Writers

(setf entry-seen).

Slot: word
Readers

entry-word.

Writers

This slot is read-only.

Structure: god-table-entry
Package

cl-permutation.

Source

god.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: move
Readers

god-table-entry-move.

Writers

(setf god-table-entry-move).

Slot: came-from
Readers

god-table-entry-came-from.

Writers

(setf god-table-entry-came-from).

Slot: depth
Readers

god-table-entry-depth.

Writers

(setf god-table-entry-depth).

Slot: transition
Readers

god-table-entry-transition.

Writers

(setf god-table-entry-transition).

Structure: queue
Package

cl-permutation.

Source

utilities.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: elements
Type

list

Readers

queue-elements.

Writers

(setf queue-elements).

Slot: last
Package

common-lisp.

Type

(or null (cons t null))

Readers

queue-last.

Writers

(setf queue-last).


Next: , Previous: , Up: Internals   [Contents][Index]

5.2.5 Classes

Class: god-table
Package

cl-permutation.

Source

god.lisp.

Direct methods
Direct slots
Slot: group
Initargs

:group

Readers

god-table-group.

Writers

This slot is read-only.

Slot: table
Initargs

:table

Readers

god-table-vector.

Writers

This slot is read-only.

Slot: target
Initargs

:target

Readers

god-table-target.

Writers

This slot is read-only.

Slot: generators
Initargs

:generators

Readers

god-table-generators.

Writers

This slot is read-only.

Class: homomorphism
Package

cl-permutation.

Source

homomorphism.lisp.

Direct superclasses

funcallable-standard-object.

Direct subclasses
Direct methods

initialize-instance.

Class: minkwitz-table

Data used to decompose elements of a group into generators (and inverses).

Package

cl-permutation.

Source

minkwitz.lisp.

Direct methods
Direct slots
Slot: group

The group for which this table is valid.

Initargs

:group

Readers

minkwitz-table-group.

Writers

This slot is read-only.

Slot: system

The transversal system storing strong generators as short words.

Specifically, this is a SIMPLE-VECTOR of HASH-TABLEs. The Nth element of this vector corresponds to the Nth stabilizer group of GROUP, ordered according to the group’s base. The table is a partial map ω ↦ π such that π(ω) = b, where b is the base point.

Initargs

:system

Readers

minkwitz-table-system.

Writers

This slot is read-only.

Slot: num-rounds

The total number of words searched to get this table.

Initargs

:num-rounds

Readers

minkwitz-table-num-rounds.

Writers

This slot is read-only.

Slot: simplifier

The simplification function that was used during the generation of the table. (See GENERATE-MINKWITZ-TABLE.)

Initargs

:simplifier

Readers

minkwitz-table-simplifier.

Writers

This slot is read-only.

Slot: word-generator

The word-generating function that was used during the creation of this table. (See GENERATE-MINKWITZ-TABLE.)

Initargs

:word-generator

Readers

minkwitz-table-word-generator.

Writers

This slot is read-only.


Previous: , Up: Internals   [Contents][Index]

5.2.6 Types

Type: raw-perm ()

Type defining the internal representation of a perm.

Package

cl-permutation.

Source

permutation.lisp.

Type: sgs ()
Package

cl-permutation.

Source

permutation-group.lisp.

Type: transversal ()
Package

cl-permutation.

Source

permutation-group.lisp.

Type: vector-index ()

Possible indexes to a vector.

Package

cl-permutation.

Source

utilities.lisp.

Type: vector-size (&key down-by)

Possible sizes of a vector.

Package

cl-permutation.

Source

utilities.lisp.

Type: word ()
Package

cl-permutation.

Source

free-group.lisp.


Appendix A Indexes


Next: , Previous: , Up: Indexes   [Contents][Index]

A.1 Concepts


Next: , Previous: , Up: Indexes   [Contents][Index]

A.2 Functions

Jump to:   %   (  
A   B   C   D   E   F   G   H   I   L   M   N   O   P   Q   R   S   T   U   V   W   Z  
Index Entry  Section

%
%djs-and-rep-printer: Private ordinary functions
%make-coord: Private ordinary functions
%make-cycle: Private ordinary functions
%make-djs: Private ordinary functions
%make-djs-rep: Private ordinary functions
%make-perm: Private ordinary functions
%make-queue: Private ordinary functions
%make-system: Private ordinary functions
%perm-compose-into/equal: Private ordinary functions
%perm-compose-into/unequal: Private ordinary functions
%perm-compose-upto: Private ordinary functions
%system-size: Private ordinary functions
%word-generator: Private ordinary functions

(
(setf block-subsystem-base-block): Private ordinary functions
(setf block-subsystem-block-size): Private ordinary functions
(setf block-subsystem-group): Private ordinary functions
(setf block-subsystem-orbit): Private ordinary functions
(setf block-subsystem-size): Private ordinary functions
(setf cardinality-cache): Private generic functions
(setf cardinality-cache): Private generic functions
(setf coord.order): Private ordinary functions
(setf coord.rank): Private ordinary functions
(setf cycle-canonicalized): Private ordinary functions
(setf cycle-rep): Private ordinary functions
(setf djs-rep-djs): Private ordinary functions
(setf djs-representative): Private ordinary functions
(setf djs-value): Private ordinary functions
(setf entry-seen): Private ordinary functions
(setf god-table-entry-came-from): Private ordinary functions
(setf god-table-entry-depth): Private ordinary functions
(setf god-table-entry-move): Private ordinary functions
(setf god-table-entry-transition): Private ordinary functions
(setf perm-group.element-size): Private generic functions
(setf perm-group.element-size): Private generic functions
(setf perm-group.factorization-generators): Private generic functions
(setf perm-group.factorization-generators): Private generic functions
(setf perm-group.free-group): Private generic functions
(setf perm-group.free-group): Private generic functions
(setf perm-group.generators): Private generic functions
(setf perm-group.generators): Private generic functions
(setf perm-group.slp-context): Private generic functions
(setf perm-group.slp-context): Private generic functions
(setf perm-group.strong-generators): Private generic functions
(setf perm-group.strong-generators): Private generic functions
(setf perm-group.transversal-system): Private generic functions
(setf perm-group.transversal-system): Private generic functions
(setf queue-elements): Private ordinary functions
(setf queue-last): Private ordinary functions
(setf sgs-ref): Private ordinary functions
(setf sigma): Private ordinary functions
(setf symbol-assignment): Public ordinary functions
(setf symbol-table): Private generic functions
(setf symbol-table): Private generic functions
(setf transversal-ref): Private ordinary functions

A
abs>: Private ordinary functions
add-generator: Private ordinary functions
allocate-perm-vector: Private ordinary functions
array-for-spec: Private ordinary functions
assert-valid-permutation-elements: Private ordinary functions
atkinson: Private ordinary functions

B
binomial-coefficient-or-zero: Private ordinary functions
block-coordinate-transformation-p: Private ordinary functions
block-slot: Private ordinary functions
block-subsystem-base-block: Private ordinary functions
block-subsystem-block-size: Private ordinary functions
block-subsystem-group: Private ordinary functions
block-subsystem-interblock-group: Private ordinary functions
block-subsystem-interblock-group-homomorphism: Private ordinary functions
block-subsystem-intrablock-group: Private ordinary functions
block-subsystem-intrablock-group-generators: Private ordinary functions
block-subsystem-orbit: Private ordinary functions
block-subsystem-p: Private ordinary functions
block-subsystem-size: Private ordinary functions
bruhat<: Public ordinary functions
bruhat<=: Public ordinary functions

C
canonicalize-cycle: Public ordinary functions
canonicalize-cycles: Public ordinary functions
canonicalize-raw-block-subsystems: Private ordinary functions
cardinality: Public generic functions
cardinality: Public generic functions
cardinality: Public generic functions
cardinality: Public generic functions
cardinality: Public generic functions
cardinality: Public generic functions
cardinality: Public generic functions
cardinality-cache: Private generic functions
cardinality-cache: Private generic functions
check-cycle-elements: Private ordinary functions
clear-membership-set: Private ordinary functions
comb.zero-count: Private generic functions
comb.zero-count: Private generic functions
commutesp: Private ordinary functions
compose: Public generic functions
compose: Public generic functions
compose: Public generic functions
compose: Public generic functions
compose: Public generic functions
compose: Public generic functions
compose: Public generic functions
compose-slp: Public ordinary functions
compute-factorization-generators: Private ordinary functions
compute-god-table: Private ordinary functions
contains-1-to-n: Private ordinary functions
coord.order: Private ordinary functions
coord.rank: Private ordinary functions
copy-block-coordinate-transformation: Private ordinary functions
copy-block-subsystem: Private ordinary functions
copy-cycle: Private ordinary functions
copy-djs: Private ordinary functions
copy-djs-rep: Private ordinary functions
copy-god-table-entry: Private ordinary functions
copy-perm: Private ordinary functions
copy-queue: Private ordinary functions
cycle-canonicalized: Private ordinary functions
cycle-identity-p: Public ordinary functions
cycle-length: Public ordinary functions
cycle-p: Private ordinary functions
cycle-ref: Public ordinary functions
cycle-rep: Private ordinary functions
cycle-type: Public ordinary functions
cycles-to-one-line: Public ordinary functions

D
dequeue: Private ordinary functions
djs: Private ordinary functions
djs-change-representative: Private ordinary functions
djs-find: Private ordinary functions
djs-p: Private ordinary functions
djs-rep-djs: Private ordinary functions
djs-rep-p: Private ordinary functions
djs-representative: Private ordinary functions
djs-union: Private ordinary functions
djs-value: Private ordinary functions
do-group-elements: Public macros
doperms: Public macros

E
enable-perm-reader: Public ordinary functions
enqueue: Private ordinary functions
entry: Private ordinary functions
entry-seen: Private ordinary functions
entry-word: Private ordinary functions
evaluate-slp: Public ordinary functions
exists-mobile-p: Private ordinary functions

F
find-conjugator: Public ordinary functions
find-minimal-block-system-containing: Public ordinary functions
find-non-trivial-block-system: Public ordinary functions
free-group->perm-group-homomorphism: Private ordinary functions
free-group-element-valid-p: Private ordinary functions
free-group-generator-to-perm-group-generator: Private ordinary functions
free-group-identity-p: Public ordinary functions
free-group-num-generators: Private generic functions
free-group-num-generators: Private generic functions
from-cycles: Public ordinary functions
Function, %djs-and-rep-printer: Private ordinary functions
Function, %make-coord: Private ordinary functions
Function, %make-cycle: Private ordinary functions
Function, %make-djs: Private ordinary functions
Function, %make-djs-rep: Private ordinary functions
Function, %make-perm: Private ordinary functions
Function, %make-queue: Private ordinary functions
Function, %make-system: Private ordinary functions
Function, %perm-compose-into/equal: Private ordinary functions
Function, %perm-compose-into/unequal: Private ordinary functions
Function, %perm-compose-upto: Private ordinary functions
Function, %system-size: Private ordinary functions
Function, %word-generator: Private ordinary functions
Function, (setf block-subsystem-base-block): Private ordinary functions
Function, (setf block-subsystem-block-size): Private ordinary functions
Function, (setf block-subsystem-group): Private ordinary functions
Function, (setf block-subsystem-orbit): Private ordinary functions
Function, (setf block-subsystem-size): Private ordinary functions
Function, (setf coord.order): Private ordinary functions
Function, (setf coord.rank): Private ordinary functions
Function, (setf cycle-canonicalized): Private ordinary functions
Function, (setf cycle-rep): Private ordinary functions
Function, (setf djs-rep-djs): Private ordinary functions
Function, (setf djs-representative): Private ordinary functions
Function, (setf djs-value): Private ordinary functions
Function, (setf entry-seen): Private ordinary functions
Function, (setf god-table-entry-came-from): Private ordinary functions
Function, (setf god-table-entry-depth): Private ordinary functions
Function, (setf god-table-entry-move): Private ordinary functions
Function, (setf god-table-entry-transition): Private ordinary functions
Function, (setf queue-elements): Private ordinary functions
Function, (setf queue-last): Private ordinary functions
Function, (setf sgs-ref): Private ordinary functions
Function, (setf sigma): Private ordinary functions
Function, (setf symbol-assignment): Public ordinary functions
Function, (setf transversal-ref): Private ordinary functions
Function, abs>: Private ordinary functions
Function, add-generator: Private ordinary functions
Function, allocate-perm-vector: Private ordinary functions
Function, array-for-spec: Private ordinary functions
Function, assert-valid-permutation-elements: Private ordinary functions
Function, atkinson: Private ordinary functions
Function, binomial-coefficient-or-zero: Private ordinary functions
Function, block-coordinate-transformation-p: Private ordinary functions
Function, block-slot: Private ordinary functions
Function, block-subsystem-base-block: Private ordinary functions
Function, block-subsystem-block-size: Private ordinary functions
Function, block-subsystem-group: Private ordinary functions
Function, block-subsystem-interblock-group: Private ordinary functions
Function, block-subsystem-interblock-group-homomorphism: Private ordinary functions
Function, block-subsystem-intrablock-group: Private ordinary functions
Function, block-subsystem-intrablock-group-generators: Private ordinary functions
Function, block-subsystem-orbit: Private ordinary functions
Function, block-subsystem-p: Private ordinary functions
Function, block-subsystem-size: Private ordinary functions
Function, bruhat<: Public ordinary functions
Function, bruhat<=: Public ordinary functions
Function, canonicalize-cycle: Public ordinary functions
Function, canonicalize-cycles: Public ordinary functions
Function, canonicalize-raw-block-subsystems: Private ordinary functions
Function, check-cycle-elements: Private ordinary functions
Function, clear-membership-set: Private ordinary functions
Function, commutesp: Private ordinary functions
Function, compose-slp: Public ordinary functions
Function, compute-factorization-generators: Private ordinary functions
Function, compute-god-table: Private ordinary functions
Function, contains-1-to-n: Private ordinary functions
Function, coord.order: Private ordinary functions
Function, coord.rank: Private ordinary functions
Function, copy-block-coordinate-transformation: Private ordinary functions
Function, copy-block-subsystem: Private ordinary functions
Function, copy-cycle: Private ordinary functions
Function, copy-djs: Private ordinary functions
Function, copy-djs-rep: Private ordinary functions
Function, copy-god-table-entry: Private ordinary functions
Function, copy-perm: Private ordinary functions
Function, copy-queue: Private ordinary functions
Function, cycle-canonicalized: Private ordinary functions
Function, cycle-identity-p: Public ordinary functions
Function, cycle-length: Public ordinary functions
Function, cycle-p: Private ordinary functions
Function, cycle-ref: Public ordinary functions
Function, cycle-rep: Private ordinary functions
Function, cycle-type: Public ordinary functions
Function, cycles-to-one-line: Public ordinary functions
Function, dequeue: Private ordinary functions
Function, djs: Private ordinary functions
Function, djs-change-representative: Private ordinary functions
Function, djs-find: Private ordinary functions
Function, djs-p: Private ordinary functions
Function, djs-rep-djs: Private ordinary functions
Function, djs-rep-p: Private ordinary functions
Function, djs-representative: Private ordinary functions
Function, djs-union: Private ordinary functions
Function, djs-value: Private ordinary functions
Function, enable-perm-reader: Public ordinary functions
Function, enqueue: Private ordinary functions
Function, entry: Private ordinary functions
Function, entry-seen: Private ordinary functions
Function, entry-word: Private ordinary functions
Function, evaluate-slp: Public ordinary functions
Function, exists-mobile-p: Private ordinary functions
Function, find-conjugator: Public ordinary functions
Function, find-minimal-block-system-containing: Public ordinary functions
Function, find-non-trivial-block-system: Public ordinary functions
Function, free-group->perm-group-homomorphism: Private ordinary functions
Function, free-group-element-valid-p: Private ordinary functions
Function, free-group-generator-to-perm-group-generator: Private ordinary functions
Function, free-group-identity-p: Public ordinary functions
Function, from-cycles: Public ordinary functions
Function, generate-minkwitz-table: Private ordinary functions
Function, generate-perm-group: Public ordinary functions
Function, generator-decomposition: Public ordinary functions
Function, generator-exponent-set: Private ordinary functions
Function, generator-orders: Private ordinary functions
Function, god-table-entry-came-from: Private ordinary functions
Function, god-table-entry-depth: Private ordinary functions
Function, god-table-entry-move: Private ordinary functions
Function, god-table-entry-p: Private ordinary functions
Function, god-table-entry-transition: Private ordinary functions
Function, group-block-subsystems: Private ordinary functions
Function, group-bsgs: Private ordinary functions
Function, group-degree: Public ordinary functions
Function, group-element-from-signature: Private ordinary functions
Function, group-element-p: Public ordinary functions
Function, group-element-rank-functions: Public ordinary functions
Function, group-from: Public ordinary functions
Function, group-from-cycles: Public ordinary functions
Function, group-from-orbit: Public ordinary functions
Function, group-identity: Public ordinary functions
Function, group-orbits: Public ordinary functions
Function, group-order: Public ordinary functions
Function, group-radix: Private ordinary functions
Function, homomorphism-induced-perm-group: Public ordinary functions
Function, intrablock-coordinate-function: Private ordinary functions
Function, invert-slp: Public ordinary functions
Function, iota: Private ordinary functions
Function, iota+1: Private ordinary functions
Function, iota-vector: Private ordinary functions
Function, last-to-position: Private ordinary functions
Function, list-minimum: Private ordinary functions
Function, list-to-perm: Public ordinary functions
Function, list-to-queue: Private ordinary functions
Function, make-block-subsystem: Private ordinary functions
Function, make-combination-spec: Public ordinary functions
Function, make-cycle: Public ordinary functions
Function, make-free-group: Public ordinary functions
Function, make-free-group-element: Public ordinary functions
Function, make-god-table-entry: Private ordinary functions
Function, make-membership-set: Private ordinary functions
Function, make-perm: Public ordinary functions
Function, make-perm-generator: Public ordinary functions
Function, make-perm-spec: Public ordinary functions
Function, make-queue: Private ordinary functions
Function, make-radix-spec: Public ordinary functions
Function, make-sgs: Private ordinary functions
Function, make-sigma-table: Private ordinary functions
Function, make-subsystem-transformations: Private ordinary functions
Function, make-transversal: Private ordinary functions
Function, map-cycle-mappings: Private ordinary functions
Function, map-exponent-subgroups: Private ordinary functions
Function, map-into-perm: Private ordinary functions
Function, map-orbit: Private ordinary functions
Function, map-spec: Public ordinary functions
Function, map-suitable-subgroups: Private ordinary functions
Function, mark-entry-as-seen: Private ordinary functions
Function, maximum: Private ordinary functions
Function, membership-set-count: Private ordinary functions
Function, membership-set-nunion: Private ordinary functions
Function, membership-sets-intersect-p: Private ordinary functions
Function, minkwitz-table-distribution: Private ordinary functions
Function, minkwitz-table-num-words: Private ordinary functions
Function, mobilep: Private ordinary functions
Function, naive-generator-decomposition: Public ordinary functions
Function, new-entry: Private ordinary functions
Function, next-perm: Private ordinary functions
Function, normal-subgroup-p: Public ordinary functions
Function, nshuffle: Private ordinary functions
Function, orbit-group-homomorphism: Public ordinary functions
Function, orbit-length: Public ordinary functions
Function, orbit-of: Public ordinary functions
Function, partition-if: Private ordinary functions
Function, perm-compose: Public ordinary functions
Function, perm-compose-flipped: Public ordinary functions
Function, perm-conjugate: Public ordinary functions
Function, perm-eject: Private ordinary functions
Function, perm-eval: Public ordinary functions
Function, perm-eval*: Public ordinary functions
Function, perm-evaluator: Public ordinary functions
Function, perm-evaluator*: Public ordinary functions
Function, perm-even-p: Public ordinary functions
Function, perm-expt: Public ordinary functions
Function, perm-extend: Private ordinary functions
Function, perm-fixpoints: Public ordinary functions
Function, perm-identity: Public ordinary functions
Function, perm-identity-p: Public ordinary functions
Function, perm-inject: Private ordinary functions
Function, perm-inverse: Public ordinary functions
Function, perm-inverse-eval: Public ordinary functions
Function, perm-inverse-eval*: Public ordinary functions
Function, perm-last-non-fixpoint: Public ordinary functions
Function, perm-length: Public ordinary functions
Function, perm-odd-p: Public ordinary functions
Function, perm-order: Public ordinary functions
Function, perm-p: Private ordinary functions
Function, perm-point-fixed-p: Public ordinary functions
Function, perm-reader: Private ordinary functions
Function, perm-ref: Public ordinary functions
Function, perm-sign: Public ordinary functions
Function, perm-size: Public ordinary functions
Function, perm-to-list: Public ordinary functions
Function, perm-to-vector: Public ordinary functions
Function, perm-transpose-entries: Public ordinary functions
Function, perm-transpose-indexes: Public ordinary functions
Function, perm.rep: Private ordinary functions
Function, perm=: Public ordinary functions
Function, perm=*: Public ordinary functions
Function, permute: Public ordinary functions
Function, permuter: Private ordinary functions
Function, primitive-group-p: Public ordinary functions
Function, print-cycle: Private ordinary functions
Function, print-objects-of-spec: Public ordinary functions
Function, print-perm: Private ordinary functions
Function, product: Private ordinary functions
Function, queue-elements: Private ordinary functions
Function, queue-empty-p: Private ordinary functions
Function, queue-last: Private ordinary functions
Function, queuep: Private ordinary functions
Function, random-between: Private ordinary functions
Function, random-element: Private ordinary functions
Function, random-group-element: Public ordinary functions
Function, random-perm: Public ordinary functions
Function, random-word-generator: Private ordinary functions
Function, raw-block-subsystems: Private ordinary functions
Function, reduce-over-trans-decomposition: Private ordinary functions
Function, reverse-direction: Private ordinary functions
Function, rotate-cycle: Public ordinary functions
Function, rotate-vector!: Private ordinary functions
Function, same-group-p: Public ordinary functions
Function, sgs-ref: Private ordinary functions
Function, sigma: Private ordinary functions
Function, sigma-symbol: Private ordinary functions
Function, sign: Private ordinary functions
Function, singletonp: Private ordinary functions
Function, slp-composition: Public ordinary functions
Function, slp-composition%0: Private ordinary functions
Function, slp-composition%1: Private ordinary functions
Function, slp-element: Public ordinary functions
Function, slp-element%0: Private ordinary functions
Function, slp-inversion: Public ordinary functions
Function, slp-inversion%0: Private ordinary functions
Function, slp-symbol: Public ordinary functions
Function, slp-symbol%0: Private ordinary functions
Function, solve-and-verify: Private ordinary functions
Function, stabilizer-orbits: Private ordinary functions
Function, subdirect-factors: Public ordinary functions
Function, subgroup-from-exponent-vector: Private ordinary functions
Function, subgroup-p: Public ordinary functions
Function, subsystem-solver: Private ordinary functions
Function, suitable-subgroup-p: Private ordinary functions
Function, symbol-assignment: Public ordinary functions
Function, tau-symbol: Private ordinary functions
Function, to-cycles: Public ordinary functions
Function, trans-decomposition: Private ordinary functions
Function, trans-element-p: Private ordinary functions
Function, transversal-decomposition: Public ordinary functions
Function, transversal-ref: Private ordinary functions
Function, trivial-block-system-p: Private ordinary functions
Function, unsafe/perm-eval: Private ordinary functions
Function, update-transversal: Private ordinary functions
Function, upper-bound-decomposition-length: Private ordinary functions
Function, vector-to-mixed-radix-spec: Public ordinary functions
Function, vector-to-perm: Public ordinary functions
Function, vector-to-word-spec: Public ordinary functions
Function, verbose: Private ordinary functions
Function, word-generator: Private ordinary functions
Function, word-length: Private ordinary functions
Function, word-simplifier: Private ordinary functions
Function, word-simplifier-for-perm-group: Private ordinary functions
Function, zero-array: Private ordinary functions

G
generate-minkwitz-table: Private ordinary functions
generate-perm-group: Public ordinary functions
generator-decomposition: Public ordinary functions
generator-exponent-set: Private ordinary functions
generator-orders: Private ordinary functions
generators: Public generic functions
generators: Public generic functions
generators: Public generic functions
Generic Function, (setf cardinality-cache): Private generic functions
Generic Function, (setf perm-group.element-size): Private generic functions
Generic Function, (setf perm-group.factorization-generators): Private generic functions
Generic Function, (setf perm-group.free-group): Private generic functions
Generic Function, (setf perm-group.generators): Private generic functions
Generic Function, (setf perm-group.slp-context): Private generic functions
Generic Function, (setf perm-group.strong-generators): Private generic functions
Generic Function, (setf perm-group.transversal-system): Private generic functions
Generic Function, (setf symbol-table): Private generic functions
Generic Function, cardinality: Public generic functions
Generic Function, cardinality-cache: Private generic functions
Generic Function, comb.zero-count: Private generic functions
Generic Function, compose: Public generic functions
Generic Function, free-group-num-generators: Private generic functions
Generic Function, generators: Public generic functions
Generic Function, god-table-generators: Private generic functions
Generic Function, god-table-group: Private generic functions
Generic Function, god-table-target: Private generic functions
Generic Function, god-table-vector: Private generic functions
Generic Function, homomorphism-function: Private generic functions
Generic Function, homomorphism-generator-map: Private generic functions
Generic Function, homomorphism-image: Public generic functions
Generic Function, homomorphism-preimage: Public generic functions
Generic Function, identity-element: Public generic functions
Generic Function, image: Public generic functions
Generic Function, inverse: Public generic functions
Generic Function, minkwitz-table-group: Private generic functions
Generic Function, minkwitz-table-num-rounds: Private generic functions
Generic Function, minkwitz-table-simplifier: Private generic functions
Generic Function, minkwitz-table-system: Private generic functions
Generic Function, minkwitz-table-word-generator: Private generic functions
Generic Function, num-generators: Public generic functions
Generic Function, perm-group.element-size: Private generic functions
Generic Function, perm-group.factorization-generators: Private generic functions
Generic Function, perm-group.free-group: Private generic functions
Generic Function, perm-group.generators: Private generic functions
Generic Function, perm-group.slp-context: Private generic functions
Generic Function, perm-group.strong-generators: Private generic functions
Generic Function, perm-group.transversal-system: Private generic functions
Generic Function, radix: Public generic functions
Generic Function, rank: Public generic functions
Generic Function, reconstruct-perm: Private generic functions
Generic Function, size: Public generic functions
Generic Function, symbol-table: Private generic functions
Generic Function, unrank: Public generic functions
Generic Function, word.type-counts: Private generic functions
Generic Function, word.types: Private generic functions
god-table-entry-came-from: Private ordinary functions
god-table-entry-depth: Private ordinary functions
god-table-entry-move: Private ordinary functions
god-table-entry-p: Private ordinary functions
god-table-entry-transition: Private ordinary functions
god-table-generators: Private generic functions
god-table-generators: Private generic functions
god-table-group: Private generic functions
god-table-group: Private generic functions
god-table-target: Private generic functions
god-table-target: Private generic functions
god-table-vector: Private generic functions
god-table-vector: Private generic functions
group-block-subsystems: Private ordinary functions
group-bsgs: Private ordinary functions
group-degree: Public ordinary functions
group-element-from-signature: Private ordinary functions
group-element-p: Public ordinary functions
group-element-rank-functions: Public ordinary functions
group-from: Public ordinary functions
group-from-cycles: Public ordinary functions
group-from-orbit: Public ordinary functions
group-identity: Public ordinary functions
group-orbits: Public ordinary functions
group-order: Public ordinary functions
group-radix: Private ordinary functions

H
homomorphism-function: Private generic functions
homomorphism-function: Private generic functions
homomorphism-generator-map: Private generic functions
homomorphism-generator-map: Private generic functions
homomorphism-image: Public generic functions
homomorphism-image: Public generic functions
homomorphism-image: Public generic functions
homomorphism-induced-perm-group: Public ordinary functions
homomorphism-preimage: Public generic functions
homomorphism-preimage: Public generic functions
homomorphism-preimage: Public generic functions

I
identity-element: Public generic functions
identity-element: Public generic functions
identity-element: Public generic functions
image: Public generic functions
image: Public generic functions
image: Public generic functions
image: Public generic functions
initialize-instance: Public standalone methods
intrablock-coordinate-function: Private ordinary functions
inverse: Public generic functions
inverse: Public generic functions
inverse: Public generic functions
invert-slp: Public ordinary functions
iota: Private ordinary functions
iota+1: Private ordinary functions
iota-vector: Private ordinary functions

L
last-to-position: Private ordinary functions
list-minimum: Private ordinary functions
list-to-perm: Public ordinary functions
list-to-queue: Private ordinary functions

M
Macro, do-group-elements: Public macros
Macro, doperms: Public macros
make-block-subsystem: Private ordinary functions
make-combination-spec: Public ordinary functions
make-cycle: Public ordinary functions
make-free-group: Public ordinary functions
make-free-group-element: Public ordinary functions
make-god-table-entry: Private ordinary functions
make-load-form: Public standalone methods
make-load-form: Public standalone methods
make-load-form: Public standalone methods
make-load-form: Public standalone methods
make-membership-set: Private ordinary functions
make-perm: Public ordinary functions
make-perm-generator: Public ordinary functions
make-perm-spec: Public ordinary functions
make-queue: Private ordinary functions
make-radix-spec: Public ordinary functions
make-sgs: Private ordinary functions
make-sigma-table: Private ordinary functions
make-subsystem-transformations: Private ordinary functions
make-transversal: Private ordinary functions
map-cycle-mappings: Private ordinary functions
map-exponent-subgroups: Private ordinary functions
map-into-perm: Private ordinary functions
map-orbit: Private ordinary functions
map-spec: Public ordinary functions
map-suitable-subgroups: Private ordinary functions
mark-entry-as-seen: Private ordinary functions
maximum: Private ordinary functions
membership-set-count: Private ordinary functions
membership-set-nunion: Private ordinary functions
membership-sets-intersect-p: Private ordinary functions
Method, (setf cardinality-cache): Private generic functions
Method, (setf perm-group.element-size): Private generic functions
Method, (setf perm-group.factorization-generators): Private generic functions
Method, (setf perm-group.free-group): Private generic functions
Method, (setf perm-group.generators): Private generic functions
Method, (setf perm-group.slp-context): Private generic functions
Method, (setf perm-group.strong-generators): Private generic functions
Method, (setf perm-group.transversal-system): Private generic functions
Method, (setf symbol-table): Private generic functions
Method, cardinality: Public generic functions
Method, cardinality: Public generic functions
Method, cardinality: Public generic functions
Method, cardinality: Public generic functions
Method, cardinality: Public generic functions
Method, cardinality: Public generic functions
Method, cardinality-cache: Private generic functions
Method, comb.zero-count: Private generic functions
Method, compose: Public generic functions
Method, compose: Public generic functions
Method, compose: Public generic functions
Method, compose: Public generic functions
Method, compose: Public generic functions
Method, compose: Public generic functions
Method, free-group-num-generators: Private generic functions
Method, generators: Public generic functions
Method, generators: Public generic functions
Method, god-table-generators: Private generic functions
Method, god-table-group: Private generic functions
Method, god-table-target: Private generic functions
Method, god-table-vector: Private generic functions
Method, homomorphism-function: Private generic functions
Method, homomorphism-generator-map: Private generic functions
Method, homomorphism-image: Public generic functions
Method, homomorphism-image: Public generic functions
Method, homomorphism-preimage: Public generic functions
Method, homomorphism-preimage: Public generic functions
Method, identity-element: Public generic functions
Method, identity-element: Public generic functions
Method, image: Public generic functions
Method, image: Public generic functions
Method, image: Public generic functions
Method, initialize-instance: Public standalone methods
Method, inverse: Public generic functions
Method, inverse: Public generic functions
Method, make-load-form: Public standalone methods
Method, make-load-form: Public standalone methods
Method, make-load-form: Public standalone methods
Method, make-load-form: Public standalone methods
Method, minkwitz-table-group: Private generic functions
Method, minkwitz-table-num-rounds: Private generic functions
Method, minkwitz-table-simplifier: Private generic functions
Method, minkwitz-table-system: Private generic functions
Method, minkwitz-table-word-generator: Private generic functions
Method, num-generators: Public generic functions
Method, num-generators: Public generic functions
Method, perm-group.element-size: Private generic functions
Method, perm-group.factorization-generators: Private generic functions
Method, perm-group.free-group: Private generic functions
Method, perm-group.generators: Private generic functions
Method, perm-group.slp-context: Private generic functions
Method, perm-group.strong-generators: Private generic functions
Method, perm-group.transversal-system: Private generic functions
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, radix: Public generic functions
Method, radix: Public generic functions
Method, rank: Public generic functions
Method, rank: Public generic functions
Method, rank: Public generic functions
Method, rank: Public generic functions
Method, rank: Public generic functions
Method, reconstruct-perm: Private generic functions
Method, size: Public generic functions
Method, symbol-table: Private generic functions
Method, unrank: Public generic functions
Method, unrank: Public generic functions
Method, unrank: Public generic functions
Method, unrank: Public generic functions
Method, unrank: Public generic functions
Method, word.type-counts: Private generic functions
Method, word.types: Private generic functions
minkwitz-table-distribution: Private ordinary functions
minkwitz-table-group: Private generic functions
minkwitz-table-group: Private generic functions
minkwitz-table-num-rounds: Private generic functions
minkwitz-table-num-rounds: Private generic functions
minkwitz-table-num-words: Private ordinary functions
minkwitz-table-simplifier: Private generic functions
minkwitz-table-simplifier: Private generic functions
minkwitz-table-system: Private generic functions
minkwitz-table-system: Private generic functions
minkwitz-table-word-generator: Private generic functions
minkwitz-table-word-generator: Private generic functions
mobilep: Private ordinary functions

N
naive-generator-decomposition: Public ordinary functions
new-entry: Private ordinary functions
next-perm: Private ordinary functions
normal-subgroup-p: Public ordinary functions
nshuffle: Private ordinary functions
num-generators: Public generic functions
num-generators: Public generic functions
num-generators: Public generic functions

O
orbit-group-homomorphism: Public ordinary functions
orbit-length: Public ordinary functions
orbit-of: Public ordinary functions

P
partition-if: Private ordinary functions
perm-compose: Public ordinary functions
perm-compose-flipped: Public ordinary functions
perm-conjugate: Public ordinary functions
perm-eject: Private ordinary functions
perm-eval: Public ordinary functions
perm-eval*: Public ordinary functions
perm-evaluator: Public ordinary functions
perm-evaluator*: Public ordinary functions
perm-even-p: Public ordinary functions
perm-expt: Public ordinary functions
perm-extend: Private ordinary functions
perm-fixpoints: Public ordinary functions
perm-group.element-size: Private generic functions
perm-group.element-size: Private generic functions
perm-group.factorization-generators: Private generic functions
perm-group.factorization-generators: Private generic functions
perm-group.free-group: Private generic functions
perm-group.free-group: Private generic functions
perm-group.generators: Private generic functions
perm-group.generators: Private generic functions
perm-group.slp-context: Private generic functions
perm-group.slp-context: Private generic functions
perm-group.strong-generators: Private generic functions
perm-group.strong-generators: Private generic functions
perm-group.transversal-system: Private generic functions
perm-group.transversal-system: Private generic functions
perm-identity: Public ordinary functions
perm-identity-p: Public ordinary functions
perm-inject: Private ordinary functions
perm-inverse: Public ordinary functions
perm-inverse-eval: Public ordinary functions
perm-inverse-eval*: Public ordinary functions
perm-last-non-fixpoint: Public ordinary functions
perm-length: Public ordinary functions
perm-odd-p: Public ordinary functions
perm-order: Public ordinary functions
perm-p: Private ordinary functions
perm-point-fixed-p: Public ordinary functions
perm-reader: Private ordinary functions
perm-ref: Public ordinary functions
perm-sign: Public ordinary functions
perm-size: Public ordinary functions
perm-to-list: Public ordinary functions
perm-to-vector: Public ordinary functions
perm-transpose-entries: Public ordinary functions
perm-transpose-indexes: Public ordinary functions
perm.rep: Private ordinary functions
perm=: Public ordinary functions
perm=*: Public ordinary functions
permute: Public ordinary functions
permuter: Private ordinary functions
primitive-group-p: Public ordinary functions
print-cycle: Private ordinary functions
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-objects-of-spec: Public ordinary functions
print-perm: Private ordinary functions
product: Private ordinary functions

Q
queue-elements: Private ordinary functions
queue-empty-p: Private ordinary functions
queue-last: Private ordinary functions
queuep: Private ordinary functions

R
radix: Public generic functions
radix: Public generic functions
radix: Public generic functions
random-between: Private ordinary functions
random-element: Private ordinary functions
random-group-element: Public ordinary functions
random-perm: Public ordinary functions
random-word-generator: Private ordinary functions
rank: Public generic functions
rank: Public generic functions
rank: Public generic functions
rank: Public generic functions
rank: Public generic functions
rank: Public generic functions
raw-block-subsystems: Private ordinary functions
reconstruct-perm: Private generic functions
reconstruct-perm: Private generic functions
reduce-over-trans-decomposition: Private ordinary functions
reverse-direction: Private ordinary functions
rotate-cycle: Public ordinary functions
rotate-vector!: Private ordinary functions

S
same-group-p: Public ordinary functions
sgs-ref: Private ordinary functions
sigma: Private ordinary functions
sigma-symbol: Private ordinary functions
sign: Private ordinary functions
singletonp: Private ordinary functions
size: Public generic functions
size: Public generic functions
slp-composition: Public ordinary functions
slp-composition%0: Private ordinary functions
slp-composition%1: Private ordinary functions
slp-element: Public ordinary functions
slp-element%0: Private ordinary functions
slp-inversion: Public ordinary functions
slp-inversion%0: Private ordinary functions
slp-symbol: Public ordinary functions
slp-symbol%0: Private ordinary functions
solve-and-verify: Private ordinary functions
stabilizer-orbits: Private ordinary functions
subdirect-factors: Public ordinary functions
subgroup-from-exponent-vector: Private ordinary functions
subgroup-p: Public ordinary functions
subsystem-solver: Private ordinary functions
suitable-subgroup-p: Private ordinary functions
symbol-assignment: Public ordinary functions
symbol-table: Private generic functions
symbol-table: Private generic functions

T
tau-symbol: Private ordinary functions
to-cycles: Public ordinary functions
trans-decomposition: Private ordinary functions
trans-element-p: Private ordinary functions
transversal-decomposition: Public ordinary functions
transversal-ref: Private ordinary functions
trivial-block-system-p: Private ordinary functions

U
unrank: Public generic functions
unrank: Public generic functions
unrank: Public generic functions
unrank: Public generic functions
unrank: Public generic functions
unrank: Public generic functions
unsafe/perm-eval: Private ordinary functions
update-transversal: Private ordinary functions
upper-bound-decomposition-length: Private ordinary functions

V
vector-to-mixed-radix-spec: Public ordinary functions
vector-to-perm: Public ordinary functions
vector-to-word-spec: Public ordinary functions
verbose: Private ordinary functions

W
word-generator: Private ordinary functions
word-length: Private ordinary functions
word-simplifier: Private ordinary functions
word-simplifier-for-perm-group: Private ordinary functions
word.type-counts: Private generic functions
word.type-counts: Private generic functions
word.types: Private generic functions
word.types: Private generic functions

Z
zero-array: Private ordinary functions

Jump to:   %   (  
A   B   C   D   E   F   G   H   I   L   M   N   O   P   Q   R   S   T   U   V   W   Z  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.3 Variables

Jump to:   %   *  
B   C   D   E   F   G   L   M   N   O   R   S   T   V   W   Z  
Index Entry  Section

%
%0: Public structures
%0: Public structures
%0: Public structures
%0: Public structures
%1: Public structures

*
*canonicalize-cycle-on-creation*: Public special variables
*context*: Private special variables
*perm-group-verbose*: Private special variables
*print-with-perm-syntax*: Private special variables
*taus*: Private special variables

B
base-block: Private structures
block-size: Private structures

C
came-from: Private structures
canonicalized: Public structures
cardinality-cache: Public classes

D
depth: Private structures
djs: Private structures

E
element-size: Public classes
elements: Private structures

F
factorization-generators: Public classes
free-group: Public classes
from-group: Public classes
from-group: Public classes
function: Public classes

G
generator-map: Public classes
generators: Public classes
generators: Private classes
group: Private structures
group: Private classes
group: Private classes

L
last: Private structures

M
move: Private structures

N
num-generators: Public classes
num-rounds: Private classes

O
orbit: Private structures
order: Private structures

R
radix: Public classes
radix: Public classes
rank: Private structures
rep: Public structures
rep: Public structures
representative: Private structures

S
seen: Private structures
simplifier: Private classes
size: Public classes
size: Private structures
Slot, %0: Public structures
Slot, %0: Public structures
Slot, %0: Public structures
Slot, %0: Public structures
Slot, %1: Public structures
Slot, base-block: Private structures
Slot, block-size: Private structures
Slot, came-from: Private structures
Slot, canonicalized: Public structures
Slot, cardinality-cache: Public classes
Slot, depth: Private structures
Slot, djs: Private structures
Slot, element-size: Public classes
Slot, elements: Private structures
Slot, factorization-generators: Public classes
Slot, free-group: Public classes
Slot, from-group: Public classes
Slot, from-group: Public classes
Slot, function: Public classes
Slot, generator-map: Public classes
Slot, generators: Public classes
Slot, generators: Private classes
Slot, group: Private structures
Slot, group: Private classes
Slot, group: Private classes
Slot, last: Private structures
Slot, move: Private structures
Slot, num-generators: Public classes
Slot, num-rounds: Private classes
Slot, orbit: Private structures
Slot, order: Private structures
Slot, radix: Public classes
Slot, radix: Public classes
Slot, rank: Private structures
Slot, rep: Public structures
Slot, rep: Public structures
Slot, representative: Private structures
Slot, seen: Private structures
Slot, simplifier: Private classes
Slot, size: Public classes
Slot, size: Private structures
Slot, slp-context: Public classes
Slot, strong-generators: Public classes
Slot, symbol-table: Public classes
Slot, system: Private classes
Slot, table: Private classes
Slot, target: Private classes
Slot, to-group: Public classes
Slot, to-group: Public classes
Slot, transition: Private structures
Slot, transversal-system: Public classes
Slot, type-counts: Public classes
Slot, types: Public classes
Slot, value: Private structures
Slot, word: Private structures
Slot, word-generator: Private classes
Slot, zero-count: Public classes
slp-context: Public classes
Special Variable, *canonicalize-cycle-on-creation*: Public special variables
Special Variable, *context*: Private special variables
Special Variable, *perm-group-verbose*: Private special variables
Special Variable, *print-with-perm-syntax*: Private special variables
Special Variable, *taus*: Private special variables
strong-generators: Public classes
symbol-table: Public classes
system: Private classes

T
table: Private classes
target: Private classes
to-group: Public classes
to-group: Public classes
transition: Private structures
transversal-system: Public classes
type-counts: Public classes
types: Public classes

V
value: Private structures

W
word: Private structures
word-generator: Private classes

Z
zero-count: Public classes

Jump to:   %   *  
B   C   D   E   F   G   L   M   N   O   R   S   T   V   W   Z  

Previous: , Up: Indexes   [Contents][Index]

A.4 Data types

Jump to:   B   C   D   E   F   G   H   M   O   P   Q   R   S   T   U   V   W  
Index Entry  Section

B
block-coordinate-transformation: Private structures
block-subsystem: Private structures
block.lisp: The cl-permutation/block․lisp file
bruhat.lisp: The cl-permutation/bruhat․lisp file

C
cl-permutation: The cl-permutation system
cl-permutation: The cl-permutation package
cl-permutation.asd: The cl-permutation/cl-permutation․asd file
Class, combination-spec: Public classes
Class, combinatorial-spec: Public classes
Class, free-group: Public classes
Class, function-homomorphism: Public classes
Class, generator-homomorphism: Public classes
Class, god-table: Private classes
Class, homomorphism: Private classes
Class, minkwitz-table: Private classes
Class, mixed-radix-spec: Public classes
Class, perm-group: Public classes
Class, perm-spec: Public classes
Class, radix-spec: Public classes
Class, slp-context: Public classes
Class, word-spec: Public classes
combination-spec: Public classes
combinatorial-ranking.lisp: The cl-permutation/combinatorial-ranking․lisp file
combinatorial-spec: Public classes
cycle: Public structures
cycle-element: Public types

D
djs: Private structures
djs-rep: Private structures
do-group-elements.lisp: The cl-permutation/do-group-elements․lisp file

E
entry: Private structures
extra-functions.lisp: The cl-permutation/extra-functions․lisp file

F
File, block.lisp: The cl-permutation/block․lisp file
File, bruhat.lisp: The cl-permutation/bruhat․lisp file
File, cl-permutation.asd: The cl-permutation/cl-permutation․asd file
File, combinatorial-ranking.lisp: The cl-permutation/combinatorial-ranking․lisp file
File, do-group-elements.lisp: The cl-permutation/do-group-elements․lisp file
File, extra-functions.lisp: The cl-permutation/extra-functions․lisp file
File, find-subgroups.lisp: The cl-permutation/find-subgroups․lisp file
File, free-group.lisp: The cl-permutation/free-group․lisp file
File, god.lisp: The cl-permutation/god․lisp file
File, group.lisp: The cl-permutation/group․lisp file
File, homomorphism.lisp: The cl-permutation/homomorphism․lisp file
File, minkwitz.lisp: The cl-permutation/minkwitz․lisp file
File, orbit.lisp: The cl-permutation/orbit․lisp file
File, package.lisp: The cl-permutation/package․lisp file
File, permutation-generation.lisp: The cl-permutation/permutation-generation․lisp file
File, permutation-group.lisp: The cl-permutation/permutation-group․lisp file
File, permutation.lisp: The cl-permutation/permutation․lisp file
File, straight-line-program.lisp: The cl-permutation/straight-line-program․lisp file
File, utilities.lisp: The cl-permutation/utilities․lisp file
find-subgroups.lisp: The cl-permutation/find-subgroups․lisp file
free-group: Public classes
free-group.lisp: The cl-permutation/free-group․lisp file
function-homomorphism: Public classes

G
generator-homomorphism: Public classes
god-table: Private classes
god-table-entry: Private structures
god.lisp: The cl-permutation/god․lisp file
group.lisp: The cl-permutation/group․lisp file

H
homomorphism: Private classes
homomorphism.lisp: The cl-permutation/homomorphism․lisp file

M
minkwitz-table: Private classes
minkwitz.lisp: The cl-permutation/minkwitz․lisp file
mixed-radix-spec: Public classes

O
orbit.lisp: The cl-permutation/orbit․lisp file

P
Package, cl-permutation: The cl-permutation package
package.lisp: The cl-permutation/package․lisp file
perm: Public structures
perm-element: Public types
perm-group: Public classes
perm-spec: Public classes
permutation-generation.lisp: The cl-permutation/permutation-generation․lisp file
permutation-group.lisp: The cl-permutation/permutation-group․lisp file
permutation.lisp: The cl-permutation/permutation․lisp file

Q
queue: Private structures

R
radix-spec: Public classes
raw-perm: Private types

S
sgs: Private types
slp: Public structures
slp-composition: Public structures
slp-context: Public classes
slp-element: Public structures
slp-inversion: Public structures
slp-symbol: Public structures
straight-line-program.lisp: The cl-permutation/straight-line-program․lisp file
Structure, block-coordinate-transformation: Private structures
Structure, block-subsystem: Private structures
Structure, cycle: Public structures
Structure, djs: Private structures
Structure, djs-rep: Private structures
Structure, entry: Private structures
Structure, god-table-entry: Private structures
Structure, perm: Public structures
Structure, queue: Private structures
Structure, slp: Public structures
Structure, slp-composition: Public structures
Structure, slp-element: Public structures
Structure, slp-inversion: Public structures
Structure, slp-symbol: Public structures
System, cl-permutation: The cl-permutation system

T
transversal: Private types
Type, cycle-element: Public types
Type, perm-element: Public types
Type, raw-perm: Private types
Type, sgs: Private types
Type, transversal: Private types
Type, vector-index: Private types
Type, vector-size: Private types
Type, word: Private types

U
utilities.lisp: The cl-permutation/utilities․lisp file

V
vector-index: Private types
vector-size: Private types

W
word: Private types
word-spec: Public classes

Jump to:   B   C   D   E   F   G   H   M   O   P   Q   R   S   T   U   V   W