Changeset 3be959 in git for Singular

Timestamp:

Feb 26, 2020, 5:15:14 PM (4 years ago)

Author:

Hans Schoenemann <hannes@…>

Branches:

(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')

Children:

ec0708752f1b91087c273c68f2c17b842db5a772

Parents:

0d6d56592c854c03d576138fd39bd0808f01ce94

Message:

changed: difform.lib: via global var Omega_R

File:

• Singular/LIB/difform.lib (modified) (148 diffs)

Singular/LIB/difform.lib

@@ -23 +23 @@
     diffAlgebra();                  provides the differential algebra structure and the differential forms dx_1,...,dx_n
     diffAlgebraStructure();         generates the structure of the differential algebra from the basering
-    diffAlgebraCheck();             checks if the basering already has a differential algebra
-    diffAlgebraSwitch();            changes the basering to the differential algebra for computations
     diffAlgebraGens();              defines the differential forms dx_1,...,dx_n
     diffAlgebraUnivDerIdeal(ideal); computes the image of an ideal under the universal derivation
@@ -71 +69 @@
 KEYWORDS: differential forms;differentials;differential algebra
 ";
-////////////////////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////////////////////
-
-
-////////////////////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////////////////////
-//                                  Initialization of library                                 //
-////////////////////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////////////////////
-
+// Libraries needed
+LIB "inout.lib";
+
+////////////////////////////////////////////////////////////////////////////////
+//                       Initialization of library                            //
+////////////////////////////////////////////////////////////////////////////////
 
 static proc mod_init()
 {
-        // Type of differential forms:
-        // These are considered as elements (polynomials) in the differential algebra
+    // Type of differential forms:
+    // These are considered as elements (polynomials) in the differential algebra
     // NOTE: the polynomials 'form' are not visible in the basering - only in the differential algebra
-        newstruct("difform","poly form");
+    newstruct("difform","poly form");
 
     // Type of derivations - these are maps: Omega_R^1 -> R
@@ -95 +89 @@
     newstruct("derivation","list genIm");
 
-        // Overloads for difform
-        system("install", "difform", "=", difformFromPoly, 1);
-        system("install", "difform", "print", difformPrint, 1);
-
-        system("install", "difform", "+", difformAdd, 2);
-        system("install", "difform", "-", difformSub, 2);
-        system("install", "difform", "-", difformNeg, 1);
-        system("install", "difform", "*", difformMul, 2);
+    // Overloads for difform
+    system("install", "difform", "=", difformFromPoly, 1);
+    system("install", "difform", "print", difformPrint, 1);
+
+    system("install", "difform", "+", difformAdd, 2);
+    system("install", "difform", "-", difformSub, 2);
+    system("install", "difform", "-", difformNeg, 1);
+    system("install", "difform", "*", difformMul, 2);
     system("install", "difform", "/", difformDiv, 2);
-        system("install", "difform", "==", difformEqu, 2);
-        system("install", "difform", "<>", difformNeq, 2);
+    system("install", "difform", "==", difformEqu, 2);
+    system("install", "difform", "<>", difformNeq, 2);
     system("install", "difform", ">", difformIsBigger,2);
     system("install", "difform", "<", difformIsSmaller,2);
 
-        system("install", "difform", "deg", difformDeg, 1);
+    system("install", "difform", "deg", difformDeg, 1);
     system("install", "difform", "homog", difformIsHomog, 1);
 
@@ -126 +120 @@
     system("install", "derivation", "diff", derivationLie, 2);
 
-    // Libraries needed
-    LIB "inout.lib";
-}
-
-
-////////////////////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////////////////////
-//                            Construction of differential algebra                            //
-////////////////////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////////////////////
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+//                  Construction of differential algebra                      //
+////////////////////////////////////////////////////////////////////////////////
 
 
 // TODO: check if qringNF option is set - if yes: turn off and set afterwards on
 proc diffAlgebra()
-"USAGE:         diffAlgebra();
-SIDE EFFECTS:   If R is the basering, the differential algebra is constructed with name Omega_R
-                and the differential forms dx_1,...,dx_n are available. The name of the differential
-                algebra is stored in the attribute attrib(R,"diffAlgebra").
-NOTE:           - computations with differential forms need the structure of the differential algebra,
-                so this procedure should be executed first.
-                - the variable names 'd' or 'D' should be avoided.
-                - the procedure also works for quotient rings
-KEYWORDS:       differential algebra; differential forms; differentials
-SEE ALSO:       diffAlgebraStructure, diffAlgebraGens, diffAlgebraUnivDerIdeal
-EXAMPLE:        example diffAlgebra; shows an example"
+"USAGE:       diffAlgebra();
+SIDE EFFECTS: If R is the basering, the differential algebra is constructed with name Omega_R
+              and the differential forms dx_1,...,dx_n are available. The name of the differential
+              algebra is stored in the attribute attrib(R,"diffAlgebra").
+NOTE:         - computations with differential forms need the structure of the differential algebra,
+              so this procedure should be executed first.
+              - the variable names 'd' or 'D' should be avoided.
+              - the procedure also works for quotient rings
+KEYWORDS:     differential algebra; differential forms; differentials
+SEE ALSO:     diffAlgebraStructure; diffAlgebraGens; diffAlgebraUnivDerIdeal
+EXAMPLE:      example diffAlgebra; shows an example"
 {
 
     // Build the differential algebra and store its name as an attribute
-    string diffAlg_name = diffAlgebraStructure();
-    attrib(basering,"diffAlgebra",diffAlg_name);
+    ring Omega_R = diffAlgebraStructure();
+    attrib(basering,"diffAlgebra","Omega_R");
 
     // Construct the differential forms dx_1,...,dx_n over the basering
@@ -173 +163 @@
     string info_text = "// The differential algebra " + attrib(basering,"diffAlgebra") + " was constructed and the differential forms " + basic_forms + " are available.";
     print(info_text);
-    return();
-
 }
 example
@@ -200 +188 @@
 qring S = std(I);
 diffAlgebra();
-setring Omega_S;
+setring Omega_R;
 
 // The differential algebra is given by:
 basering;
 
-kill Omega_S,dx,dy,dz;
-}
-
-
-////////////////////////////////////////////////////////////////////////////////////////////////
+kill Omega_R,dx,dy,dz;
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
 
 
@@ -224 +212 @@
 {
 
-    string basering_name = nameof(basering);
-        list base_list = ringlist(basering);
+    list base_list = ringlist(basering);
     def R_old = basering;
     ideal quot_ideal = base_list[4];
 
-        // Add Dx_1,...,Dx_n as first variables
-        list ext_var = base_list[2];
-        int n = size(ext_var);
-        int i;
-
-        for(i = 1; i <= n; i++){
-        ext_var[n+i] = ext_var[i];
-                ext_var[i] = "D" + ext_var[n+i];
-        }
-
-        base_list[2] = ext_var;
+    // Add Dx_1,...,Dx_n as first variables
+    list ext_var = base_list[2];
+    int n = size(ext_var);
+    int i;
+
+    for(i = 1; i <= n; i++)
+    {
+      ext_var[n+i] = ext_var[i];
+      ext_var[i] = "D" + ext_var[n+i];
+    }
+
+    base_list[2] = ext_var;
 
     // Preserve the monomial order of the basering
@@ -246 +234 @@
     base_list[3] = list(list("dp",weight_vec)) + base_list[3];
 
-        // Add relations x_i*x_j = x_j*x_i and dx_i*dx_j = -dx_j*dx_i
-        int k = 2*n;
-        matrix C[k][k];
-        matrix D[k][k];
-        int j;
-
-        // Generate strictly upper triangular matrix describing the relations
-        for(i = 1; i <= k; i++){
-            for(j = i+1; j <= k ; j++){
-            if(j <= n){
-                        C[i,j] = -1;
-            }else{
-                C[i,j] = 1;
-            }
-                }
-        }
+    // Add relations x_i*x_j = x_j*x_i and dx_i*dx_j = -dx_j*dx_i
+    int k = 2*n;
+    matrix C[k][k];
+    matrix D[k][k];
+    int j;
+
+    // Generate strictly upper triangular matrix describing the relations
+    for(i = 1; i <= k; i++)
+    {
+      for(j = i+1; j <= k ; j++)
+      {
+        if(j <= n)
+        {
+          C[i,j] = -1;
+        }
+        else
+        {
+          C[i,j] = 1;
+        }
+      }
+    }
 
     base_list[4] = ideal(0);
-        base_list[5] = C;
-        base_list[6] = D;
-
-        // Pass to non-commutative ring with extra variables and relations
-        ring R_intermediate = ring(base_list);
-
-        // Add relations Dx_i*Dx_i = 0 via generating a quotient ring
-        ideal REL;
-        for(i = 1; i <= n; i++){
-                REL[i] = var(i)*var(i);
-        }
-
-        // Build the differential algebra for the polynomial ring - the free module
+    base_list[5] = C;
+    base_list[6] = D;
+
+    // Pass to non-commutative ring with extra variables and relations
+    ring R_intermediate = ring(base_list);
+
+    // Add relations Dx_i*Dx_i = 0 via generating a quotient ring
+    ideal REL;
+    for(i = 1; i <= n; i++)
+    {
+      REL[i] = var(i)*var(i);
+    }
+
+    // Build the differential algebra for the polynomial ring - the free module
     qring diffAlg_poly = twostd(REL);
 
@@ -282 +276 @@
     ideal quot_ideal = imap(R_old,quot_ideal);
 
-    if(quot_ideal != 0){
-
-        // Compute the universal derivation of the generators of the ideal
-        quot_ideal = quot_ideal + diffAlgebraUnivDerIdeal(quot_ideal);
-
-        // Add the additional relations, generate the differential algebra with name Omega_R and export it
-        string diffAlg_name = "Omega_" + basering_name;
-            execute("qring " + diffAlg_name + " = twostd(quot_ideal);");
-        execute("exportto(Top," + diffAlg_name + ");");
-
-        return(diffAlg_name);
+    if(size(quot_ideal) != 0)
+    {
+      // Compute the universal derivation of the generators of the ideal
+      quot_ideal = quot_ideal + diffAlgebraUnivDerIdeal(quot_ideal);
+
+      // Add the additional relations, generate the differential algebra with name Omega_R and export it
+      qring Omega_R = twostd(quot_ideal);
+      exportto(Top,Omega_R);
+
+      return(Omega_R);
     }
 
     // Give the differential algebra the name Omega_basering and export it
-    string diffAlg_name = "Omega_" + basering_name;
-        execute("ring " + diffAlg_name + " = diffAlg_poly;");
-    execute("exportto(Top," + diffAlg_name + ");");
-
-    return(diffAlg_name);
-
-}
-
-
-////////////////////////////////////////////////////////////////////////////////////////////////
-
-
-proc diffAlgebraCheck()
-"USAGE:         diffAlgebraCheck();
-SIDE EFFECTS:   Checks if the basering has a differential algebra and aborts with an error if this is not the case
-REMARKS:        The procedure checks if the name in the attribute attrib(basering,"diffAlgebra") is not empty. This
-                is the case if the procedure diffAlgebra was executed first.
-NOTE:           whenever computations with differential forms are done, it should be checked if the differential
-                algebra was already generated since differential forms are polynomials in the differential algebra
-KEYWORDS:       differential algebra
-SEE ALSO:       diffAlgebraSwitch"
-{
-    string diffAlg_name = attrib(basering,"diffAlgebra");
-    if(size(diffAlg_name) == 0){
-        ERROR("Ring does not have a differential algebra!");
-    }
-}
-
-
-////////////////////////////////////////////////////////////////////////////////////////////////
-
-
-proc diffAlgebraSwitch()
-"USAGE:         diffAlgebraSwitch();
-ASSUME:         The differential algebra was already constructed.
-SIDE EFFECTS:   Changes the ring: from the basering to the differential algebra.
-NOTE:           whenever computations with differential forms are done, the ring must be changed to the differential
-                algebra since differential forms are polynomials there. But first it should be checked if the algebra
-                is actually available: so before executing diffAlgebraSwitch there should always be an preceding diffAlgebraCheck
-KEYWORDS:       differential algebra
-SEE ALSO:       diffAlgebraCheck"
-{
-
-    string diffAlg_name = attrib(basering,"diffAlgebra");
-    execute("setring " + diffAlg_name);
-    execute("keepring " + diffAlg_name);
-
-}
-
-
-////////////////////////////////////////////////////////////////////////////////////////////////
+    ring Omega_R = diffAlg_poly;
+    exportto(Top,Omega_R);
+
+    return(Omega_R);
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+
+
+////////////////////////////////////////////////////////////////////////////////
+
+
+////////////////////////////////////////////////////////////////////////////////
 
 
@@ -356 +312 @@
 {
 
-    diffAlgebraSwitch();
-
-    list ext_var = ringlist(basering)[2];
+    setring Omega_R;
+
+    list ext_var = ringlist(Omega_R)[2];
     int n = size(ext_var) div 2;
     int i;
@@ -391 +347 @@
     ideal d_I;
 
-    for(j = 1; j <= k; j++){
+    for(j = 1; j <= k; j++)
+    {
         d_I[j] = 0;
-        for(i = 1; i <= n; i++){
+        for(i = 1; i <= n; i++)
+        {
             d_I[j] = d_I[j] + diff(I[j],var(i+n))*var(i);
         }
     }
-
     return(d_I);
 
@@ -435 +392 @@
 
     // Get information from input
-    for(i = 1; i <= n; i++){
-        if(typeof(#[i]) == "string"){
-
-            if(#[i] == "gen" && typeof(#[i+1]) == "string"){
+    for(i = 1; i <= n; i++)
+    {
+        if(typeof(#[i]) == "string")
+        {
+            if(#[i] == "gen" && typeof(#[i+1]) == "string")
+            {
                 gen_ord = #[i+1];
-                if(typeof(#[i+2]) == "intvec"){
+                if(typeof(#[i+2]) == "intvec")
+                {
                     intvec gen_weight = #[i+2];
                 }
             }
-
-            if(#[i] == "ringvar" && typeof(#[i+1]) == "string"){
+            if(#[i] == "ringvar" && typeof(#[i+1]) == "string")
+            {
                 ringvar_ord = #[i+1];
-                if(typeof(#[i+2]) == "intvec"){
+                if(typeof(#[i+2]) == "intvec")
+                {
                     intvec ringvar_weight = #[i+2];
                 }
@@ -456 +417 @@
     // Check input for consistency
     // Generator ordering must be a valid monomial ordering
-    if(gen_ord != "" && gen_ord != "lp" && gen_ord != "rp" && gen_ord != "dp" && gen_ord != "Dp" && gen_ord != "wp" && gen_ord != "Wp"){
-        if(gen_ord != "ls" && gen_ord != "ds" && gen_ord != "Ds" && gen_ord != "ws" && gen_ord != "Ws"){
+    if(gen_ord != "" && gen_ord != "lp" && gen_ord != "rp" && gen_ord != "dp" && gen_ord != "Dp" && gen_ord != "wp" && gen_ord != "Wp")
+    {
+        if(gen_ord != "ls" && gen_ord != "ds" && gen_ord != "Ds" && gen_ord != "ws" && gen_ord != "Ws")
+        {
             ERROR("Not a valid ordering!");
         }
     }
-
     // Ringvariable ordering must be a valid monomial ordering
-    if(ringvar_ord != "" && ringvar_ord != "lp" && ringvar_ord != "rp" && ringvar_ord != "dp" && ringvar_ord != "Dp" && ringvar_ord != "wp" && ringvar_ord != "Wp"){
-        if(ringvar_ord != "ls" && ringvar_ord != "ds" && ringvar_ord != "Ds" && ringvar_ord != "ws" && ringvar_ord != "Ws"){
+    if(ringvar_ord != "" && ringvar_ord != "lp" && ringvar_ord != "rp" && ringvar_ord != "dp" && ringvar_ord != "Dp" && ringvar_ord != "wp" && ringvar_ord != "Wp")
+    {
+        if(ringvar_ord != "ls" && ringvar_ord != "ds" && ringvar_ord != "Ds" && ringvar_ord != "ws" && ringvar_ord != "Ws")
+        {
             ERROR("Not a valid ordering!");
         }
     }
-
     // If the generator ordering is a weighted monomial ordering, a weight-vector is needed
-    if(gen_ord == "wp" || gen_ord == "Wp" || gen_ord == "ws" || gen_ord == "Ws"){
-        if(!defined(gen_weight)){
+    if(gen_ord == "wp" || gen_ord == "Wp" || gen_ord == "ws" || gen_ord == "Ws")
+    {
+        if(!defined(gen_weight))
+        {
             ERROR("No weight vector given!");
         }
-
-        if(size(gen_weight) != k){
+        if(size(gen_weight) != k)
+        {
             ERROR("Weight vector has wrong size!");
         }
-    }else{
+    }
+    else
+    {
     // If a weight vector is given although the monomial ordering is not weighted
-        if(defined(gen_weight)){
+        if(defined(gen_weight))
+        {
             kill gen_weight;
         }
     }
-
     // If the ordering for the ring variables is a weighted monmial ordering, a weight-vector is needed
-    if(ringvar_ord == "wp" || ringvar_ord == "Wp" || ringvar_ord == "ws" || ringvar_ord == "Ws"){
-        if(!defined(ringvar_weight)){
+    if(ringvar_ord == "wp" || ringvar_ord == "Wp" || ringvar_ord == "ws" || ringvar_ord == "Ws")
+    {
+        if(!defined(ringvar_weight))
+        {
             ERROR("No weight vector given!");
         }
-
-        if(size(ringvar_weight) != k){
+        if(size(ringvar_weight) != k)
+        {
             ERROR("Weight vector has wrong size!");
         }
-    }else{
+    }
+    else
+    {
     // If a weight vector is given although the monomial ordering is not weighted
-        if(defined(ringvar_weight)){
+        if(defined(ringvar_weight))
+        {
             kill ringvar_weight;
         }
     }
-
     list L_diff_Alg = ringlist(basering);
     n = size(L_diff_Alg[3]);
 
     // Change ordering of generators
-    if(gen_ord != ""){
+    if(gen_ord != "")
+    {
         L_diff_Alg[3][1][1] = gen_ord;
-        if(defined(gen_weight)){
+        if(defined(gen_weight))
+        {
             L_diff_Alg[3][1][2] = gen_weight;
         }
@@ -513 +486 @@
 
     // Change the ordering of the ringvariables
-    if(ringvar_ord != ""){
+    if(ringvar_ord != "")
+    {
         list L;
         L[1] = L_diff_Alg[3][1];
-
         L[2] = list();
         L[2][1] = ringvar_ord;
-        if(defined(ringvar_weight)){
+        if(defined(ringvar_weight))
+        {
             L[2][2] = ringvar_weight;
-        }else{
+        }
+        else
+        {
             L[2][2] = 1:k;
         }
-
         L_diff_Alg[3] = L;
     }
@@ -530 +505 @@
     def T = ring(L_diff_Alg);
     return(T);
-
 }
 
@@ -539 +513 @@
 proc diffAlgebraListGen(list #)
 "USAGE: diffAlgebraListGen(#); # list
-RETURN:     - a list of generetors of the differential algebra as module over the basering
+RETURN:     - a list of generators of the differential algebra as module over the basering
             - a list of generators of a graded part of the differential algebra
 REMARKS:    In order to find all generators, they are counted 'binary': The generators are in
@@ -552 +526 @@
 EXAMPLE:    example diffAlgebraListGen; shows an example"
 {
-
-    diffAlgebraCheck();
-
     int n = size(ringlist(basering)[2]);
     int i,k,j;
@@ -564 +535 @@
 
     // Get optional degree
-    if(size(#) > 0){
-        if(typeof(#[1]) == "int"){
+    if(size(#) > 0)
+    {
+        if(typeof(#[1]) == "int")
+        {
             degr = #[1];
         }
@@ -572 +545 @@
     // Build the list of all dx_i
     def R_old = basering;
-    diffAlgebraSwitch();
-
-    for(i = 1; i <= n; i++){
+    setring Omega_R;
+
+    for(i = 1; i <= n; i++)
+    {
         current_var.form = var(i);
         var_list[i] = current_var;
@@ -583 +557 @@
     // Find all generators (of given degree)
     list dual_i;
-    for(i = 1; i < 2^n; i++){
+    for(i = 1; i < 2^n; i++)
+    {
         // Compute dual number representation
         dual_i = diffAlgebraIntToDual(i);
@@ -590 +565 @@
 
         // Convert dual number to generator
-        for(j = 1; j <= k; j++){
-            if(dual_i[j] != 0){
+        for(j = 1; j <= k; j++)
+        {
+            if(dual_i[j] != 0)
+            {
                 current_gen = current_gen*var_list[j];
             }
@@ -597 +574 @@
 
         // Add generator if it has the given degree or degree was not chosen
-        if(degr == -1 || difformDeg(current_gen) == degr){
+        if(degr == -1 || difformDeg(current_gen) == degr)
+        {
             GEN_list = GEN_list + list(current_gen);
         }
@@ -603 +581 @@
 
     // Add generator 1
-    if(degr == 0 || degr == -1){
+    if(degr == 0 || degr == -1)
+    {
         difform gen_one = 1;
         GEN_list = list(gen_one) + GEN_list;
@@ -609 +588 @@
 
     return(difformListSort(GEN_list));
-
 }
 example
@@ -631 +609 @@
 
 
-////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 
 
@@ -641 +619 @@
 SEE ALSO:   diffAlgebraListGen"
 {
-
     list dual_number;
 
-    while(l div 2 != 0){
+    while(l div 2 != 0)
+    {
         dual_number = dual_number + list(l mod 2);
         l = l div 2;
     }
-
     dual_number = dual_number + list(l mod 2);
-
     return(dual_number);
-
-}
-
-
-////////////////////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////////////////////
-//                                Procedures for type difform                                 //
-////////////////////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////////////////////
-
-
-////////////////////////////////////////////////////////////////////////////////////////////////
-//----------------------------------- Structural procedures ----------------------------------//
-////////////////////////////////////////////////////////////////////////////////////////////////
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+//                     Procedures for type difform                            //
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+
+////////////////////////////////////////////////////////////////////////////////
+//----------------------- Structural procedures ------------------------------//
+////////////////////////////////////////////////////////////////////////////////
 
 
@@ -677 +652 @@
 {
 
-    diffAlgebraCheck();
     def R_old = basering;
-    diffAlgebraSwitch();
+    setring Omega_R;
 
     poly g = imap(R_old,f);
@@ -686 +660 @@
 
     return(df);
-
 }
 example
@@ -712 +685 @@
 
 
-////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 
 
@@ -726 +699 @@
 EXAMPLE:    example difformCoef; shows an example"
 {
-
-    diffAlgebraCheck();
     def R_old = basering;
-    diffAlgebraSwitch();
+    setring Omega_R;
     def diff_Alg = basering;
 
@@ -736 +707 @@
     int i;
 
-        // Build the wedge product of all differential forms dx_i
-        poly wedge_mon = 1;
-        for(i = 1; i <= n; i++){
-                wedge_mon = wedge_mon*var(i);
-        }
-
-        // Find the coefficients of the generators
+    // Build the wedge product of all differential forms dx_i
+    poly wedge_mon = 1;
+    for(i = 1; i <= n; i++)
+    {
+      wedge_mon = wedge_mon*var(i);
+    }
+
+    // Find the coefficients of the generators
     matrix df_coefs = coef(f,wedge_mon);
     int k = ncols(df_coefs);
@@ -753 +725 @@
     list repr;
 
-    for(i = 1;i <= k;i++){
-        repr[i] = list();
-        setring diff_Alg;
-
-        // Generators as differential forms
-        current_gen.form = df_coefs[1,i];
-
-        // Coefficients are polynomials in the basering
-        coeff_above = df_coefs[2,i];
-        setring R_old;
-        coeff = imap(diff_Alg,coeff_above);
-
-        repr[i][1] = current_gen;
-        repr[i][2] = coeff;
+    for(i = 1;i <= k;i++)
+    {
+      repr[i] = list();
+      setring diff_Alg;
+
+      // Generators as differential forms
+      current_gen.form = df_coefs[1,i];
+
+      // Coefficients are polynomials in the basering
+      coeff_above = df_coefs[2,i];
+      setring R_old;
+      coeff = imap(diff_Alg,coeff_above);
+
+      repr[i][1] = current_gen;
+      repr[i][2] = coeff;
     }
 
     // Return representation
     return(repr);
-
 }
 example
@@ -797 +769 @@
 
 
-////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 
 
@@ -809 +781 @@
 SEE ALSO:   difformToString"
 {
-
-    diffAlgebraSwitch();
+    setring Omega_R;
     string df_out_un = string(df.form);
-    list vars_ = ringlist(basering)[2];
+    list vars_ = ringlist(Omega_R)[2];
     int n = size(vars_) div 2;
     int i,j;
 
     // Replace the Dx_i in the string with the dx_i
-    for(i = 1; i <= n; i++){
+    for(i = 1; i <= n; i++)
+    {
         j = find(df_out_un,string(vars_[i]));
 
-        while(j!=0){
+        while(j!=0)
+        {
             df_out_un[j] = "d";
             j = find(df_out_un,vars_[i]);
         }
     }
-
     return(df_out_un);
-
-}
-
-
-////////////////////////////////////////////////////////////////////////////////////////////////
-
+}
+
+////////////////////////////////////////////////////////////////////////////////
 
 // TODO: check optionIsSet("qringNF") - ADD ring.lib !!! and reduce by hand
@@ -848 +817 @@
 EXAMPLE:    example difformToString; shows an example"
 {
-
     // Get the coefficients
     list repr = difformCoef(df);
@@ -857 +825 @@
     int i;
 
-    for(i = 1; i <= n; i++){
-        if(typeof(#[i]) == "string"){
-            if(#[i] == "gen" && typeof(#[i+1]) == "string"){
+    for(i = 1; i <= n; i++)
+    {
+        if(typeof(#[i]) == "string")
+        {
+            if(#[i] == "gen" && typeof(#[i+1]) == "string")
+            {
                 gen_ord = #[i+1];
-                if(typeof(#[i+2]) == "intvec"){
+                if(typeof(#[i+2]) == "intvec")
+                {
                     intvec gen_weight = #[i+2];
                 }
@@ -869 +841 @@
 
     // Sort the generator/coefficients by the chosen ordering
-    if(gen_ord != ""){
-        if(defined(gen_weight)){
+    if(gen_ord != "")
+    {
+        if(defined(gen_weight))
+        {
             repr = difformListSort(repr,"Llist","gen",gen_ord,gen_weight);
-        }else{
+        }
+        else
+        {
             repr = difformListSort(repr,"Llist","gen",gen_ord);
         }
-    }else{
+    }
+    else
+    {
         repr = difformListSort(repr,"Llist");
     }
@@ -888 +866 @@
     string df_coef_str;
 
-    for(i = n; i >= 1; i--){
+    for(i = n; i >= 1; i--)
+    {
         df_gen = repr[i][1];
         df_gen_str = difformGenToString(df_gen);
@@ -895 +874 @@
 
         // Check the coefficients and generators
-        while(1){
+        while(1)
+        {
             // Special cases without brackets:
 
@@ -912 +892 @@
 
         // Add a plus sign
-        if(i > 1){
+        if(i > 1)
+        {
             df_out = df_out + "+";
         }
     }
 
-        return(df_out);
-
+    return(df_out);
 }
 example
@@ -955 +935 @@
 EXAMPLE:        example difformPrint; shows an example"
 {
-
     // Print in ds-order on the generators
-        print(difformToString(df,"gen","ds"));
-    return();
-
+    print(difformToString(df,"gen","ds"));
 }
 example
@@ -990 +967 @@
 "
 {
-
-    diffAlgebraCheck();
     list df_gen_repr = difformCoef(df);
     int n = size(df_gen_repr);
 
-    if(n == 1 && df_gen_repr[1][2] == 1){
+    if(n == 1 && df_gen_repr[1][2] == 1)
+    {
         return(1);
     }
-
     return(0);
-
 }
 example
@@ -1043 +1017 @@
 EXAMPLE:    example difformAdd; shows an example"
 {
-
-    diffAlgebraCheck();
-    diffAlgebraSwitch();
+    setring Omega_R;
 
     difform dsum;
@@ -1089 +1061 @@
 EXAMPLE:    example difformSub; shows an example"
 {
-
-        diffAlgebraCheck();
-    diffAlgebraSwitch();
+    setring Omega_R;
 
     difform dsub;
@@ -1098 +1068 @@
 
     return(dsub);
-
 }
 example
@@ -1135 +1104 @@
 EXAMPLE:    example difformNeg; shows an example"
 {
-
-        diffAlgebraCheck();
-    diffAlgebraSwitch();
+    setring Omega_R;
 
     difform dneg;
@@ -1144 +1111 @@
 
     return(dneg);
-
 }
 example
@@ -1163 +1129 @@
 
 
-////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 
 
@@ -1173 +1139 @@
 EXAMPLE:    example difformMul; shows an example"
 {
-
-        diffAlgebraCheck();
-    diffAlgebraSwitch();
+    setring Omega_R;
 
     difform dmul;
@@ -1182 +1146 @@
 
     return(dmul);
-
 }
 example
@@ -1219 +1182 @@
 EXAMPLE:    example difformDiv; shows an example"
 {
-
-    diffAlgebraCheck();
-    diffAlgebraSwitch();
+    setring Omega_R;
 
     difform ddiv;
@@ -1228 +1189 @@
 
     return(ddiv);
-
 }
 example
@@ -1255 +1215 @@
 
 
-////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 
 
@@ -1265 +1225 @@
 EXAMPLE:    example difformEqu; shows an example"
 {
-
-        diffAlgebraCheck();
-    diffAlgebraSwitch();
-
+    setring Omega_R;
     return(df.form == dg.form);
-
 }
 example
@@ -1293 +1249 @@
 
 
-////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 
 
@@ -1303 +1259 @@
 EXAMPLE:    example difformNeq; shows an example"
 {
-
         return(!difformEqu(df,dg));
-
 }
 example
@@ -1347 +1301 @@
 EXAMPLE:    example difformIsBigger; shows an example"
 {
-
-    diffAlgebraCheck();
-    diffAlgebraSwitch();
+    setring Omega_R;
 
     poly df_form = df.form;
     poly dg_form = dg.form;
 
-    if(size(#) > 0){
-        def diff_Alg = basering;
+    if(size(#) > 0)
+    {
+        def diff_Alg = Omega_R;
         ring T = diffAlgebraChangeOrd(#);
 
@@ -1364 +1317 @@
 
     return(df_form > dg_form);
-
 }
 example
@@ -1392 +1344 @@
 
 
-////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 
 
@@ -1411 +1363 @@
 EXAMPLE:    example difformIsSmaller; shows an example"
 {
-
-    diffAlgebraCheck();
-    diffAlgebraSwitch();
+    setring Omega_R;
 
     poly df_form = df.form;
     poly dg_form = dg.form;
 
-    if(size(#) > 0){
+    if(size(#) > 0)
+    {
         def diff_Alg = basering;
         ring T = diffAlgebraChangeOrd(#);
@@ -1426 +1377 @@
         return(df_form_T < dg_form_T);
     }
-
     return(df.form < dg.form);
-
 }
 example
@@ -1456 +1405 @@
 
 
-////////////////////////////////////////////////////////////////////////////////////////////////
-//------------------------- Procedures for computing with the degree -------------------------//
-////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+//------------ Procedures for computing with the degree ----------------------//
+////////////////////////////////////////////////////////////////////////////////
 
 
@@ -1471 +1420 @@
 EXAMPLE:    example difformDeg; shows an example"
 {
-
-    diffAlgebraCheck();
-    diffAlgebraSwitch();
+    setring Omega_R;
 
     // Degree of a difform is the degree of the poly with weights 0 for the basering variables
-    int n = size(ringlist(basering)[2]) div 2;
+    int n = size(ringlist(Omega_R)[2]) div 2;
     int i;
     intvec var_weights;
 
-    for(i = 1; i <= n; i++){
+    for(i = 1; i <= n; i++)
+    {
         var_weights[i] = 1;
         var_weights[i+n] = 0;
     }
-
     return(deg(df.form,var_weights));
-
 }
 example
@@ -1511 +1457 @@
 }
 
-
-////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 
 
@@ -1525 +1470 @@
 EXAMPLE:    example difformIsHomog; shows an example"
 {
-
-        diffAlgebraCheck();
-    diffAlgebraSwitch();
-
-    int n = size(ringlist(basering)[2]) div 2;
+    setring Omega_R;
+
+    int n = size(ringlist(Omega_R)[2]) div 2;
     int i;
     intvec var_weights;
 
-    for(i = 1; i <= n; i++){
+    for(i = 1; i <= n; i++)
+    {
         var_weights[i] = 1;
         var_weights[i+n] = 0;
     }
-
     return(homog(df.form,var_weights));
-
 }
 example
@@ -1572 +1514 @@
 
 
-////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 
 
@@ -1583 +1525 @@
 EXAMPLE:    example difformIsHomogDeg; shows an example"
 {
-
         int df_deg = difformDeg(df);
         int is_hom = difformIsHomog(df);
         return(df_deg == p && is_hom == 1);
-
 }
 example
@@ -1620 +1560 @@
 
 
-////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 
 
@@ -1632 +1572 @@
 EXAMPLE:    example difformHomogDecomp; shows an example"
 {
-
-    diffAlgebraCheck();
-
     // Highest degree is the nr. of variables in the basering
     int n = size(ringlist(basering)[2]);
@@ -1643 +1580 @@
 
     // Generate a list full of 0s
-    for(i = 1;i <= (n+1); i++){
+    for(i = 1;i <= (n+1); i++)
+    {
         homog_part[i] = 0;
     }
@@ -1652 +1590 @@
 
     // Sort in list
-    for(i = 1; i <= k; i++){
+    for(i = 1; i <= k; i++)
+    {
         current_gen = df_gen_repr[i][1];
         current_coef = df_gen_repr[i][2];
         j = difformDeg(current_gen);
 
-        if(j == 0){
+        if(j == 0)
+        {
             homog_part[n+1] = homog_part[n+1] + current_coef*current_gen;
-        }else{
+        }
+        else
+        {
             homog_part[j] = homog_part[j] + current_coef*current_gen;
         }
     }
-
     return(homog_part);
-
 }
 example
@@ -1686 +1626 @@
 
 
-////////////////////////////////////////////////////////////////////////////////////////////////
-//------------------------ Procedures for lists of differential forms ------------------------//
-////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+//--------------- Procedures for lists of differential forms -----------------//
+////////////////////////////////////////////////////////////////////////////////
 
 
@@ -1699 +1639 @@
 EXAMPLE:    example difformListCont; shows an example"
 {
-
-    diffAlgebraCheck();
-
     int n = size(L);
     int i;
 
-    for(i = 1; i <= n; i++){
-        if(typeof(L[i]) == "difform"){
-            if(difformEqu(df,L[i])){
+    for(i = 1; i <= n; i++)
+    {
+        if(typeof(L[i]) == "difform")
+        {
+            if(difformEqu(df,L[i]))
+            {
                 return(1);
             }
         }
     }
-
     return(0);
-
 }
 example
@@ -1742 +1680 @@
 
 
-////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 
 
@@ -1768 +1706 @@
 EXAMPLE:    example difformListSort; shows an example"
 {
-
-    diffAlgebraCheck();
-
     list orderings = #;
     int n = size(orderings);
@@ -1778 +1713 @@
 
     // Check for double list
-    for(i = 1; i <= n; i++){
-        if(typeof(orderings[i]) == "string"){
-            if(orderings[i] == "Dlist"){
+    for(i = 1; i <= n; i++)
+    {
+        if(typeof(orderings[i]) == "string")
+        {
+            if(orderings[i] == "Dlist")
+            {
                 Dlist_flag = 1;
                 orderings = delete(orderings,i);
@@ -1788 +1726 @@
 
     // Check for list of lists
-    for(i = 1; i <= n; i++){
-        if(typeof(orderings[i]) == "string"){
-            if(orderings[i] == "Llist"){
+    for(i = 1; i <= n; i++)
+    {
+        if(typeof(orderings[i]) == "string")
+        {
+            if(orderings[i] == "Llist")
+            {
                 Llist_flag = 1;
                 orderings = delete(orderings,i);
@@ -1798 +1739 @@
 
     // Not both list forms allowed
-    if(Dlist_flag == 1 && Llist_flag == 1){
+    if(Dlist_flag == 1 && Llist_flag == 1)
+    {
         ERROR("Cannot sort double list of lists!");
     }
 
     // Double list detected
-    if(Dlist_flag == 1){
+    if(Dlist_flag == 1)
+    {
         poly temp_form_sec;
         list L_sec = L[2];
@@ -1810 +1753 @@
 
     // List of lists detected
-    if(Llist_flag == 1){
+    if(Llist_flag == 1)
+    {
         poly temp_form_sec;
         n = size(L);
@@ -1817 +1761 @@
 
         // Transform list of lists to double list
-        for(i = 1; i <= n; i++){
+        for(i = 1; i <= n; i++)
+        {
             L_temp[i] = L[i][1];
             L_sec[i] = L[i][2];
@@ -1829 +1774 @@
     n = size(L);
 
-    for(i = 1; i <= n; i++){
+    for(i = 1; i <= n; i++)
+    {
         temp_form = L[i];
 
-        if(Dlist_flag == 1 || Llist_flag == 1){
+        if(Dlist_flag == 1 || Llist_flag == 1)
+        {
             temp_form_sec = L_sec[i];
         }
@@ -1838 +1785 @@
         j = i;
 
-        while(j > 1){
-            if(difformIsBigger(L[j-1],temp_form,orderings)){
+        while(j > 1)
+        {
+            if(difformIsBigger(L[j-1],temp_form,orderings))
+            {
                 L[j] = L[j-1];
 
-                if(Dlist_flag == 1 || Llist_flag == 1){
+                if(Dlist_flag == 1 || Llist_flag == 1)
+                {
                     L_sec[j] = L_sec[j-1];
                 }
 
                 j--;
-            }else{
+            }
+            else
+            {
                 break;
             }
@@ -1854 +1806 @@
         L[j] = temp_form;
 
-        if(Dlist_flag == 1 || Llist_flag == 1){
+        if(Dlist_flag == 1 || Llist_flag == 1)
+        {
             L_sec[j] = temp_form_sec;
         }
@@ -1860 +1813 @@
 
     // For double list - return a double list
-    if(Dlist_flag == 1){
+    if(Dlist_flag == 1)
+    {
         return(list(L,L_sec));
     }
 
     // For list of lists - return a list of lists
-    if(Llist_flag == 1){
+    if(Llist_flag == 1)
+    {
         L_temp = list();
-        for(i = 1; i <= n; i++){
+        for(i = 1; i <= n; i++)
+        {
             L_temp[i] = list(L[i],L_sec[i]);
         }
@@ -1873 +1829 @@
         return(L_temp);
     }
-
     return(L);
-
 }
 example
@@ -1918 +1872 @@
 
 
-////////////////////////////////////////////////////////////////////////////////////////////////
-//------------ Procedures for computing with universal derivation and differential -----------//
-////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+//---- Procedures for computing with universal derivation and differential ---//
+////////////////////////////////////////////////////////////////////////////////
 
 
@@ -1930 +1884 @@
 EXAMPLE:    example difformUnivDer; shows an example"
 {
-
-    diffAlgebraCheck();
-
-        difform df = 0;
+    difform df = 0;
     difform d_var;
-        int n = size(ringlist(basering)[2]);
-        int i;
-
-        // Build the image under the universal derivation
-        for(i = 1; i <= n; i++){
+    int n = size(ringlist(basering)[2]);
+    int i;
+
+    // Build the image under the universal derivation
+    for(i = 1; i <= n; i++)
+    {
         execute("d_var = d" + string(var(i)));
                 df = df + diff(f,var(i))*d_var;
-        }
-
-        return(df);
-
+    }
+    return(df);
 }
 example
@@ -1965 +1915 @@
 
 
-////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 
 
@@ -1980 +1930 @@
 EXAMPLE:    example difformDiff; shows an example"
 {
-
-    diffAlgebraCheck();
-
     difform d_df = 0;
     list df_gen_repr = difformCoef(df);
@@ -1989 +1936 @@
 
     // Derivate each coefficient
-    for(i = 1; i <= n; i++){
+    for(i = 1; i <= n; i++)
+    {
         d_df = d_df + difformUnivDer(df_gen_repr[i][2])*df_gen_repr[i][1];
     }
-
     return(d_df);
-
 }
 example
@@ -2025 +1971 @@
 
 
-////////////////////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////////////////////
-//                               Procedures for type derivation                               //
-////////////////////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////////////////////
-
-
-////////////////////////////////////////////////////////////////////////////////////////////////
-//----------------------------------- Structural procedures ----------------------------------//
-////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+//                      Procedures for type derivation                        //
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+
+////////////////////////////////////////////////////////////////////////////////
+//-------------------------- Structural procedures ---------------------------//
+////////////////////////////////////////////////////////////////////////////////
 
 
@@ -2051 +1997 @@
 EXAMPLE:    example derivationFromList; shows an example"
 {
-
-    diffAlgebraCheck();
-
     // Check the structure of the given list
     derivationCheckList(L);
@@ -2062 +2005 @@
     derivation phi;
     phi.genIm = L;
-
     return(phi);
-
 }
 example
@@ -2095 +2036 @@
 
 
-////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 
 
@@ -2111 +2052 @@
 SEE ALSO:   derivationFromList, difformIsGen, difformListCont"
 {
-
-    if(size(L) != 2){
+    if(size(L) != 2)
+    {
         ERROR("Given list has wrong size!");
     }
-
-    if(typeof(L[1]) != "list" || typeof(L[2]) != "list"){
+    if(typeof(L[1]) != "list" || typeof(L[2]) != "list")
+    {
         ERROR("Given list does not contain lists!");
     }
-
-    if(size(L[1]) != size(L[2])){
+    if(size(L[1]) != size(L[2]))
+    {
         ERROR("Given list does not have the right form!");
     }
@@ -2128 +2069 @@
 
     // Need an image for any generator
-    if(n != size(ringlist(basering)[2])){
+    if(n != size(ringlist(basering)[2]))
+    {
         ERROR("Given list has wrong size!");
     }
 
-    for(i = 1; i <= n; i++){
+    for(i = 1; i <= n; i++)
+    {
         // Right type needed
-        if(typeof(L[1][i]) != "difform" || (typeof(L[2][i]) != "poly" && typeof(L[2][i]) != "int" && typeof(L[2][i]) != "number")){
+        if(typeof(L[1][i]) != "difform" || (typeof(L[2][i]) != "poly" && typeof(L[2][i]) != "int" && typeof(L[2][i]) != "number"))
+        {
             ERROR("Given list contains wrong type!");
         }
 
         // Generator of Omega_R^1
-        if(!(difformIsGen(L[1][i]) && deg(L[1][i]) == 1)){
+        if(!(difformIsGen(L[1][i]) && deg(L[1][i]) == 1))
+        {
             ERROR("Given list contains a non-generator or a generator not of degree 1!");
         }
@@ -2146 +2091 @@
     // Now check the list L[1] for duplicates of the generators
     list L_i;
-    for(i = 1; i <= n; i++){
+    for(i = 1; i <= n; i++)
+    {
         L_i = delete(L[1],i);
-        if(difformListCont(L_i,L[1][i])){
+        if(difformListCont(L_i,L[1][i]))
+        {
             ERROR("Given list contains duplicate of a generator!");
         }
@@ -2155 +2102 @@
 
 
-////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 
 
@@ -2167 +2114 @@
 EXAMPLE:    example derivationFromPoly; shows an example"
 {
-
-    diffAlgebraCheck();
-
     list L;
     // First entry of list are the degree-1 generators
@@ -2179 +2123 @@
     int n = size(L[1]);
     int i;
-    for(i = 1; i <= n; i++){
+    for(i = 1; i <= n; i++)
+    {
         L[2][i] = f;
     }
@@ -2187 +2132 @@
     phi.genIm = L;
     return(phi);
-
 }
 example
@@ -2206 +2150 @@
 
 
-////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 
 
@@ -2220 +2164 @@
 EXAMPLE:    example derivationConstructor; shows an example"
 {
-
-    if(typeof(inp) == "list"){
+    if(typeof(inp) == "list")
+    {
         derivation der_cons = derivationFromList(inp);
         return(der_cons);
     }
-    if(typeof(inp) == "poly" || typeof(inp) == "number" || typeof(inp) == "int" || typeof(inp) == "bigint"){
+    if(typeof(inp) == "poly" || typeof(inp) == "number" || typeof(inp) == "int" || typeof(inp) == "bigint")
+    {
         derivation der_cons = derivationFromPoly(inp);
         return(der_cons);
@@ -2266 +2211 @@
 EXAMPLE:    example derivationToString; shows an example"
 {
-
-    diffAlgebraCheck();
     list temp_genIm = phi.genIm;
 
@@ -2275 +2218 @@
     int i;
 
-    for(i = 1; i <= n; i++){
-        if(typeof(#[i]) == "string"){
-            if(#[i] == "gen" && typeof(#[i+1]) == "string"){
+    for(i = 1; i <= n; i++)
+    {
+        if(typeof(#[i]) == "string")
+        {
+            if(#[i] == "gen" && typeof(#[i+1]) == "string")
+            {
                 gen_ord = #[i+1];
-                if(typeof(#[i+2]) == "intvec"){
+                if(typeof(#[i+2]) == "intvec")
+                {
                     intvec gen_weight = #[i+2];
                 }
@@ -2287 +2234 @@
 
     // Sort the generator/coefficients by the chosen ordering
-    if(gen_ord != ""){
-        if(defined(gen_weight)){
+    if(gen_ord != "")
+    {
+        if(defined(gen_weight))
+        {
             temp_genIm = difformListSort(temp_genIm,"Dlist","gen",gen_ord,gen_weight);
-        }else{
+        }
+        else
+        {
             temp_genIm = difformListSort(temp_genIm,"Dlist","gen",gen_ord);
         }
@@ -2304 +2255 @@
     int ring_name_size = size(ring_name);
 
-    for(i = 1; i <= n; i++){
+    for(i = 1; i <= n; i++)
+    {
         phi_out = phi_out + tab(6 + ring_name_size) + difformGenToString(gens[i]) + " |--> " + string(images[i]) + newline;
     }
 
     return(phi_out);
-
 }
 example
@@ -2336 +2287 @@
 
 
-////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 
 
@@ -2347 +2298 @@
 EXAMPLE:        example derivationPrint; shows an example"
 {
-
     // Orders the generators in ls-order
     print(derivationToString(phi,"gen","ls"));
-
 }
 example
@@ -2377 +2326 @@
 
 
-////////////////////////////////////////////////////////////////////////////////////////////////
-//------------------------------ Basic computational procedures ------------------------------//
-////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+//-------------------- Basic computational procedures ------------------------//
+////////////////////////////////////////////////////////////////////////////////
 
 
@@ -2392 +2341 @@
 EXAMPLE:    example derivationAdd; shows an example"
 {
-
-    diffAlgebraCheck();
-
     // Structure for derivation
     derivation add_der;
@@ -2405 +2351 @@
     int i;
 
-    for(i = 1; i <= n; i++){
+    for(i = 1; i <= n; i++)
+    {
         // Lists are sorted the same way
         add_list[2][i] = phi.genIm[2][i] + psi.genIm[2][i];
@@ -2413 +2360 @@
     add_der.genIm = add_list;
     return(add_der);
-
 }
 example
@@ -2443 +2389 @@
 
 
-////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 
 
@@ -2456 +2402 @@
 EXAMPLE:    example derivationSub; shows an example"
 {
-
-    diffAlgebraCheck();
-
     // Structure for derivation
     derivation sub_der;
@@ -2469 +2412 @@
     int i;
 
-    for(i = 1; i <= n; i++){
+    for(i = 1; i <= n; i++)
+    {
         // Lists are sorted the same way
         sub_list[2][i] = phi.genIm[2][i] - psi.genIm[2][i];
@@ -2477 +2421 @@
     sub_der.genIm = sub_list;
     return(sub_der);
-
 }
 example
@@ -2507 +2450 @@
 
 
-////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 
 
@@ -2517 +2460 @@
 EXAMPLE:    example derivationNeg; shows an example"
 {
-
-    diffAlgebraCheck();
-
     // Structure for derivation
     derivation neg_der;
@@ -2530 +2470 @@
     int i;
 
-    for(i = 1; i <= n; i++){
+    for(i = 1; i <= n; i++)
+    {
         neg_list[2][i] = -phi.genIm[2][i];
     }
@@ -2537 +2478 @@
     neg_der.genIm = neg_list;
     return(neg_der);
-
 }
 example
@@ -2566 +2506 @@
 
 
-////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 
 
@@ -2578 +2518 @@
 EXAMPLE:    derivationMul; shows an example"
 {
-
-    diffAlgebraCheck();
-
     // Structure for derivation
     derivation mul_der;
@@ -2591 +2528 @@
     int i;
 
-    for(i = 1; i <= n; i++){
+    for(i = 1; i <= n; i++)
+    {
         // Lists are sorted the same way
         mul_list[2][i] = phi.genIm[2][i]*psi.genIm[2][i];
@@ -2599 +2537 @@
     mul_der.genIm = mul_list;
     return(mul_der);
-
 }
 example
@@ -2629 +2566 @@
 
 
-////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 
 
@@ -2642 +2579 @@
 EXAMPLE:    example derivationEqu; shows an example"
 {
-
-    diffAlgebraCheck();
-
     int n = size(phi.genIm[1]);
     int i;
 
-    for(i = 1; i <= n; i++){
+    for(i = 1; i <= n; i++)
+    {
         // Lists are sorted the same way
-        if(phi.genIm[2][i] != psi.genIm[2][i]){
+        if(phi.genIm[2][i] != psi.genIm[2][i])
+        {
             // Different images
             return(0);
@@ -2658 +2594 @@
     // Images are the same
     return(1);
-
 }
 example
@@ -2687 +2622 @@
 
 
-////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 
 
@@ -2699 +2634 @@
 EXAMPLE:    example derivationNeq; shows an example"
 {
-
     return(!derivationEqu(phi,psi));
-
 }
 example
@@ -2730 +2663 @@
 
 
-////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 
 
@@ -2747 +2680 @@
 EXAMPLE:    example derivationEval; shows an example"
 {
-
-    diffAlgebraCheck();
-
-    if(!homog(df)){
+    if(!homog(df))
+    {
         ERROR("Cannot apply derivation to non-homogeneous element!");
     }
 
-    if(deg(df) != 1 && deg(df) != -1){
+    if(deg(df) != 1 && deg(df) != -1)
+    {
         ERROR("Cannot apply derivation to differential form not of degree 1!");
     }
@@ -2765 +2697 @@
     int j = 1;
 
-    for(i = 1; i <= n; i++){
+    for(i = 1; i <= n; i++)
+    {
         // Both lists are sorted by the monomial ordering on the differential algebra
         // So the generators are sorted the same way in both lists
         // If given df does not involve all generators avoid gaps using j
-        if(j <= k){
-            if(df_gen_repr[j][1] == phi.genIm[1][i]){
+        if(j <= k)
+        {
+            if(df_gen_repr[j][1] == phi.genIm[1][i])
+            {
                 df_eval = df_eval + df_gen_repr[j][2]*phi.genIm[2][i];
                 j++;
@@ -2776 +2711 @@
         }
     }
-
     return(df_eval);
-
 }
 example
@@ -2819 +2752 @@
 
 
-////////////////////////////////////////////////////////////////////////////////////////////////
-//----------------------- Procedures for computing the Lie-Derivative ------------------------//
-////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+//------------ Procedures for computing the Lie-Derivative -------------------//
+////////////////////////////////////////////////////////////////////////////////
 
 
@@ -2834 +2767 @@
 SEE ALSO:   derivationContraction"
 {
-
     // Sort the list, that dx_1 is the first form, dx_2 the second,...
     list gen_list = phi.genIm[1];
@@ -2845 +2777 @@
 
     // Go through all degree-1 generators and test if, dx_i occurs in d_gen
-    for(i = 1; i <= n; i++){
-        if(d_gen / gen_list[i] != 0){
+    for(i = 1; i <= n; i++)
+    {
+        if(d_gen / gen_list[i] != 0)
+        {
             applic = applic + ((-1)^(j+1))*derivationEval(phi,gen_list[i])*(d_gen/gen_list[i]);
             j++;
@@ -2855 +2789 @@
 
 
-////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 
 
@@ -2869 +2803 @@
 EXAMPLE:    example derivationContraction; shows an example"
 {
-
-    diffAlgebraCheck();
-
     list coef_list = difformCoef(df);
     int k = size(coef_list);
@@ -2878 +2809 @@
 
     // Apply the contraction map to the generators since it is linear
-    for(i = 1; i <= k; i++){
+    for(i = 1; i <= k; i++)
+    {
         applic = applic + coef_list[i][2]*derivationContractionGen(phi,coef_list[i][1]);
     }
-
     return(applic);
-
 }
 example
@@ -2917 +2847 @@
 
 
-////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 
 
@@ -2930 +2860 @@
 EXAMPLE:    example derivationLie; shows an example"
 {
-
     difform lie_form = derivationContraction(phi,difformDiff(df)) + difformDiff(derivationContraction(phi,df));
     return(lie_form);
-
 }
 example
@@ -2969 +2897 @@
 
 
-////////////////////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////////////////////
-
-
-////////////////////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////////////////////
-//                                       Test examples                                        //
-////////////////////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+//                             Test examples                                  //
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 
 
 // EXAMPLE: differential algebra over ring of characteristic 0
-proc diffAlgebra_example_1(){
+proc diffAlgebra_example_1()
+{
     ring R = 0,(x,y,z),dp;
     diffAlgebra();
-
     exportto(Top,R);
 }
 
 
-////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 
 
 // EXAMPLE: differential algebra over big ring of characteristic 0 and block ordering
-proc diffAlgebra_example_2(){
+proc diffAlgebra_example_2()
+{
     ring R = 0,(a,b,x,y,z,t,s,e,r,w,i),(ls(3),dp(4),lp);
     diffAlgebra();
-
     exportto(Top,R);
 }
 
 
-////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 
 
 // EXAMPLE: differential algebra over ring of positive characteristic
-proc diffAlgebra_example_3(){
+proc diffAlgebra_example_3()
+{
     ring R = 31,(a,b,x),dp;
     diffAlgebra();
-
     exportto(Top,R);
 }
 
 
-////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 
 
 // EXAMPLE: differential algebra over quotient ring
-proc diffAlgebra_example_4(){
+proc diffAlgebra_example_4()
+{
     ring S = 0,(x,y,z),lp;
     ideal I = x2-y4,xyz;
     qring R = std(I);
     diffAlgebra();
-
     exportto(Top,R);
 }
 
 
-////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 
 
 // EXAMPLE: differential form over ring of characteristic 0
-proc difform_example_1(){
+proc difform_example_1()
+{
     ring R = 0,(x,y,z),ds;
     diffAlgebra();
@@ -3042 +2971 @@
 
 
-////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 
 
 // EXAMPLE: differential form over ring of positive characteristic
-proc difform_example_2(){
+proc difform_example_2()
+{
     ring R = 31,(x,y,z,a,b,c),lp;
     diffAlgebra();
@@ -3057 +2987 @@
 
 
-////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 
 
 // EXAMPLE: derivation by list
-proc derivation_example_1(){
+proc derivation_example_1()
+{
     ring R = 0,(x,y,z),lp;
     diffAlgebra();
@@ -3076 +3007 @@
 
 
-////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 
 
 // EXAMPLE: derivation by list
-proc derivation_example_2(){
+proc derivation_example_2()
+{
     ring R = 0,(a,b,c,x,y,z),lp;
     diffAlgebra();
@@ -3094 +3026 @@
 
 
-////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 
 
 // EXAMPLE: derivations by list
-proc derivation_example_3(){
+proc derivation_example_3()
+{
     ring R = 0,(x,y,z),dp;
     diffAlgebra();
@@ -3121 +3054 @@
 }
 
-