List of Usage statements in AbstractAlgebra

A B C D E F G H I J K L M N O P Q R S T U V W X Y Z lower case items

• A::usage = "A[n] returns the group of even permutations on the set {1,2,..n} under composition. See Alternating for more details.";

• AGroupoid::usage = "AGroupoid[R] returns the additive Groupoid associated with the Ringoid R. This is equivalent to AdditiveGroupoid[R].";

• AbelianQ::usage = "AbelianQ[G] returns True if the Groupoid G is Abelian (commutative), and False otherwise. This is equivalent to CommutativeQ[G].";

• AddPermToGroup::usage = "AddPermToGroup[p] will add the permutation p to the list of alleged symmetries (which is called MySymmetryGroup). Note that p can be in the form of a list ({1,3,4,2}) or a list of rules ({1->1, 2->3, 3->4, 4->2}).";

• Addition::usage = "Addition[S] is the addition operator in the Ringoid S. If S is a Groupoid, Addition[S] is simply the Groupoid's operation. Given an extension Ext of a ring, Addition[Ext] is the addition in this extension. Addition is also a value for the Operation option that is used in some ring functions.";

• AdditiveGroupoid::usage = "AdditiveGroupoid[R] returns the additive Groupoid of the ring R. A shortcut is AGroupoid[R].";

• AdditiveToMultiplicative::usage = "AdditiveToMultiplicative[R, add] returns the multiplicative form of the element add, currently given in additive form, from the ringoid (typically a Galois field) R.";

• Adjoin::usage = "Adjoin[list, num] returns the elements in list with num adjoined. If num is the nth root of rad, then the set of all 'polynomials' of degree less than n in the 'indeterminate' rad with coefficients from list is returned. If num is anything else, the function fails. Adjoin[S, num], for a structured set S, is equivalent to Adjoin[Elements[S], num]. Adjoin[list, ind, deg] returns the set of polynomials in the indeterminate ind of degree deg (or less) with coefficients from list. Adjoin[S, ind, deg], for a structured set S, is equivalent to Adjoin[Elements[S], ind, deg].";

• Adjoint::usage = "Adjoint[A] returns Transpose[MatrixConjugate[A]], the transpose of the conjugate of a matrix. (For the usage of adjoint as it relates to determinants, see DetAdjoint.)";

• Alternating::usage = "Alternating[n] returns the group of even permutations on the set {1,2,..n} under composition. There are two options for this function, ProductOrder and IndexLimit. Since the elements of this group are permutations, one can specify the order that the product is taken. See ProductOrder for more information, including the values that can be used. IndexLimit defaults to 6 and indicates the upper limit for the value of the index n.";

• AlternatingGroup::usage = "AlternatingGroup[n] - see Alternating.";

• Annihilator::usage = "Annihilator[R, S] returns the annihilator of S in R. This consists of all elements r in R such that r s = Zero[R] for all elements s in S.";

• AntiCommutingMatricesQ::usage = "AntiCommutingMatricesQ[R, A, B] returns True or False depending on whether the matrices A and B over the Ringoid R anti-commute in the sense that A B = - B A. AntiCommutingMatricesQ[MatricesOver[R,{n,n}], A, B] works similarly. For matrices with numeric entries (over Integers, Rationals, Reals or Complex), AntiCommutingMatricesQ[A, B] works similarly.";

• Any::usage = "Any is a value for the SelectFrom option for RandomElement and RandomElements. This value allows any element to be returned. Alternatively, one may use NonIdentity (or NonZero or NonUnity when working with rings).";

• AsIJK::usage = "AsIJK is a value for the Form option for the QuaternionGroup function. This specifies that the quaternion group is to be represented by the elements {± 1, ± I, ± JJ, ± KK}. (Note that K is a reserved symbol in version 3 and J is used with rings), with a set of relations governing these elements.";

• AsMatrices::usage = "AsMatrices is a value for the Form option for the QuaternionGroup function. This specifies that the quaternion group is to be represented by 2-by-2 matrices. This is the default value.";

• AsSymbols::usage = "AsSymbols is a value for the Form option for the QuaternionGroup function. This specifies that the quaternion group is to be generated by the symbols {a, b} subject to a set of relations governing these symbols. In this form, the elements used are given in the form of Mathematica strings.";

• Associates::usage = "Associates is a value for the Combine option of IntegerDivisors and ZdDivisors. With this value, the divisors of n are grouped in pairs {a, b} such that a and b are associates.";

• AssociativeQ::usage = "AssociativeQ[S] returns True if the structure S is associative, and False otherwise. When used with rings, one has the Operation option, which can have the value Addition, Multiplication or Both.";

• Aut::usage ="Aut[G] is a shortcut for AutomorphismGroup[G].";

• Automorphism::usage="Automorphism[G, a \[Rule] b] forms the automorphism determined by the single rule a \[Rule] b, if a and b are both generators of the cyclic group G.";

• AutomorphismGroup::usage="AutomorphismGroup[G] returns the group of automorphisms of a cyclic group G.";

• BackgroundColors::usage = "BackgroundColors is a global constant consisting of a string of colors from the Graphics`Colors` package that are used for colors in the Cayley table and other similar places. Although the colors are given in RGBColor format, the default list for this variable uses the following names of colors:\n {Yellow, Orange, Violet, Blue, Mint, Turquoise, EmeraldGreen, GreenDark, Pink, BlueLight, Banana, Green, Brown, Gray, Red, Purple, CadmiumYellow, Maroon, Navy, Salmon, Aquamarine, Indigo, Lavender, Antique, Bisque, Burlywood, Eggshell, Khaki, BlueViolet, CadmiumOrange, CadmiumRedDeep, Cerulean, Chartreuse, Cyan, DeepPink, Magenta, OrangeRed, Peacock, SkyBlueDeep, TurquoiseDark, Ultramarine}";

• BaseRing::usage="BaseRing[R] returns the base ring of an extension or quotient ring. If p is a polynomial, BaseRing[p] returns the underlying base ring for the polynomial p.";

• BooleanRing::usage = "BooleanRing[n] constructs the Boolean Ring consisting of the set of subsets of {1, 2, ..., n} with the operations symmetric difference and intersection. BooleanRing[B] constructs the ring with subsets of the list B.";

• Both::usage = "Both is a value for the Operation option used in various ring functions.";

• CInf::usage = "Special symbol used for this lab.";

• Canonical::usage = "Canonical is a value for the Representatives option for the QuotientGroup (and QuotientRing) function. This value causes QuotientGroup to use the 'first' element in the coset.";

• CartesianProduct::usage = "CartesianProduct[els1, els2] returns the Cartesian product, as a list of ordered pairs, of the two sets els1 and els2. CartesianProduct[els1, els2, Partition ® True] partitions the ordered pairs using the Partition function, cut to the length of els2. CartesianProduct[ListOfLists] returns the Cartesian product of the lists of elements in ListOfLists.";

• Cautious::usage="Cautious is an option for IsomorphismQ, indicating whether MorphismQ (using value True) or ProbableMorphismQ (using value False) should be used. The default value is False.";

• CayleyForm::usage = "CayleyForm is an option for CayleyTable (and functions that form Groupoids or Ringoids) to indicate whether the elements in the Cayley table should be displayed in InputForm, OutputForm or some other form. The default value is OutputForm.";

• CayleyTable::usage = "CayleyTable[G] returns the Cayley table for the structure G colored with a different color for each element in G. If it is desired that Elements[G] be reordered, then CayleyTable[G, TheSet ® NewOrder] will return a new Cayley table according to the new ordering of the elements as found in the list NewOrder. When used with rings, the Operation option can be used, which can have the value Addition, Multiplication or Both. Other options specific to CayleyTable (with the default value given in parentheses) are HeadingsColored (True), ShowOperator (True), ShowName (True), ShowBodyText (True), ShowSidesText (True), ShowKey (True), VarToUse ('g'), KeyForm (InputForm), and CayleyForm (InputForm). CayleyTable[{G1,G2,..Gn},opts] returns CayleyTable[G1,opts], CayleyTable[G2,opts] and so on. Multiple CayleyTables can also be obtained by using the following variant forms: CayleyTable[{G1,G2,..Gn}, {opts1, opts2, .. optsn}] (optsi applies to Gi) and CayleyTable[{{G1, opts1}, {G2, opts2},..{Gn, optsn}}] (optsi applies to Gi).";

• CayleyTables::usage = "CayleyTables[R] returns the Cayley tables (in double array form), for the additive and multiplicative Groupoids associated with the Ringoid R. CayleyTables[R, Mode \[Rule] Visual] returns a graphical view of these tables. See CayleyTable for a description of the available options.";

• Center::usage = "Center[G] returns the center of the group G. This is identical to GroupCenter. \nThe standard (built-in) usage still exists: Center is used to specify alignment in printforms such as ColumnForm and TableForm.";

• Centralizer::usage = "Centralizer[G, g] returns the centralizer of g in the group G. Centralizer[G, H] returns the centralizer of the subgroup H in the group G.";

• Characteristic::usage = "Characteristic[R] returns the characteristic of the structure R.";

• CloseSets::usage = "CloseSets[list1, list2, op] returns a list of all the distinct elements obtained by applying the operation op on the Cartesian product of list1 and list2]";

• ClosedDiffQ::usage = "ClosedDiffQ[R, S] returns True if S is closed with respect to subtraction in the structure R, and False otherwise.";

• ClosedPlusQ::usage = "ClosedPlusQ[R, S] returns True if S is closed with respect to addition in the structure R, and False otherwise.";

• ClosedQ::usage = "ClosedQ[S] returns True if the set of elements in the structure S is closed under its operation, and False otherwise. Additionally, ClosedQ[S, H] determines whether H is a closed subset of the structure S. When used with rings, the Operation option can be used, which can have the value Addition, Multiplication or Both.";

• ClosedTimesQ::usage = "ClosedTimesQ[R, S] returns True if S is closed with respect to multiplication in the structure R, and False otherwise.";

• Closure::usage = "Closure[G, H] returns the subgroup of G generated by the elements in the set H (assuming H is a subset of G or a Groupoid whose elements are a subset of G). The option ReportIterations (defaulting to False) indicates whether the result of each iteration is also returned. The option Staged (defaulting to False), applicable if Mode ® Visual is used, indicates whether or not the graphics are shown one stage at a time or they are all display at once. When set to True, NextStage[Closure] returns the next iteration and PreviousStage[Closure] returns the previous iteration. (Adding an integer k as a second parameter to either NextStage or PreviousStage specifies how many steps forward or backwards to take.) The option Sort, when set to False (default), returns the elements in the order they are generated, while when set to True, returns the elements sorted. When using the Visual mode, Output ® GraphicsArray causes the graphics to be placed in array form, rather than being presented serially.";

• Codomain::usage = "Codomain[f] returns the structure used in the image of the Morphoid f.";

• Coefficient::usage = "Coefficient[poly, ind, n], given a polynomial over some ring in the indeterminate ind, returns the coefficient of ind^n. Coefficient[poly, n] works similarly, without the indeterminate needing to be specified. \nThe standard (built-in) usage still exists: Coefficient[expr, form] gives the coefficient of form in the polynomial expr. Coefficient[expr, form, n] gives the coefficient of form^n in expr.";

• CoefficientList::usage = "CoefficientList[poly] returns the list of coefficients used in the polynomial poly over some ring R. Note that these are returned in the order as if PowersIncrease -> RightToLeft was given. In other words, CoefficientList[x^2 + 2x + 3] returns {3,2,1}. \nThe standard (built-in) usage still exists: CoefficientList[poly, var] gives a list of coefficients of powers of var in poly, starting with power 0. CoefficientList[poly, {var1, var2, ...}] gives a matrix of coefficients of the vari.";

• CollectOrders::usage = "CollectOrders[G], when given the output of the function OrderOfAllElements, will organize the data in the form {p, A} where p is one of the orders of the elements g in the Groupoid G and A is the set of all elements from G with the order being p.";

• ColorCodomain::usage = "ColorCodomain is an option for the VisualizeMorphoid function. By specifying ColorCodomain \[Rule] {{color1, cod1}, {color2, cod2},...}, the arrows to the codomain element codi will be colored colori. Note that these requests supersede those requests from the ColorDomain option, if an arrow is requested to be colored by both ColorDomain and ColorCodomain.";

• ColorDomain::usage = "ColorDomain is an option for the VisualizeMorphoid function. By specifying ColorDomain \[Rule] {{color1, dom1}, {color2, dom2},...}, the arrow from domain element domi will be colored colori, unless superseded by a color request by the ColorCodomain option.";

• Combine::usage = "Combine is an option name for both IntegerDivisors and ZdDivisors. Its default value is False, which means the divisors are not grouped in any fashion. Other values are Products, Associates, or Negations.";

• CommutativeQ::usage = "CommutativeQ[S] returns True if the structure S is commutative, and False otherwise. When S is a group, this is identical to AbelianQ[S]. When used with rings, one has the Operation option, which can take on the values Addition, Multiplication or Both.";

• Commutator::usage = "Commutator[G, x, y] returns the commutator xyx^(-1)y^(-1) in the Groupoid G.";

• CommutatorSubgroup::usage = "CommutatorSubgroup[G] returns the commutator subgroup of the Groupoid G generated by the commutators of G.";

• Commutators::usage = "Commutators[G] returns the complete set of commutators in the Groupoid G.";

• CommutingMatricesQ::usage = "CommutingMatricesQ[R, A, B] returns True or False depending on whether the matrices A and B commute over the Ringoid R. CommutingMatricesQ[MatricesOver[R,{n,n}], A, B] works similarly. For matrices with numeric entries (over Integers, Rationals, Reals or Complex), CommutingMatricesQ[A, B] works similarly.";

• ComplementNoSort::usage = "ComplementNoSort[eall, e1, e2, ...] gives the elements in eall which are not in any of the ei. This is similar to Complement except the returned values are NOT sorted as they are with Complement.";

• CompleteGroupQ::usage = "CompleteGroupQ[] will return True or False depending on whether or not the list of alleged symmetries found in MySymmetryGroup is the complete actual symmetry group. Other messages may be generated as well, if incomplete or in error.";

• ComplexMatrixQ::usage = "ComplexMatrixQ[A] returns True or False depending on whether the matrix A has all of its entries being complex numbers (in the mathematical sense - entries can be Integer, Rational, Algebraic, Real, or Complex).";

• ComplexToPoint::usage = "ComplexToPoint[z] returns {Re[z], Im[z]} given any complex number z.";

• Computational::usage = "Computational is the default setting for the Mode option for most functions. When Mode ® Computational is set, the function returns the desired computation with no textual or visual information given.";

• ConjugacyClass::usage = "ConjugacyClass[G, h] returns the conjugacy class of the element h in G.";

• Conjugate::usage = "Conjugate[G, h, x] returns the element x h x^(-1) in the Groupoid G. Additionally, Conjugate[G, H, x] returns the set x H x^(-1) for the subgroup H of the group G. \nThe standard (built-in) usage still exists: Conjugate[z] gives the complex conjugate of the complex number z. \n(Note that the Listable attribute has been turned off.)";

• CosetLists::usage = "CosetLists is a value for the Form option of QuotientGroup and QuotientRing. With this option, the output is a list of the cosets in list form.";

• CosetToList::usage = "CosetToList[G, coset] returns the coset (represented as a list) in the quotient group/ring corresponding to the coset represented in the form g + NS (or g NS).";

