Singular Manual: num_radical_via_decom

| #### D.8.7.11 num_radical_via_decom Procedure from library `recover.lib` (see recover_lib). Usage: num_radical_via_decom(I,D); ideal I, int D D a bound to the degree of the elements of the components. Return: ideal: the radical of I Remarks: Uses Bertini. This procedure merely calls num_prime_decom with the same input and then intersects the returned components. Note: Should only be called from a ring over the rational numbers. Example:
    LIB "recover.lib";
    //First, we attempt to compute the radical via the hybrid algorithm.
    ring R=0,(x,y,z),dp;
    ideal I=(x+y)^2*(y+2z)^3, (x+y)^3*(x-3z)^2;
    int D=2;
    int Prec=300;
    ideal numRad=num_radical_via_decom(I,D,Prec);
    ==>
    ==>    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: 1.280000000000e+02, DegreeBound: 5.000000000000e+00
    ==> AMPSafetyDigits1: 1, AMPSafetyDigits2: 1, AMPMaxPrec: 1024
    ==>
    ==>
    ==> Tracking regeneration codim 1 of 2: 5 paths to track.
    ==> Tracking path 0 of 5
    ==> Tracking path 1 of 5
    ==> Tracking path 2 of 5
    ==> Tracking path 3 of 5
    ==> Tracking path 4 of 5
    ==>
    ==> Sorting codimension 1 of 2: 5 paths to sort.
    ==> Sorting 0 of 5
    ==> Sorting 1 of 5
    ==> Sorting 2 of 5
    ==> Sorting 3 of 5
    ==> Sorting 4 of 5
    ==>
    ==> Preparing regeneration codim 2 of 2: 12 witness points to move.
    ==> Moving 0 of 12
    ==> Moving 1 of 12
    ==> Moving 2 of 12
    ==> Moving 3 of 12
    ==> Moving 4 of 12
    ==> Moving 5 of 12
    ==> Moving 6 of 12
    ==> Moving 7 of 12
    ==> Moving 8 of 12
    ==> Moving 9 of 12
    ==> Moving 10 of 12
    ==> Moving 11 of 12
    ==>
    ==> Tracking regeneration codim 2 of 2: 15 paths to track.
    ==> Tracking path 0 of 15
    ==> Tracking path 1 of 15
    ==> Tracking path 2 of 15
    ==> Tracking path 3 of 15
    ==> Tracking path 4 of 15
    ==> Tracking path 5 of 15
    ==> Tracking path 6 of 15
    ==> Tracking path 7 of 15
    ==> Tracking path 8 of 15
    ==> Tracking path 9 of 15
    ==> Tracking path 10 of 15
    ==> Tracking path 11 of 15
    ==> Tracking path 12 of 15
    ==> Tracking path 13 of 15
    ==> Tracking path 14 of 15
    ==>
    ==> Sorting codimension 2 of 2: 15 paths to sort.
    ==> Sorting 0 of 15
    ==> Sorting 1 of 15
    ==> Sorting 2 of 15
    ==> Sorting 3 of 15
    ==> Sorting 4 of 15
    ==> Sorting 5 of 15
    ==> Sorting 6 of 15
    ==> Sorting 7 of 15
    ==> Sorting 8 of 15
    ==> Sorting 9 of 15
    ==> Sorting 10 of 15
    ==> Sorting 11 of 15
    ==> Sorting 12 of 15
    ==> Sorting 13 of 15
    ==> Sorting 14 of 15
    ==>
    ==>
    ==> ************ 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   |   5       |   2            |  0          |  2       |  3         \
       |   0           |  0
    ==> | 2   |   15      |   15           |  0          |  15      |  0         \
       |   0           |  0
    ==> ----------------------------------------------------------------------------------------------------------------
    ==> |total|   20
    ==>
    ==> ****************************************************
    ==>
    ==>
    ==> Removing junk points from codimension 2: 2 endpoints to check.
    ==> Checking 0 of 2
    ==> Checking 1 of 2
    ==>
    ==>
    ==> *************** Witness Set Summary ****************
    ==>
    ==> NOTE: nonsingular vs singular is based on rank deficiency and identical e\
       ndpoints
    ==>
    ==> |codim| witness points | nonsingular | singular
    ==> -------------------------------------------------
    ==> | 1   |   1            |  0          |  1
    ==> | 2   |   1            |  0          |  1
    ==> -------------------------------------------------
    ==>
    ==> ****************************************************
    ==>
    ==>
    ==> Calculating traces for codimension 1.
    ==> Calculating 0 of 1
    ==>
    ==> Using combinatorial trace test to decompose codimension 1.
    ==>
    ==> Calculating traces for codimension 2.
    ==> Calculating 0 of 1
    ==>
    ==>
    ==> ************* Witness Set Decomposition *************
    ==>
    ==> | dimension | components | classified | unclassified
    ==> -----------------------------------------------------
    ==> |   1       |   0        |   0        |  1
    ==> |   0       |   1        |   1        |  0
    ==> -----------------------------------------------------
    ==>
    ==> ************** Decomposition by Degree **************
    ==>
    ==> Dimension 0: 1 classified component
    ==> -----------------------------------------------------
    ==>    degree 1: 1 component
    ==>
    ==> *****************************************************
    ==>
    ==> Witness Points Deflated: 2
    ==> 0
    numRad;
    ==> numRad[1]=1
    //Then we compute the radical symbolically and compare the results.
    ideal Rad=radical(I);
    Rad;
    ==> Rad[1]=xy+y2+2xz+2yz
    ==> Rad[2]=x2-y2-5xz-5yz
    reduce(Rad,std(numRad));
    ==> _[1]=0
    ==> _[2]=0
    reduce(numRad,std(Rad));
    ==> _[1]=1
See also: num_prime_decom; num_radical_via_randlincom.

User manual for Singular version 4.3.1p1, 2022, generated by texi2html.