Category:ApCoCoA-1:Package ncpoly

Package ncpoly is designed to enable us to do basic computations in non-commutative polynomial rings (or free associative algebras), over the field of rational numbers Q or over finite field Z/(p) where p is a prime. For instance, in the package, there are functions for addition of two (non-commutative) polynomials (via Add(F1,F2)), subtraction (via Sub(F1,F2)), multiplication (via Mul(F1,F2)), getting the leading word (via Lw(F)) and leading coefficient (via Lc(F)) of a non-zero polynomial, computing the normal remainder (via NR(F,G)) of a polynomial w.r.t a LIST of polynomials, interreducing (via Interreduction(G)) a LIST of polynomials, etc. Moreover, we can, check if a LIST of polynomials is a Groebner basis (via IsGB(G)), enumerate (reduced) (partial) Groebner bases (via GB(G[,Optimize,OFlag,DB,LB]) and RedGB(G[,Optimize,OFlag,DB,LB])), and compute truncated Groebner bases (via TruncatedGB(G[,Optimize,OFlag,DB])) of finitely generated (two-sided) ideals. Consequently, we can apply the package to many algebraic applications, for instance, to compute Macaulay basis (via MB(Gb)) and the values of Hilbert function (via HF(Gb)), compute generating systems for leading term ideals, kernel of K-algebra homomorphism, intersection of ideals, etc.

Generally speaking, a finitely presented monoid ring is defined by P=K<X|R>=K<X>/<R>, where K is a field, X is a finite alphabet (a finite set of indeterminates), and R is a finite set of relations. Particularly, P becomes a free associative K-algebra if R is empty.

Things to know about this package.

(a) Predefined alias for this package is as follows.

             Alias NC := $apcocoa/gbmr;

(b) By default, the field K is rational numbers. It can be set to a finite field Fp through the functions

             NC.SetFp(); and NC.SetFp(Prime);

where Prime is a prime number. The former sets finite field to F2=Z/(2), and the latter to F_{Prime}=Z/(Prime). One can reset K to rational number via the function

             NC.UnsetFp();

(c) The alphabet X is represented as a STRING of letters. Every letter in X must have a unique occurrence. The order of letters in X is important since it induces an admissible ordering specified by Ordering. X is set through the function

             NC.SetX(X);

where X is a STRING of letters.

      (c.1) Each word (term) in the free monoid <X> is represented as a STRING with all letters coming from X.

      For example, X:="abc"; W:="ba"; means a word W=ba.

      Note that the identity element in <X> is the empty word which is represented as the empty STRING "".

      (c.2) Each polynomial in K<X> (or K<X|R>) is represented as a LIST of monomials, and each monomial is represented as a LIST consisting of an element (coefficient) in K and a word (term) in <X>.

      For example, X := "abc"; P := [[1,"ab"],[1,"bb"],[1,""]]; means a polynomial P=ab+b^2+1.

      Note that the zero polynomial 0 is represented as the empty LIST [].

      (c.3) In the case that K=F2, every polynomial can be represented as a LIST of words (terms) in <X>. For example, the polynomial P=ab+b^2+1 in F2<a,b> is represented as P := ["ab","bb",""]. We refer to the examples of functions in free monoid rings over F2 (functions with the prefix "G") for more details.

(d) An admissible ordering Ordering is a STRING indicating which ordering we are working with. Currently, the package only supports length-lexicographic ordering ("LLEX"), elimination ordering ("ELIM") and length-reverse-lexicographic ordering ("LRLEX"), which are induced from the order of letters in X. We refer to the function NC.SetOrdering for the definitions of these orderings. Note that the default ordering is "LLEX".

For example, X:="abc"; Ordering:="ELIM"; means the elimination ordering induced by a>b>c.

Ordering is set through the function

             NC.SetOrdering(Ordering);

where Ordering is one of the orderings supported by the package. One can reset Ordering to "LLEX" via the function

             NC.UnsetOrdering();

(e) A set Relations of relations is a finite set represented as a LIST. Each relation in Relations is represented as a LIST composed of two words in <X>.

For example, X := "abc"; Relations := [["ba","ab"], ["ca","ac"], ["cb","bc"]]; means Relations containing relations ba=ab, ca=ac and cb=bc.

Relations is set through the function

             NC.SetRelations(Relations);

where Relations is a set of properly represented relations. One can set Relations to empty via the function

             NC.UnsetRelations();

Note that using the functions UnsetRelations() is a tricky way to change a monoid ring to a free monoid ring.

(f) A set Rules of rewriting rules is a finite set represented as a LIST. Each rewriting rule in Rules is represented as a LIST composed of a word in <X> and a polynomial in K<X> (or K<X|R>).

For example, X := "ab"; Rules := [["ba", [[1,"ab"], [1,""]]]]; means Rules containing rewriting rule ba=ab+1.

Rules is set through the function

             NC.SetRules(Rules);

where Rules is a set of properly represented rules. One can set Rules to empty via the function

             NC.UnsetRules();

(g) There is a function for showing general information on ring environment.

             NC.RingEnv();