• Cosets::usage = "Cosets is a value for the Form option of QuotientGroup and QuotientRing. This causes the elements to be written as cosets of the form gNS or g + NS, where NS represents the normal subgroup (or ideal for rings).";

• Cycle::usage = "Cycle[e1, e2, ...] represents an object that is a cycle of a permutation. Cycle is also a value for the CycleAs option of the ToCycles and FromCycles functions.";

• CycleAs::usage = "CycleAs is an option for ToCycles and FromCycles that indicates whether a cycle is given as a list or with the head Cycle. In these packages, the default value is Cycle; to conform with the DiscreteMath`Permutations` package's use, use the value List.";

• Cyclic::usage = "Cyclic[n] returns the cyclic group of order n with the default generator the string 'g'. Cyclic[n, Generator ® gen] returns the same group but written with generator gen (which could be a string or a symbol with no value). Cyclic[n, k] returns the Groupoid generated by g^k.";

• CyclicGenerators::usage = "CyclicGenerators[G] returns a list of elements that are generators for the cyclic group G.";

• CyclicGroup::usage = "CyclicGroup[n] - see Cyclic.";

• CyclicQ::usage = "CyclicQ[G] returns True if the Groupoid G is cyclic, and False otherwise.";

• CyclicSubgroups::usage = "CyclicSubgroups[G] returns the list of the cyclic subgroups of the group G.";

• D1Prod::usage = "Special symbol used for this lab.";

• D2Prod::usage = "Special symbol used for this lab.";

• D::usage = "D[n] returns the dihedral group of index n with order 2n. See Dihedral for more information.\nThe standard (built-in) usage still exists: D[f, x] gives the partial derivative of f with respect to x. D[f, {x, n}] gives the nth partial derivative with respect to x. D[f, x1, x2, ...] gives a mixed derivative.";

• DefaultOrder::usage = "DefaultOrder is a global variable that contains the order that permutations are to be multiplied. It starts out with the value RightToLeft, until changed by an option or directly.";

• DefaultStructure::usage = "DefaultStructure is a global variable that has one of two values, Group or Ring. This value indicates what the default assumption is for various functions that have meanings for both groups and rings. For these functions, this default value can always be temporarily overridden by using the option Structure ® Group or Structure ® Ring. This variable can be changed manually or by using the function SwitchStructureTo.";

• Degree::usage = "Degree[PolynomialsOver[R], p] determines the degree of the polynomial p when viewed as an element in the ring of polynomials over the Ringoid R. Degree[p] assumes p is defined in some ring of polynomials. \nThe standard (built-in) usage still exists: Degree gives the number of radians in one degree. It has a numerical value of Pi/180.";

• Det::usage="Det[R, A] returns the determinant of the square matrix A over the Ringoid R. Det[MatricesOver[R,{n,n}],A] is equivalent to Det[R, A]. \nThe standard (built-in) usage still exists: Det[m] gives the determinant of the square matrix m.";

• DetAdjoint::usage = "DetAdjoint[A] returns the adjoint of a matrix A, which is defined as (-1)^(i+j) Det[Transpose[Bij]], where Bij is the matrix Aij with the ith row and jth column removed.";

• Diag::usage = "Diag[n, R] (alternately, Diag[R, n]) returns the extension of invertible n-by-n diagonal matrices over the Ringoid R.";

• DiagQ::usage = "DiagQ[R, A] returns True or False depending on whether the matrix A over the Ringoid R is in Diag[R, n] (where A is an n-by-n matrix).";

• DiagonalMatrices::usage = "DiagonalMatrices[n, R] (alternately, DiagonalMatrices[R, n]) - see Diag.";

• Dihedral::usage = "Dihedral[n] returns the dihedral group of index n with order 2n. By default, the generators are indicated by Rot (for the smallest angle of rotation) and Ref (for any reflection). D[n, Form ® Permutations] uses the permutations corresponding to Rot and Ref; the default is Form ® RotRef. D[n, RotSym ® newsy1, RefSym ® newsy2] uses the symbols newsy1 and newsy2 for Rot and Ref respectively. Alternate names for Dihedral are D and DihedralGroup.";

• DihedralGroup::usage = "DihedralGroup[n] - see Dihedral.";

• DirectProduct::usage = "DirectProduct[S1, S2] returns the direct product of the structured sets (Groupoids or Ringoids) S1 and S2. (Any number of arguments can be used.)";

• DirectSum::usage = "DirectSum[S1, S2] returns the direct sum of the structured sets (Groupoids or Ringoids) S1 and S2. (Any number of arguments can be used.)";

• DisguiseGroupoid::usage = "DisguiseGroupoid[G] returns the Groupoid G with the elements of G replaced with the strings 'a', 'b', etc. The purpose is to present a generic Groupoid without any indication of the form of the elements or operation. DisguiseGroupoid[G, rules] does the same except that rules is a list of Rules which specify how the matching should occur. Adding the option Randomize -> True will randomize the original elements before the rules are assigned; the default for this option is False.";

• DisguiseRingoid::usage="DisguiseRingoid[R] returns the Ringoid R with the elements of R replaced with the strings 'a', 'b', etc. The purpose is to present a generic ring without any indication of the form of the elements or operation. Adding the option Randomize -> True will randomize the original elements in the Ringoid; the default for this option is False. One can also add one's own mapping rules, as in DisguiseGroupoid.";

• DisjointCyclesQ::usage = "DisjointCyclesQ[cyclist] returns True if the cycles in cyclist are disjoint, and False otherwise. The cycles in cyclist can be either in List form or using Cycle notation. Also, cyclist can be of any length and either given as a list or a sequence of cycles.";

• DistributiveQ::usage = "DistributiveQ[R] returns True if the Multiplication is (two-sided) distributive over the Addition in the structure R, and False otherwise.";

• DividesQ::usage = "DividesQ[r, s] returns True if the integer s divided by the integer r is an integer, and False otherwise. DividesQ[r, s, Radical \[Rule] d] works similarly in \[DoubleStruckCapitalZ][\!\(\@d\)], returning True if r | s over this ring, and False otherwise.";

• DivisorsComplete::usage = "DivisorsComplete is an option for IntegerDivisors and ZdDivisors. Its default value is False. With this, only one divisor from each class of associates is given. For integers, when set to False, this returns the positive divisors. For Gaussian integers (d = -1), when set to False, this returns the Gaussian integers in the first quadrant. In all other cases, when set to False, this returns the one that is in the right half-plane (or first quadrant for those on the imaginary axis) when the number a + b \!\(\@d\) is considered the ordered pair (a, b). In contrast, with the value True, all the divisors are included.";

• Domain::usage = "Domain[f] returns the structure used in the domain of the Morphoid f. Domain[S] returns the elements in the Groupoid or Ringoid S; this is equivalent to the Elements function.";

• Dot::usage="Dot[R, a, b] generalizes the (scalar) dot product over a Ringoid R and computes a.b (for vectors a and b over R) using the arithmetic of R. \nThe standard (built-in) usage still exists: a.b.c or Dot[a, b, c] gives products of vectors, matrices and tensors.";

• DrawNgon::usage = "DrawNgon[n] draws a regular n-gon (n > 2) with the vertices labeled with the integers 1 through n.";

• DropPermFromGroup::usage = "DropPermFromGroup[p] deletes the permutation p from the list of alleged symmetries (which is called MySymmetryGroup). Note that p can be in the form of a list ({1,3,4,2}) or a list of rules ({1->1, 2->3, 3->4, 4->2}).";

• ESG::usage = "ESG[code] returns the group corresponding to the one given by 'code' as used in the software package Exploring Small Groups.";

• EisensteinsCriterionQ::usage = "EisensteinsCriterionQ[zpo\ ly] returns True if Eisenstein's Criterion indicates that the polynomial zpoly, with coefficients from the integers, is irreducible, and False otherwise. The Textual mode is available.";

• ElementConjugate::usage = "ElementConjugate[G, h, x] returns the element x h x^(-1) in the Groupoid G.";

• ElementQ::usage = "ElementQ[x, S] yields True or False depending on whether or not x is an element of the structured set S.";

• ElementToCoset::usage = "ElementToCoset[Q, el], assuming Q is the quotient group G/N and el is an element in G, this returns the coset containing el.";

• ElementToKey::usage = "ElementToKey[G, el] returns the key value used for el in the Key that is made when the elements in the structure S are too wide for a graphical image.";

• ElementToPower::usage = "ElementToPower[G, g, n] returns the nth power (multiple, in an additive groupoid) of the element g in the structure G, where n can be any integer).";

• Elements::usage = "Elements[S] returns the list of elements contained in the structured set S (either a Groupoid or Ringoid). Elements[{S1,S2,..}] returns the elements in each of the structured sets.";

• ElementsQ::usage = "ElementsQ[els, S] yields True or False depending on whether or not all the items in the list els are elements of the structured set S.";

• Equal::usage = "Equal[PolynomialsOver[R], p, q] returns True or False depending on whether the polynomials p and q are equal as elements in the ring of polynomials over the Ringoid R. Equal[p, q] assumes that both p and q are well-defined in some ring of polynomials. The option IgnoreIndeterminate can be set to True (default) or False and determines whether the indeterminate used should be considered when deciding equality. \nThe standard (built-in) usage still exists: lhs == rhs returns True if lhs and rhs are identical.";

• EqualGroupoidQ::usage = "EqualGroupoidQ[G1, G2] returns True if G1 and G2 can be considered equal as Groupoids, and False otherwise.";

• EqualMorphoidQ::usage="EqualMorphoidQ[f, g] compares two Morphoids f and g and returns True if their functions are identical and are between identical types of structures, and False otherwise. The operations of the structures are not compared.";

• EvaluationInExtension::usage = "EvaluationInExtension[E, p, q] evaluates the polynomial p (a polynomial over the base ring of the extension E) at q, an element of that extension. Note: Both p and q should both be polynomials over the base ring with identical indeterminates.";

• EvenPermutationQ::usage = "EvenPermutationQ[p] returns True if p is an even permutation, and False otherwise.";

• Exponent::usage = "Exponent[PolynomialsOver[R], p] determines the degree of the polynomial p when viewed as an element in the ring of polynomials over the Ringoid R. Exponent[p] assumes p is defined in some ring of polynomials. \nThe standard (built-in) usage still exists: Exponent[expr, form] gives the maximum power with which form appears in expr. Exponent[expr, form, h] applies h to the set of exponents with which form appears in expr.";

• ExtendPermutation::usage = "ExtendPermutation[p, n] takes a permutation p in S[m] (for m < n) and returns a permutation in S[n] using the components of p in the first m positions and filling out positions m+1 to n with the integers m+1 to n, so that p is naturally extended.";

• ExtensionDegree::usage = "ExtensionDegree[GF[n]] gives the degree of the extension of GF[n]. In other words, when n is written as n = p^d for some prime p, d is the ExtensionDegree of GF[n].";

• ExtensionType::usage = "ExtensionType[ext] returns the type of extension for this extension ring ext.";

• FactorGroup::usage = "FactorGroup[G, N, opts] is equivalent to QuotientGroup[G, N, opts]; see this function for further details.";

• FactorRing::usage = "FactorRing[R, S] is equivalent to QuotientRing[R, S]; see QuotientRing for details.";

• Fiber::usage="Fiber[f, S] is equivalent to InverseImage[f, S].";

• FieldIrreducible::usage = "FieldIrreducible[GF[n]] returns the irreducible polynomial used in establishing the Galois field GF[n].";

• FieldQ::usage = "FieldQ[R] returns True if the Ringoid R is a field, and False otherwise.";

• FirstTaker::usage = "FirstTaker[n] returns the Groupoid with elements {1,2,...n} and the operation that returns the first of the two inputs.";

• FixQ::usage = "FixQ[S, p, el] returns True if the permutation p (where p permutes the elements of S) fixes the element el, and False otherwise. If p is a permutation in S[n], then FixQ[p, el] is equivalent to FixQ[Range[n], p, el].";

• FlexibleEntering::usage = "FlexibleEntering is an option, taking either True or False, for the Poly function, which creates polynomials. When set to True (the default value), the function call Poly[R, x^2 - 2x + 1] is treated as Poly[R, x^2 + NegationOf[R, 2]x + 1]. Additionally, if R = Z[n], then the coefficients can be any integers and are reduced mod n before processing.";

• Form::usage = "Form is an option when working with the dihedral group D[n]. By default we have Form ® RotRef. Also possible is Form ® Permutations. See Dihedral for more information. Form is also an option for QuotientGroup and QuotientRing. Form ® Cosets is the default here and specifies that the elements of the quotient group (or quotient ring) should appear in coset form. Form ® Representatives causes the quotient elements to be represented by a representative from the cosets. The option Representatives can be used to specify these representatives. Form ® CosetLists is yet another option, where the cosets appear as lists of elements. Finally, Form is also an option for QuaternionGroup; see this function for more information.";

• FormGroupoid::usage = "FormGroupoid[els, op, opsym, opts] is the basic command for forming a Groupoid consisting of the list els governed by the operation op. The symbol opsym defaults to * if not specified. The available options for opts are WideElements, IsAGroup, Generators, GroupoidDescription, GroupoidName, FormatOperator, FormatElements, MaxElementsToList, KeyForm, and CayleyForm. See each one for more information. \n\nThis function, rather than just wrapping Groupoid around a list and an operation, is strongly recommended.";

• FormGroupoidByTable::usage = "FormGroupoidByTable[els, tab, opsym, opts] is a command for forming a Groupoid consisting of the list els and governed by the operation implicit in the Cayley table tab. The symbol opsym defaults to * unless specified. The available options for opts are WideElements, IsAGroup, Generators, GroupoidDescription, GroupoidName, FormatOperator, FormatElements, MaxElementsToList, KeyForm, and CayleyForm. See each of these individually for more information.";

• FormGroupoidFromCycles::usage = "FormGroupoidFromCycles[cl, opts] forms the Groupoid of permutations whose elements are (initially) written as either cycles or products of cycles. The option opts takes on values similar to FormGroupoid, as well as the option ProductOrder (since we are working with permutations).";

• FormMorphoid::usage = "FormMorphoid[f, S1, S2, (opts)] is the standard means for creating a Morphoid. Here, S1 and S2 are Groupoids or Ringoids, and f is either a list of Rules, a Function, or a Symbol. In the special case where S1 is a cyclic Groupoid, f can consist of just one rule that sets up the morphism. Additionally, if S1 consists of n elements and S2 consists of m elements, then FormMorphoid[{p1, p2, ... pn}, S1, S2] forms the Morphoid by sending the first element in S1 to the element in S2 in position p1, the second element in S1 to the element in position p2 in S2, until finally the nth element goes to the element in position pn in S2. FormMorphoidSetup may be useful in using this method. The options opts can consist of setting the Mode or the value of FormatFunction (default is False), which determines if the function should be formatted or not.";

• FormMorphoidSetup::usage= "FormMorphoidSetup[S1, S2] produces a graphic that assists in the preparation of a list of positions to use in FormMorphoid. The arguments S2 and S2 must be Groupoids or Ringoids.";

