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

From ApCoCoAWiki
Line 1: Line 1:
 
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.
 
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.
+
Generally, a finitely presented monoid ring is defined by <tt>P=K<X|R>=K<X>/<R></tt>, where <tt>K</tt> is a field, <tt>X</tt> is an alphabet or a finite set of letters, and <tt>R</tt> is a finite set of relations. If <tt>R</tt> is empty, then <tt>P</tt> becomes a free associative <tt>K</tt>-algebra.
  
  
Line 11: Line 11:
  
  
(b) K is field of rational number by default. It can be set to a finite field through the functions
+
(b) <tt>K</tt> is field of rational number by default. It can be set to a finite field through the functions
  
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; NC.SetFp(); and NC.SetFp(P);
+
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; NC.SetFp(); and NC.SetFp(Prime);
  
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
+
where <tt>Prime</tt> should be a prime number, the prevouse one sets finite field to <tt>F(2)</tt> and the later to <tt>F(Prime)</tt>. And <tt>K</tt> can be reset to field of rational number through the function
  
 
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; NC.UnsetFp();
 
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 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
+
(c) <tt>X</tt> (or Alphabet) is represented as a STRING of letters. Every letter in <tt>X</tt> should occurrence only once. And the order of letters in <tt>X</tt> is important since it induces an admissible ordering indicated later. <tt>X</tt> can be set through the function
  
 
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; NC.SetX(X)
 
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; NC.SetX(X)
  
where X is a STRING of letters. And X can be reset to empty through the function
+
where <tt>X</tt> is a STRING of letters. And <tt>X</tt> can be reset to empty through the function
  
 
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; NC.UnsetX();
 
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; NC.UnsetX();
Line 31: Line 31:
  
  
(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.  
+
(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 <tt>X</tt>.  
  
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 <tt>a>b>c</tt>.  
  
 
Since for most situations ordering is very important, the default Ordering "LLEX" is set. Ordering can be set through the function
 
Since for most situations ordering is very important, the default Ordering "LLEX" is set. Ordering can be set through the function
Line 44: Line 44:
  
  
(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*.  
+
(e) Relations, which is a finite generating set, is represented as a LIST of relations. Each relation of Relations is represented as a LIST (pair) composting of two words over <tt>X*</tt>.  
  
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;(d0) Each word over X* is presented as a STRING with all letters coming from X.   
+
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;(d0) Each word over <tt>X*</tt> is represented as a STRING with all letters coming from <tt>X</tt>.   
  
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;For example, X := "abc"; W := "ba"; means w=ba.  
+
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;For example, X := "abc"; W := "ba"; means <tt>w=ba</tt>.  
  
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Note that unit in X* is empty word "".
+
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Note that unit in <tt>X*</tt> is empty word represented as an empty STRING "".
  
For example, X := "abc"; Relations := [["ba","ab"], ["ca","ac"], ["cb","bc"]]; means Relations generated by {ba=ab, ca=ac, cb=bc}.  
+
For example, X := "abc"; Relations := [["ba","ab"], ["ca","ac"], ["cb","bc"]]; means Relations generated by <tt>{ba=ab, ca=ac, cb=bc}</tt>.  
  
 
Relations can be set through the function
 
Relations can be set through the function
Line 62: Line 62:
 
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; NC.UnsetRelations();
 
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; NC.UnsetRelations();
  
which might be very useful for forcing a ring to be a free associated K algebra.
+
which might be very useful for forcing a ring to be a free associative <tt>K</tt>-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>.
+
(f) Rules, which is also a finite generating set, is represented as a LIST of (rewriting) rules. Each rule of Rules is represented as a LIST (pair) consisting of one word over <tt>X*</tt> and one polynomial over  <tt>K<X|R></tt>.
  
&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 <tt>K<X|R></tt> is represented as a LIST of monomials. Each monomial of polynomial is represented as a LIST (pair) consisting of one coefficient over <tt>K</tt> and one word (term) over <tt>X*</tt>.  
  
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;For example, X := "abc"; P := [[1,"ab"], [1,""]]; means P=ab+1.  
+
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;For example, X := "abc"; P := [[1,"ab"], [1,""]]; means <tt>P=ab+1</tt>.  
  
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Note that 0 polynomial is an empty LIST [].
+
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Note that 0 polynomial is represented as an empty LIST [].
  
For example, X := "ab"; Rules := [["ba",  [[1,"ab"], [1,""]]]]; means Rules generated by {ba=ab+1}.  
+
For example, X := "ab"; Rules := [["ba",  [[1,"ab"], [1,""]]]]; means Rules generated by <tt>{ba=ab+1}</tt>.  
  
 
Rules can be set through the function
 
Rules can be set through the function

Revision as of 09:06, 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(Prime);

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

             NC.UnsetFp();


(c) X (or Alphabet) is represented 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 represented as a LIST of relations. Each relation of Relations is represented as a LIST (pair) composting of two words over X*.

      (d0) Each word over X* is represented 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 represented as an empty STRING "".

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 associative K-algebra.


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

      (e0) Each polynomial over K<X|R> is represented as a LIST of monomials. Each monomial of polynomial is represented as a LIST (pair) consisting 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 represented as 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.