Ticket #391: badlib3.lib

version="$Id: buglib3.lib $";
category="General purpose";
info="
LIBRARY:  bugexample.lib   Shows bug with map declaration and example part


PROCEDURES: goodproc(f);  return f via identity map
            goodproc2(f); return f via identity map
            badproc(f);   return f via identity map

DESCRIPTION: Without an explicit 'def d = basering' inside the proc definition,
             the definition of a map may refer a wrong ring accesses wrong 
             objects. 
";
//////////////////////////////////////////////////////////////////////////////

proc badproc(poly f)
"USAGE:  badproc(f); f poly; 
RETURN:  poly, the input
EXAMPLE: example badproc; shows an example
"
{
   // def d = basering;   // this should not be required, but 
   //  due to a bug with map and the example part, it is necessary
   map phi;  
   poly g;
   phi = basering,maxideal(1);
   "hello";
   basering;
   listvar(); // This listvar is not excuted(?) without def d = basering above
   "-- end";
   g = phi(f);
   return(g);
} 
example
{ "EXAMPLE:"; echo = 2;

   ring r = 0,(x,y),dp;
   poly h = 2x3y4 + x5+ y3;
   listvar();
   badproc(h);
} 
///////////////////////////////////////////////////////////////////////////////

proc goodproc(poly f)
"USAGE:  goodproc(f); f poly; 
RETURN:  poly, the input
EXAMPLE: example goodproc; shows an example
"
{
   def d = basering;    // with this definition it is OK
   map phi;  
   poly g;
   phi = basering,maxideal(1);  // doesn't refer explicitely to d, but OK 
   "hello";
   basering;
   listvar();   // this listvar works here
   "-- end";
   g = phi(f);
   return(g);
} 
example
{ "EXAMPLE:"; echo = 2;

   ring r = 0,(x,y),dp;
   poly h = 2x3y4 + x5+ y3;
   listvar();
   goodproc(h);
}
///////////////////////////////////////////////////////////////////////////////

proc goodproc2(poly f)
"USAGE:  goodproc2(f); f poly; 
RETURN:  poly, the input
EXAMPLE: example goodproc2; shows an example
"
{
   def d = basering;   // with this definition it is OK
   map phi;  
   poly g;
   phi = d,maxideal(1); // refer to d 
   "hello";
   basering;
   listvar();   // this listvar works here
   "-- end";
   g = phi(f);
   return(g);
} 
example
{ "EXAMPLE:"; echo = 2;

   ring r = 0,(x,y),dp;
   poly h = 2x3y4 + x5+ y3;
   listvar();
   goodproc2(h);
}
///////////////////////////////////////////////////////////////////////////////

/*
 Extended description:

The procs goodproc, goodproc2, badproc do nothing else than to return
the input polynomial after having called the identity map via
  phi = basering,maxideal(1);

Suppose that there is ring defined with the same name as that defined in 
the example part.
Then the problem occurs that, when calling the example part, Singular
might access to the userdefined ring, but not to that of the example.

This, see proc badproc, has the following effect: 
   1.) Either example stops with an ERROR since outside there is no object
       with that name as in the example, or
   2.) it choose the object from the userdefined ring, in case an object
       equally named as in the *argumentlist* of the proc exists.

To avoid this side effect, see proc goodproc, one has to write explicitely 
     def d = basering; 
before defining the map. However the 'd' itself has not to be used in the 
definition of the map. I.e.
  map phi = basering,maxideal(1);
is enough, it is not necessary to write
  map phi = d,maxideal(1);


The example part contains:
   ring r = 0,(x,y),dp;
   poly h = 2x3y4 + x5+ y3;

and the argumentlist is (poly f).
*/

/*

// Input file badlib3.in
LIB "badlib3.lib";
basering;

example badproc;
example goodproc;

// Everything fine upto here.

// Now define a ring with the same name in the example.
ring r=0,(x,y,z),dp;
example goodproc;
// example goodproc;   // gives the same good result as goodproc
example badproc;       // ERROR - interrupt undefined object f (!?) 
                       // f is the name from  the argument list  !!


// Now if we define such a poly f: 
poly f = x2+y3+z4;     
example badproc;       // again ERROR, Singular accesses *this* poly f
                       // but uses the maxideal(1) from the twovariable ring
                       // as declared in the example!
//example goodproc;
//example goodproc2;
*/