• FormRingoid::usage = "FormRingoid[list, addition, multiplication, {plussym, multsymb}, opts] is the basic command for forming a Ringoid consisting of the list of elements found in list governed by the operations addition and multiplication. The symbol plussym defaults to + and the multsymb defaults to *, if not specified. The options for opts can be WideElements, IsARing, RingoidDescription, RingoidName, FormatOperator, FormatElements, MaxElementsToList, KeyForm, and CayleyForm. See each one for more information. Alternatively, FormRingoid[AG, MG, opts] forms the Ringoid using the Groupoid AG for the additive part and the Groupoid MG for the multiplicative part (assuming the same elements are used).\n\n This function, rather than just wrapping Ringoid around a list and the operations, is strongly recommended.";

• FormRingoidByTable::usage = "FormRingoidByTable[list, additiontab, multiplicationtab, opts] is used for generating a Ringoid consisting of the elements in list and governed by the operations implicit in the Cayley tables additiontab and multiplicationtab. The options for opts can be WideElements, IsARing, RingoidDescription, RingoidName, FormatOperator, FormatElements, MaxElementsToList, KeyForm, and CayleyForm. See each of these individually for more information.";

• FormatElements::usage = "FormatElements is an option for functions which form Groupoids or Ringoids, whose default value is False. When set to True, whenever a structured set is displayed, {-Elements-} will be displayed instead of the actual list of elements.";

• FormatFunction::usage = "FormatFunction is an option for the FormMorphoid function that indicates whether a MorphoidÕs function should be displayed in an abbreviated (or formatted) form. While the default value is False, it can also be set to True.";

• FormatOperator::usage = "FormatOperator is an option for functions which form Groupoids or Ringoids, whose default value is True. When set to True, whenever a structured set is displayed, -Operation- (or -Addition- and -Multiplication- for Ringoids) will be displayed instead of the actual definition of the operator(s).";

• FromCycles::usage ="FromCycles[{c1, c2,...,cn}] gives the permutation that corresponds to the product of the cycles c1, c2, ...cn, assuming that the cycles ci are disjoint. This is a modification and improvement on the function from the DiscreteMath`Permutations` package.";

• Func::usage="Func is the head for a function in a FunctionsOver extension.";

• FuncRing::usage="FuncRing is the first parameter for any function extension.";

• FuncToRules::usage="FuncToRules[f, FunctionsOver[R]] converts f to a list of rules.";

• FunctionForm::usage="FunctionForm is an option for InnerAutomorphism that controls whether the Morphoid is defined by Rules (default value) or by a function is to be created.";

• FunctionsOver::usage="FunctionsOver[R] returns the extension of functions on the Ringoid R.";

• GF::usage = "GF[n] returns the Galois field of order n (if n = p^d for some prime p and positive integer d), while GF[p, d] returns the field of order p^d (where p is the prime modulus and d is the degree of a irreducible polynomial to create the field). The field takes the form of a quotient ring of polynomials over Z[p] mod the ideal generated by the irreducible polynomial, and consequently consisting of polynomials of degree less than d. GF[n, poly] or GF[p, d, poly] returns the finite field using the specified irreducible polynomial. The option Indeterminate can be used to specify the symbol to be used for the indeterminate.";

• GL::usage = "GL[n, R] (alternately, GL[R, n]) returns the extension of invertible n-by-n matrices over the Ringoid R. For a positive integer k, GL[n,k] is equivalent to GL[n,Z[k]].";

• GLQ::usage = "GLQ[R, A] returns True or False depending on whether the matrix A over the Ringoid R is in GL[R, n] (where A is an n-by-n matrix).";

• GaloisFieldQ::usage = "GaloisFieldQ[R] returns True or False depending on whether the ring R is a Galois field and was created using the GF function.";

• GaussianIntegerQ::usage = "GaussianIntegerQ[z] returns True if the complex number z is a Gaussian integer and false otherwise.";

• GaussianIntegers::usage = "GaussianIntegers[n] returns the Ringoid of Gaussian integers mod n under ordinary complex addition and multiplication mod n. \nThe standard use of this name as an option for several built-in functions still works and is described as follows: GaussianIntegers is an option for FactorInteger, PrimeQ, Factor and related functions. With GaussianIntegers ® True, factorization is done over the Gaussian integers when possible. With GaussianIntegers ® False, factorization is done over the integers.";

• GaussianIntegersAdditive::usage = "GaussianIntegersAdditive[n] returns the additive Groupoid of Gaussian integers mod n. This is equivalent to Z[n, I].";

• GaussianIntegersMultiplicative::usage = "GaussianIntegersMultiplicative[n] returns the multiplicative Groupoid of Gaussian integers mod n. This is equivalent to Zx[n, I].";

• GaussianUnits::usage = "GaussianUnits returns the Groupoid consisting of {1,-1, I, -I} under ordinary complex multiplication.";

• GeneralLinear::usage = "GeneralLinear[args] - see GL.";

• GeneralLinearGroup::usage = "GeneralLinearGroup[args] - see GL.";

• GenerateGroupoid::usage = "GenerateGroupoid[gens, op, opsym, opts] is a command for generating a Groupoid by using the generators in the list gens governed by the operation op. The symbol opsym defaults to * unless specified otherwise. The options for opts can be WideElements, IsAGroup, SizeLimit, Generators, GroupoidDescription, GroupoidName, FormatOperator, FormatElements, MaxElementsToList, KeyForm, and CayleyForm. See each of these individually for more information.";

• GeneratingSet::usage = "GeneratingSet[G] gives a set of generators for determining G. If $Failed is returned, this indicates that a generating set is not yet known to Mathematica. The option Generators for FormGroupooid is used to specify a generating set, as is the first argument for GenerateGroupoid.";

• Generator::usage = "Generator is an option for the Cyclic function, specifying which symbol should be used for the generator of the group.";

• Generators::usage = "Generators is an option for functions which form Groupoids, whose default value is {}. Specifying Generators ® {g1,g2,...} indicates that these generators are known to generate this Groupoid.";

• GoodGroupElementsQ::usage = "GoodGroupElementsQ[] will return True or False depending on whether or not the list of alleged symmetries found in MySymmetryGroup are all elements of the actual symmetry group.";

• Graphics::usage = "Graphics is a value for the Output option that can be used when a function uses the Visual Mode. Adding the option Output ® Graphics will cause the graphics of the Visual mode to be the output (given as -Graphics-). This is a method of capturing the graphics involved in a computation instead of the actual computation. (Using GraphicsArray instead of Graphics works similarly when the output is going to be a series of graphics. These are then put into an array of graphics.) \nThe standard (built-in) definition still exists: Graphics[primitives, options] represents a two-dimensional graphical image.";

• Group::usage = "Group is a value for the Structure option that is used for the functions FormMorphoid, ZMap, and Z (including Z[n] and Z[n, I]). It is also the argument for the SwitchStructureTo function when switching from rings to groups.";

• GroupCenter::usage = "GroupCenter[G] returns the center of the group G. This is identical to Center.";

• GroupExponent::usage = "GroupExponent[G] returns the smallest positive integer n such that g^n is the identity for all elements g in the Groupoid G.";

• GroupIdentity::usage = "GroupIdentity[G] returns the (two-sided) identity of the Groupoid G, if it exists. If there is no identity, a message indicates this and $Failed is returned. HasIdentityQ[G] is similar, except it only returns True or False regarding the existence of an identity.";

• GroupInfo::usage = "GroupInfo[G] returns a list of information obtained about the Groupoid G that has been gathered thus far by calling various functions.";

• GroupInverse::usage = "GroupInverse[G, g] returns the inverse of g in G, if it exists, and $Failed otherwise.";

• GroupQ::usage = "GroupQ[G] returns True if G is a group, and False otherwise.";

• Groupoid::usage = "Groupoid is the head for an ordered pair where the first component is a set of elements and the second is an operation. A Groupoid is one of the basic structures of these packages.";

• GroupoidDescription::usage = "GroupoidDescription[G] yields a description, if available, of the Groupoid G. This can be set with the option GroupoidDescription when using the functions FormGroupoid or GenerateGroupoid. If the empty string is returned (default value), no description has been given.";

• GroupoidName::usage = "GroupoidName[G] yields the name, if given, of the group G. This can be set with the option GroupoidName in FormGroupoid and GenerateGroupoid. If the empty string or TheGroup (default) is returned, no name has yet been given.";

• Groups::usage = "Groups is an acceptable argument for the SwitchStructureTo function.";

• GroupsToConsider::usage = "GroupsToConsider is a list of groups to consider for this lab.";

• HasIdentityQ::usage = "HasIdentityQ[S] returns True or False depending on whether or not the (two-sided) identity (or identities for rings) of the structure S exists. When used with rings, the Operation option can be used, which can have the value Addition, Multiplication or Both. If S is a group, GroupIdentity[S] returns the identity, if one exists, while for rings, Zero[S] and Unity[S] return the additive and multiplicative identities, if they exist.";

• HasInversesQ::usage = "HasInversesQ[G] returns True or False depending on whether all the elements in G have inverses or not. When used with rings, the Operation option can be used, which can have the value Addition, Multiplication or Both.";

• HasLeftIdentityQ::usage = "HasLeftIdentityQ[G] returns True or False depending on whether the Groupoid G has a left identity or not. If one exists, LeftIdentity[G] returns its value.";

• HasNegativeQ::usage = "HasNegativeQ[R, r] returns True if r has a negative in the structure R, and False otherwise.";

• HasRightIdentityQ::usage = "HasRightIdentityQ[G] returns True or False depending on whether the Groupoid G has a right identity or not. If one exists, RightIdentity[G] returns its value.";

• HasUnityQ::usage = "HasUnityQ[R] returns True if the structure R has a unity, and False otherwise.";

• HasZeroQ::usage = "HasZeroQ[R] returns True if the structure R has a zero, and False otherwise.";

• HeadingsColored::usage = "HeadingsColored is an option for CayleyTable. Setting it to True or False determines whether the top row and left column are colored according to the default coloring of the elements residing in these positions.";

• HermitianQ::usage = "HermitianQ[A] returns True or False depending on whether the matrix A is Hermitian (i.e., A = Adjoint[A]).";

• HomomorphismQ::usage = "HomomorphismQ[f] returns True if the Morphoid f is a homomorphism, and False otherwise. This is equivalent to MorphismQ.";

• IdealQ::usage = "IdealQ[S, R] returns True if the set S is an ideal of the structure R, and False otherwise.";

• IdempotentQ::usage = "IdempotentQ[R, r] returns True if r is an idempotent in the structure R, and False otherwise.";

• Idempotents::usage = "Idempotents[R] returns all the idempotent elements in the structure R.";

• Identity::usage = "Identity[G] returns the (two-sided) identity of the structure G, if it exists. If there is no identity, a message indicates this. For groups, this is identical in functionality to GroupIdentity[G]. HasIdentityQ[G] is similar, except it only returns True or False regarding the existence. When used with rings, the Operation option can be used, which can have the value Addition, Multiplication or Both. This use is equivalent to RingIdentity. \nThe standard (built-in) usage still exists: Identity[expr] gives expr (the identity operation).";

• IgnoreIndeterminate::usage = "IgnoreIndeterminate is an option for the Equal command that is used when determining when two polynomials are equal. The default value for this option is True, which means that 4x^2 + 3x + 1 and 4y^2 + 3y + 1 are considered equal as polynomials. One can optionally set this to False.";

• Image::usage = "Image[f] returns a Groupoid or Ringoid (as appropriate) consisting of the image values of the Morphoid f. Additionally, Image[f, S] returns the images of the substructure S of the domain of f.";

• Ind::usage = "Special symbol used for this lab.";

• Indeterminate::usage = "Indeterminate is an option for the Poly function (that creates polynomials). The default value is 'x', though one can specify any other symbol as the indeterminate to be used in a polynomial. \nThe standard (built-in) usage still exists: Indeterminate is a symbol that represents a numerical quantity whose magnitude cannot be determined.";

• Index::usage = "Index[G, H] returns the index of the subgroup H in the group G.";

• IndexLimit::usage = "IndexLimit is an option for some groups to enable one to obtain larger groups (whose index is more than the default limit on the index). Examples where this is used is with the Symmetric and Alternating groups with the default value of 6.";

• InducedCanonical::usage = "InducedCanonical[f], given a Morphoid f: G \[Rule] H, returns the Morphoid g : G \[Rule] G/Ker[f].";

• InducedIsomorphism::usage = "InducedIsomorphism[f], given a Morphoid f: G \[Rule] H, returns the Morphoid g : G/Kernel[f] \[Rule] Image[H].";

• InjectiveQ::usage="InjectiveQ[f] returns True if the Morphoid f is injective (one-to-one), and False otherwise.";

• Inn::usage = "Inn[G] is identical to InnerAutomorphismGroup[G].";

• InnerAutomorphism::usage = "InnerAutomorphism[G, g], when given an element g in the group G, returns the inner automorphism of G induced by g.";

• InnerAutomorphismGroup::usage="InnerAutomorphismGroup[G] returns the group of inner automorphisms of G, if G is a group.";

• IntegerDivisors::usage = "IntegerDivisors[n, opts] returns the divisors of the integer n, just as the built-in function Divisors[n] does. The options are Combine, NonTrivialOnly and DivisorsComplete. See these for more details.";

• IntegerLatticeGrid::usage = "IntegerLatticeGrid[{a, b}, {c, d}, opts] returns a ListPlot of an integer lattice with domain [a,b] and range [c,d]. Any opts given are used by ListPlot.";

• IntegerMatrixQ::usage = "IntegerMatrixQ[A] returns True or False depending on whether the matrix A has all of its entries being integers.";

• IntegerUnits::usage = "IntegerUnits returns the Groupoid consisting of {1, -1} under ordinary multiplication.";

• IntegralDomainQ::usage = "IntegralDomainQ[R] returns True if the structure R is an integral domain, and False otherwise."

• InterpolatingPolynomial::usage = "InterpolatingPolynomial[R,{{x,y},...}] returns the interpolating polynomial of degree at most n-1 where n is the number of pairs in {{x,y},...}. The x coordinates must all be distinct and R should be a field, for example Z[p] for prime p.\nThe standard (built-in) usage still exists: InterpolatingPolynomial[data, var] gives a polynomial in the variable var which provides an exact fit to a list of data. The data can have the forms {{x1, f1}, {x2, f2}, ...} or {f1, f2, ...}, where in the second case, the xi are taken to have values 1, 2, .... The fi can be replaced by {fi, dfi, ddfi, ...}, specifying derivatives at the points xi.";

• Inverse::usage = "Inverse[G, g] returns the inverse of g in G, if it exists, otherwise $Failed. When used with rings, the Operation option can be used, which can have the value Addition, Multiplication or Both. \nThe standard (built-in) usage still exists: Inverse[m] gives the inverse of a square matrix m.";

• InverseImage::usage="InverseImage[f, S] returns the elements of the domain of the Morphoid f that map into elements of the list or element S (from the codomain). There is a Visual mode for this function.";

• InverseImages::usage = "InverseImages[f] returns the set of inverse images. This is partially equivalent to InverseImage[f, Elements[Codomain[f]]] except the latter returns a single (unsorted) list of the inverse images while this function partitions them according to the elements in Codomain[f]. The option WithImages (defaulting to False) indicates whether the image elements should be included in the output. There is a Visual mode for this function.";

• Inverses::usage = "Inverses[G] returns a list of ordered pairs of the form {g, h}. If g has an inverse in G, then h is that element; otherwise h is 'no inverse'. When used with rings, the Operation option can be used, which can have the value Addition, Multiplication or Both.";

