  
  [1m[4m[31m1. The [1mGAP[1m[4m[31m interface to [1mSingular[1m[4m[31m[0m
  
  This  is  the  manual  of  the  [1mGAP[0m  package  ``[1msingular[0m''  that provides an
  interface  to  the  [1mSingular[0m computer algebra system. One of the main things
  provided  by  this  interface  is a function for computing Groebner bases of
  ideals  in polynomial rings. This function uses the [1mSingular[0m implementation,
  which is very fast.
  
  This  manual  is  yet  incomplete,  and  the  next  version will be released
  shortly.
  
  
  [1m[4m[31m1.1 Background[0m
  
  The interface to [1mSingular[0m relies on the Gap function [22m[34mInputOutputLocalProcess[0m
  (see  the  [1mGAP[0m  manual),  and this function is available only in Gap 4.2 (or
  newer)  for  an  Unix  environment or in Gap 4.4 (or newer) for Windows with
  Cygwin;   auto-detection  is  used.  In  the  case  that  the  Gap  function
  [22m[34mInputOutputLocalProcess[0m  is  not available, then the singular interface will
  use  the Gap function [22m[34mProcess[0m; however in this case only a limited subset of
  the  functionalities  of  the  interface  will  be  available:  for  example
  [22m[34mStartSingular[0m  and [1m[34mGeneratorsOfInvariantRing[0m ([1m1.3-11[0m) are not available, but
  [1m[34mGroebnerBasis[0m ([1m1.3-5[0m) is.
  
  
  [1m[4m[31m1.2 How things are started[0m
  
  In  order  to use this interface one must have [1mGAP[0m4, and [1mSingular[0m installed.
  [1mSingular[0m can be obtained for free from [34mhttp://www.singular.uni-kl.de[0m.
  
  Then  in  order  to  use  the  interface,  [1mGAP[0m  has to be told where to find
  [1mSingular[0m.  This can be done in three ways. First, if the [1mSingular[0m executable
  file is in the search path, then [1mGAP[0m will find it. Second, it is possible to
  edit  one of the first lines of the file [22m[34msingular/gap/singular.g[0m (that comes
  with  this  package). Third, it is possible to give the path of the [1mSingular[0m
  executable  file  during  the  [1mGAP[0m  session  assigning  it  to  the variable
  [22m[34msing\_exec[0m (after this package has been loaded). For example:
  
  [22m[35m---------------------------  Example  ----------------------------[0m
    [22m[35mgap> LoadPackage("singular");[0m
    [22m[35mThe GAP interface to Singular[0m
    [22m[35mtrue[0m
    [22m[35mgap> sing_exec:= "/home/wdg/Singular/2-0-3/ix86-Linux/Singular";;[0m
  [22m[35m------------------------------------------------------------------[0m
  
  After  the  interface  has  been loaded, [1mSingular[0m is started when one of the
  functions  of the interface is called. Alternatively, one can start [1mSingular[0m
  with the command
  
  [22m[35m---------------------------  Example  ----------------------------[0m
    [22m[35mStartSingular();[0m
  [22m[35m------------------------------------------------------------------[0m
  
  If  at  some  point [1mSingular[0m is no longer needed, then it can be closed with
  the command
  
  [22m[35m---------------------------  Example  ----------------------------[0m
    [22m[35mCloseSingular();[0m
  [22m[35m------------------------------------------------------------------[0m
  
  [1m[4m[31m1.2-1 InfoSingular[0m
  
  [1m[34m> InfoSingular____________________________________________________[0minfo class
  
  This  is the info class used by the interface. It can be set to levels 0, 1,
  2,  3.  At  level  0  no  information  is  printed on the screen. At level 1
  (default)  the  interface prints a message when it starts [1mSingular[0m. At level
  2,  information on the activities of the interface are printed (e.g., when a
  Groebner  basis  calculation  is  started,  or  terminated).  At level 3 all
  strings  that [1mGAP[0m sends to [1mSingular[0m are printed, as well as all strings that
  [1mSingular[0m sends back.
  
  [22m[35m---------------------------  Example  ----------------------------[0m
    [22m[35mgap> SetInfoLevel( InfoSingular, 2 );[0m
    [22m[35mgap> G:= SymmetricGroup( 3 );;[0m
    [22m[35mgap> R:= PolynomialRing( GF(2), 3 );;[0m
    [22m[35mgap> GeneratorsOfInvariantRing( R, G );[0m
    [22m[35m#I  using temporary Directory("/tmp/tmp.9Aqqkx/")[0m
    [22m[35m#I  Started Singular (version 2003)[0m
    [22m[35m[ x_1+x_2+x_3, x_1*x_2+x_1*x_3+x_2*x_3, x_1*x_2*x_3 ][0m
    [22m[35mgap> I:= Ideal( R, last );;[0m
    [22m[35mgap> GroebnerBasis( I );[0m
    [22m[35m#I  running GroebnerBasis...[0m
    [22m[35m#I  done GroebnerBasis.[0m
    [22m[35m[ x_1+x_2+x_3, x_2^2+x_2*x_3+x_3^2, x_3^3 ][0m
  [22m[35m------------------------------------------------------------------[0m
  
  
  [1m[4m[31m1.3 The functions of the package[0m
  
  [1m[4m[31m1.3-1 TermOrdering[0m
  
  [1m[34m> TermOrdering( [0m[22m[34mR[0m[1m[34m ) _______________________________________________[0mattribute
  
  All  non-trivial  algorithms  in  [1mSingular[0m require the prior definition of a
  (polynomial)  ring, and any polynomial (resp. vector) in [1mSingular[0m is ordered
  w.r.t.  a  term  ordering (or, monomial ordering), which has to be specified
  together  with the declaration of a ring; see the documentation of [1mSingular[0m,
  paragraph ``3.3 Rings and orderings''.
  
  Let [22m[34mR[0m be a polynomial ring. The value of [22m[34mTermOrdering ( R )[0m can be a string,
  a  list,  or a monomial ordering of Gap. If it is a string, for instance one
  of  [22m[34m"lp"[0m  (lexicographical  ordering),  [22m[34m"dp"[0m (degree reverse lexicographical
  ordering),  or  [22m[34m"Dp"[0m  (degree lexicographical ordering), this string will be
  passed  to  [1mSingular[0m without being interpreted. It can also be a list of two
  elements, namely a string, and a list of positive integers. In that case the
  string  has  to  be [22m[34m"wp"[0m (weighted reverse lexicographical ordering) or [22m[34m"Wp"[0m
  (weighted  lexicographical ordering); the second element is a list of length
  equal to the number of variables of the ring [22m[34mR[0m, that specifies the degree of
  each variable.
  
  [22m[34mSetTermOrdering[0m  can  be  used  to set the term ordering of a ring. The term
  ordering   must   be   set   before  the  ring  is  sent  to  [1mSingular[0m,  see
  [1m[34mSingularSetBaseRing[0m  ([1m1.3-2[0m).  If  no term ordering is set, then the default
  [22m[34m"dp"[0m will be used.
  
  [22m[35m---------------------------  Example  ----------------------------[0m
    [22m[35mgap> R:= PolynomialRing( Rationals, ["x","y","z"] );;[0m
    [22m[35mgap> SetTermOrdering( R, [ "wp", [1,1,2] ] );[0m
  [22m[35m------------------------------------------------------------------[0m
  
  [1m[4m[31m1.3-2 SingularSetBaseRing[0m
  
  [1m[34m> SingularSetBaseRing( [0m[22m[34mR[0m[1m[34m ) _________________________________________[0mfunction
  
  Here  [22m[34mR[0m  is  a polynomial ring. This function sets the base ring in [1mSingular[0m
  equal  to  [22m[34mR[0m. After this, all functions of the interface will work with this
  ring.  However, for some functions it is not necessary to explicitly set the
  base   ring  first.  This  will  be  specified  for  each  function  in  the
  corresponing section of this manual.
  
  [22m[35m---------------------------  Example  ----------------------------[0m
    [22m[35mgap> R:= PolynomialRing( Rationals, ["x","y","z"] );;[0m
    [22m[35mgap> SingularSetBaseRing( R );[0m
  [22m[35m------------------------------------------------------------------[0m
  
  [1m[4m[31m1.3-3 SingularLibrary[0m
  
  [1m[34m> SingularLibrary( [0m[22m[34mstring[0m[1m[34m ) ________________________________________[0mfunction
  
  Here  [22m[34mstring[0m  is  a  string  containing the name of a [1mSingular[0m library. This
  function  makes  sure  that  this  library is loaded into [1mSingular[0m. For some
  functionality   of   [1mSingular[0m   this   is  necessary,  see  the  example  in
  [1m[34mSingularInterface[0m ([1m1.3-12[0m).
  
  [22m[35m---------------------------  Example  ----------------------------[0m
    [22m[35mgap> SingularLibrary( "general.lib");[0m
  [22m[35m------------------------------------------------------------------[0m
  
  [1m[4m[31m1.3-4 SingularHelp[0m
  
  [1m[34m> SingularHelp( [0m[22m[34mtopic[0m[1m[34m ) ____________________________________________[0mfunction
  
  Here  [22m[34mtopic[0m  is  a  string  containing  the  name  of a [1mSingular[0m topic. This
  function  provides an help on that topic using the [1mSingular[0m help system; see
  the  [1mSingular[0m documentation, paragraphs ``3.1.3 The online help system'' and
  ``5.1.43  help''.  If  [22m[34mtopic[0m is the empty string, then the title page of the
  manual is displayed.
  
  [22m[35m---------------------------  Example  ----------------------------[0m
    [22m[35mgap> SingularHelp("");[0m
    [22m[35m#I  // ** Displaying help in browser 'mozilla'.[0m
    [22m[35m// ** Use 'system("--browser", <browser>);' to change browser,[0m
    [22m[35m// ** where <browser> can be: "mozilla", "xinfo", "info", "builtin", "dummy", \[0m
    [22m[35m"emacs".[0m
  [22m[35m------------------------------------------------------------------[0m
  
  The   [1mSingular[0m   function   [22m[34msystem[0m   can   be  accessed  with  the  function
  [1m[34mSingularInterface[0m ([1m1.3-12[0m).
  
  [1m[4m[31m1.3-5 GroebnerBasis[0m
  
  [1m[34m> GroebnerBasis( [0m[22m[34mI[0m[1m[34m ) ______________________________________________[0moperation
  
  Here  [22m[34mI[0m  is an ideal of a polynomial ring. This function computes a Groebner
  basis  of [22m[34mI[0m. For this function it is [22m[36mnot[0m necessary to set the base ring with
  [1m[34mSingularSetBaseRing[0m ([1m1.3-2[0m).
  
  As term ordering [1mSingular[0m will use the value of [1m[34mTermOrdering[0m ([1m1.3-1[0m) (of the
  corresponding  ring).  Again,  if  this  value  is  not set, then the degree
  reverse lexicographical ordering will be used ([22m[34m"dp"[0m).
  
  [22m[35m---------------------------  Example  ----------------------------[0m
    [22m[35mgap> R:= PolynomialRing( Rationals, ["x","y","z"] );;[0m
    [22m[35mgap> i:= IndeterminatesOfPolynomialRing(R);;[0m
    [22m[35mgap> x:= i[1]; y:= i[2]; z:= i[3];[0m
    [22m[35mx[0m
    [22m[35my[0m
    [22m[35mz[0m
    [22m[35mgap> r:= [ x*y*z -x^2*z, x^2*y*z-x*y^2*z-x*y*z^2, x*y-x*z-y*z];;[0m
    [22m[35mgap> I:= Ideal( R, r );[0m
    [22m[35m<two-sided ideal in PolynomialRing(..., [ x, y, z ]), (3 generators)>[0m
    [22m[35mgap> GroebnerBasis( I );[0m
    [22m[35m[ x*y-x*z-y*z, x^2*z-x*z^2-y*z^2, x*z^3+y*z^3, -x*z^3+y^2*z^2-y*z^3 ][0m
  [22m[35m------------------------------------------------------------------[0m
  
  [1m[4m[31m1.3-6 SINGULARGBASIS[0m
  
  [1m[34m> SINGULARGBASIS_____________________________________________[0mglobal variable
  
  This is a record containing the component [22m[34mGroebnerBasis[0m. When this record is
  assigned  to  the  global  record [22m[34mGBASIS[0m, then the computation of a Groebner
  basis  via  [1mGAP[0m's  internal  function  for  that ([22m[34mGroebnerBasis[0m, see the [1mGAP[0m
  manual) are done by [1mSingular[0m.
  
  [1mSingular[0m  claims  that  it  ``features  one  of the fastest and most general
  implementations  of  various  algorithms for computing Groebner bases''. The
  [1mGAP[0m's  internal  function  claims  to  be  ``a  na{\"\i}ve implementation of
  Buchberger's  algorithm  (which  is  mainly intended as a teaching tool): it
  might  not  be  sufficient  for  serious  problems.''  Currently,  the  term
  orderings  that  can  be  used  with  this function are [22m[34mMonomialLexOrdering[0m,
  [22m[34mMonomialGrevlexOrdering[0m, [22m[34mMonomialGrlexOrdering[0m.
  
  [22m[35m---------------------------  Example  ----------------------------[0m
    [22m[35mgap> R:= PolynomialRing( Rationals, 3 );;[0m
    [22m[35mgap> i:= IndeterminatesOfPolynomialRing( R );;[0m
    [22m[35mgap> pols:= [i[1]+i[2]+i[3], i[1]*i[2]+i[1]*i[3]+i[2]*i[3], i[1]*i[2]*i[3]];;[0m
    [22m[35mgap> o:= MonomialLexOrdering();;[0m
    [22m[35mgap> GroebnerBasis( pols, o );   # This is the internal GAP method.[0m
    [22m[35m[ x_1+x_2+x_3, x_1*x_2+x_1*x_3+x_2*x_3, x_1*x_2*x_3, -x_2^2-x_2*x_3-x_3^2,[0m
    [22m[35m  x_3^3 ][0m
    [22m[35mgap> GBASIS:= SINGULARGBASIS;;[0m
    [22m[35mgap> GroebnerBasis( pols, o ); # Now this uses Singular.[0m
    [22m[35m[ x_3^3, x_2^2+x_2*x_3+x_3^2, x_1+x_2+x_3 ][0m
  [22m[35m------------------------------------------------------------------[0m
  
  [1m[4m[31m1.3-7 HasTrivialGroebnerBasis[0m
  
  [1m[34m> HasTrivialGroebnerBasis( [0m[22m[34mI[0m[1m[34m ) _____________________________________[0mfunction
  
  This  returns  [22m[34mtrue[0m  if  the Groebner basis of the ideal [22m[34mI[0m is trivial, false
  otherwise.
  
  [22m[35m---------------------------  Example  ----------------------------[0m
    [22m[35mgap> R:= PolynomialRing( Rationals, ["x","y","z"] );;[0m
    [22m[35mgap> i:= IndeterminatesOfPolynomialRing(R);;[0m
    [22m[35mgap> x:= i[1];; y:= i[2];; z:= i[3];;[0m
    [22m[35mgap> f:= (x*y-z)*(x*y*z+y^2*z+x^2*z);;[0m
    [22m[35mgap> g:= (x*y-z)*(x*y*z^2+x*y^2*z+x^2*y*z);;[0m
    [22m[35mgap> I:= Ideal( R, [f,g] );;[0m
    [22m[35mgap> HasTrivialGroebnerBasis( I );[0m
    [22m[35mfalse[0m
  [22m[35m------------------------------------------------------------------[0m
  
  [1m[4m[31m1.3-8 GcdUsingSingular[0m
  
  [1m[34m> GcdUsingSingular( [0m[22m[34marg[0m[1m[34m ) __________________________________________[0mfunction
  
  Here  [22m[34marg[0m are (possibly multivariate) polynomials separated by commas, or it
  is  a list of polynomials. This function returns the greatest common divisor
  of  these polynomials. For this function it is [22m[36mnecessary[0m for the polynomials
  to lie in the base ring, as set by [1m[34mSingularSetBaseRing[0m ([1m1.3-2[0m).
  
  [22m[35m---------------------------  Example  ----------------------------[0m
    [22m[35mgap> R:= PolynomialRing( Rationals, ["x","y","z"] );;[0m
    [22m[35mgap> i:= IndeterminatesOfPolynomialRing(R);;[0m
    [22m[35mgap> x:= i[1];; y:= i[2];; z:= i[3];;[0m
    [22m[35mgap> f:= (x*y-z)*(x*y*z+y^2*z+x^2*z);[0m
    [22m[35mx^3*y*z+x^2*y^2*z+x*y^3*z-x^2*z^2-x*y*z^2-y^2*z^2[0m
    [22m[35mgap> g:= (x*y-z)*(x*y*z^2+x*y^2*z+x^2*y*z);[0m
    [22m[35mx^3*y^2*z+x^2*y^3*z+x^2*y^2*z^2-x^2*y*z^2-x*y^2*z^2-x*y*z^3[0m
    [22m[35mgap> SingularSetBaseRing( R );[0m
    [22m[35mgap> GcdUsingSingular( f, g );[0m
    [22m[35m-x*y*z+z^2[0m
  [22m[35m------------------------------------------------------------------[0m
  
  [1m[4m[31m1.3-9 FactorsUsingSingularNC[0m
  
  [1m[34m> FactorsUsingSingularNC( [0m[22m[34mf[0m[1m[34m ) ______________________________________[0mfunction
  
  Here   [22m[34mf[0m   is   a  (multivariate)  polynomial.  This  function  returns  the
  factorization  of  [22m[34mf[0m  into  irreducible factors. The function does not check
  that the product of these factors gives [22m[34mf[0m (for that use [1m[34mFactorsUsingSingular[0m
  ([1m1.3-10[0m)):  [1mSingular[0m  version  2-0-3  contains  a  bug  so  that the command
  [22m[34mfactorize[0m  may  give wrong results. For this function it is [22m[36mnecessary[0m that [22m[34mf[0m
  lies in the base ring, as set by [1m[34mSingularSetBaseRing[0m ([1m1.3-2[0m).
  
  [22m[35m---------------------------  Example  ----------------------------[0m
    [22m[35mgap> R:= PolynomialRing( Rationals, ["x","y","z"] );;[0m
    [22m[35mgap> i:= IndeterminatesOfPolynomialRing(R);;[0m
    [22m[35mgap> x:= i[1];; y:= i[2];; z:= i[3];;[0m
    [22m[35mgap> f:= (x*y-z)*(x*y*z+y^2*z+x^2*z);[0m
    [22m[35mx^3*y*z+x^2*y^2*z+x*y^3*z-x^2*z^2-x*y*z^2-y^2*z^2[0m
    [22m[35mgap> SingularSetBaseRing( R );[0m
    [22m[35mgap> FactorsUsingSingularNC( f );[0m
    [22m[35m[ 1, -x^2-x*y-y^2, -x*y+z, z ][0m
  [22m[35m------------------------------------------------------------------[0m
  
  [1m[4m[31m1.3-10 FactorsUsingSingular[0m
  
  [1m[34m> FactorsUsingSingular( [0m[22m[34mf[0m[1m[34m ) ________________________________________[0mfunction
  
  This does the same as [1m[34mFactorsUsingSingularNC[0m ([1m1.3-9[0m), except that on the [1mGAP[0m
  level  it  is checked that the product of these factors gives [22m[34mf[0m. Again it is
  [22m[36mnecessary[0m  that  [22m[34mf[0m  lies  in  the  base  ring, as set by [1m[34mSingularSetBaseRing[0m
  ([1m1.3-2[0m).
  
  [1m[4m[31m1.3-11 GeneratorsOfInvariantRing[0m
  
  [1m[34m> GeneratorsOfInvariantRing( [0m[22m[34mR, G[0m[1m[34m ) ________________________________[0mfunction
  
  Here  [22m[34mR[0m is a polynomial ring, and [22m[34mG[0m a finite group, which is either a matrix
  group  or  a permutation group. If it is a matrix group then its degree must
  be  less  than  or  equal  to  the number of indeterminates of [22m[34mR[0m. If it is a
  permutation  group,  then its maximal moved point must be less than or equal
  to  the  number  of  indeterminates  of  [22m[34mR[0m. This function computes a list of
  generators  of  the  invariant  ring of [22m[34mG[0m, corresponding to its action on [22m[34mR[0m.
  This action is taken to be from the left.
  
  For   this  function  it  is  [22m[36mnot[0m  necessary  to  set  the  base  ring  with
  [1m[34mSingularSetBaseRing[0m ([1m1.3-2[0m).
  
  [22m[35m---------------------------  Example  ----------------------------[0m
    [22m[35mgap> m:=[[1,1,1],[0,1,1],[0,0,1]]*One(GF(3));;[0m
    [22m[35mgap> G:= Group( [m] );;[0m
    [22m[35mgap> R:= PolynomialRing( GF(3), 3 );[0m
    [22m[35mPolynomialRing(..., [ x_1, x_2, x_3 ])[0m
    [22m[35mgap> GeneratorsOfInvariantRing( R, G );[0m
    [22m[35m[ x_3, x_1*x_3+x_2^2+x_2*x_3, x_1^3+x_1^2*x_3-x_1*x_2^2-x_1*x_2*x_3 ][0m
  [22m[35m------------------------------------------------------------------[0m
  
  [1m[4m[31m1.3-12 SingularInterface[0m
  
  [1m[34m> SingularInterface( [0m[22m[34msingcom, arguments, type\_output[0m[1m[34m ) ____________[0mfunction
  
  Here  [22m[34msingcom[0m is a [1mSingular[0m command (given as a string), [22m[34marguments[0m is a list
  of  [1mGAP[0m  objects,  and  [22m[34mtype\_output[0m  is  the type of the output in [1mSingular[0m
  (given  as  a string). The [22m[34mtype\_output[0m is one of following: "def", "ideal",
  "int",  "intmat",  "intvec",  "link",  "list",  "map",  "matrix",  "module",
  "number",  "poly", "proc", "qring", "resolution", "ring", "string", "vector"
  (or  the empty string "", if no output is expected). If in doubt you can use
  "def". This function tries to pass the [1mGAP[0m objects to [1mSingular[0m and apply the
  function [22m[34msingcom[0m to it. Finally it tries to convert the result back to [1mGAP[0m.
  
  [22m[34marguments[0m  may also be a string: in this case it is assumed that it contains
  one  or  more  [1mSingular[0m  identifiers,  and  it is passed to [1mSingular[0m without
  parsing or checking.
  
  As  this  is  a rather general function, it is not guaranteed that it always
  works.  When passing polynomials (or vectors, matrices) to [1mSingular[0m, it is a
  good  idea  to  first  set the base ring with [1m[34mSingularSetBaseRing[0m ([1m1.3-2[0m) in
  order  to ensure that [1mSingular[0m knows about it. (This is not necessary if the
  input is a ring or an ideal.)
  
  In  the  next example we compute the primary decomposition of an ideal. Note
  that for that we need to load the [1mSingular[0m library [22m[34mprimdec.lib[0m.
  
  [22m[35m---------------------------  Example  ----------------------------[0m
    [22m[35mgap> R:= PolynomialRing( Rationals, ["x","y","z"] );;[0m
    [22m[35mgap> i:= IndeterminatesOfPolynomialRing(R);;[0m
    [22m[35mgap> x:= i[1];; y:= i[2];; z:= i[3];;[0m
    [22m[35mgap> f:= (x*y-z)*(x*y*z+y^2*z+x^2*z);;[0m
    [22m[35mgap> g:= (x*y-z)*(x*y*z^2+x*y^2*z+x^2*y*z);;[0m
    [22m[35mgap> I:= Ideal( R, [f,g] );;[0m
    [22m[35mgap> SingularLibrary("primdec.lib");[0m
    [22m[35mgap> SingularInterface("primdecGTZ", [ I ], "def" );[0m
    [22m[35m#I  Singular type "list"[0m
    [22m[35m[ [ <two-sided ideal in PolynomialRing(..., [ x, y, z ]), (1 generators)>,[0m
    [22m[35m      <two-sided ideal in PolynomialRing(..., [ x, y, z ]), (1 generators)> ][0m
    [22m[35m    ,[0m
    [22m[35m  [ <two-sided ideal in PolynomialRing(..., [ x, y, z ]), (1 generators)>,[0m
    [22m[35m      <two-sided ideal in PolynomialRing(..., [ x, y, z ]), (1 generators)> ][0m
    [22m[35m    ,[0m
    [22m[35m  [ <two-sided ideal in PolynomialRing(..., [ x, y, z ]), (2 generators)>,[0m
    [22m[35m      <two-sided ideal in PolynomialRing(..., [ x, y, z ]), (2 generators)> ][0m
    [22m[35m    ,[0m
    [22m[35m  [ <two-sided ideal in PolynomialRing(..., [ x, y, z ]), (3 generators)>,[0m
    [22m[35m      <two-sided ideal in PolynomialRing(..., [ x, y, z ]), (2 generators)>[0m
    [22m[35m     ] ][0m
  [22m[35m------------------------------------------------------------------[0m
  
  
  [1m[4m[31m1.4 Troubleshooting[0m
  
  As every software, also this package may contain bugs. If you find a bug, or
  a  missing  feature, or some other problems, or if you need some help, write
  an e-mail to both the authors. Please use an e-mail subject that begins with
  ``[22m[34msingular package: [0m''. Please include in the report the code that cause the
  problem,  so  that we can replicate the problem. If appropriate, you may set
  [1m[34mInfoSingular[0m ([1m1.2-1[0m) to [22m[34m3[0m, to see what happens between [1mGAP[0m and [1mSingular[0m (but
  this may give a lot of output).
  
  The  probability  that  your  problem will be fixed quickly increases if you
  read     the     text     ``How     to     Report     Bugs    Effectively'',
  [34mhttp://www.chiark.greenend.org.uk/~sgtatham/bugs.html[0m   ,  and  send  a  bug
  report according to this text.
  
  The  following  performs  a  test  of the package functionality (see the [1mGAP[0m
  documentation ``Test Files'').
  
  [22m[35m---------------------------  Example  ----------------------------[0m
    [22m[35mgap> fn := Filename( DirectoriesPackageLibrary( "singular", "tst" ), "test" );[0m
    [22m[35m"/usr/local/gap_dev/4.0/pkg/singular/tst/test"[0m
    [22m[35mgap> ReadTest( fn );[0m
    [22m[35mtrue[0m
  [22m[35m------------------------------------------------------------------[0m
  
  [1m[4m[31m1.4-1 SingularReportInformations[0m
  
  [1m[34m> SingularReportInformations( [0m[22m[34m[0m[1m[34m ) ___________________________________[0mfunction
  
  The  function  [22m[34mSingularReportInformations()[0m  collects  a  description of the
  system, that should be included in any bug report.
  
  [22m[35m---------------------------  Example  ----------------------------[0m
    [22m[35mgap> SingularReportInformations();[0m
    [22m[35mGap_Version := "4.dev";[0m
    [22m[35mGap_Architecture := "i686-pc-linux-gnu-gcc";[0m
    [22m[35mGap_BytesPerVariable := 4;[0m
    [22m[35muname := "Linux 2.4.20 i686";[0m
    [22m[35mSingular_Version: := 2004;[0m
    [22m[35mSingular_Name: := "/usr/local/Singular/2-0-4/ix86-Linux/Singular";[0m
    [22m[35m[0m
    [22m[35m"Gap_Version := \"4.dev\";\nGap_Architecture := \"i686-pc-linux-gnu-gcc\";\nGa\[0m
    [22m[35mp_BytesPerVariable := 4;\nuname := \"Linux 2.4.20 i686\";\nSingular_Version: :\[0m
    [22m[35m= 2004;\nSingular_Name: := \"/usr/local/Singular/2-0-4/ix86-Linux/Singular\";\[0m
    [22m[35m\n"[0m
  [22m[35m------------------------------------------------------------------[0m
  