/*
// Output file badlib3.out
> LIB"badlib3.lib";
// ** loaded badlib3.lib ($",?)
> basering;
   ? `basering` is undefined
   ? error occurred in or before STDIN line 2: `basering;`
> example badproc;
// proc badproc from lib badlib3.lib
EXAMPLE:

   ring r = 0,(x,y),dp;
   poly h = 2x3y4 + x5+ y3;
   listvar();
// r                    [1]  *ring
//      h                    [1]  poly
   badproc(h);
hello
//   characteristic : 0
//   number of vars : 2
//        block   1 : ordering dp
//                  : names    x y
//        block   2 : ordering C
-- end
2x3y4+x5+y3

> example goodproc;
// proc goodproc from lib badlib3.lib
EXAMPLE:

   ring r = 0,(x,y),dp;
   poly h = 2x3y4 + x5+ y3;
   listvar();
// r                    [1]  *ring
//      h                    [1]  poly
   goodproc(h);
hello
//   characteristic : 0
//   number of vars : 2
//        block   1 : ordering dp
//                  : names    x y
//        block   2 : ordering C
// d                    [2]  *ring
//      g                    [2]  poly
//      phi                  [2]  map from d
//      f                    [2]  poly
//      h                    [1]  poly
-- end
2x3y4+x5+y3

> ring r=0,(x,y,z),dp;
> example goodproc;
// proc goodproc from lib badlib3.lib
EXAMPLE:

   ring r = 0,(x,y),dp;
   poly h = 2x3y4 + x5+ y3;
   listvar();
// r                    [1]  *ring
//      h                    [1]  poly
// r                    [0]  ring
   goodproc(h);
hello
//   characteristic : 0
//   number of vars : 2
//        block   1 : ordering dp
//                  : names    x y
//        block   2 : ordering C
// d                    [2]  *ring
//      g                    [2]  poly
//      phi                  [2]  map from d
//      f                    [2]  poly
//      h                    [1]  poly
-- end
2x3y4+x5+y3

> example badproc;
// proc badproc from lib badlib3.lib
EXAMPLE:

   ring r = 0,(x,y),dp;
   poly h = 2x3y4 + x5+ y3;
   listvar();
// r                    [1]  *ring
//      h                    [1]  poly
// r                    [0]  ring
   badproc(h);
hello
//   characteristic : 0
//   number of vars : 2
//        block   1 : ordering dp
//                  : names    x y
//        block   2 : ordering C
-- end
   ? f undefined in r
   ? error occurred in or before badlib3.lib::badproc line 32: `   g = phi(f);`
   ? leaving badlib3.lib::badproc
   skipping text from `;` error at token `)`
   ? leaving badlib3.lib::badproc

> poly f = x2+z;
> example badproc;
// proc badproc from lib badlib3.lib
EXAMPLE:

   ring r = 0,(x,y),dp;
   poly h = 2x3y4 + x5+ y3;
   listvar();
// r                    [1]  *ring
//      h                    [1]  poly
// r                    [0]  ring
   badproc(h);
hello
//   characteristic : 0
//   number of vars : 2
//        block   1 : ordering dp
//                  : names    x y
//        block   2 : ordering C
-- end
x2


> example goodproc;
// proc goodproc from lib badlib3.lib
EXAMPLE:

   ring r = 0,(x,y),dp;
   poly h = 2x3y4 + x5+ y3;
   listvar();
// r                    [1]  *ring
//      h                    [1]  poly
// r                    [0]  ring
   goodproc(h);
hello
//   characteristic : 0
//   number of vars : 2
//        block   1 : ordering dp
//                  : names    x y
//        block   2 : ordering C
// d                    [2]  *ring
//      g                    [2]  poly
//      phi                  [2]  map from d
//      f                    [2]  poly
//      h                    [1]  poly
-- end
2x3y4+x5+y3


*/