• InvertibleQ::usage = "InvertibleQ[S, g] returns True if the (two-sided) inverse of g in the structure S exists, and False otherwise. When used with rings, the Operation option can be used, which can have the value Addition, Multiplication or Both.";

• IrreduciblePolyOverZpQ::usage = "IrreduciblePolyOverZpQ[poly, p] returns True or False depending on whether the polynomial poly is irreducible over the ring Z[p]. Note that poly can be a standard Mathematica polynomial in some indeterminate or it can be constructed from the Poly function in the RingExtensions package.";

• IrreduciblePolynomial::usage = "IrreduciblePolynomial[ind, p, d] finds an irreducible polynomial in the indeterminate ind of degree d over the integers mod p (where p is prime). The code for this comes from the Mathematica package Algebra`FiniteFields`.";

• IsAGroup::usage = "IsAGroup is an option for functions which form Groupoids, whose default value is False. When set to True, the Groupoid constructed will be assumed to be known as a group.";

• IsARing::usage = "IsARing is an option for functions which form Ringoids, whose default value is False. When set to True, the Ringoid constructed will be assumed to be known to be a ring.";

• IsomorphismQ::usage = "IsomorphismQ[f] returns True if the Morphoid f is an isomorphism (group or ring, as appropriate), and False otherwise. The option Cautious (defaulting to False) indicates whether MorphismQ (if True) or ProbableMorphismQ (if False) should be used for the testing.";

• J::usage = "J is the symbol to represent an ideal in the quotient ring Z[I]/ for a Gaussian integer z.";

• JoinDivisors::usage = "JoinDivisors[n] returns the Groupoid consisting of the divisors of n with operation LCM.";

• KSubsets::usage = "KSubsets[L, k] returns all subsets of set L containing exactly k elements, ordered lexicographically. (From DiscreteMath`Combinatorica`.)";

• Kernel::usage = "Kernel[f] returns the kernel of the Morphoid f, if the codomain has an identity element. It is not necessary that f satisfies MorphismQ. The object returned is a Groupoid or Ringoid (as appropriate). There is a Visual mode for this function.";

• KeyForm::usage = "KeyForm is an option for CayleyTable (and functions that form Groupoids or Ringoids) to indicate whether the elements in the Key of the Cayley table should be displayed in InputForm, OutputForm or some other form. The default value is InputForm.";

• KeyToElement::usage = "KeyToElement[S, key] returns the element corresponding to the value key found in the Key, when the elements in the structure S are too wide for a graphical image.";

• Klein4::usage = "Klein4 returns the Klein-4 group (Viergruppe).";

• LG::usage = "LG[n] is the nth groupoid found in a list called 'Lab Groupoids.' These are groupoids used in a variety of labs.";

• LT::usage = "LT[n, R] (alternately, LT[R, n]) returns the extension of n-by-n lower triangular matrices (fully below the diagonal) over the Ringoid R.";

• LTD::usage = "LTD[n, R] (alternately, LTD[R, n]) returns the extension of n-by-n lower triangular matrices (including the diagonal) over the Ringoid R.";

• Lab2::usage = "Special symbol used for this lab.";

• Lab3::usage = "Special symbol used for this lab.";

• Lab4::usage = "Special symbol used for this lab.";

• LatticeRing::usage = "LatticeRing[n] returns the Ringoid of divisors of n with LCM/GCD for the addition and GCD for the multiplication.";

• LeftCoset::usage = "LeftCoset[G, H, g] returns the left coset gH (or g + H) when given the element g from G and the subgroup H of G. G is assumed to be either a Groupoid or Ringoid (for which H needs to be a subring).";

• LeftCosets::usage = "LeftCosets[G, H] returns the set of cosets of the subgroup (or subring) H in the Groupoid (or Ringoid) G.";

• LeftDistributiveQ::usage = "LeftDistributiveQ[ R] returns True if the Multiplication is left distributive over the Addition in the structure R, and False otherwise.";

• LeftIdealQ::usage = "LeftIdealQ[S, R] returns True if the set S is a left ideal of the structure R, and False otherwise.";

• LeftIdentity::usage = "LeftIdentity[G] returns the left identity of the Groupoid G, if one exists, or $Failed otherwise.";

• LeftInverse::usage = "LeftInverse[G, g] returns the left inverse of g in G, if it exists, otherwise $Failed.";

• LeftInvertibleQ::usage = "LeftInvertibleQ[G, g] returns True if the left inverse of g in G exists, and False otherwise.";

• LeftToRight::usage = "LeftToRight is a value for the ProductOrder option of MultiplyPermutations and MultiplyCycles, as well for the PowersIncrease option for Poly (when working with polynomials over a ring). When ProductOrder is set to this value, then MultiplyPermutations[p1,p2] will be computed by taking p1 followed by p2. For the use in Poly, see PowersIncrease.";

• ListOperationPreservingElements::usage = "Special symbol used for this lab.";

• LowerDegreeOK::usage = "LowerDegreeOK is an option for RandomElement[RingExtension[PolyRing,...]] that controls whether random polynomials MUST have the specified degree (using the value False, the default value) or may have a degree less than or equal to the specified degree (using the value True).";

• MGroupoid::usage = "MGroupoid[R] returns the multiplicative Groupoid associated with the Ringoid R. This is equivalent to MultiplicativeGroupoid[R].";

• Mat::usage = "Mat[R,n] (alternatively, Mat[n, R]) returns the extension ring of n-by-n matrices over the Ringoid R. Mat[R, {m,n}] (or Mat[{m,n},R]) returns the extension ring of m-by-n matrices over R.";

• MatA::usage = "MatA[R,{m,n}] (alternatively, MatA[{m,n}, R]) returns the extension of m-by-n matrices over the Ringoid R with the operation being addition of matrices.";

• MatM::usage = "MatM[R,n] (alternatively, MatM[n, R]) returns the extension of n-by-n matrices over the Ringoid R with the operation being multiplication of matrices.";

• Matrices::usage = "Matrices is a possible type of RingExtension.";

• MatricesOver::usage="MatricesOver[R,{m,n}] generates the ring extension of m-by-n matrices over R. MatricesOver[R,n] is equivalent to MatricesOver[R,{n,n}].";

• MatrixConjugate::usage = "MatrixConjugate[A], where A is a matrix, returns the matrix with all of the entries being the complex conjugate of those that occur in A.";

• MatrixDelete::usage = "MatrixDelete[A, {i, j}] returns the matrix remaining when the ith row and jth column of the matrix A are removed.";

• MatrixOperation::usage = "MatrixOperation[MatricesOver[R, {m,n}]] returns the operation inherent in the matrix extension. Values are the same as for Operation (Both, Addition, or Multiplication).";

• MatrixOverQ::usage = "MatrixOverQ[R, A] returns True or False depending on whether the elements of the matrix A come from the Ringoid R.";

• MatrixPower::usage = "MatrixPower[MatricesOver[R, {n,n}], A, k] returns the kth power of the matrix A, as an element of the n-by-n matrices over the Ringoid R. MatrixPower[R, A, k] works similarly. \nThe standard (built-in) usage still exists: MatrixPower[mat, n] gives the nth matrix power of mat.";

• MatrixTrace::usage = "MatrixTrace[R, A] returns the trace of the square matrix A. MatrixTrace[MatricesOver[R,{n,n}], A] works similarly. For matrices with numeric entries (over Integers, Rationals, Reals or Complex), MatrixTrace[A] works similarly.";

• MatrixType::usage = "MatrixType is the name of an option for working with matrix extension rings. It can have the value GL, SL, Diag, UT, LT, UTD, or LTD (and defaults to All).";

• MaxElementsToList::usage = "MaxElementsToList is an option for functions which form Groupoids or Ringoids, whose default value is 50. This means that if a structured set has more than 50 elements, it will default to showing simply {-Elements-} instead of the actual list. Some groups/rings may have lower values.";

• MaxTaker::usage = "MaxTaker[n] returns the Groupoid with elements {1,2,...n} and the operation that returns the maximum of the two inputs. MaxTaker[m, n] is similar but the elements range over [m, n].";

• MaximalIdealQ::usage = "MaximalIdealQ[S, R] returns if the set S is a maximal ideal in the structure R, and False otherwise.";

• MeetDivisors::usage = "MeetDivisors[n] returns the Groupoid consisting of the divisors of n with operation GCD.";

• MinTaker::usage = "MinTaker[n] returns the Groupoid with elements {1,2,...n} and the operation that returns the minimum of the two inputs. MinTaker[m, n] is similar but the elements range over [m, n].";

• MixedDivisors::usage = "MixedDivisors[n] returns the Groupoid consisting of the divisors of n with operation LCM/GCD.";

• Mode::usage = "Mode is an option for many of the functions in these packages. Standard modes are Computational, Textual and Visual, and sometimes Visual2. See each of these individually for more information. \nThe standard (built-in) definition still exists: Mode is an option to Solve and related functions that specifies in what sense the equations are to be solved. The possible settings for Mode are Generic, Modular, and Rational.";

• ModpIrreducibilityQ::usage = "ModpIrreducibilityQ[zpoly] returns True if the Mod p Irreducibility Test indicates that the polynomial zpoly, with coefficients from the integers, is irreducible, and False otherwise. (This method tries the first 25 primes.) The Textual mode is available. ModpIrreducibilityQ[p, zpoly] tests the polynomial zpoly specifically with the prime p.";

• ModulusPolynomial::usage="ModulusPolynomial[Q] is the polynomial from which a quotient ring Q has been created.";

• Monic::usage = "Monic is an option to RandomElement for Polynomial Rings. When set to True, the random polynomial is to be monic, having the unit for the leading coefficient, while False does not impose this restriction.";

• MonoidQ::usage = "MonoidQ[G] returns True if G is a monoid (the set is closed under a binary operation that is associative with an identity), and False otherwise.";

• Monomial::usage="Monomial[R, c, n] returns the monomial c x^n in the ring extension PolynomialsOver[R]; Monomial[PolynomialsOver[R], c, n] returns the same.";

• MorphismQ::usage = "MorphismQ[f] returns True if the Morphoid f is a homomorphism, and False otherwise. This function automatically checks to see if f represents a group homomorphism or a ring homomorphism according to whether the structures involved are groups or rings. The Visual mode can be used with this function. MorphismQ[f, {S1, op1}, {S2, op2}] or MorphismQ[f, {S1, op1, op3}, {S2, op2, op4}] are alternative usages, where f is either a list of Rules, a Function or a Symbol.";

• Morphoid::usage = "Morphoid is the data structure for possible morphisms. This is the head of the object returned by FormMorphoid when one creates a morphism. This is one of the basic structures in these packages.";

• MorphoidComposition::usage="MorphoidComposition[g, f] forms the composition of f and g if the codomain of f and the domain of g are the same structured system. Note: This function creates a Morphoid with function g[f[#]]& and then converts it to rules.";

• MorphoidFunction::usage = "MorphoidFunction[f] returns the function defining the Morphoid f.";

• MorphoidRules::usage = "MorphoidRules[f] returns the list of rules defining the Morphoid f.";

• MultipleOfElement::usage = "MultipleOfElement[R, r, n] returns the nth multiple of the element r in the structure R. In other words, r + r + ... + r (n times) is returned. This is the additive version of ElementToPower.";

• Multiplication::usage = "Multiplication[R] is the multiplication in the Ringoid R. Given an extension Ext of a ring, Multiplication[Ext] is the multiplication in this extension. Multiplication is also a value for the Operation option that is used in some ring functions.";

• MultiplicationTable::usage = "MultiplicationTable[R] returns the multiplication table of the Ringoid R. MultiplicationTable[R, Mode \[Rule] Visual] returns a graphical view of this table.";

• MultiplicativeGroupoid::usage = "MultiplicativeGroupoid[R] returns the multiplicative Groupoid of the ring R. A shortcut is MGroupoid[R].";

• MultiplicativeInverse::usage = "MultiplicativeInverse[R, a] returns the multiplicative inverse of a in the structure R, if it exists, and $Failed otherwise.";

• MultiplicativeToAdditive::usage = "MultiplicativeToAdditive[R, mult] returns the additive form of the element mult, currently in multiplicative form, from the ringoid (typically a Galois field) R.";

• MultiplyCycles::usage = "MultiplyCycles[c2, c1, n] views both cycles c1 and c2 as in S[n] and determines the permutation representing their product. Note that the order of the multiplication is from right to left (unless specified otherwise by ProductOrder). MultiplyCycles[c2, c1] does the same but determines the value for n by the equation n = Max[Join[c1, c2]]. MultiplyCycles[c3, c2, c1] starts from the right and multiplies the cycles as it moves left through c2 and c3. MultiplyCycles[cyclelist] or MultiplyCycles[{cyclelist}] will work on any length of list of cycles and finds the product, working from right to left if the option ProductOrder is set to RightToLeft, or from left to right if set to LeftToRight. See ProductOrder for details on its values.";

• MultiplyPermutations::usage = "MultiplyPermutations[perm2, perm1], by default, computes the product of perm1 followed by perm2 (right to left). The option ProductOrder is by default set to RightToLeft, but can also be set to LeftToRight. Note that the permutations can be expressed as rules (eg., {1->3, 2->2,3->1}), or lists (eg., {3,2,1}) or mixed, though the output will always be a list.";

• MySymmetryGroup::usage = "MySymmetryGroup is a global variable which contains the accumulated list of alleged permutations representing the symmetries of the object given by ShowOne[Lab2]. Note that since it is a variable, it does not need [] following it.";

• NS::usage = "NS is a symbol for Input and Output to represent whatever Normal Subgroup is in use at the time.";

• NegationOf::usage = "NegationOf[R, r] returns the additive inverse of r in the structure R, if it exists, and $Failed otherwise.";

• Negations::usage = "Negations is a value for the Combine option of IntegerDivisors and ZdDivisors. With this value, the divisors of n are grouped in pairs {a, b} such that a and b are negations.";

• NextStage::usage = "NextStage[func] returns the next stage of an animation for the function func when Mode is set to Visual. NextStage[func, k] indicates that k steps forward should be taken (or backwards, if negative). The functions supporting this include Closure, SubgroupClosure, and QuotientRing in some cases.";

• NilpotentDegree::usage = "NilpotentDeg ree[R, r] returns 0 if the element r is NOT nilpotent in the structure R; otherwise a positive integer n is returned, which is the least positive integer such that r^n is the zero element.";

• NilpotentQ::usage = "NilpotentQ[R, r] returns True if r is a nilpotent element in the structure R, and False otherwise.";

• Nilpotents::usage = "Nilpotents[R] returns all the nilpotent elements in the structure R.";

• NonAssociatingTriples::usage = "NonAssociatingTriples[G] returns the triples of elements {a, b, c} in the Groupoid G that do not associate.";

• NonCommutingPairs::usage = "NonCommutingPairs[G] returns the pairs of elements in the Groupoid G that do not commute.";

• NonIdentity::usage = "NonIdentity is a value for the SelectFrom option for RandomElement and RandomElements. This allows any element to be returned except the identity element, if it exists. Alternatively, one may use the value Any. Note: for rings, this option excludes both the zero and unity (if they exist) and other related options are NonUnity and NonZero.";

• NonTrivialOnly::usage = "NonTrivialOnly is an option name for both IntegerDivisors and ZdDivisors. Its default value is False, which means that trivial divisors (± 1 and ± n) are included, but excluded if set to True.";

• NonUnity::usage = "NonUnity is value for the SelectFrom option for the RandomElement function, which when having the value True specifies that the chosen element should not be the unity.";

