Singular

LIB "recover.lib";
//First, we write the input file for bertini and compute the radical symbolically.
ring r=0,(x,y,z),dp;
ideal I=4xy2-4z3,-2x2y+5xz2;
ideal Rad=radical(I);
writeBertiniInput(I,100);
//Then we attempt to compute the radical via the hybrid algorithm.
ring R=(complex,100,i),(x,y,z),dp;
system("sh","bertini input");
==> 
==>    Bertini(TM) v1.6
==>     (May 22, 2018)
==> 
==>  D.J. Bates, J.D. Hauenstein,
==>  A.J. Sommese, C.W. Wampler
==> 
==> (using GMP v6.0.0, MPFR v3.1.2)
==> 
==> 
==> 
==> NOTE: You have requested to use adaptive path tracking.  Please make sure\
    that you have
==> setup the following tolerances appropriately:
==> CoeffBound: 8.000000000000e+00, DegreeBound: 3.000000000000e+00
==> AMPSafetyDigits1: 1, AMPSafetyDigits2: 1, AMPMaxPrec: 352
==> 
==> 
==> Tracking regeneration codim 1 of 2: 3 paths to track.
==> Tracking path 0 of 3
==> Tracking path 1 of 3
==> Tracking path 2 of 3
==> 
==> Sorting codimension 1 of 2: 3 paths to sort.
==> Sorting 0 of 3
==> Sorting 1 of 3
==> Sorting 2 of 3
==> 
==> Preparing regeneration codim 2 of 2: 6 witness points to move.
==> Moving 0 of 6
==> Moving 1 of 6
==> Moving 2 of 6
==> Moving 3 of 6
==> Moving 4 of 6
==> Moving 5 of 6
==> 
==> Tracking regeneration codim 2 of 2: 9 paths to track.
==> Tracking path 0 of 9
==> Tracking path 1 of 9
==> Tracking path 2 of 9
==> Tracking path 3 of 9
==> Tracking path 4 of 9
==> Tracking path 5 of 9
==> Tracking path 6 of 9
==> Tracking path 7 of 9
==> Tracking path 8 of 9
==> 
==> Sorting codimension 2 of 2: 9 paths to sort.
==> Sorting 0 of 9
==> Sorting 1 of 9
==> Sorting 2 of 9
==> Sorting 3 of 9
==> Sorting 4 of 9
==> Sorting 5 of 9
==> Sorting 6 of 9
==> Sorting 7 of 9
==> Sorting 8 of 9
==> 
==> 
==> ************ Regenerative Cascade Summary ************
==> 
==> NOTE: nonsingular vs singular is based on rank deficiency and identical e\
   ndpoints
==> 
==> |codim|   paths   |witness superset| nonsingular | singular |nonsolutions\
   | inf endpoints | other bad endpoints
==> ----------------------------------------------------------------------------------------------------------------
==> | 1   |   3       |   0            |  0          |  0       |  3         \
   |   0           |  0
==> | 2   |   9       |   9            |  1          |  8       |  0         \
   |   0           |  0
==> ----------------------------------------------------------------------------------------------------------------
==> |total|   12
==> 
==> ****************************************************
==> 
==> 
==> 
==> *************** Witness Set Summary ****************
==> 
==> NOTE: nonsingular vs singular is based on rank deficiency and identical e\
   ndpoints
==> 
==> |codim| witness points | nonsingular | singular 
==> -------------------------------------------------
==> | 2   |   3            |  1          |  2       
==> -------------------------------------------------
==> 
==> ****************************************************
==> 
==> 
==> Calculating traces for codimension 2.
==> Calculating 0 of 3
==> Calculating 1 of 3
==> Calculating 2 of 3
==> 
==> 
==> ************* Witness Set Decomposition *************
==> 
==> | dimension | components | classified | unclassified
==> -----------------------------------------------------
==> |   0       |   3        |   3        |  0
==> -----------------------------------------------------
==> 
==> ************** Decomposition by Degree **************
==> 
==> Dimension 0: 3 classified components
==> -----------------------------------------------------
==>    degree 1: 3 components
==> 
==> *****************************************************
==> 
==> Witness Points Deflated: 2
==> 0
list P=getWitnessSet();
int D=2;
bigint C=bigint(10)**30;
ideal Rad1=num_radical1(P,D,C);
//Lastly, we compare the results.
Rad1;
==> Rad1[1]=yz-0.4*z2
==> Rad1[2]=xz-6.25*z2
==> Rad1[3]=xy-2.5*z2
ideal Rad=fetch(r,Rad);
Rad;
==> Rad[1]=5*yz-2*z2
==> Rad[2]=4*xz-25*z2
==> Rad[3]=2*xy-5*z2
reduce(Rad,std(Rad1));
==> // ** groebner base computations with inexact coefficients can not be tru\
   sted due to rounding errors
==> _[1]=0
==> _[2]=0
==> _[3]=0
reduce(Rad1,std(Rad));
==> // ** groebner base computations with inexact coefficients can not be tru\
   sted due to rounding errors
==> _[1]=0
==> _[2]=0
==> _[3]=0