#### D.2.9.12 rcgs

Procedure from library `redcgs.lib` (see redcgs_lib).

Usage:
  rcgs(F);
  F is the ideal from which to obtain the Reduced CGS.
  rcgs(F,L);
  where L is a list of the null conditions ideal N, and W the set of non-null polynomials (ideal). If this option is set, the ideals N and W must depend only on the parameters and the parameter space is reduced to V(N) \ V(h), where h=prod(w), for w in W.
  A reduced specification of (N,W) will be computed and used to restrict the parameter-space. The output will omit the known restrictions given as option.

Return:
  The list representing the Reduced CGS.
  The description given here is analogous as for mrcgs and crcgs. The elements of the list T computed by rcgs are lists representing a rooted tree.
  Each element has as the two first entries with the following content:
  [1]: The label (intvec) representing the position in the rooted tree: 0 for the root (and this is a special element) i for the root of the segment i
  (i,...) for the children of the segment i
  [2]: the number of children (int) of the vertex.
  There thus three kind of vertices:
  1) the root (first element labelled 0),
  2) the vertices labelled with a single integer i,
  3) the rest of vertices labelled with more indices.
  Description of the root. Vertex type 1)
  There is a special vertex (the first one) whose content is the following:
  [3] lpp of the given ideal
  [4] the given ideal
  [5] the red-spec of the (optional) given null and non-null conditions (see redspec for the description)
  [6] RCGS (to remember which algorithm has been used). If the algorithm used is mrcgs or crcgs then this will be stated at this vertex (mrcgs or CRCGS).
  Description of vertices type 2). These are the vertices that initiate a segment, and are labelled with a single integer. [3] lpp (ideal) of the reduced basis. If they are repeated lpp's this will correspond to a sheaf.
  [4] the reduced basis (ideal) of the segment.
  Description of vertices type 3). These vertices have as first label i and descend form vertex i in the position of the label (i,...). They contain moreover a unique prime ideal in the parameters and form ascending chains of ideals.
  How is to be read the rcgs tree? The vertices with an even number of integers in the label are to be considered as additive and those with an odd number of integers in the label are to be considered as subtraction. As an example consider the following vertices: v1=((i),2,lpp,B),
  v2=((i,1),2,P_{(i,1)}),
  v3=((i,1,1),0,P_{(i,1,1)}, v4=((i,1,2),0,P_{(i,1,1)}), v5=((i,2),2,P_{(i,2)},
  v6=((i,2,1),0,P_{(i,2,1)}, v7=((i,2,2),0,P_{(i,2,2)}
  They represent the segment:
  (V(i,1)\(V(i,1,1) u V(i,1,2))) u
  (V(i,2)\(V(i,2,1) u V(i,2,2)))
  where V(i,j,..) = V(P_{(i,j,..)}

Note:
  There are three fundamental routines in the library: mrcgs, rcgs and crcgs. rcgs (Reduced CGS) is an algorithm that first homogenizes the basis of the given ideal then applies mrcgs and finally de-homogenizes and reduces the resulting bases. (See the note of mrcgs). As a result of Wibmer's Theorem, the resulting segments are locally closed (i.e. difference of varieties). Nevertheless, the output is not completely canonical as the homogeneous ideal considered is not the homogenized ideal of the given ideal but only the ideal obtained by homogenizing the given basis.

  The output can be visualized using cantreetoMaple, that will write a file with the content of mrcgs that can be read in Maple and plotted using the Maple plotcantree routine of the Monte's dpgb library You can also use the routine cantodiffcgs as the segments are all difference of two varieties to have a simpler view of the output.

Example:

    LIB "redcgs.lib";
    ring R=(0,b,c,d,e,f),(x,y),dp;
    ideal F=x^2+b*y^2+2*c*x*y+2*d*x+2*e*y+f, 2*x+2*c*y+2*d, 2*b*y+2*c*x+2*e;
    def T=rcgs(F);
    ==> // ** redefining @R (  exportto(Top,@R);      // global ring K[a][x])
    ==> // ** redefining @P (  exportto(Top,@P);      // global ring K[a])
    ==> // ** redefining @RP (  exportto(Top,@RP);     // global ring K[x,a] with\
        product order)
    ==> // ** redefining @R (  exportto(Top,@R);      // global ring K[a][x])
    ==> // ** redefining @P (  exportto(Top,@P);      // global ring K[a])
    ==> // ** redefining @RP (  exportto(Top,@RP);     // global ring K[x,a] with\
        product order)
    T;
    ==> [1]:
    ==>    [1]:
    ==>       0
    ==>    [2]:
    ==>       5
    ==>    [3]:
    ==>       _[1]=x2
    ==>       _[2]=x
    ==>       _[3]=x
    ==>    [4]:
    ==>       _[1]=x2+(2c)*xy+(b)*y2+(2d)*x+(2e)*y+(f)
    ==>       _[2]=2*x+(2c)*y+(2d)
    ==>       _[3]=(2c)*x+(2b)*y+(2e)
    ==>    [5]:
    ==>       [1]:
    ==>          _[1]=0
    ==>       [2]:
    ==>          _[1]=0
    ==>       [3]:
    ==>          [1]:
    ==>             _[1]=0
    ==>    [6]:
    ==>       RCGS
    ==> [2]:
    ==>    [1]:
    ==>       1
    ==>    [2]:
    ==>       1
    ==>    [3]:
    ==>       _[1]=1
    ==>    [4]:
    ==>       _[1]=1
    ==> [3]:
    ==>    [1]:
    ==>       1,1
    ==>    [2]:
    ==>       2
    ==>    [3]:
    ==>       _[1]=0
    ==> [4]:
    ==>    [1]:
    ==>       1,1,1
    ==>    [2]:
    ==>       0
    ==>    [3]:
    ==>       _[1]=(bd2-bf+c2f-2cde+e2)
    ==> [5]:
    ==>    [1]:
    ==>       1,1,2
    ==>    [2]:
    ==>       0
    ==>    [3]:
    ==>       _[1]=(b-c2)
    ==> [6]:
    ==>    [1]:
    ==>       2
    ==>    [2]:
    ==>       1
    ==>    [3]:
    ==>       _[1]=y
    ==>       _[2]=x
    ==>    [4]:
    ==>       _[1]=(b-c2)*y+(-cd+e)
    ==>       _[2]=(-b+c2)*x+(-bd+ce)
    ==> [7]:
    ==>    [1]:
    ==>       2,1
    ==>    [2]:
    ==>       1
    ==>    [3]:
    ==>       _[1]=(bd2-bf+c2f-2cde+e2)
    ==> [8]:
    ==>    [1]:
    ==>       2,1,1
    ==>    [2]:
    ==>       0
    ==>    [3]:
    ==>       _[1]=(cd-e)
    ==>       _[2]=(b-c2)
    ==> [9]:
    ==>    [1]:
    ==>       3
    ==>    [2]:
    ==>       1
    ==>    [3]:
    ==>       _[1]=1
    ==>    [4]:
    ==>       _[1]=1
    ==> [10]:
    ==>    [1]:
    ==>       3,1
    ==>    [2]:
    ==>       1
    ==>    [3]:
    ==>       _[1]=(b-c2)
    ==> [11]:
    ==>    [1]:
    ==>       3,1,1
    ==>    [2]:
    ==>       0
    ==>    [3]:
    ==>       _[1]=(cd-e)
    ==>       _[2]=(b-c2)
    ==> [12]:
    ==>    [1]:
    ==>       4
    ==>    [2]:
    ==>       1
    ==>    [3]:
    ==>       _[1]=1
    ==>    [4]:
    ==>       _[1]=1
    ==> [13]:
    ==>    [1]:
    ==>       4,1
    ==>    [2]:
    ==>       1
    ==>    [3]:
    ==>       _[1]=(cd-e)
    ==>       _[2]=(b-c2)
    ==> [14]:
    ==>    [1]:
    ==>       4,1,1
    ==>    [2]:
    ==>       0
    ==>    [3]:
    ==>       _[1]=(d2-f)
    ==>       _[2]=(cf-de)
    ==>       _[3]=(cd-e)
    ==>       _[4]=(b-c2)
    ==> [15]:
    ==>    [1]:
    ==>       5
    ==>    [2]:
    ==>       1
    ==>    [3]:
    ==>       _[1]=x
    ==>    [4]:
    ==>       _[1]=x+(c)*y+(d)
    ==> [16]:
    ==>    [1]:
    ==>       5,1
    ==>    [2]:
    ==>       1
    ==>    [3]:
    ==>       _[1]=(d2-f)
    ==>       _[2]=(cf-de)
    ==>       _[3]=(cd-e)
    ==>       _[4]=(b-c2)
    ==> [17]:
    ==>    [1]:
    ==>       5,1,1
    ==>    [2]:
    ==>       0
    ==>    [3]:
    ==>       _[1]=1
    cantreetoMaple(T,"Tr","Tr.txt");
    cantodiffcgs(T);
    ==> // ** redefining NP (    def NP=imap(RR,N);) redcgs.lib::cantodiffcgs:396\
       0
    ==> // ** redefining MP (    def MP=imap(RR,M);) redcgs.lib::cantodiffcgs:396\
       1
    ==> // ** redefining NP (    def NP=imap(RR,N);) redcgs.lib::cantodiffcgs:396\
       0
    ==> // ** redefining MP (    def MP=imap(RR,M);) redcgs.lib::cantodiffcgs:396\
       1
    ==> // ** redefining NP (    def NP=imap(RR,N);) redcgs.lib::cantodiffcgs:396\
       0
    ==> // ** redefining MP (    def MP=imap(RR,M);) redcgs.lib::cantodiffcgs:396\
       1
    ==> // ** redefining NP (    def NP=imap(RR,N);) redcgs.lib::cantodiffcgs:396\
       0
    ==> // ** redefining MP (    def MP=imap(RR,M);) redcgs.lib::cantodiffcgs:396\
       1
    ==> // ** redefining NP (    def NP=imap(RR,N);) redcgs.lib::cantodiffcgs:396\
       0
    ==> // ** redefining MP (    def MP=imap(RR,M);) redcgs.lib::cantodiffcgs:396\
       1
    ==> [1]:
    ==>    [1]:
    ==>       0
    ==>    [2]:
    ==>       5
    ==>    [3]:
    ==>       _[1]=x^2
    ==>       _[2]=x
    ==>       _[3]=x
    ==>    [4]:
    ==>       _[1]=x^2+(2*c)*x*y+(b)*y^2+(2*d)*x+(2*e)*y+(f)
    ==>       _[2]=2*x+(2*c)*y+(2*d)
    ==>       _[3]=(2*c)*x+(2*b)*y+(2*e)
    ==>    [5]:
    ==>       [1]:
    ==>          _[1]=0
    ==>       [2]:
    ==>          _[1]=0
    ==>       [3]:
    ==>          [1]:
    ==>             _[1]=0
    ==>    [6]:
    ==>       RCGS
    ==> [2]:
    ==>    [1]:
    ==>       _[1]=1
    ==>    [2]:
    ==>       _[1]=1
    ==>    [3]:
    ==>       _[1]=0
    ==>    [4]:
    ==>       _[1]=(b^2*d^2-b^2*f-b*c^2*d^2+2*b*c^2*f-2*b*c*d*e+b*e^2-c^4*f+2*c^3\
       *d*e-c^2*e^2)
    ==> [3]:
    ==>    [1]:
    ==>       _[1]=y
    ==>       _[2]=x
    ==>    [2]:
    ==>       _[1]=(b-c^2)*y+(-c*d+e)
    ==>       _[2]=(-b+c^2)*x+(-b*d+c*e)
    ==>    [3]:
    ==>       _[1]=(b*d^2-b*f+c^2*f-2*c*d*e+e^2)
    ==>    [4]:
    ==>       _[1]=(c*d-e)
    ==>       _[2]=(b-c^2)
    ==> [4]:
    ==>    [1]:
    ==>       _[1]=1
    ==>    [2]:
    ==>       _[1]=1
    ==>    [3]:
    ==>       _[1]=(b-c^2)
    ==>    [4]:
    ==>       _[1]=(c*d-e)
    ==>       _[2]=(b-c^2)
    ==> [5]:
    ==>    [1]:
    ==>       _[1]=1
    ==>    [2]:
    ==>       _[1]=1
    ==>    [3]:
    ==>       _[1]=(c*d-e)
    ==>       _[2]=(b-c^2)
    ==>    [4]:
    ==>       _[1]=(d^2-f)
    ==>       _[2]=(c*f-d*e)
    ==>       _[3]=(c*d-e)
    ==>       _[4]=(b-c^2)
    ==> [6]:
    ==>    [1]:
    ==>       _[1]=x
    ==>    [2]:
    ==>       _[1]=x+(c)*y+(d)
    ==>    [3]:
    ==>       _[1]=(d^2-f)
    ==>       _[2]=(c*f-d*e)
    ==>       _[3]=(c*d-e)
    ==>       _[4]=(b-c^2)
    ==>    [4]:
    ==>       _[1]=1

User manual for Singular version 4.4.1, 2025, generated by texi2html.