This is the cl-permutation Reference Manual, generated automatically by Declt version 4.0 beta 2 "William Riker" on Sun Dec 15 05:16:05 2024 GMT+0.
cl-permutation/cl-permutation.asdcl-permutation/package.lispcl-permutation/utilities.lispcl-permutation/permutation.lispcl-permutation/bruhat.lispcl-permutation/permutation-generation.lispcl-permutation/group.lispcl-permutation/free-group.lispcl-permutation/straight-line-program.lispcl-permutation/permutation-group.lispcl-permutation/minkwitz.lispcl-permutation/4-list-algorithm.lispcl-permutation/homomorphism.lispcl-permutation/orbit.lispcl-permutation/do-group-elements.lispcl-permutation/block.lispcl-permutation/combinatorial-ranking.lispcl-permutation/find-subgroups.lispcl-permutation/god.lispcl-permutation/block-subsystem-solver.lispcl-permutation/extra-functions.lispThe main system appears first, followed by any subsystem dependency.
cl-permutationA library for operating on permutations and permutation groups.
Robert Smith <robert@stylewarning.com>
BSD 3-clause (See LICENSE)
alexandria (system).
iterate (system).
cl-algebraic-data-type (system).
closer-mop (system).
uiop (system).
bordeaux-fft (system).
priority-queue (system).
cl-cont (system).
package.lisp (file).
utilities.lisp (file).
permutation.lisp (file).
bruhat.lisp (file).
permutation-generation.lisp (file).
group.lisp (file).
free-group.lisp (file).
straight-line-program.lisp (file).
permutation-group.lisp (file).
minkwitz.lisp (file).
4-list-algorithm.lisp (file).
homomorphism.lisp (file).
orbit.lisp (file).
do-group-elements.lisp (file).
block.lisp (file).
combinatorial-ranking.lisp (file).
find-subgroups.lisp (file).
god.lisp (file).
block-subsystem-solver.lisp (file).
extra-functions.lisp (file).
Files are sorted by type and then listed depth-first from the systems components trees.
cl-permutation/cl-permutation.asdcl-permutation/package.lispcl-permutation/utilities.lispcl-permutation/permutation.lispcl-permutation/bruhat.lispcl-permutation/permutation-generation.lispcl-permutation/group.lispcl-permutation/free-group.lispcl-permutation/straight-line-program.lispcl-permutation/permutation-group.lispcl-permutation/minkwitz.lispcl-permutation/4-list-algorithm.lispcl-permutation/homomorphism.lispcl-permutation/orbit.lispcl-permutation/do-group-elements.lispcl-permutation/block.lispcl-permutation/combinatorial-ranking.lispcl-permutation/find-subgroups.lispcl-permutation/god.lispcl-permutation/block-subsystem-solver.lispcl-permutation/extra-functions.lispcl-permutation/cl-permutation.asdcl-permutation (system).
cl-permutation/utilities.lisppackage.lisp (file).
cl-permutation (system).
%make-queue (function).
clear-membership-set (function).
copy-queue (function).
dequeue (function).
enqueue (function).
iota (function).
iota+1 (function).
iota-vector (function).
list-minimum (function).
list-to-queue (function).
make-membership-set (function).
make-queue (function).
maximum (function).
membership-set-count (function).
membership-set-nunion (function).
membership-sets-intersect-p (function).
nshuffle (function).
partition-if (function).
product (function).
queue (structure).
queue-elements (reader).
(setf queue-elements) (writer).
queue-empty-p (function).
queue-last (reader).
(setf queue-last) (writer).
queuep (function).
random-between (function).
random-element (function).
sign (function).
singletonp (function).
vector-index (type).
vector-size (type).
cl-permutation/permutation.lisputilities.lisp (file).
cl-permutation (system).
*canonicalize-cycle-on-creation* (special variable).
canonicalize-cycle (function).
canonicalize-cycles (function).
commutesp (function).
cycle (structure).
cycle-element (type).
cycle-identity-p (function).
cycle-length (function).
cycle-ref (function).
cycle-type (function).
cycles-to-one-line (function).
enable-perm-reader (function).
find-conjugator (function).
from-cycles (function).
list-to-perm (function).
make-cycle (function).
make-perm (function).
orbit-length (function).
orbit-of (function).
perm (structure).
perm-compose (function).
perm-compose-flipped (function).
perm-conjugate (function).
perm-element (type).
perm-eval (function).
perm-eval* (function).
perm-evaluator (function).
perm-evaluator* (function).
perm-even-p (function).
perm-expt (function).
perm-fixpoints (function).
perm-identity (function).
perm-identity-p (function).
perm-inverse (function).
perm-inverse-eval (function).
perm-inverse-eval* (function).
perm-last-non-fixpoint (function).
perm-length (function).
perm-odd-p (function).
perm-order (function).
perm-point-fixed-p (function).
perm-ref (function).
perm-sign (function).
perm-size (function).
perm-to-list (function).
perm-to-vector (function).
perm-transpose-entries (function).
perm-transpose-indexes (function).
perm< (function).
perm= (function).
perm=* (function).
permute (function).
print-object (method).
print-object (method).
random-perm (function).
rotate-cycle (function).
to-cycles (function).
vector-to-perm (function).
%make-cycle (function).
%make-perm (function).
%perm-compose-into/equal (function).
%perm-compose-into/unequal (function).
%perm-compose-upto (function).
*print-with-perm-syntax* (special variable).
allocate-identity-vector (function).
allocate-perm-vector (function).
assert-valid-permutation-elements (function).
check-cycle-elements (function).
contains-1-to-n (function).
copy-cycle (function).
copy-perm (function).
cycle-canonicalized (reader).
(setf cycle-canonicalized) (writer).
cycle-p (function).
cycle-rep (reader).
(setf cycle-rep) (writer).
map-cycle-mappings (function).
map-orbit (function).
perm-p (function).
perm-reader (function).
perm.rep (reader).
permuter (function).
print-cycle (function).
print-perm (function).
raw-perm (type).
rotate-vector! (function).
unsafe/perm-eval (function).
cl-permutation/bruhat.lisppermutation.lisp (file).
cl-permutation (system).
cl-permutation/permutation-generation.lispbruhat.lisp (file).
cl-permutation (system).
doperms (macro).
make-perm-generator (function).
abs> (function).
exists-mobile-p (function).
map-into-perm (function).
mobilep (function).
next-perm (function).
reverse-direction (function).
cl-permutation/group.lisppermutation-generation.lisp (file).
cl-permutation (system).
compose (generic function).
generators (generic function).
identity-element (generic function).
inverse (generic function).
num-generators (generic function).
cl-permutation/free-group.lispgroup.lisp (file).
cl-permutation (system).
compose (method).
compose (method).
compose (method).
compose (method).
compose (method).
free-group (class).
free-group-identity-p (function).
generators (method).
identity-element (method).
inverse (method).
make-free-group (function).
make-free-group-element (function).
num-generators (method).
%word-generator (function).
free-group-element-valid-p (function).
free-group-num-generators (reader method).
random-word-generator (function).
word (type).
word-generator (function).
word-length (function).
word-simplifier (function).
cl-permutation/straight-line-program.lispfree-group.lisp (file).
cl-permutation (system).
compose-slp (function).
evaluate-slp (function).
invert-slp (function).
make-load-form (method).
make-load-form (method).
make-load-form (method).
make-load-form (method).
print-object (method).
print-object (method).
print-object (method).
print-object (method).
slp (structure).
slp-composition (function).
slp-composition (structure).
slp-context (class).
slp-element (function).
slp-element (structure).
slp-inversion (function).
slp-inversion (structure).
slp-symbol (function).
slp-symbol (structure).
symbol-assignment (function).
(setf symbol-assignment) (function).
slp-composition%0 (reader).
slp-composition%1 (reader).
slp-element%0 (reader).
slp-inversion%0 (reader).
slp-symbol%0 (reader).
symbol-table (reader method).
(setf symbol-table) (writer method).
cl-permutation/permutation-group.lispstraight-line-program.lisp (file).
cl-permutation (system).
compose (method).
generate-perm-group (function).
generators (method).
group-degree (function).
group-element-p (function).
group-from (function).
group-from-cycles (function).
group-identity (function).
group-order (function).
identity-element (method).
inverse (method).
naive-generator-decomposition (function).
normal-subgroup-p (function).
num-generators (method).
perm-group (class).
print-object (method).
random-group-element (function).
same-group-p (function).
subgroup-p (function).
transversal-decomposition (function).
*context* (special variable).
*perm-group-verbose* (special variable).
*taus* (special variable).
add-generator (function).
free-group->perm-group-homomorphism (function).
free-group-generator-to-perm-group-generator (function).
group-bsgs (function).
make-sgs (function).
make-sigma-table (function).
make-transversal (function).
perm-group.element-size (reader method).
(setf perm-group.element-size) (writer method).
perm-group.factorization-generators (reader method).
(setf perm-group.factorization-generators) (writer method).
perm-group.free-group (reader method).
(setf perm-group.free-group) (writer method).
perm-group.generators (reader method).
(setf perm-group.generators) (writer method).
perm-group.slp-context (reader method).
(setf perm-group.slp-context) (writer method).
perm-group.strong-generators (reader method).
(setf perm-group.strong-generators) (writer method).
perm-group.transversal-system (reader method).
(setf perm-group.transversal-system) (writer method).
reduce-over-trans-decomposition (function).
sgs (type).
sgs-ref (function).
(setf sgs-ref) (function).
sigma (function).
(setf sigma) (function).
sigma-symbol (function).
tau-symbol (function).
trans-decomposition (function).
trans-element-p (function).
transversal (type).
transversal-ref (function).
(setf transversal-ref) (function).
update-transversal (function).
word-simplifier-for-perm-group (function).
cl-permutation/minkwitz.lisppermutation-group.lisp (file).
cl-permutation (system).
generator-decomposition (function).
print-object (method).
%make-system (function).
%system-size (function).
compute-factorization-generators (function).
entry (function).
entry (structure).
entry-seen (reader).
(setf entry-seen) (writer).
entry-word (reader).
generate-minkwitz-table (function).
mark-entry-as-seen (function).
minkwitz-table (class).
minkwitz-table-distribution (function).
minkwitz-table-group (reader method).
minkwitz-table-num-rounds (reader method).
minkwitz-table-num-words (function).
minkwitz-table-simplifier (reader method).
minkwitz-table-system (reader method).
minkwitz-table-word-generator (reader method).
new-entry (function).
stabilizer-orbits (function).
upper-bound-decomposition-length (function).
cl-permutation/4-list-algorithm.lispminkwitz.lisp (file).
cl-permutation (system).
print-object (method).
%make-perm-trie (function).
%make-sparse-array (function).
assoc* (function).
collect-perm-trie (function).
collect-perm-trie2 (function).
copy-perm-trie (function).
copy-sparse-array (function).
do-perm-trie (macro).
generate-words-of-bounded-length (function).
in-common? (function).
in-common?* (function).
ingest-perm (function).
make-perm-trie (function).
make-sparse-array (function).
map-perm-trie (function).
occupancy (function).
perm-trie (structure).
perm-trie-least (function).
perm-trie-next-perm (function).
perm-trie-num-elements (reader).
(setf perm-trie-num-elements) (writer).
perm-trie-p (function).
perm-trie-perm-size (reader).
(setf perm-trie-perm-size) (writer).
perm-trie-ref (function).
perm-trie-root (reader).
(setf perm-trie-root) (writer).
raw-saref (function).
saref (function).
(setf saref) (function).
schroeppel-shamir2 (function).
sparse-array (structure).
sparse-array-count (function).
sparse-array-elements (reader).
(setf sparse-array-elements) (writer).
sparse-array-p (function).
sparse-array-singleton-p (function).
test-ss (function).
transform-trie (function).
cl-permutation/homomorphism.lisp4-list-algorithm.lisp (file).
cl-permutation (system).
function-homomorphism (class).
generator-homomorphism (class).
homomorphism-image (generic reader).
homomorphism-induced-perm-group (function).
homomorphism-preimage (generic reader).
image (generic function).
initialize-instance (method).
homomorphism (class).
homomorphism-function (reader method).
homomorphism-generator-map (reader method).
cl-permutation/orbit.lisphomomorphism.lisp (file).
cl-permutation (system).
group-from-orbit (function).
group-orbits (function).
orbit-group-homomorphism (function).
subdirect-factors (function).
cl-permutation/do-group-elements.lisporbit.lisp (file).
cl-permutation (system).
do-group-elements (macro).
group-element-rank-functions (function).
group-element-from-signature (function).
group-radix (function).
cl-permutation/block.lispdo-group-elements.lisp (file).
cl-permutation (system).
find-minimal-block-system-containing (function).
find-non-trivial-block-system (function).
primitive-group-p (function).
print-object (method).
print-object (method).
%djs-and-rep-printer (function).
%make-coord (function).
%make-djs (function).
%make-djs-rep (function).
atkinson (function).
block-coordinate-transformation (structure).
block-coordinate-transformation-p (function).
block-slot (function).
block-subsystem (structure).
block-subsystem-base-block (reader).
(setf block-subsystem-base-block) (writer).
block-subsystem-block-size (reader).
(setf block-subsystem-block-size) (writer).
block-subsystem-group (reader).
(setf block-subsystem-group) (writer).
block-subsystem-interblock-group (function).
block-subsystem-interblock-group-homomorphism (function).
block-subsystem-intrablock-group (function).
block-subsystem-intrablock-group-generators (function).
block-subsystem-orbit (reader).
(setf block-subsystem-orbit) (writer).
block-subsystem-p (function).
block-subsystem-size (reader).
(setf block-subsystem-size) (writer).
canonicalize-raw-block-subsystems (function).
coord.order (reader).
(setf coord.order) (writer).
coord.rank (reader).
(setf coord.rank) (writer).
copy-block-coordinate-transformation (function).
copy-block-subsystem (function).
copy-djs (function).
copy-djs-rep (function).
djs (function).
djs (structure).
djs-change-representative (function).
djs-find (function).
djs-p (function).
djs-rep (structure).
djs-rep-djs (reader).
(setf djs-rep-djs) (writer).
djs-rep-p (function).
djs-representative (reader).
(setf djs-representative) (writer).
djs-union (function).
djs-value (reader).
(setf djs-value) (writer).
group-block-subsystems (function).
intrablock-coordinate-function (function).
make-block-subsystem (function).
make-subsystem-transformations (function).
raw-block-subsystems (function).
trivial-block-system-p (function).
cl-permutation/combinatorial-ranking.lispblock.lisp (file).
cl-permutation (system).
cardinality (generic function).
combination-spec (class).
combinatorial-spec (class).
make-combination-spec (function).
make-perm-spec (function).
make-radix-spec (function).
map-spec (function).
mixed-radix-spec (class).
perm-spec (class).
print-objects-of-spec (function).
radix (reader method).
radix (reader method).
radix-spec (class).
rank (generic function).
size (reader method).
unrank (generic function).
vector-to-mixed-radix-spec (function).
vector-to-word-spec (function).
word-spec (class).
array-for-spec (function).
binomial-coefficient-or-zero (function).
cardinality-cache (reader method).
(setf cardinality-cache) (writer method).
comb.zero-count (reader method).
word.type-counts (reader method).
word.types (reader method).
zero-array (function).
cl-permutation/find-subgroups.lispcombinatorial-ranking.lisp (file).
cl-permutation (system).
generator-exponent-set (function).
generator-orders (function).
map-exponent-subgroups (function).
map-suitable-subgroups (function).
subgroup-from-exponent-vector (function).
suitable-subgroup-p (function).
cl-permutation/god.lispfind-subgroups.lisp (file).
cl-permutation (system).
compute-god-table (function).
copy-god-table-entry (function).
god-table (class).
god-table-entry (structure).
god-table-entry-came-from (reader).
(setf god-table-entry-came-from) (writer).
god-table-entry-depth (reader).
(setf god-table-entry-depth) (writer).
god-table-entry-move (reader).
(setf god-table-entry-move) (writer).
god-table-entry-p (function).
god-table-entry-transition (reader).
(setf god-table-entry-transition) (writer).
god-table-generators (reader method).
god-table-group (reader method).
god-table-target (reader method).
god-table-vector (reader method).
make-god-table-entry (function).
reconstruct-perm (generic function).
cl-permutation/block-subsystem-solver.lispgod.lisp (file).
cl-permutation (system).
solve-and-verify (function).
subsystem-solver (function).
verbose (function).
cl-permutation/extra-functions.lispblock-subsystem-solver.lisp (file).
cl-permutation (system).
last-to-position (function).
perm-eject (function).
perm-extend (function).
perm-inject (function).
Packages are listed by definition order.
cl-permutationperm
common-lisp.
*canonicalize-cycle-on-creation* (special variable).
bruhat< (function).
bruhat<= (function).
canonicalize-cycle (function).
canonicalize-cycles (function).
cardinality (generic function).
combination-spec (class).
combinatorial-spec (class).
commutesp (function).
compose (generic function).
compose-slp (function).
cycle (structure).
cycle-element (type).
cycle-identity-p (function).
cycle-length (function).
cycle-ref (function).
cycle-type (function).
cycles-to-one-line (function).
do-group-elements (macro).
doperms (macro).
enable-perm-reader (function).
evaluate-slp (function).
find-conjugator (function).
find-minimal-block-system-containing (function).
find-non-trivial-block-system (function).
free-group (class).
free-group-identity-p (function).
from-cycles (function).
function-homomorphism (class).
generate-perm-group (function).
generator-decomposition (function).
generator-homomorphism (class).
generators (generic function).
group-degree (function).
group-element-p (function).
group-element-rank-functions (function).
group-from (function).
group-from-cycles (function).
group-from-orbit (function).
group-identity (function).
group-orbits (function).
group-order (function).
homomorphism-image (generic reader).
homomorphism-induced-perm-group (function).
homomorphism-preimage (generic reader).
identity-element (generic function).
image (generic function).
inverse (generic function).
invert-slp (function).
list-to-perm (function).
make-combination-spec (function).
make-cycle (function).
make-free-group (function).
make-free-group-element (function).
make-perm (function).
make-perm-generator (function).
make-perm-spec (function).
make-radix-spec (function).
map-spec (function).
mixed-radix-spec (class).
naive-generator-decomposition (function).
normal-subgroup-p (function).
num-generators (generic function).
orbit-group-homomorphism (function).
orbit-length (function).
orbit-of (function).
perm (structure).
perm-compose (function).
perm-compose-flipped (function).
perm-conjugate (function).
perm-element (type).
perm-eval (function).
perm-eval* (function).
perm-evaluator (function).
perm-evaluator* (function).
perm-even-p (function).
perm-expt (function).
perm-fixpoints (function).
perm-group (class).
perm-identity (function).
perm-identity-p (function).
perm-inverse (function).
perm-inverse-eval (function).
perm-inverse-eval* (function).
perm-last-non-fixpoint (function).
perm-length (function).
perm-odd-p (function).
perm-order (function).
perm-point-fixed-p (function).
perm-ref (function).
perm-sign (function).
perm-size (function).
perm-spec (class).
perm-to-list (function).
perm-to-vector (function).
perm-transpose-entries (function).
perm-transpose-indexes (function).
perm< (function).
perm= (function).
perm=* (function).
permute (function).
primitive-group-p (function).
print-objects-of-spec (function).
radix (generic reader).
radix-spec (class).
random-group-element (function).
random-perm (function).
rank (generic function).
rotate-cycle (function).
same-group-p (function).
size (generic reader).
slp (structure).
slp-composition (function).
slp-composition (structure).
slp-context (class).
slp-element (function).
slp-element (structure).
slp-inversion (function).
slp-inversion (structure).
slp-symbol (function).
slp-symbol (structure).
subdirect-factors (function).
subgroup-p (function).
symbol-assignment (function).
(setf symbol-assignment) (function).
to-cycles (function).
transversal-decomposition (function).
unrank (generic function).
vector-to-mixed-radix-spec (function).
vector-to-perm (function).
vector-to-word-spec (function).
word-spec (class).
%djs-and-rep-printer (function).
%make-coord (function).
%make-cycle (function).
%make-djs (function).
%make-djs-rep (function).
%make-perm (function).
%make-perm-trie (function).
%make-queue (function).
%make-sparse-array (function).
%make-system (function).
%perm-compose-into/equal (function).
%perm-compose-into/unequal (function).
%perm-compose-upto (function).
%system-size (function).
%word-generator (function).
*context* (special variable).
*perm-group-verbose* (special variable).
*print-with-perm-syntax* (special variable).
*taus* (special variable).
abs> (function).
add-generator (function).
allocate-identity-vector (function).
allocate-perm-vector (function).
array-for-spec (function).
assert-valid-permutation-elements (function).
assoc* (function).
atkinson (function).
binomial-coefficient-or-zero (function).
block-coordinate-transformation (structure).
block-coordinate-transformation-p (function).
block-slot (function).
block-subsystem (structure).
block-subsystem-base-block (reader).
(setf block-subsystem-base-block) (writer).
block-subsystem-block-size (reader).
(setf block-subsystem-block-size) (writer).
block-subsystem-group (reader).
(setf block-subsystem-group) (writer).
block-subsystem-interblock-group (function).
block-subsystem-interblock-group-homomorphism (function).
block-subsystem-intrablock-group (function).
block-subsystem-intrablock-group-generators (function).
block-subsystem-orbit (reader).
(setf block-subsystem-orbit) (writer).
block-subsystem-p (function).
block-subsystem-size (reader).
(setf block-subsystem-size) (writer).
canonicalize-raw-block-subsystems (function).
cardinality-cache (generic reader).
(setf cardinality-cache) (generic writer).
check-cycle-elements (function).
clear-membership-set (function).
collect-perm-trie (function).
collect-perm-trie2 (function).
comb.zero-count (generic reader).
compute-factorization-generators (function).
compute-god-table (function).
contains-1-to-n (function).
coord.order (reader).
(setf coord.order) (writer).
coord.rank (reader).
(setf coord.rank) (writer).
copy-block-coordinate-transformation (function).
copy-block-subsystem (function).
copy-cycle (function).
copy-djs (function).
copy-djs-rep (function).
copy-god-table-entry (function).
copy-perm (function).
copy-perm-trie (function).
copy-queue (function).
copy-sparse-array (function).
cycle-canonicalized (reader).
(setf cycle-canonicalized) (writer).
cycle-p (function).
cycle-rep (reader).
(setf cycle-rep) (writer).
dequeue (function).
djs (function).
djs (structure).
djs-change-representative (function).
djs-find (function).
djs-p (function).
djs-rep (structure).
djs-rep-djs (reader).
(setf djs-rep-djs) (writer).
djs-rep-p (function).
djs-representative (reader).
(setf djs-representative) (writer).
djs-union (function).
djs-value (reader).
(setf djs-value) (writer).
do-perm-trie (macro).
enqueue (function).
entry (function).
entry (structure).
entry-seen (reader).
(setf entry-seen) (writer).
entry-word (reader).
exists-mobile-p (function).
free-group->perm-group-homomorphism (function).
free-group-element-valid-p (function).
free-group-generator-to-perm-group-generator (function).
free-group-num-generators (generic reader).
generate-minkwitz-table (function).
generate-words-of-bounded-length (function).
generator-exponent-set (function).
generator-orders (function).
god-table (class).
god-table-entry (structure).
god-table-entry-came-from (reader).
(setf god-table-entry-came-from) (writer).
god-table-entry-depth (reader).
(setf god-table-entry-depth) (writer).
god-table-entry-move (reader).
(setf god-table-entry-move) (writer).
god-table-entry-p (function).
god-table-entry-transition (reader).
(setf god-table-entry-transition) (writer).
god-table-generators (generic reader).
god-table-group (generic reader).
god-table-target (generic reader).
god-table-vector (generic reader).
group-block-subsystems (function).
group-bsgs (function).
group-element-from-signature (function).
group-radix (function).
homomorphism (class).
homomorphism-function (generic reader).
homomorphism-generator-map (generic reader).
in-common? (function).
in-common?* (function).
ingest-perm (function).
intrablock-coordinate-function (function).
iota (function).
iota+1 (function).
iota-vector (function).
last-to-position (function).
list-minimum (function).
list-to-queue (function).
make-block-subsystem (function).
make-god-table-entry (function).
make-membership-set (function).
make-perm-trie (function).
make-queue (function).
make-sgs (function).
make-sigma-table (function).
make-sparse-array (function).
make-subsystem-transformations (function).
make-transversal (function).
map-cycle-mappings (function).
map-exponent-subgroups (function).
map-into-perm (function).
map-orbit (function).
map-perm-trie (function).
map-suitable-subgroups (function).
mark-entry-as-seen (function).
maximum (function).
membership-set-count (function).
membership-set-nunion (function).
membership-sets-intersect-p (function).
minkwitz-table (class).
minkwitz-table-distribution (function).
minkwitz-table-group (generic reader).
minkwitz-table-num-rounds (generic reader).
minkwitz-table-num-words (function).
minkwitz-table-simplifier (generic reader).
minkwitz-table-system (generic reader).
minkwitz-table-word-generator (generic reader).
mobilep (function).
new-entry (function).
next-perm (function).
nshuffle (function).
occupancy (function).
partition-if (function).
perm-eject (function).
perm-extend (function).
perm-group.element-size (generic reader).
(setf perm-group.element-size) (generic writer).
perm-group.factorization-generators (generic reader).
(setf perm-group.factorization-generators) (generic writer).
perm-group.free-group (generic reader).
(setf perm-group.free-group) (generic writer).
perm-group.generators (generic reader).
(setf perm-group.generators) (generic writer).
perm-group.slp-context (generic reader).
(setf perm-group.slp-context) (generic writer).
perm-group.strong-generators (generic reader).
(setf perm-group.strong-generators) (generic writer).
perm-group.transversal-system (generic reader).
(setf perm-group.transversal-system) (generic writer).
perm-inject (function).
perm-p (function).
perm-reader (function).
perm-trie (structure).
perm-trie-least (function).
perm-trie-next-perm (function).
perm-trie-num-elements (reader).
(setf perm-trie-num-elements) (writer).
perm-trie-p (function).
perm-trie-perm-size (reader).
(setf perm-trie-perm-size) (writer).
perm-trie-ref (function).
perm-trie-root (reader).
(setf perm-trie-root) (writer).
perm.rep (reader).
permuter (function).
print-cycle (function).
print-perm (function).
product (function).
queue (structure).
queue-elements (reader).
(setf queue-elements) (writer).
queue-empty-p (function).
queue-last (reader).
(setf queue-last) (writer).
queuep (function).
random-between (function).
random-element (function).
random-word-generator (function).
raw-block-subsystems (function).
raw-perm (type).
raw-saref (function).
reconstruct-perm (generic function).
reduce-over-trans-decomposition (function).
reverse-direction (function).
rotate-vector! (function).
saref (function).
(setf saref) (function).
schroeppel-shamir2 (function).
sgs (type).
sgs-ref (function).
(setf sgs-ref) (function).
sigma (function).
(setf sigma) (function).
sigma-symbol (function).
sign (function).
singletonp (function).
slp-composition%0 (reader).
slp-composition%1 (reader).
slp-element%0 (reader).
slp-inversion%0 (reader).
slp-symbol%0 (reader).
solve-and-verify (function).
sparse-array (structure).
sparse-array-count (function).
sparse-array-elements (reader).
(setf sparse-array-elements) (writer).
sparse-array-p (function).
sparse-array-singleton-p (function).
stabilizer-orbits (function).
subgroup-from-exponent-vector (function).
subsystem-solver (function).
suitable-subgroup-p (function).
symbol-table (generic reader).
(setf symbol-table) (generic writer).
tau-symbol (function).
test-ss (function).
trans-decomposition (function).
trans-element-p (function).
transform-trie (function).
transversal (type).
transversal-ref (function).
(setf transversal-ref) (function).
trivial-block-system-p (function).
unsafe/perm-eval (function).
update-transversal (function).
upper-bound-decomposition-length (function).
vector-index (type).
vector-size (type).
verbose (function).
word (type).
word-generator (function).
word-length (function).
word-simplifier (function).
word-simplifier-for-perm-group (function).
word.type-counts (generic reader).
word.types (generic reader).
zero-array (function).
Definitions are sorted by export status, category, package, and then by lexicographic order.
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.
Iterate over all permutations of size N, optionally returning RESULT.
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.
Does W precede V in the Bruhat sense, or are they equal?
Rotate a cycle CYCLE so its least value is syntactically first.
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.
Do the permutations A and B commute?
Compose two SLPs SLP1 and SLP2.
Is the cycle CYCLE representative of an identity permutation?
Compute the length of the cycle CYCLE.
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).
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.
Convert CYCLES to one-line notation. This is the same as flattening the cycles.
Note: This is not the same as FROM-CYCLES.
Enable the use of #[...] for perms.
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.
Find an element that conjugates X to Y. In other words, find the permutation C such that
Y = C X C^-1.
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.
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.
Is X an identity element of a free group?
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.
Generate a permutation group generated by the list of permutations 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".
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.
Decide if the permutation PERM is an element of the group 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.
Generate a permutation group from a list of generators, which are represented as lists.
Generate a permutation group from a list of generators, which are represented as cycles.
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.
Return the identity element of the group GROUP.
Compute the orbits of the group GROUP. This will be a list of arrays of points.
Compute the order of the permutation group GROUP.
Given a group GROUP, and a homomorphism HOM mapping elements of that group to permutations,compute the homomorphism-induced group.
Invert the SLP SLP.
Construct a perm from a list LIST.
Make a COMBINATION-SPEC representing the space of objects representing M items being chosen out of N total.
Create a new cycle with the elements ELEMENTS.
Make a free group that contains NUM-GENERATORS generators.
Make an element of the free group G where ELEMENTS are either integer generators of G, or other elements created by this function.
Construct a permutation from the numbers ELEMENTS.
Create a generator that generates permutations of size N.
Make a PERM-SPEC representing the set of permutations S_n.
Make a RADIX-SPEC representing all numbers between 0 and RADIX^SIZE - 1.
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.
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.
Is the group SUBGROUP a normal subgroup of GROUP?
Compute a homomorphism between elements of the permutation group ORIGINAL-GROUP to the naturally induced group of an orbit ORBIT of ORIGINAL-GROUP.
Compute the length of the orbit of the element N in the permutation PERM.
Compute the orbit of the element N in the permutation PERM. Return a cycle representing the orbit of N.
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.
Compose the permutatons P1 and P2: x |-> P2(P1(x)). This is equivalent to (PERM-COMPOSE P2 P1).
Conjugate the permutation P by C. This is C P C^-1.
Evaluate the permutation PERM at index N.
Evaluate the permutation PERM at index N. If N is larger than the size of the permutation, return the fixed point.
Return an evaluation function for the permutation PERM (a la PERM-EVAL).
Return an evaluation function for the permutation PERM (a la PERM-EVAL*).
Is PERM an even permutation?
Raise a permutation PERM to the Nth power. If N is negative, then the inverse will be raised to the -Nth power.
Return a list of the fixed points in PERM less than or equal to N, which is the perm’s size by default.
The identity permutation of size N.
Is the permutation PERM an identity permutation?
Find the inverse of the permutation PERM.
Evaluate the inverse of the permutation PERM at index 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.
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.
Count the number of inversions in the permutation PERM.
Is PERM an odd permutation?
Compute the order of a permutation PERM. This is the non-negative power required to exponentiate it to identity.
Is K fixed in the perm PERM?
Compute the zero-based index of PERM at N.
The sign of a permutation PERM.
The size of a permutation PERM.
Convert a permutation PERM to a list representation.
Convert a permutation PERM to a vector.
Transpose the entries A and B in PERM.
Transpose the indexes A and B in PERM.
Is the permutation A lexicographically preceding B?
Are PERM and OTHER-PERM mathematically equal? (Note: Different sized perms are considered unequal. See PERM=* for extended equality.)
Are PERM and OTHER-PERM mathematically equal when viewed as functions on naturals? (Note: For inequality on different sized perms, see PERM=.)
Permute the sequence A according to PERM. Retun an object of the same kind as A by default unless TYPE is specified.
Is the perm group GROUP primitive?
Given the combinatorial specification SPEC, enumerate all possible objects represented by that specification, printing them to the stream STREAM.
Generate a random element of the group GROUP.
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
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.
Are the groups GROUP1 and GROUP2 the same (i.e., have the same permutation elements)?
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.
Is the group SUBGROUP a subgroup of GROUP?
Within the context CTX and the symbol SYMBOL, look up its representation. Return NIL if it does not exist.
Assign to the symbol SYMBOL the representation REPRESENTATION within the context CTX.
Convert a permutation PERM in its standard representation to its cycle representation.
Decompose the permutation PERM into transversal sigmas of the group GROUP.
Make a MIXED-RADIX-SPEC representing all mixed-radix numbers specified by the vector RADIX.
Convert a vector VECTOR to a permutation. VECTOR must represent a valid elements of a permutation.
WORD should be a vector containing 1, 2, ..., N, possibly with repeated elements.
Compute the cardinality of SPEC. This represents the total number of elements described by the spec.
combination-spec)) ¶mixed-radix-spec)) ¶radix-spec)) ¶combinatorial-spec)) ¶Compose two elements A and B within the group G.
perm-group) a b) ¶free-group) a b) ¶free-group) a (b (eql 0))) ¶free-group) a (b null)) ¶free-group) (a (eql 0)) b) ¶free-group) (a null) b) ¶Return a list of the generators of G.
perm-group)) ¶free-group)) ¶Image group of the homomorphism HOM.
generator-homomorphism)) ¶Image of the homomorphism.
function-homomorphism)) ¶Image of the homomorphism.
Preimage group of the homomorphism HOM.
generator-homomorphism)) ¶Preimage of the homomorphism.
function-homomorphism)) ¶Preimage of the homomorphism.
Return the identity element of the group G.
perm-group)) ¶free-group)) ¶Compute the image of object OBJECT with respect to the homomorphism HOMOMORPHISM.
generator-homomorphism) (elt perm)) ¶Given a homomorphism HOM, compute the image of ELT.
function-homomorphism) obj) ¶function) object) ¶Compute the inverse of A within the group G.
perm-group) a) ¶free-group) a) ¶Return the number of generators of the group G.
perm-group)) ¶free-group)) ¶mixed-radix-spec)) ¶automatically generated reader method
radix-spec)) ¶automatically generated reader method
Rank the set SET to an integer according to the spec SPEC.
combination-spec) set) ¶mixed-radix-spec) set) ¶radix-spec) set) ¶combinatorial-spec)) ¶automatically generated reader method
size.
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.)
combination-spec) (idx integer) &key set) ¶mixed-radix-spec) (idx integer) &key set) ¶radix-spec) (idx integer) &key set) ¶homomorphism) &key) ¶slp-symbol) &optional environment-3) ¶slp-inversion) &optional environment-3) ¶slp-composition) &optional environment-3) ¶slp-element) &optional environment-3) ¶slp-symbol) stream) ¶perm-group) stream) ¶slp-inversion) stream) ¶slp-composition) stream) ¶slp-element) stream) ¶minkwitz-table) stream) ¶structure-object.
algebraic-data-type.
A component of ADT CL-PERMUTATION:SLP
slp.
cl-algebraic-data-type.
cl-permutation:slp
(error "unspecified field.")
This slot is read-only.
cl-algebraic-data-type.
cl-permutation:slp
(error "unspecified field.")
This slot is read-only.
A component of ADT CL-PERMUTATION:SLP
A component of ADT CL-PERMUTATION:SLP
A component of ADT CL-PERMUTATION:SLP
Representation of a sequence
:zero-count
This slot is read-only.
Abstract class representing linear sequences of objects of size SIZE.
(or null unsigned-byte)
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).
:num-generators
This slot is read-only.
Simple class which wraps homomorphic functions, associating them with the preimage and image of the function.
Preimage of the homomorphism.
:from-group
This slot is read-only.
Image of the homomorphism.
:to-group
This slot is read-only.
Homomorphism function.
common-lisp.
:function
This slot is read-only.
A perm group homomorphism constructed from images of its genertators.
This class is FUNCALLable.
Preimage of the homomorphism.
:from-group
This slot is read-only.
Image of the homomorphism.
:to-group
This slot is read-only.
A unary function mapping generators of FROM-GROUP to objects of the resulting group TO-GROUP.
:generator-map
This slot is read-only.
Representation of a mixed-radix number of size SIZE with mixed radix RADIX.
cardinality.
radix.
rank.
unrank.
Representation of a permutation group generated by a finite number of generators.
compose.
generators.
identity-element.
inverse.
num-generators.
(setf perm-group.element-size).
perm-group.element-size.
(setf perm-group.factorization-generators).
perm-group.factorization-generators.
(setf perm-group.free-group).
perm-group.free-group.
(setf perm-group.generators).
perm-group.generators.
(setf perm-group.slp-context).
perm-group.slp-context.
(setf perm-group.strong-generators).
perm-group.strong-generators.
(setf perm-group.transversal-system).
perm-group.transversal-system.
print-object.
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.
:element-size
A list of generators of the group.
:generators
The strong generating set of the group. This is a vector mapping integers to lists of generators which generate the i’th stabilizer.
:strong-generators
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.
:transversal-system
A free group corresponding to the given permutation group.
:free-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.
:factorization-generators
SLPs corresponding to all sigmas and strong generators.
:slp-context
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.)
Representation of a sequence of numbers of length SIZE whose elements are between 0 and RADIX - 1.
cardinality.
radix.
rank.
unrank.
Represents a context (e.g., symbol assignments) in which an SLP can be evaluated.
A mapping between symbols and their representation as SLPs.
(make-hash-table :test (quote eq))
Representation of a word of elements 1 to 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.
:types
This slot is read-only.
Vector of non-negative integers representing the count of each individual element type. (The sum of this vector should equal TYPES.)
:type-counts
This slot is read-only.
Special variable used to hold the context being built up for a group.
Print permutations with special permutation syntax?
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.
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.
Allocate a vector compatible with a size-N permutation.
Verify (via assertions) that the elements
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.
If N < K, return 0, otherwise return the binomial coefficient.
In which slot is BLK found in the block subsystem BLOCK-SUBSYSTEM?
Compute the interblock group of a block subsystem SUBSYS.
Given a block subsystem SUBSYS, compute a homomorphism to its interblock group.
Compute (possibly redundant) generators of the intrablock group, along with the computed reference frames.
size.
Take a raw list of block systems BSS and canonicalize them.
Ensure that the elements ELEMENTS are those of a valid cycle.
Modify the permutation group PERM-GROUP so that it is capable of factorizing elements into generators.
Check that ELEMENTS contains the integers between 1 and the length of the sequence, inclusive.
rank.
rep.
Remove and return an element from the queue QUEUE.
Construct a fresh DJS node.
Change the representative of DJS to point to itself.
Find the canonical DJS node of which the DJS node D is a part.
djs.
Link together the DJS nodes A and B.
The representative of the union will be that of B.
Add an element OBJ to the end of the queue QUEUE.
seen.
Construct a homomorphism from the perm group PERM-GROUP’s free group to elements of the perm group itself.
Given the free group G and some purported element ELEMENT, return a boolean indicating whether it is a valid element of G.
Convert the free group generator FREE-GROUP-GENERATOR to a generator within the perm group PERM-GROUP.
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.)
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.
Return the orders of each generator of the group G.
move.
Return a list of block subsystems of the group GROUP.
Retrieve a base and associated strong generating set (BSGS) as two values respectively for the permutation group PERM-GROUP.
Compute the radix of the group GROUP.
Generate a list of numbers between 0 and N-1.
Generate a list of numbers between 1 and N.
Generate the equivalent of (COERCE (IOTA N) ’VECTOR).
Create a permutation that will permute the last element of a permutation of size SIZE to the position NEW-POS.
Find the minimum element of the list via CL:MIN.
Convert the list LIST into a queue. Note: LIST may be modified.
Create a new empty queue.
Make a strong generating set of size N.
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.
Make a transversal of size N.
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.
Map the unary function F across all exponent subgroups of the group GROUP.
Given a unary function F, apply it to each element of the orbit of N within the perm PERM.
Visit the permutations of TRIE in lexicographic order. F should be a function taking two arguments:
1. The perm
2. The value associated with the perm.
RE-ORDER is an optional argument, either a function or a perm that re-orders the children.
For example, if SIZE = 10, then #[10 9 8 7 6 5 4 3 2 1] would traverse in reverse lexicographic order.
Map the unary function F across all suitable subgroups of the group GROUP.
Compute the maximum of LIST, optionally via the function KEY.
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.
How many words are represented by the Minkwitz table M?
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.
Given a predicate F, partition SEQ into two sublists, the first of which has elements that satisfy F, the second which do not.
Remove the largest element of a permutation.
Extend a permutation PERM
For a permutation PERM of size N, inject N+1 to the position INJECT-TO.
Find the lexicographic successor to a perm.
root.
Compute a permutation P such that (PERMUTE P FROM) == TO.
Printer for cycles.
An asterisk in printed syntax denotes that the cycle has not been canonicalized (though it may be already be canonical).
Printer for perms.
Compute the product of the items in SEQ, optionally via the function KEY.
Is the queue QUEUE empty?
last.
Generate a random integer between A and B, inclusive.
Select a random element from the sequence SEQ.
Compute all minimal, disjoint block subsystems of the group GROUP.
Returns a list of block systems.
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.
Rotate the vector VEC a total of N elements left/counterclockwise in-place. If N is negative, rotate in the opposite direction.
Retrieve sigma_kj for the transversal system TRANS, or NIL if it doesn’t exist.
Return a symbol representing sigma_kj. This is used for perms that are added to the transversal system during group construction.
Return the sign of X.
Does X contain one element?
Compute a list of orbits corresponding to the BSGS of GROUP. In particular, calculate { i ↦ G⁽ⁱ⁾bᵢ₊₁ }.
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).
Is the group G (which is presumably a subgroup of some other group) suitable for further computation?
Return a freshly made symbol for tau.
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).
Get the Kth element of the transversal TRANS. This is representative of all sigma_k.
Is the block system BS a trivial block system?
What is the maximum length of a decomposition using the Minkwitz table M?
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.
What is the length of the word W?
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.
Construct a simplifier for the permutation group G according to its free group.
Make an array of zeroes of length LENGTH.
combinatorial-spec)) ¶automatically generated reader method
combinatorial-spec)) ¶automatically generated writer method
combination-spec)) ¶automatically generated reader method
free-group)) ¶automatically generated reader method
function-homomorphism)) ¶Homomorphism function.
generator-homomorphism)) ¶A unary function mapping generators of FROM-GROUP to objects of the resulting group TO-GROUP.
minkwitz-table)) ¶The group for which this table is valid.
minkwitz-table)) ¶The total number of words searched to get this table.
minkwitz-table)) ¶The simplification function that was used during the generation of the table. (See GENERATE-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.
minkwitz-table)) ¶The word-generating function that was used during the creation of this table. (See GENERATE-MINKWITZ-TABLE.)
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.
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.
perm-group)) ¶perm-group)) ¶A free group corresponding to the given permutation group.
perm-group)) ¶perm-group)) ¶A list of generators of the group.
perm-group)) ¶perm-group)) ¶SLPs corresponding to all sigmas and 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.
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.
slp-context)) ¶slp-context)) ¶A mapping between symbols and their representation as SLPs.
Representation of a block subsystem of a group. A "block subsystem" is a G-orbit of a block.
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.
Pointer to the representative element of a DJS.
structure-object.
cl-permutation::djs
Representation of an entry in a Minkwitz table.
A trie-like data structure to store permutations.
structure-object.
list
:group
This slot is read-only.
:table
This slot is read-only.
:target
This slot is read-only.
:generators
This slot is read-only.
funcallable-standard-object.
Data used to decompose elements of a group into generators (and inverses).
The group for which this table is valid.
:group
This slot is read-only.
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.
:system
This slot is read-only.
The total number of words searched to get this table.
:num-rounds
This slot is read-only.
The simplification function that was used during the generation of the table. (See GENERATE-MINKWITZ-TABLE.)
:simplifier
This slot is read-only.
The word-generating function that was used during the creation of this table. (See GENERATE-MINKWITZ-TABLE.)
:word-generator
This slot is read-only.
Type defining the internal representation of a perm.
Possible indexes to a vector.
Possible sizes of a vector.
| Jump to: | %
(
A B C D E F G H I L M N O P Q R S T U V W Z |
|---|
| Jump to: | %
(
A B C D E F G H I L M N O P Q R S T U V W Z |
|---|
| Jump to: | %
*
B C D E F G L M N O P R S T V W Z |
|---|
| Jump to: | %
*
B C D E F G L M N O P R S T V W Z |
|---|
| Jump to: | 4
B C D E F G H M O P Q R S T U V W |
|---|
| Jump to: | 4
B C D E F G H M O P Q R S T U V W |
|---|