Difference between revisions of "Category:ApCoCoA-1:Package gbmr"

From ApCoCoAWiki
Line 6: Line 6:
 
Things to know about this package.
 
Things to know about this package.
  
(a) K is field of rational number by default. It can be set to a finite field through the functions
+
(a) Predefined alias for this package is
 +
 
 +
Alias NC := $apcocoa/gbmr;
 +
 
 +
(b) K is field of rational number by default. It can be set to a finite field through the functions
  
 
             NC.SetFp(); and NC.SetFp(P);
 
             NC.SetFp(); and NC.SetFp(P);
Line 15: Line 19:
  
  
(b) X (or Alphabet) is presented as a STRING of letters. Every letter in X should occurrence only once. And the order of letters in X is important since it induces an admissible ordering indicated later. X can be set through the function
+
(c) X (or Alphabet) is presented as a STRING of letters. Every letter in X should occurrence only once. And the order of letters in X is important since it induces an admissible ordering indicated later. X can be set through the function
  
 
             NC.SetX(X)
 
             NC.SetX(X)
Line 26: Line 30:
  
  
(c) Ordering is a STRING indicating which ordering we are working with. In the package we use admissible orderings. Currently, the package only supports length-lexicographic ordering ("LLEX") and elimination ordering ("ELIM") induced from the order of letters in X.  
+
(d) Ordering is a STRING indicating which ordering we are working with. In the package we use admissible orderings. Currently, the package only supports length-lexicographic ordering ("LLEX") and elimination ordering ("ELIM") induced from the order of letters in X.  
  
 
For example, X:="abc"; Ordering:="ELIM"; means elimination ordering induced from a>b>c.  
 
For example, X:="abc"; Ordering:="ELIM"; means elimination ordering induced from a>b>c.  
Line 39: Line 43:
  
  
(d) Relations, which is a finite generating set, is presented as a LIST of relations. Each relation of Relations is presented as a LIST (pair) composted of two words over X*.  
+
(e) Relations, which is a finite generating set, is presented as a LIST of relations. Each relation of Relations is presented as a LIST (pair) composted of two words over X*.  
  
 
      (d0) Each word over X* is presented as a STRING with all letters coming from X.   
 
      (d0) Each word over X* is presented as a STRING with all letters coming from X.   
Line 60: Line 64:
  
  
(e) Rules, which is also a finite generating set, is presented as a LIST of (rewriting) rules. Each rule of Rules is presented as a LIST (pair) consisted of one word over X* and one polynomial over  K<X|R>.
+
(f) Rules, which is also a finite generating set, is presented as a LIST of (rewriting) rules. Each rule of Rules is presented as a LIST (pair) consisted of one word over X* and one polynomial over  K<X|R>.
  
 
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;(e0) Each polynomial over K<X|R> is presented as a LIST of monomials. Each monomial of polynomial is presented as a LIST (pair) consist of one coefficient over K and one word (term) over X*.  
 
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;(e0) Each polynomial over K<X|R> is presented as a LIST of monomials. Each monomial of polynomial is presented as a LIST (pair) consist of one coefficient over K and one word (term) over X*.  
Line 79: Line 83:
  
  
(f) There is a function to get general information about ring.
+
(g) There is a function to get general information about ring.
  
 
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; NC.RingEnv();
 
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; NC.RingEnv();

Revision as of 07:29, 14 July 2010

Package gbmr is designed to enable us to do basic operations (addition, subtraction, multiplication, normal remainder, leading term, etc.) over Non-Commutative algebra, i.e. finitely presented monoid rings, compute (partial) Groebner bases of finitely generated (one-sided/two-sided) ideals, and experiment on applications of Groebner bases.

Generally, a finitely presented monoid ring is defined by P=K<X|R>=K<X>/<R>, where K is a field, X is an alphabet or a finite set of letters, and R is a finite set of relations. If R is empty, then P becomes a free associative K-algebra.


Things to know about this package.

(a) Predefined alias for this package is

Alias NC := $apcocoa/gbmr;

(b) K is field of rational number by default. It can be set to a finite field through the functions

             NC.SetFp(); and NC.SetFp(P);

where P should be a prime number, the prevouse one sets finite field to F(2) and the later to F(P). And K can be reset to field of rational number through the function

             NC.UnsetFp();


(c) X (or Alphabet) is presented as a STRING of letters. Every letter in X should occurrence only once. And the order of letters in X is important since it induces an admissible ordering indicated later. X can be set through the function

             NC.SetX(X)

where X is a STRING of letters. And X can be reset to empty through the function

             NC.UnsetX();

however, for the time being, I fail to find a proper situation to use it.


(d) Ordering is a STRING indicating which ordering we are working with. In the package we use admissible orderings. Currently, the package only supports length-lexicographic ordering ("LLEX") and elimination ordering ("ELIM") induced from the order of letters in X.

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

Since for most situations ordering is very important, the default Ordering "LLEX" is set. Ordering can be set through the function

             NC.SetOrdering(Ordering);

where Ordering is the ordering supported by the package. And Ordering can be reset to "LLEX" through the function

             NC.UnsetOrdering();


(e) Relations, which is a finite generating set, is presented as a LIST of relations. Each relation of Relations is presented as a LIST (pair) composted of two words over X*.

      (d0) Each word over X* is presented as a STRING with all letters coming from X.

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

      Note that unit in X* is empty word "".

For example, X := "abc"; Relations := [["ba","ab"], ["ca","ac"], ["cb","bc"]]; means Relations generated by {ba=ab, ca=ac, cb=bc}.

Relations can be set through the function

             NC.SetRelations(Relations);

where Relations is a properly presented Relations. And Relations can be reset to empty through the function

             NC.UnsetRelations();

which might be very useful for forcing a ring to be a free associated K algebra.


(f) Rules, which is also a finite generating set, is presented as a LIST of (rewriting) rules. Each rule of Rules is presented as a LIST (pair) consisted of one word over X* and one polynomial over K<X|R>.

      (e0) Each polynomial over K<X|R> is presented as a LIST of monomials. Each monomial of polynomial is presented as a LIST (pair) consist of one coefficient over K and one word (term) over X*.

      For example, X := "abc"; P := [[1,"ab"], [1,""]]; means P=ab+1.

      Note that 0 polynomial is an empty LIST [].

For example, X := "ab"; Rules := [["ba", [[1,"ab"], [1,""]]]]; means Rules generated by {ba=ab+1}.

Rules can be set through the function

             NC.SetRules(Rules);

where Rules is a properly presented Rules. And Rules can be reset to empty through the function

             NC.UnsetRules();


(g) There is a function to get general information about ring.

             NC.RingEnv();


Please note: The function(s) explained on this page is/are using the ApCoCoAServer. You will have to start the ApCoCoAServer in order to use it/them.