• NonZero::usage = "NonZero is value for the SelectFrom option for the RandomElement function, which when having the value True specifies that the chosen element should not be the zero.";

• NonZeroMGroupoid::usage = "NonZeroMGroupoid[R] returns the Groupoid of nonzero elements of R with the Multiplication from R. If R is a field, this is the group of units.";

• NormalQ::usage = "NormalQ[H, G] returns True if H is a normal subgroup of G, and False otherwise.";

• Normalize::usage = "Normalize is an option for ToCycles and FromCycles that indicates whether a list of cycles in Cycle notation (this assumes that we have CycleAs -> Cycle as an option) is normalized. If the list consists only of cycles of length 1, it drops all of them except the one with maximal value; otherwise, all cycles of length one are dropped (unless needed to show the length of the permutation), the remaining cycles are normalized by rotating until the smallest entry occurs first, and then the list of cycles is sorted from shortest to longest.";

• NormalizeCycleList::usage = "NormalizeCycleList[cl], given a list of cycles, returns a list of cycles in a canonical form. If cl consists only of cycles of length 1, it drops all of them except the one with maximal value; otherwise, all cycles of length one are dropped, the remaining cycles are normalized by NormalizeCycle, and then the list is sorted from shortest to longest.";*)

• Normalizer::usage = "Normalizer[G, H] returns the normalizer of the subgroup H in G.";

• OddPermutationQ::usage = "OddPermutationQ[p] returns True if p is an odd permutation, and False otherwise.";

• OneToOneQ::usage="OneToOneQ[f] is equivalent to InjectiveQ[f].";

• OntoQ::usage = "OntoQ[f] is equivalent to SurjectiveQ[f].";

• Operation::usage = "Operation[G] returns the operation used in the Groupoid G. Operation is also an option for various functions when working with rings; possible settings are Addition, Multiplication, and Both.";

• OperatorSymbol::usage = "OperatorSymbol[G] returns the symbol used for the operation in the Groupoid G. FormGroupoid and GenerateGroupoid set this to be * by default.";

• Orbit::usage = "Orbit[G, S, x] is the orbit of x (from S) under G. Here, G is a group of permutations of the set S. Orbit[S, x] assumes G is the full set of all permutations of S.";

• Order::usage = "Order[G] returns the cardinality of the set of elements in the group G. This is identical to the function Size. Order[G, g] gives the order of the element g in G. This is identical to the function OrderOfElement. \nThe standard (built-in) definition still exists: Order[expr1, expr2] gives 1 if expr1 is before expr2 in canonical order, and -1 if expr1 is after expr2 in canonical order. It gives 0 if expr1 is identical to expr2.";

• OrderOfAllElements::usage = "OrderOfAllElements[G] returns a list of the orders of each element in the Groupoid G in the form {element, order}.";

• OrderOfElement::usage = "OrderOfElement[G, g] returns the order of the element g in the Groupoid G.";

• Ordering::usage = "Ordering[list] gives the permutation that puts the elements in list in (a canonical) order. If list is a permutation, this is equivalent to PermutationInverse. (This is from the DiscreteMath`Permutations` package.)";

• Orders::usage = "Orders[G] returns a list of the orders of each element in the Groupoid G in the form {element, order}. Orders[G, list] works similarly, where list is a list of elements from the Groupoid G.";

• OrthogonalQ::usage = "OrthogonalQ[R, A] returns True or False depending on whether the matrix A over the Ringoid R is an orthogonal matrix (i.e., the product of the transpose of A and A itself is the identity matrix). For matrices with real entries, OrthogonalQ[A] works similarly.";

• Output::usage = "Output is an option that can be used when a Visual mode is used and determines the form of the output. By default, the value of the option is Computational, which means that the output is the normal computation. Alternatively, using Output ® Graphics will cause the graphics of the Visual mode to be the output (given as -Graphics-). This is a method of capturing the graphics involved in a computation instead of the actual computation. Additionally, in a few cases were a series of graphics are produced, the value GraphicsArray option can be used.";

• Parity::usage = "Parity[perm] returns 1 if the permutation perm is an even permutation and -1 if odd.";

• Partition::usage = "Partition is an option for Cartesian Product. By default, it is set to False. When set to True, the list is partitioned according to the size of the second (last) list. \nThe standard (built-in) definition still exists: Partition[list, n] partitions list into non-overlapping sublists of length n. Partition[list, n, d] generates sublists with offset d. Partition[list, {n1, n2, ...}, {d1, d2, ...}] partitions successive levels in list into length ni sublists with offsets di.";

• PermutationComposition::usage = "PermutationComposition[p2, p1] returns the product of permutation p1 followed by permutation p2.";

• PermutationGroup::usage = "PermutationGroup[list] returns the permutation group on the elements in list. It is assumed that the length of list is less than 7. PermutationGroup[n] acts just as Symmetric[n].";

• PermutationImage::usage = "PermutationImage[S, p, el] returns the image of the element el under the action of the permutation p, where p permutes the elements of S. If p is a permutation in S[n], then PermutationImage[p, el] is equivalent to PermutationImage[Range[n], p, el].";

• PermutationInverse::usage = "PermutationInverse[perm] gives the permutation that is the inverse of perm";

• PermutationMatrix::usage = "PermutationMatrix[p] shows a permutation in matrix form, where the top row consists of 1, 2, ... Length[p] and the bottom row consists of the corresponding images.";

• PermutationQ::usage = "PermutationQ[e] yields True if e is a list representing a permutation. (This is a modified version of that found in the DiscreteMath`Permutations` package.)";

• PermutationToPower::usage = "PermutationToPower[perm, n] returns the nth power of the permutation perm, where n is any integer. (If n < 0, this returns the nth power of the inverse of perm.)";

• Permutations::usage = "Permutations is a value for the Form option when working with the dihedral group. See Dihedral for more information. \nThe standard (built-in) definition still works: Permutations[list] generates a list of all possible permutations of the elements in list.";

• Permutations::usage = "Permutations is a value for the Form option when working with the dihedral group. See Dihedral for more information.\nThe standard (built-in) definition still works: Permutations[list] generates a list of all possible permutations of the elements in list.";

• PermuteColoredSquares::usage = "PermuteColoredSquares[p] will show a row of randomly colored squares (as in RandomColoredSquares) and below this a row of squares obtained by permuting the first list using the permutation given by p. This function only works after RandomColoredSquares has been called. See ShowColoredPermutation also.";

• PlusSymbol::usage = "PlusSymbol is an option for FormRingoid to specify the symbol used for addition in forming a Ringoid. The default is PlusSymbol ® +.";

• Poly::usage = "Poly[R, expr, opts] creates the polynomial over the Ringoid R given by expr and using the options given by opts. A polynomial such as 2 + 3x + x^3 (over some ring R) can be constructed by Poly[R, 2 + 3x + x^3], which, by default, would return 2 + 3x + x^3. The form x^3 + 3x + 2 could be returned by entering Poly[R, 2 + 3x + x^3, PowersIncrease -> RightToLeft], or by changing this option globally. One can also specify a polynomial by just using the coefficients. Thus, Poly[R, 1, 0, 3, 2] returns 1 + 3x^2 + 2x^3, while Poly[R, 1, 0, 3, 2, PowersIncrease -> RightToLeft] returns x^3 + 3x + 2. When entering just the coefficients, the default indeterminate is 'x', but this can be changed by using the option Indeterminate -> var, where var is any (undefined) symbol. FlexibleEntering, an option taking either True or False (defaulting to True), can be used if one wishes to enter polynomials allowing subtraction of terms or allowing entering the negation of an element by using -r. It also allows all coefficients of the polynomial to be reduced mod n if the base ring is Z[n]. If RP is a ring of polynomials, Poly[RP, expr, opts] works in a similar fashion.";

• PolyQ::usage = "PolyQ[p] returns True if p is a polynomial obtained by the Poly function in AbstractAlgebra, and False otherwise.";

• PolyRing::usage="PolyRing is a parameter of RingExtension.";

• PolyToFunction::usage = "PolyToFunction[R, p] constructs the function on the ringoid R that is defined by the polynomial p (constructed with Poly). If R has no unity, then $Failed is returned.";

• PolynomialDivision::usage="PolynomialDivision[PolynomialsOver[R], a, b], for polynomials a and b in the ring of polynomials over R, returns the pair of polynomials {q, r} where a = b q + r with r = 0 or deg r < deg b, provided that the leading coefficient of b is a unit in R. PolynomialDivision[a, b] works similarly as long as polynomials a and b are both from the same ring of polynomials. \nThe standard (built-in) usage still exists: PolynomialDivision[p, q, x] gives a list of the quotient and remainder obtained by division of the polynomials p and q in x.";

• PolynomialEvaluation::usage = "PolynomialEvaluation[PolynomialsOver[R], p, alpha] evaluates the polynomial p at alpha using the operations of the Ringoid R. PolynomialEvaluation[p, alpha] works similarly.";

• PolynomialGCD::usage = "PolynomialGCD[PolynomialsOver[R], p, q] returns the greatest common divisor of the polynomials p and q (as elements of the ring of polynomials over R). PolynomialGCD[p, q] works similarly as long as polynomials p and q are both from the same ring of polynomials. \nThe standard (built-in) usage still exists: PolynomialGCD[poly1, poly2, ...] gives the greatest common divisor of the polynomials poly1, poly2, ... . PolynomialGCD[poly1, poly2, ..., Modulus->p] gives the GCD modulo the prime p.";

• PolynomialLCM::usage = "PolynomialLCM[PolynomialsOver[R], p, q] returns the least common multiple of the polynomials p and q (as elements of the ring of polynomials over R). PolynomialLCM[p, q] works similarly as long as polynomials p and q are both from the same ring of polynomials. \nThe standard (built-in) usage still exists: PolynomialLCM[poly1, poly2, ...] gives the least common multiple of the polynomials poly1, poly2, ... . PolynomialLCM[poly1, poly2, ..., Modulus->p] gives the LCM modulo the prime p.";

• PolynomialQuotient::usage = "PolynomialQuotient[PolynomialsOver[R], p, q] returns the quotient when the polynomial p is divided by the polynomial q (as elements of the ring of polynomials over R), provided that the leading coefficient of q is a unit in R. PolynomialQuotient[p, q] works similarly as long as polynomials p and q are both from the same ring of polynomials. \nThe standard (built-in) usage still exists: PolynomialQuotient[p, q, x] gives the quotient of p and q, treated as polynomials in x, with any remainder dropped.";

• PolynomialRemainder::usage = "PolynomialRemainder[PolynomialsOver[R], p, q] returns the remainder when the polynomial p is divided by the polynomial q (as elements of the ring of polynomials over R), provided that the leading coefficient of q is a unit in R. PolynomialRemainder[p, q] works similarly as long as polynomials p and q are both from the same ring of polynomials. \nThe standard (built-in) usage still exists: PolynomialRemainder[p, q, x] gives the remainder from dividing p by q, treated as polynomials in x.";

• PolynomialsOfDegreeN::usage = "PolynomialsOfDegreeN[R, n, opts] returns all polynomials of degree n over the ring R. Since this number can increase rather quickly, the option SizeLimit provides a maximum for the number of polynomials that will be produced. The default value is 125, but this can be changed using the option. Unless Indeterminate -> symbol is set, the default indeterminate is 'x'. A related function is PolynomialsUpToDegreeN.";

• PolynomialsOver::usage="PolynomialsOver[R] generates the RingExtension of polynomials over R.";

• PolynomialsUpToDegreeN::usage = "PolynomialsUpToDegreeN[R, n, opts] returns all polynomials of degree n or less over the ring R. Since this number can increase rather quickly, the option SizeLimit provides a maximum for the number of polynomials that will be produced. The default value is 125, but this can be changed using the option. Unless Indeterminate -> symbol is set, the default indeterminate is 'x'. A related function is PolynomialsOfDegreeN.";

• PowerList::usage = "PowerList[GF[n]] is equivalent to TableOfPowers, added for compatibility with the Algebra`FiniteFields` package.";

• PowersIncrease::usage = "PowersIncrease is an option that is used in specifying how a polynomial should be presented when called with the Poly function. It takes two values, RightToLeft and LeftToRight. The former returns a polynomial in the form 4x^2 + 3x + 1 while the latter returns 1 + 3x + 4x^2 for the same polynomial.";

• PreservesQ::usage = "PreservesQ[f, {a, b}] returns True if the Morphoid f preserves the binary operation(s) for the pair (a,b), and False otherwise. Alternatively, if f is either a list of Rules, a Function or a Symbol, Si is a set of Elements, and opi is a binary operation, then the following are also acceptable usages: PreservesQ[f, {S1, op1}, {S2, op2}, {a, b}], PreservesQ[f, {S1, op1, op3}, {S2, op2, op4}, {a, b}]. This also supports the Visual Mode.";

• PreviousStage::usage = "PreviousStage[func] returns the previous stage of an animation for the function func when Mode is set to Visual. PreviousStage[func, k] indicates that k steps backwards (or forward, if negative) should be taken. The functions supporting this include Closure, SubgroupClosure, and QuotientRing in some cases.";

• PrimeIdealQ::usage = "PrimeIdealQ[S, R] returns True if the set S is a prime ideal in the structure R, and False otherwise.";

• PrimitivePolynomials::usage = "PrimitivePolynomials[GF[n]] returns the set of primitive polynomials in GF[n]. (Actually, GF[n] can be replaced by any ring R and this will return the set of elements that generate the multiplicative Groupoid of non-zero elements in R.)";

• PrincipalIdeal::usage = "PrincipalIdeal[ R, r] returns the Ringoid in the Ringoid R. This is the principal ideal generated by r in R.";

• PrintMessage::usage="PrintMessage is an option for the ProbableMorphismQ function. When set to True (the default value), it will warn the user that a positive result is not absolutely certain, but only probabilistic.";

• ProbableGroupQ::usage = "ProbableGroupQ[G] returns True or False depending on whether the tests for a group are valid, using RandomAssociativeQ instead of AssociativeQ.";

• ProbableMorphismQ::usage="ProbableMorphismQ[f] returns True if checking random pairs of elements in the domain of Morphoid f indicates that f preserves the operation(s), and False otherwise. This is a fast, effective, although not foolproof, way of testing whether a Morphoid is a morphism. The option SampleSize controls the number of pairs tested. SamplePairs, by default set to Random, controls the specific pairs (by giving positions or indices in the domain) to be tested, if not chosen randomly.";

• ProbableRingQ::usage = "ProbableRingQ[R] returns True if R is probably a ring (all properties are checked, except associativity and distributivity use the randomized versions), and False otherwise.";

• ProductOrder::usage = "ProductOrder is an option for the function MultiplyPermutations and other functions that call this. The value of this, which defaults to RightToLeft, specifies the order in which the permutations are multiplied. Alternatively, one can specify LeftToRight.";

• Products::usage = "Products is a value for the Combine option of IntegerDivisors and ZdDivisors. With this value, the divisors of n are grouped in pairs {a, b} such that a*b = n.";

• ProperSubsetQ::usage = "ProperSubsetQ[A, B] returns True if A is a proper subset of B, and False otherwise.";

• QuaternionGroup::usage = "QuaternionGroup[] returns the 8 element quaternion group. This group can be represented in various forms; the default is to represent it as 2-by-2 matrices. The option Form controls what form to use, with the default value being AsMatrices. Other values are AsIJK and AsSymbols.";

