| #### D.8.7.13 num_radical1 Procedure from library `recover.lib` (see recover_lib). Usage: num_radical1(P,D,C); list P, int D, bigint C P a list of lists representing a witness point set representing an ideal I D should be a bound to the degree of the elements of the components C the number with which the images of the Veronese embeddings are multiplied Return: list of ideals: each of the ideals a prime component of the radical of I Remarks: This procedure merely calls num_prime_decom1 with the same input and then intersects the returned components. Note: Should only be called from a ring over the complex numbers. Example:
    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
See also: num_prime_decom1; num_radical2.

User manual for Singular version 4.4.0, 2024, generated by texi2html.