# Singular

### 5.1.130 ringlist

`Syntax:`
`ringlist (` ring_expression `)`
`ringlist (` qring_expression `)`
`Type:`
list
`Purpose:`
decomposes a ring/qring into a list of 4 (or 6 in the non-commutative case, see ringlist (plural)) components:
1. the field description in the following format:
• for Q, Z/p: the characteristic, type int (0 or prime number)
• for real, complex: a list of:
the characteristic, type int (always 0)
the precision, type list (2 integers: external, internal precision)
the name of the imaginary unit, type string
• for transcendental or algebraic extensions: described as a ringlist (that is, as list L with 4 entries: L[1] the characteristic, L[2] the names of the parameters, L[3] the monomial ordering for the ring of parameters (default: lp), L[4] the minimal polynomial (as ideal))
• for Z, Z/n, Z/n^m a list ["integer", [n, m]] with:
the base n is of type int or bigint (if not given n = 0, Z/0 = Z)
the exponent m is of type int (if not given m = 1)
2. the names of the variables (a list L of strings: L[i] is the name of the i-th variable)
3. the monomial ordering (a list L of lists): each block L[i] consists of
• the name of the ordering ( string )
• parameters specifying the ordering and the size of the block ( intvec : typically the weights for the variables [default: 1] )
4. the quotient ideal.
From a list of such structure, a new ring may be defined by the command `ring` ( see the following example ).
`Note: All data which depends on a ring belong to the current ring,`
not to a ring which can be contructed fron a modified list. These data will be mapped via fetch to the ring to be constructed.
`Example:`
 ``` ring r = 0,(x(1..3)),dp; list l = ringlist(r); l; ==> [1]: ==> 0 ==> [2]: ==> [1]: ==> x(1) ==> [2]: ==> x(2) ==> [3]: ==> x(3) ==> [3]: ==> [1]: ==> [1]: ==> dp ==> [2]: ==> 1,1,1 ==> [2]: ==> [1]: ==> C ==> [2]: ==> 0 ==> [4]: ==> _[1]=0 // Now change l and create a new ring, by //- changing the base field to the function field with parameter a, //- introducing one extra variable y, //- defining the block ordering (dp(2),wp(3,4)). //- define the minpoly after creating the function field l[1]=list(0,list("a"),list(list("lp",1)),ideal(0)); l[2][size(l[2])+1]="y"; l[3][3]=l[3][2]; // save the module ordering l[3][1]=list("dp",intvec(1,1)); l[3][2]=list("wp",intvec(3,4)); def ra = ring(l); //creates the newring ra; setring ra; ==> // characteristic : 0 ==> // 1 parameter : a ==> // minpoly : 0 ==> // number of vars : 4 ==> // block 1 : ordering dp ==> // : names x(1) x(2) ==> // block 2 : ordering wp ==> // : names x(3) y ==> // : weights 3 4 ==> // block 3 : ordering C list lra = ringlist(ra); lra[1][4]=ideal(a2+1); def Ra = ring(lra); setring Ra; Ra; ==> // characteristic : 0 ==> // 1 parameter : a ==> // minpoly : (a^2+1) ==> // number of vars : 4 ==> // block 1 : ordering dp ==> // : names x(1) x(2) ==> // block 2 : ordering wp ==> // : names x(3) y ==> // : weights 3 4 ==> // block 3 : ordering C ```
See qring; ring.