• QuotientGroup::usage = "QuotientGroup[G, N] returns the quotient group formed by the group G and the normal subgroup N. Options for this function are Form and Representatives. Form can have the value Cosets (default) which returns the elements in coset form g + NS or g NS where NS is a symbol representing the Normal Subgroup. The value CosetLists returns the quotient group as a list of all the cosets in list form. Alternatively, one can use Form -> Representatives and then only the representatives of the cosets will be returned. The default list of representatives uses the 'smallest' element in the coset and is indicated by Representatives -> Canonical; if you wish to change this list, use Representatives -> list, where list is a list of one element from each coset, or use Representatives -> Random to have these representatives randomly chosen. This can be used also if one has Form -> Cosets. By default, left cosets are used.";

• QuotientRing::usage = "QuotientRing[R, S] returns the quotient ring formed by the ring R and the ideal S. Options for this function are Form and Representatives. Form can have the value Cosets (default) which returns the elements in coset form g + NS or g NS where NS is a symbol representing the Ideal (normal subgroup). Alternatively, one can use Form \[Rule] Representatives and then only the representatives of the cosets will be returned. The default list of representatives uses the 'smallest' element in the coset and is indicated by Representatives \[Rule] Canonical; if you wish to change this list, use Representatives \[Rule] list, where list is a list of one element from each coset. This can be used also if one has Form \[Rule] Cosets. By default, left cosets are used. For a polynomial p over the base ring R, QuotientRing[R, p] returns the Ringoid of polynomials mod p, if R is a Ringoid with unity and the leading coefficient of p is a unit of R. QuotientRing[Z[I], z] returns the quotient ring Z[I]/ for a Gaussian integer z; this has a Visual mode. WARNING: This function may use a lot of memory if R is large and/or the degree of p is large. (Note: A portion of the code that creates the Visual mode of QuotientRing[Z[I], z] utilize several functions in Stan Wagon's 'Mathematica in Action' book, pages 334, 335 (in the first edition from Freeman).)";

• Radical::usage = "Radical is an option for DividesQ that specifies the value of d when division takes place in \[DoubleStruckCapitalZ][\!\(\@d\)]. The value for this option needs to be a square-free integer.";

• RandomAssociativeQ::usage = "RandomAssociativeQ[S] returns a Boolean value of True or False depending on whether the structure S appears to be associative after 50 random choices of testing a triple of elements from S. RandomAssociativeQ[S, n] will randomly test n times. When used with rings, the Operation option can be used, which can have the value Addition, Multiplication or Both.";

• RandomColoredSquares::usage = "RandomColoredSquares[n] returns a row of n colored squares chosen randomly from a default list. Optionally, RandomColoredSquares[n,colors] will choose the n from the list provided in colors.";

• RandomDistributiveQ::usage = "RandomDistributiveQ[R] returns True if the Multiplication is likely to be distributive over the Addition in structure R (by checking 20 triples), and False otherwise. RandomDistributive[R, n] checks n triples.";

• RandomElement::usage = "RandomElement[S] returns a random element from the Groupoid or Ringoid (or simply the list) S. Available options are SelectFrom ® NonIdentity (this, the default, guarantees that the identity is not selected for Groupoids and neither the zero nor the unit is selected for Ringoids), SelectFrom ® NonUnity (which guarantees the unity is not selected with Ringoids), SelectFrom ® NonZero (which guarantees the zero is not selected with Ringoids), and SelectFrom ® Any (which imposes no restrictions). For polynomial extension rings, the options LowerDegreeOK and Monic are also available; see these for details (after working with rings). Additionally, one can obtain a random element from some specialized sets as follows: RandomElement[Z[Sqrt[p]],max] (for p square-free and max defaulting to 100) returns a + b Sqrt[p] with both a and b in the range [-max, max]. One can use p = -1 also, or use equivalently use Z[I].";

• RandomElements::usage = "RandomElements[S, n] returns a set of n random elements from the Groupoid or Ringoid (or list) S. Available options are SelectFrom ® NonIdentity (this default guarantees that the identity is not selected for Groupoids and neither the zero nor the unit is selected for Ringoids), SelectFrom ® NonZero (which guarantees the zero is not selected with Ringoids), and SelectFrom ® Any (which imposes no restrictions). Additionally, Replacement ® True will allow an element to be selected more than once (while set to False will not allow this). Additionally, one obtain a random element from some specialized sets as indicated under RandomElement, by adding the final parameter indicating how many to choose.";

• RandomGroupoid::usage = "RandomGroupoid[n, k] returns a random Groupoid of order n. If k = 1, the Cayley table is a collection of n^2 random elements from a list of n generic elements; if k = 2, each row is a permutation of a list of n generic elements; if k = 3, each column is a permutation of a list of n generic elements.";

• RandomMatrix::usage = "RandomMatrix[R, n, MatrixType -> type] returns a random n-by-n matrix over the Ringoid R of the specified type; see MatrixType for the possible values.";

• RandomPermutation::usage = "RandomPermutation[n] returns a random permutation of length n. (This is a modified version of that found in the DiscreteMath`Permutations` package.)";

• Randomize::usage = "Randomize[list] will randomly permute the elements in list.";

• RationalMatrixQ::usage = "RationalMatrixQ[A] returns True or False depending on whether the matrix A has all of its entries being rational numbers (in the mathematical sense - entries can be Integer or Rational).";

• RationalRootCandidates::usage = "Ration alRootCandidates[poly] returns a list of candidates for the Rational Root Theorem, given the polynomial poly.";

• RationalRootTheorem::usage = "RationalRootTheorem[poly] returns a list of two lists, given a polynomial poly. The first list consists of those rational candidates which are zeros for poly, while the second list consists of those rational candidates which are not zeros for poly.";

• RealMatrixQ::usage = "RealMatrixQ[A] returns True or False depending on whether the matrix A has all of its entries being real numbers (in the mathematical sense - entries can be Integer, Rational, Algebraic, or Real).";

• ReduceList::usage = "ReduceList[polyList] effectively is the equivalent to Union[polyList, SameTest -> Equal] where polyList is a list of polynomials formed using the Poly function and Equal is the function designed to test when two polynomials built from Poly are equal.";

• Ref::usage = "This is the standard (default) symbol to represent a reflection when working with the dihedral group D[n].";

• RefSym::usage = "When working with dihedral groups, by default we use the option RefSym ® Ref. This can be changed so that any other symbol is used to represent the reflection. See Dihedral for more information.";

• ReorderGroupoid::usage = "ReorderGroupoid[G, neworder] takes the Groupoid G and forms a new Groupoid with all the properties of G using the order of the elements presented in neworder. (Note that mathematically the result of this and G are identical since groups do not have an order assumed among the elements. This is simply for the convenience of using the functions in these packages.)";

• Replacement::usage = "Replacement is an option for RandomElement and RandomElements. The value True means that replacement is to be allowed while False if not.";

• ReportIterations::usage = "ReportIterations is a Boolean option for Closure. If set to true, all of the iterations of the closure process will also be shown, in addition to the final result.";

• Representatives::usage = "Representatives is a value for the Form option of QuotientGroup and QuotientRing. This causes the elements to be written as representatives of the cosets. Representatives is also an option name for QuotientGroup and QuotientRing. It can take values Canonical (default), Random, or {g1, g2,...} where the gi's are representatives from the cosets. The Canonical option uses the 'first' element in the coset, while the Random chooses them randomly.";

• RestrictList::usage = "RestrictList[r], given a rule r given as either {i -> j} or as i -> j, will produce output similar to what is given in ShowPossiblePermsAsRules except that only those permutations containing r will be shown. This can be useful if you are exploring what possibilities exist given vertex i is to go to vertex j. RestrictList[{r1, r2,..}] is similar except it will take the intersection of what is obtained by RestrictList[r1], RestrictList[r2]...";

• RightCoset::usage = "RightCoset[G, H, g] returns the right coset Hg (or H + g) when given the element g from G and the subgroup H of G.";

• RightCosets::usage = "RightCosets[G, H] returns a list of the cosets of the subgroup (or subring) H in the Groupoid (or Ringoid) G.";

• RightDistributiveQ::usage = "RightDistributiveQ[R] returns True if the Multiplication is right distributive over the Addition in the structure R, and False otherwise.";

• RightIdealQ::usage = "RightIdealQ[S, R] returns True if the set S is a right ideal of the structure R, and False otherwise.";

• RightIdentity::usage = "RightIdentity[G] returns the right identity of the Groupoid G, if one exists, or $Failed otherwise.";

• RightInverse::usage = "RightInverse[G, g] returns the right inverse of g in G, if it exists, otherwise $Failed.";

• RightInvertibleQ::usage = "RightInvertibleQ[G, g] returns True if the right inverse of g in G exists, and False otherwise.";

• RightToLeft::usage = "RightToLeft is a value for the ProductOrder option for the MultiplyPermutations and MultiplyCycles functions, as well for the PowersIncrease option for Poly (when working with polynomials over a ring). When ProductOrder is set to this value, then MultiplyPermutations[p2,p1] will be computed by taking p1 followed by p2. For the use in Poly, see PowersIncrease.";

• RightToLeft::usage = "RightToLeft is a value for the ProductOrder option of MultiplyPermutations and MultiplyCycles, as well for the PowersIncrease option for Poly (when working with polynomials over a ring). When ProductOrder is set to this value, then MultiplyPermutations[p2,p1] will be computed by taking p1 followed by p2. For the use in Poly, see PowersIncrease.";

• Ring::usage = "Ring is a value for the Structure option that is used for several functions, including FormMorphoid, ZMap, and Z (including Z[n] and Z[n, I]). It is also an acceptable argument for the SwitchStructureTo function.";

• RingExtension::usage="RingExtension is the head for ring extensions.";

• RingInfo::usage = "RingInfo[R] is a list of facts about R that are generated by various tests of R.";

• RingInfo::usage = "RingInfo[R] returns a list of information obtained about the Ringoid R which has been gathered by calling various functions.";

• RingQ::usage = "RingQ[R] returns True if R is a ring, and False otherwise.";

• RingSolve::usage = "RingSolve[R, a, b] solves the linear equation a x == b in the Ringoid R, returning a list of elements that solve the equation. The Solve command may also be useful.";

• Ringoid::usage = "Ringoid is the head for a triple where the first component is a set of elements and the second and third are the addition and multiplication operations. A Ringoid is one of the basic structures of these packages.";

• RingoidDescription::usage = "RingoidDescription[R] returns a description, if given, of the ring R. This can be set with the RingoidDescription option (of the same name) in FormRingoid. If the empty string is returned, no description has been given.";

• RingoidName::usage = "RingoidName[R] yields the name, if given, of the Ringoid R. This can be set with the RingoidName option (of the same name) in FormRingoid. If the empty string is returned (or TheRing, the default value), no name has been given.";

• Rings::usage = "Rings is an acceptable name for the SwitchStructureTo function.";

• RootsOfUnity::usage = "RootsOfUnity[n] returns the Groupoid consisting of the n complex roots of the equation z^n = 1, under multiplication.";

• Rot::usage = "This is the standard (default) symbol used to represent the rotation of the smallest angle when working with the dihedral group D[n].";

• RotRef::usage = "RotRef is a value for the Form option when working with the dihedral group. See Dihedral for more information.";

• RotSym::usage = "When working with dihedral groups, by default we use the option RotSym ® Rot. This can be changed so that any other symbol is used to represent the rotation. See Dihedral for more information.";

• Rules::usage="Rules is a value for the FunctionForm option.";

• S::usage = "S[n] returns the group of permutations on the set {1,2,..n} under composition. See Symmetric.";

• SE::usage = "SE[n] is the nth 'Standard Example' group from a list of commonly used groups.";

• SL::usage = "SL[n, R] (alternately, SL[R, n]) returns the extension of invertible n-by-n matrices over the Ringoid R that have determinant Unity[R]. For a positive integer k, SL[n,k] is equivalent to SL[n,Z[k]].";

• SLQ::usage = "SLQ[R, A] returns True or False depending on whether the matrix A over the Ringoid R is in SL[R, n] (where A is an n-by-n matrix).";

• SamePermutationQ::usage = "SamePermutationQ[cyclist1, cyclist2] returns True if the cycle representation for the permutation found in cyclist1 yields the same permutation represented by cyclist2, and False otherwise.";

• SameSetQ::usage = "SameSetQ[list1, list2] returns True if the sets list1 and list2 are equal as sets, and False otherwise. Note that this tests the mathematical equality of two sets and so SameSetQ[{2,3,1},{1,3,2}] returns True while SameQ[{2,3,1},{1,3,2}] returns False.";

• SamplePairs::usage="SamplePairs is an option for ProbableMorphismQ, whose default value is Random, meaning the pairs are chosen randomly. Alternatively, the value Default uses a short, built-in list of pairs, one can give a list of pairs of indices (not elements) to test, for example: {{2,3},{3,5}}.";

• SampleSize::usage="SampleSize is an option for ProbableMorphismQ that specifies the number of tests to perform.";

• SelectBaseElementsFrom::usage = "SelectBaseElementsFrom is an option for RandomElement and RandomElements when using extension rings. The acceptable values for this option are Any, NonZero, NonUnity and NonIdentity.";

• SelectFrom::usage = "SelectFrom is an option for RandomElement and RandomElements. For Groups, the values are Any and NonIdentity; the former allows any element to be returned while the latter will not return the identity element, if one exists. For Ringoids, NonZero and NonUnity are also available values.";

• SemiGroupQ::usage = "SemiGroupQ[G] returns True if G is a semi-group (a set that is closed under a binary operation that is associative), and False otherwise.";

• Sgn::usage = "Sgn[G] gives the Morphoid whose domain is the group of permutations G and codomain is the group IntegerUnits and the function is the Parity function.";

• ShowBodyText::usage = "ShowBodyText is an option for CayleyTable with settings True or False depending on whether the text in the body of the table is to be shown.";

• ShowCircle::usage = "ShowCircle[n] creates a unit circle with n points labeled {0,1,..n-1} starting at (0,1). ShowCircle[n,labels] is similar except the set labels is used for the labeling.";

• ShowColoredPermutation::usage = "ShowColoredPermutation[p] is similar to PermuteColoredSquares except that it does not require RandomColoredSquares to be called first.";

• ShowFigure::usage = "ShowFigure[n, perm, sym] draws an ngon with permutation perm applied to the vertices and having Dihedral or Cyclic symmetry group if sym is D or Z respectively. ShowFigure[perm] will apply the permutation perm to the vertices of the figure, with the permutation in list or rule form. Additionally, assuming a figure has already been drawn, ShowFigure[] will redraw it.";

• ShowGroupOrders::usage = "ShowGroupOrders[G] displays a ListPlot containing pairs {g,|g|} for all g in the Groupoid G. It also shows a bar chart indicating how many elements there are of each order in the Groupoid G";

• ShowKey::usage = "ShowKey is an option for CayleyTable with settings True or False depending on whether a key is shown when the elements in the set are too wide and a key needs to be used for identification purposes.";

• ShowName::usage = "ShowName is an option for CayleyTable with settings True or False depending on whether the name of the structured set is to be shown.";

• ShowOne::usage = "ShowOne[Labx] shows the appropriate information needed for lab numbered x. Note that ShowOne[Lab2,k] returns the group k while ShowOne[Lab3, k] returns case k, if one needs to return to a specific group in Lab 2 or case in Lab 3.";

• ShowOperator::usage = "ShowOperator is an option for CayleyTable with settings True or False depending on whether the symbol for the operation of the structured set is to be shown.";

• ShowPermutation::usage = "ShowPermutation[perm] shows a graphics array of the (predetermined) n-gon (if n>2) 'before' and 'after' the permutation perm has been applied. The permutation can be in list form or rule form. ShowPermutation[n, perm, symtype] combines ShowFigure[n, IdentityPermutation, symtype] with ShowPermutation[perm].";

• ShowPossiblePermsAsRules::usage = "ShowPossiblePermsAsRules[n] shows the complete list of all possible permutations of the integers {1,2,3,...n} where n must be 5 or less. If the object in question is an n-gon, then use n as the parameter. This differs from ShowPossiblePermutations only in the way they are presented - here as rules. Note that the permutations are labeled ppp[i] and these labels can be used to refer to the given permutation.";

• ShowPossiblePermutations::usage = "ShowPossiblePermutations[n] shows the complete list of all possible permutations of the integers {1,2,3,...n} where n must be 5 or less. If the object in question is an n-gon, then use n as the parameter. Note that the permutations are labeled ppp[i] and these labels can be used to refer to the given permutation.";

• ShowSidesText::usage = "ShowSidesText is an option for CayleyTable with settings True or False depending on whether the text in the top row and left column (representing the elements of the Groupoid) is to be shown.";

• SideBySideMatrices::usage = "SideBySideMatrices[p,q] displays permutation p as a matrix on the left and permutation q as a matrix on the right, with some space in between. This simply illustrates how we begin to multiply matrices.";

• Size::usage = "Size[S] returns the cardinality of the set of elements in the structured set S. This is identical to the function Order.";

• SizeLimit::usage = "SizeLimit is an option for the GenerateGroupoid function. By default it is set to 25. When the size of the generated set exceeds this limit, no further generation will take place.";

• SizeOfMatrices::usage = "SizeOfMatrices[matrixExtension] returns the dimensions of the matrices used in this extension ring.";

• SkewHermitianQ::usage = "SkewHermitianQ[A] returns True or False depending on whether the matrix A is skew-Hermitian in the sense that A = -Adjoint[A].";

• SkewSymmetricQ::usage = "SkewSymmetricQ[R, A] returns True or False depending on whether the matrix A is skew-symmetric in the sense that A = -Transpose[A]. For matrices with numeric entries (over Integers, Rationals, Reals or Complex), SkewSymmetricQ[A] works similarly.";

• Solve::usage = "Solve[PolynomialsOver[R], poly == r], when given a polynomial poly from the ring of polynomials over the Ringoid R and an element r from R, solves the equation poly == r in the indeterminate x. (Solve[poly == r] can also be used, with the underlying ring extracted from poly.) Solutions are returned as a list of rules (as per normal usage). These solutions can be used with ReplaceAll (or its equivalent, /.) just as the results of the ordinary (built-in) Solve, whose functionality still works: \nSolve[eqns, vars] attempts to solve an equation or set of equations for the variables vars. Any variable in eqns but not vars is regarded as a parameter. Solve[eqns] treats all variables encountered as vars above. Solve[eqns, vars, elims] attempts to solve the equations for vars, eliminating the variables elims.";

• SortGroupoid::usage = "SortGroupoid[G] returns the Groupoid with the elements sorted by the Sort function. Typically, this is already the case.";

• SpecialLinear::usage = "SpecialLinear[args] - see SL.";

• SpecialLinearGroup::usage = "SpecialLinearGroup[args] - see SL.";

• Stabilizer::usage = "Stabilizer[G, S, x] returns the stabilizer of the element x (from S) in the group G. Here, G is a group of permutations of the set S. Stabilizer[S, x] assumes G is the full set of all permutations of S.";

• Staged::usage = "This is an option for some functions (including Closure, SubgroupClosure, and QuotientRing in some cases) and can be set to True if an animation is to be conducted manually using NextStage and PreviousStage, and False otherwise.";

• Structure::usage = "Structure is an option for several functions. Using Structure ® Group (default when working with groups) specifies that we are working with a group structure, while Structure ® Ring (default in Rings) specifies that rings are involved. Functions that have this option are ZMap, FormMorphoid, and Z (and related functions).";

• SubgroupClosure::usage = "SubgroupClosure[G, H] returns the subgroup of G generated by the elements in the set H (which is a subset of G). The option ReportIterations (defaults to False) indicates whether the result of each iteration is also returned. The option Staged (default to False), applicable if Mode ® Visual is given, indicates whether or not the graphics are shown one stage at a time. If set to true, NextStage[SubgroupClosure] returns the next iteration and PreviousStage[SubgroupClosure] returns the previous iteration.";

• SubgroupConjugate::usage = "SubgroupConjugate[G, H, x] returns the set x H x^(-1) for the subgroup H of the Groupoid G.";

• SubgroupGenerated::usage = "SubgroupGenerated[G, g] returns the subgroup generated by the element g in the group G. Options include Mode -> Visual2 (as well as the other modes). When using the Visual mode, Output -> GraphicsArray causes the graphics to be placed in array form, rather than being presented serially.";

• SubgroupIntersection::usage = "SubgroupIntersection[G, H, K] returns the subGroupoid of G which is the intersection of subgroups H and K.";

• SubgroupJoin::usage = "SubgroupJoin[G, H, K] returns the subGroupoid of G generated by the elements in the subgroups H and K.";

• SubgroupProduct::usage = "SubgroupProduct[G, H, K] returns the subGroupoid (of G) HK = {hk | h in H, k in K} for subgroups H and K.";

• SubgroupQ::usage = "SubgroupQ[H, G] returns True if H is a subgroup of the group G, and False otherwise. H can be in the form of a list of elements or a Groupoid consisting of elements from G. Options include Mode ® Visual2 (as well as the other modes).";

• SubgroupUnion::usage = "SubgroupUnion[G, H, K] returns the subGroupoid of G which is the union of subgroups H and K.";

• Subgroupoid::usage = "Subgroupoid[G, H] creates the Groupoid with the elements from the list H (assumed to be elements from G) and the operation from the Groupoid G. Subgroupoid[G,{H1, H2}] or Subgroupoid[{G, H1}, {G, H2}] can be used if there are 2 (or more) subsets H.";

• Subgroups::usage = "Subgroups[G] returns a list of all the subgroups of the group G. Warning: This may take a long time for high order (non-cyclic) groups!";

• SubringQ::usage = "SubringQ[S, R] returns True if S is a subring of R, and False otherwise. (This function tests whether S is nonempty and closed with respect to difference and multiplication in R.)";

• SubsetQ::usage = "SubsetQ[A, B] returns True if A is a subset of B, and False otherwise.";

• SurjectiveQ::usage="Surjective[f] returns True if the Morphoid f is surjective (onto), and False otherwise.";

• SwitchStructureTo::usage = "SwitchStructureTo[structure] sets various options and definitions so that the given structure is the default. Acceptable values are Group (or Groups or Groupoid) and Ring (or Rings or Ringoid).";

• Symmetric::usage = "Symmetric[n] returns the group of permutations on the set {1,2,..n} under composition. There are two options for this function, ProductOrder and IndexLimit. Since the elements of this group are permutations, one can specify the order that the product is taken by using ProductOrder; see ProductOrder for more information, including the values which can be used. IndexLimit defaults to 6 and indicates the upper limit for the value of the index n.";

• SymmetricGroup::usage = "SymmetricGroup[n] behaves just as the function Symmetric, but also has the functionality of PermutationGroup.";

• SymmetricQ::usage = "SymmetricQ[R, A] returns True or False depending on whether the matrix A is symmetric. For matrices with numeric entries (over Integers, Rationals, Reals or Complex), SymmetricQ[A] works similarly.";

• TableOfPowers::usage = "TableOfPowers[GF[n]] returns a table consisting of first the element {0, 0} followed by pairs of the form {poly^j, r} where r is an element in GF[n], poly is the 'simplest' primitive polynomial for this ring, and j is the power to which poly needs to be raised to be equal to r.";

• TestFunction::usage = "TestFunction[ext] returns the function for the ring extension ext that determines if an element is a member of the extension.";

• TestPermutationQ::usage = "TestPermutationQ[p] tests to see if p is indeed a symmetry of the object given by ShowOne[Lab2]. True or False is returned. The permutation p can be as a simple list or as a list of rules.";

• TextCayley::usage = "TextCayley[G] returns a simple, text-only version equivalent of CayleyTable[G, Mode ® Visual].";

• Textual::usage = "Mode ® Textual is a common option for many functions in these packages. Generally, a written description and/or definition will be given to help clarify the function/concept being explored.";

• TheSet::usage = "TheSet is an option for the CayleyTable function to be used to change the order that the elements appear in the construction of the table. TheSet ® list indicates that Elements[S] are to be arranged according to the order in list and then the Cayley table is constructed with this ordering. To change the ordering on a more permanent basis, see ReorderGroupoid.";

• TimesSymbol::usage = "TimesSymbol is an option to FormRingoid to specify the symbol used for multiplication in forming a Ringoid. The default value is *.";

• ToCycles::usage ="ToCycles[p] writes the permutation p as a list of disjoint cyclic permutations (i.e., cycles) whose product is p. If p is a list of permutations, this will return a list of cycles for each permutation. There are two options for ToCycles, CycleAs and Normalize. Using CycleAs -> List, the cycles are returned in the form returned by the ToCycles function in the DiscreteMath`Permutations` package (so that the permutation {2,1,4,3} is returned as {{2,1},{4,3}}), while CycleAs -> Cycle (default) uses Cycle[2,1] for {2,1} in the cycle list. If CycleAs -> Cycle is used, Normalize -> True (default) applies NormalizeCycleList to the list of cycles. See Normalize for details on how this works.";

• ToFunction::usage = "ToFunction[rules] returns a function of the form ffx (where x is an integer), which is the result of converting the list of rules to a function. ToFunction[rules, f] specifies that the returned function is represented by the symbol f. ToFunction[f] converts the Morphoid based on the Rules definition to one based on a Function (or Symbol) definition, using a function of the form ffx (where x is an integer). ToFunction[f, g] specifies that the returned function is represented by the symbol g.";

• ToGroupoid::usage = "ToGroupoid[extension], where extension might be GL[R,n] or some similar extension (such as MatricesOver[R, {m,n}, opts]), calculates the actual elements and forms a Groupoid when the number of elements is not larger than the default value of the option SizeLimit. Setting this option higher allows more Groupoids to be formed, but one needs to be sure there is sufficient memory to do so, since these Groupoids can become rather large. Using Size first may be a good idea, to see how many elements there are. To just get the list of elements, use the function Elements (which uses the same SizeLimit restriction).";

• ToOrdinaryPolynomial::usage = "ToOrdinaryPolynomial[p] returns an expression that will be regarded as a polynomial in Mathematica's ordinary sense. Note that the underlying ring is lost in this transition and the new polynomial may or may not make sense (for ordinary Mathematica functions), depending on the ring.";

• ToPermutation::usage = "ToPermutation[RuleList] returns the permutation determined by a list of rules. For example, {1®2, 2®1} becomes {2,1}. Similarly, {{1®2}, {2®1}} becomes {2,1}. ToPermutation[c, n] rewrites the cycle c of length <= n as a permutation of length n (or in S[n]). ToPermutation[c] uses the maximum value appearing in c for n.";

• ToRingoid::usage = "ToRingoid[Mat[R, n]], if the SizeLimit permits, returns the Ringoid consisting of the n-by-n matrices over the Ringoid R. See ToGroupoid for more details.";

• ToRules::usage = "ToRules[f, S] converts the function f with domain S to a list of rules of the form x ® f[x]. When it is important to check that the range values belong to a set T, use ToRules[f, S, T] (which returns $Failed if T does not contain all the images). S can be a list of values, a Groupoid, or a Ringoid. ToRules[f], where f is a Morphoid, converts the Morphoid based on a Function (or Symbol) to one based on a list of rules. ToRules[perm] converts any permutation (as a list) to a list of rules. For example, {2,1,3} becomes {1®2, 2®1, 3®3}. \nThe standard (built-in) usage still exists: ToRules[eqns] takes logical combinations of equations, in the form generated by Reduce or Roots, and converts them to a sequence of lists of rules where the sequence corresponds to Or and the lists correspond to And. {ToRules[eqns]} gives a result of the form produced by Solve.";

• ToTranspositions::usage = "ToTranspositions[c] rewrites the cycle c as a product of transpositions. ToTranspositions[perm] rewrites the permutation perm as a product of transpositions.";

• Trivial::usage = "Trivial returns the trivial Groupoid consisting of just a single element.";

• TrivialZR::usage = "TrivialZR[n] returns the ring of integers mod n with mod n addition but a multiplication with all products being zero.";

• TwistedZ::usage = "TwistedZ[n] returns the Groupoid with elements {0, 1, ... n-2} and operation Mod[#1 + #2 + #1 #2, n]&.";

• U::usage = "U[n] returns the group of integers mod n which are relatively prime to n, under multiplication. These elements are also the units in the ring Z[n]. (In other words, these are the elements that have inverses in the Groupoid Zx[n].)";

• UT::usage = "UT[n, R] (alternately, UT[R, n]) returns the extension of n-by-n upper triangular matrices (fully above the diagonal) over the Ringoid R.";

• UTD::usage = "UTD[n, R] (alternately, UTD[R, n]) returns the extension of n-by-n upper triangular matrices (including the diagonal) over the Ringoid R.";

• UnionNoSort::usage = "UnionNoSort[list] removes duplicates in list but does NOT sort list as the Union function does. UnionNoSort[list1, list2,...] returns a single list with all duplicates removed, but unsorted. (This also works with other structures besides Lists.)";

• UnitQ::usage = "UnitQ[R, r] returns True if r is a unit in the structure R, and False otherwise.";

• UnitaryQ::usage = "UnitaryQ[A] returns True or False depending on whether the matrix A (over the complex numbers) is an unitary matrix in the sense that the product of the adjoint of A and A itself is the identity matrix.";

• Units::usage = "Units[R] returns the list of units of the structure R.";

• Unity::usage = "Unity[R] returns the unity of R, if one exists in R, and $Failed otherwise.";

• ValuesHavingGivenNorm::usage = "ValuesHavingGivenNorm[d, nrm], for negative d, returns the list (possibly empty) of values in Z[Sqrt[d]] that have the norm value of nrm. For positive d, ValuesHavingGivenNorm[d, nrm, iter] returns a (partial) list of values having the given norm obtained after iter number of iterations of an algorithm to search along the relevant hyperbola. The value for iter defaults to 50 if omitted. For positive d, the list is incomplete.";

• VarToUse::usage = "VarToUse is an option for CayleyTable to specify the generic label for elements in the body of the Cayley table when the elements are wide and a key is used. (See ShowKey.)";

• Verbal::usage = "Special symbol used for this lab.";

• Visual2::usage = "Mode ® Visual2 is an option for some functions in these packages. Generally, some visual component will be drawn that is intended to further clarify the meaning of a concept/function.";

• Visual::usage = "Mode ® Visual is a common option for many functions in these packages. Generally, some visual component will be drawn which is intended to further clarify the meaning of a concept/function.";

• VisualTextShown::usage = "VisualTextShown is a global variable whose value indicates the number of times any text accompanying a graphic image should be shown. (If multiple graphic images are shown, the text will never be displayed.) For single images, the variable can be set to Infinity, to always display the text; n, to only show it the first n times (a particular function is called); or 0, to never show the text.";

• VisualizeMorphoid::usage = "VisualizeMorphoid[f, opts] provides a visualization of the Morphoid f by using arrows from the domain to the codomain to indicate the map. Available options are ColorDomain and ColorCodomain, both of whose default value is {}. See these names for more details.";

• WideElements::usage = "WideElements is an option for functions which form Groupoids or Ringoids, whose default value is False. When set to True, any formation of a Cayley table will set up a key, under the assumption that the elements are too wide to fit in the grid of the Cayley table.";

• WithImages::usage = "WithImages is an option for the InverseImages function. If set to False (default), only the list of inverse images are listed, while if set to True, each inverse image is listed with its image element.";

• WithUnityQ::usage = "WithUnityQ[R] returns True if the structure R has a unity, and False otherwise.";

• Z::usage = "Z[n] returns the cyclic group of integers mod n under addition when in the context of groups or the ring of integers mod n when in the context of rings. The option Structure can be set to Group or Ring; by default, when working with groups, it is set to Group and set to Ring when working with rings. (See SwitchStructureTo for further information.) Note that ZG[args] is equivalent to Z[args, Structure ® Group], while ZR[args] is equivalent to Z[args, Structure ® Ring]. Z[n, k] returns the group (or ring) of multiples of k mod n, if k is a divisor of n. Additionally, Z[n, I] when working with groups (or Z[n, I, Structure ® Group] while working with rings) returns the additive Gaussian integers mod n, while Z[n, I] returns the ring of Gaussian integers mod n when working with rings.";

• ZG::usage = "ZG[n] returns the group of integers mod n with the operation addition mod n. ZG[n, k] returns the ring of multiples of k mod n if k is a divisor of n. This is equivalent to Z[n, Structure ® Group].";

• ZMap::usage = "ZMap[m, n] creates Morphoid[Mod[#, n]&, Z[m], Z[n]]. ZMap[m, n, g \[Rule] h] creates Morphoid[g \[Rule] h, Z[m], Z[n]], where g must be a generator in Z[m]. In either case, one can add the option Structure \[Rule] Ring to indicate that Z[m] and Z[n] should be considered rings.";

• ZR::usage = "ZR[n] returns the ring of integers mod n with operations addition mod n and multiplication mod n. ZR[n, k] returns the ring of multiples of k mod n if k is a divisor of n. This is equivalent to Z[n, Structure ® Ring].";

• ZdAssociatesQ::usage = "ZdAssociatesQ[d, a, b] returns True if a and b are associates over \[DoubleStruckCapitalZ][\!\(\@d\)], and False otherwise.";

• ZdCombineAssociates::usage = "ZdCombineAssociates[d, lst] takes the list of elements lst from \[DoubleStruckCapitalZ][\!\(\@d\)] and returns a new list of lists, with each new list containing those elements in lst that are associates with each other.";

• ZdConjugate::usage = "ZdConjugate[a + b Sqrt[d]] returns a - b \!\(\@d\), the conjugate in \[DoubleStruckCapitalZ][\!\(\@d\)].";

• ZdDivide::usage = "ZdDivide[x, y] returns the quotient x/y in the form r + s \!\(\@d\) when x and y are both in \[DoubleStruckCapitalZ][\!\(\@d\)].";

• ZdDividesQ::usage = "ZdDividesQ[d, a, b] is equivalent to DividesQ[a, b, Radical \[Rule] d].";

• ZdDivisors::usage = "ZdDivisors[d, x, (opts)], when d is negative, returns all the divisors of the number x in \[DoubleStruckCapitalZ][\!\(\@d\)], possibly restricted by the options in opts. When d is positive, ZdDivisors[d, x, max] returns all the divisors of x (possibly modified by opts) in \[DoubleStruckCapitalZ][\!\(\@d\)] whose norm is less than or equal to the norm of the integer max. Available options are Combine, NonTrivialOnly, and DivisorsComplete. See them for more details.";

• ZdIrreducibleQ::usage = "ZdIrreducibleQ[d, x], for negative d, returns True if x is irreducible in \[DoubleStruckCapitalZ][\!\(\@d\)], and False otherwise.";

• ZdNorm::usage = "ZdNorm[x] returns the norm of x as an element in \[DoubleStruckCapitalZ][\!\(\@d\)] for some d, which is the value |a^2 - d b^2| when x = a + b \!\(\@d\).";

• ZdPossibleNormQ::usage = "ZdPossibleNormQ[d, nrm], for negative d only, returns True if the value nrm can occur (i.e., it is possible) in \[DoubleStruckCapitalZ][\!\(\@d\)], and False otherwise.";

• ZdPossibleNorms::usage = "ZdPossibleNorms[d, max], for negative d only, returns all the norms that can occur in \[DoubleStruckCapitalZ][\!\(\@d\)] that are less than or equal to max. This function has a Visual mode available.";

• ZdQ::usage = "ZdQ[x] returns True if x can be viewed as an element in \[DoubleStruckCapitalZ][\!\(\@d\)] for some d, and False otherwise.";

• ZdUnitQ::usage = "ZdUnitQ[d, x] returns True if x is a unit in \[DoubleStruckCapitalZ][\!\(\@d\)], and False otherwise.";

• Zero::usage = "Zero[R] returns the zero of R, if one exists in R, and $Failed otherwise.";

• ZeroDivisorQ::usage = "ZeroDivisorQ[R, r] returns True if r is a zero divisor of the structure R, and False otherwise. Since this calls ZeroDivisors (which generates a complete list of zero divisors), a noticeable delay may be noticed upon the first call for large Ringoids.";

• ZeroDivisors::usage = "ZeroDivisors[R] returns a list of all the zero divisors in the structure R. If R does not have a zero (HasZeroQ[R] == False), a message is returned. This calculation is based on the definition that if nonzero r and nonzero s have the product Zero[R], then r and s are both zero divisors.";

• Zeros::usage = "Zeros[PolynomialsOver[R], p] returns the zeros, if any, of the polynomial p as a polynomial with coefficients from R. In other words, if z is the zero of R, this returns {x : p(x) = z}. Zeros[p] is another method of obtaining the same result.";

• Zx::usage = "Zx[n] returns the Groupoid of integers mod n under multiplication. Zx[n, k] returns the Groupoid of multiples of k mod n, if k is a divisor of n. Finally, Zx[n, I] returns the Groupoid of the Gaussian integers under mod n multiplication.";

• myDiv::usage = "Special symbol used for this lab.";

• myDivisorSigma::usage = "Special symbol used for this lab.";

• myDot::usage = "Special symbol used for this lab.";

• myMod::usage = "Special symbol used for this lab.";

• myPower::usage = "Special symbol used for this lab.";

• myZees::usage = "Special symbol used for this lab.";

• quatOp::usage = "Special symbol used for this lab.";

• trivProd::usage = "Special symbol used for this lab.";

• undef::usage = "Special symbol used for this lab.";

Here is a list of all names used in AbstractAlgebra:

A, AbelianQ, Addition, AdditiveGroupoid, AdditiveToMultiplicative, Adjoin, Adjoint, AGroupoid, Alternating, AlternatingGroup, Annihilator, AntiCommutingMatricesQ, Any, AsIJK, AsMatrices, Associates, AssociativeQ, AsSymbols, Aut, Automorphism, AutomorphismGroup, BackgroundColors, BaseRing, BooleanRing, Both, Canonical, CartesianProduct, Cautious, CayleyForm, CayleyTable, CayleyTables, Centralizer, Characteristic, ClosedDiffQ, ClosedPlusQ, ClosedQ, ClosedTimesQ, CloseSets, Closure, Codomain, CollectOrders, ColorCodomain, ColorDomain, Combine, CommutativeQ, Commutator, Commutators, CommutatorSubgroup, CommutingMatricesQ, ComplementNoSort, ComplexMatrixQ, ComplexToPoint, Computational, ConjugacyClass, CosetLists, Cosets, CosetToList, Cycle, CycleAs, Cyclic, CyclicGenerators, CyclicGroup, CyclicQ, CyclicSubgroups, DefaultOrder, DefaultStructure, DetAdjoint, Diag, DiagonalMatrices, DiagQ, Dihedral, DihedralGroup, DirectProduct, DirectSum, DisguiseGroupoid, DisguiseRingoid, DisjointCyclesQ, DistributiveQ, DividesQ, DivisorsComplete, Domain, DrawNgon, EisensteinsCriterionQ, ElementConjugate, ElementQ, Elements, ElementsQ, ElementToCoset, ElementToKey, ElementToPower, EqualGroupoidQ, EqualMorphoidQ, ESG, EvaluationInExtension, EvenPermutationQ, ExtendPermutation, ExtensionDegree, ExtensionType, FactorGroup, FactorRing, Fiber, FieldIrreducible, FieldQ, FirstTaker, FixQ, FlexibleEntering, Form, FormatElements, FormatFunction, FormatOperator, FormGroupoid, FormGroupoidByTable, FormGroupoidFromCycles, FormMorphoid, FormMorphoidSetup, FormRingoid, FormRingoidByTable, FromCycles, Func, FuncRing, FunctionForm, FunctionsOver, FuncToRules, GaloisFieldQ, GaussianIntegerQ, GaussianIntegersAdditive, GaussianIntegersMultiplicative, GaussianUnits, GeneralLinear, GeneralLinearGroup, GenerateGroupoid, GeneratingSet, Generator, Generators, GF, GL, GLQ, Group, GroupCenter, GroupExponent, GroupIdentity, GroupInfo, GroupInverse, Groupoid, GroupoidDescription, GroupoidName, GroupQ, Groups, HasIdentityQ, HasInversesQ, HasLeftIdentityQ, HasNegativeQ, HasRightIdentityQ, HasUnityQ, HasZeroQ, HeadingsColored, HermitianQ, HomomorphismQ, IdealQ, IdempotentQ, Idempotents, IgnoreIndeterminate, Image, Index, IndexLimit, InducedCanonical, InducedIsomorphism, InjectiveQ, Inn, InnerAutomorphism, InnerAutomorphismGroup, IntegerDivisors, IntegerLatticeGrid, IntegerMatrixQ, IntegerUnits, IntegralDomainQ, InverseImage, InverseImages, Inverses, InvertibleQ, IrreduciblePolynomial, IrreduciblePolyOverZpQ, IsAGroup, IsARing, IsomorphismQ, J, JoinDivisors, Kernel, KeyForm, KeyToElement, Klein4, KSubsets, LatticeRing, LeftCoset, LeftCosets, LeftDistributiveQ, LeftIdealQ, LeftIdentity, LeftInverse, LeftInvertibleQ, LeftToRight, LG, ListOperationPreservingElements, LowerDegreeOK, LT, LTD, Mat, MatA, MatM, Matrices, MatricesOver, MatrixConjugate, MatrixDelete, MatrixOperation, MatrixOverQ, MatrixTrace, MatrixType, MaxElementsToList, MaximalIdealQ, MaxTaker, MeetDivisors, MGroupoid, MinTaker, MixedDivisors, ModpIrreducibilityQ, ModulusPolynomial, Monic, MonoidQ, Monomial, MorphismQ, Morphoid, MorphoidComposition, MorphoidFunction, MorphoidRules, MultipleOfElement, Multiplication, MultiplicationTable, MultiplicativeGroupoid, MultiplicativeInverse, MultiplicativeToAdditive, MultiplyCycles, MultiplyPermutations, NegationOf, Negations, NextStage, NilpotentDegree, NilpotentQ, Nilpotents, NonAssociatingTriples, NonCommutingPairs, NonIdentity, NonTrivialOnly, NonUnity, NonZero, NonZeroMGroupoid, Normalize, Normalizer, NormalQ, NS, OddPermutationQ, OneToOneQ, OntoQ, Operation, OperatorSymbol, Orbit, Ordering, OrderOfAllElements, OrderOfElement, Orders, OrthogonalQ, Output, Parity, PermutationComposition, PermutationGroup, PermutationImage, PermutationInverse, PermutationMatrix, PermutationQ, PermutationToPower, PermuteColoredSquares, PlusSymbol, Poly, PolynomialEvaluation, PolynomialsOfDegreeN, PolynomialsOver, PolynomialsUpToDegreeN, PolyQ, PolyRing, PolyToFunction, PowerList, PowersIncrease, PreservesQ, PreviousStage, PrimeIdealQ, PrimitivePolynomials, PrincipalIdeal, PrintMessage, ProbableGroupQ, ProbableMorphismQ, ProbableRingQ, ProductOrder, Products, ProperSubsetQ, QuaternionGroup, QuotientGroup, QuotientRing, Radical, RandomAssociativeQ, RandomColoredSquares, RandomDistributiveQ, RandomElement, RandomElements, RandomGroupoid, Randomize, RandomMatrix, RandomPermutation, RationalMatrixQ, RationalRootCandidates, RationalRootTheorem, RealMatrixQ, Ref, RefSym, ReorderGroupoid, Replacement, ReportIterations, Representatives, RightCoset, RightCosets, RightDistributiveQ, RightIdealQ, RightIdentity, RightInverse, RightInvertibleQ, RightToLeft, Ring, RingExtension, RingInfo, Ringoid, RingoidDescription, RingoidName, RingQ, Rings, RingSolve, RootsOfUnity, Rot, RotRef, RotSym, Rules, S, SamePermutationQ, SameSetQ, SamplePairs, SampleSize, SelectBaseElementsFrom, SelectFrom, SemiGroupQ, Sgn, ShowBodyText, ShowCircle, ShowColoredPermutation, ShowFigure, ShowGroupOrders, ShowKey, ShowName, ShowOne, ShowOperator, ShowPermutation, ShowSidesText, SideBySideMatrices, Size, SizeLimit, SizeOfMatrices, SkewHermitianQ, SkewSymmetricQ, SL, SLQ, SortGroupoid, SpecialLinear, SpecialLinearGroup, Stabilizer, Staged, Structure, SubgroupClosure, SubgroupConjugate, SubgroupGenerated, SubgroupIntersection, SubgroupJoin, Subgroupoid, SubgroupProduct, SubgroupQ, Subgroups, SubgroupUnion, SubringQ, SubsetQ, SurjectiveQ, SwitchStructureTo, Symmetric, SymmetricGroup, SymmetricQ, TableOfPowers, TestFunction, TextCayley, Textual, TheSet, TimesSymbol, ToCycles, ToFunction, ToGroupoid, ToOrdinaryPolynomial, ToPermutation, ToRingoid, ToTranspositions, Trivial, TrivialZR, TwistedZ, U, UnionNoSort, UnitaryQ, UnitQ, Units, Unity, UT, UTD, ValuesHavingGivenNorm, VarToUse, Visual, Visual2, VisualizeMorphoid, VisualTextShown, WideElements, WithImages, WithUnityQ, Z, ZdAssociatesQ, ZdCombineAssociates, ZdConjugate, ZdDivide, ZdDividesQ, ZdDivisors, ZdIrreducibleQ, ZdNorm, ZdPossibleNormQ, ZdPossibleNorms, ZdQ, ZdUnitQ, Zero, ZeroDivisorQ, ZeroDivisors, Zeros, ZG, ZMap, ZR, Zx,

Back up to the top.

Back to the EAAM homepage.