#### D.2.4.12 envelop

Procedure from library `grobcov.lib` (see grobcov_lib).

Usage:
  envelop(poly F,ideal C[,options]);
  poly F must represent the family of hyper-surfaces for which on want to compute its envelop. ideal C must be
  the ideal of restrictions on the variables defining the family, and should contain less polynomials than the
  number of variables. (x_1,..,x_n) are the variables of the hyper-surfaces of F, that are considered as
  parameters of the parametric ring. (u_1,..,u_m) are
  the parameteres of the hyper-surfaces, that are
  considered as variables of the parametric ring.
  In the actual version, parametric envelope are accepted. To include fixed parameters a1,..ap, to the problem, one must declare them as the first parameters of the ring. if the the number of free parameters is p, the option "numpar",p is required.
  Calling sequence:
  ring R=(0,a1,..,ap,x_1,..,x_n),(u_1,..,u_m),lp;
  poly F=F(a1,..ap,x_1,..,x_n,u_1,..,u_m);
  ideal C=g_1(a1,..,ap,u_1,..u_m),..,g_s(a1,..ap,u_1,..u_m); envelop(F,C[,options]); where s<m.
  x1,..,xn are the tracer variables.
  u_1,..,u_m are the auxiliary variables.
  a1,..,ap are the fixed parameters if they exist
  If the problem is a parametric envelope, and a's exist, then the option "numpar",p m must be given.
  By default the las n variables are the mover variables. See the EXAMPLE of parametric envelop by calling
  example envelop,

Return:
  The output is a list of the components [C_1, .. , C_n] of the locus. Each component is given by
  Ci=[pi,[pi1,..pi_s_i],tax] where
  pi,[pi1,..pi_s_i] is the canonical P-representation of the component.
  Concerning tax: (see help for locus)
  For normal-point components is
  tax=[d,taxonomy,anti-image], being
  d=dimension of the anti-image
  taxonomy="Normal" or "Special"
  anti-image=values of the mover corresponding
  to the component
  For non-normal-point components is
  tax=[d,taxonomy]
  d=dimension of the component
  taxonomy="Accumulation" or "Degenerate".

Options:
  An option is a pair of arguments: string, integer.
  To modify the default options,
  pairs of arguments -option name, value- of valid options must be added to the call.

  The algorithm allows the following options as pair of arguments: "comments", c: by default it is 0, but it can be set to 1. "anti-image", a: by default a=1 and the anti-image is shown also for "Normal" components.
  For a=0, it is not shown.
  "moverdim", k: by default it is equal to n, the number of x-tracer variables.
  "numpar",p when fixed parameters are included

Note:
  grobcov and locus are called internally.
  The basering R, must be of the form Q[a,x][u]
  (x=variables, u=auxiliary variables), (a fixed parameters). This routine uses the generalized definition of envelop introduced in the book
  A. Montes. "The Groebner Cover" (Discussing Parametric
  Polynomial Systems) not yet published.

Example:

    LIB "grobcov.lib";
    "EAXMPLE:";
    ==> EAXMPLE:
    // EXAMPLE 1
    // Steiner Deltoid
    // 1. Consider the circle x1^2+y1^2-1=0, and a mover point M(x1,y1) on it.
    // 2. Consider the triangle A(0,1), B(-1,0), C(1,0).
    // 3. Consider lines passing through M perpendicular to two sides of ABC triangle.
    // 4. Determine the envelope of the lines above.
    if(defined(R)){kill R;}
    ring R=(0,x,y),(x1,y1,x2,y2),lp;
    short=0;
    ideal C=(x1)^2+(y1)^2-1,
    x2+y2-1,
    x2-y2-x1+y1;
    matrix M[3][3]=x,y,1,x2,y2,1,x1,0,1;
    poly F=det(M);
    // The lines of family F are
    F;
    ==> -x1*y2+(y)*x1+(-y)*x2+(x)*y2
    // The conditions C are
    C;
    ==> C[1]=x1^2+y1^2-1
    ==> C[2]=x2+y2-1
    ==> C[3]=-x1+y1+x2-y2
    envelop(F,C);
    ==> [1]:
    ==>    [1]:
    ==>       _[1]=(x^4+2*x^2*y^2+10*x^2*y-x^2+y^4-6*y^3+12*y^2-8*y)
    ==>    [2]:
    ==>       [1]:
    ==>          _[1]=1
    ==>    [3]:
    ==>       [1]:
    ==>          1
    ==>       [2]:
    ==>          Normal
    ==>       [3]:
    ==>          _[1]=x2+y2-1
    ==> [2]:
    ==>    [1]:
    ==>       _[1]=(x+y-1)
    ==>    [2]:
    ==>       [1]:
    ==>          _[1]=1
    ==>    [3]:
    ==>       [1]:
    ==>          0
    ==>       [2]:
    ==>          Special
    ==>       [3]:
    ==>          _[1]=4*y2^4-4*y2^3-y2^2
    ==>          _[2]=x2+y2-1
    // EXAMPLE 2
    // Parametric envelope
    // Let c be the circle centered at the origin O(0,0) and having radius 1.
    // M(x1,y1) be a mover point gliding on c.
    // Let A(a0,b0) be a parametric fixed point:
    // Consider the set of lines parallel to the line AO passing thoug M.
    // Determine the envelope of these lines
    // We let the fixed point A coordinates as free parameters of the envelope.
    // We have to declare the existence of two parameters when
    // defining the ring in which we call envelop,
    // and set a0,b0 as the first variables of the parametric ring
    // The ring is thus
    if(defined(R1)){kill R1;}
    ring R1=(0,a0,b0,x,y),(x1,y1),lp;
    short=0;
    // The lines are  F1
    poly F1=b0*(x-x1)-a0*(y-y1);
    // and the mover is on the circle c
    ideal C1=x1^2+y1^2-1;
    // The call is thus
    def E1=envelop(F1,C1,"numpar",2);
    E1;
    ==> [1]:
    ==>    [1]:
    ==>       _[1]=(a0^2*y^2-a0^2-2*a0*b0*x*y+b0^2*x^2-b0^2)
    ==>    [2]:
    ==>       [1]:
    ==>          _[1]=(x^2+y^2)
    ==>          _[2]=(a0*y-b0*x)
    ==>          _[3]=(a0*x+b0*y)
    ==>          _[4]=(a0^2+b0^2)
    ==>       [2]:
    ==>          _[1]=(b0)
    ==>          _[2]=(a0)
    ==>    [3]:
    ==>       [1]:
    ==>          0
    ==>       [2]:
    ==>          Special
    ==>       [3]:
    ==>          _[1]=(a0^2+b0^2)*y1^2+(-a0^2)
    ==>          _[2]=(a0)*x1+(b0)*y1
    ==> [2]:
    ==>    [1]:
    ==>       _[1]=(b0)
    ==>       _[2]=(a0)
    ==>    [2]:
    ==>       [1]:
    ==>          _[1]=1
    ==>    [3]:
    ==>       [1]:
    ==>          -1
    ==>       [2]:
    ==>          Accumulation
    // The interesting first component  EC1 is
    def EC1=E1[1][1][1];
    EC1;
    ==> (a0^2*y^2-a0^2-2*a0*b0*x*y+b0^2*x^2-b0^2)
    // that is equivalent to  (a0*y-b0*x)^2-a0^2-b0^2.
    // As expected it consists of the two lines
    //    a0*y-b0*x - sqrt(a0^2+b0^2),
    //    a0*y-b0*x + sqrt(a0^2+b0^2),
    // parallel to the line OM passing at the
    // points of the circle in the line perpendicular to OA.
    // EXAMPLE 3
    // Parametric envelope
    // Let c be the circle centered at the origin O(a1,b1) and having radiusr,
    // where a1,b1,r are fixed parameters
    // M(x1,y1) be a mover point gliding on c.
    // Let A(a0,b0) be a parametric fixed point:
    // Consider the set of lines parallel to the line AO passing thoug M.
    // Determine the envelope of these lines
    // We let the fixed point A,point M and r as free parameters of the envelope.
    // We have to declare the existence of 5 parameters when
    // defining the ring in which we call envelop,
    // and set a0,b0,a1,b1,r as the first variables of the parametric ring
    // The ring is thus
    if(defined(R1)){kill R1;}
    ring R1=(0,a0,b0,a1,b1,r,x,y),(x1,y1),lp;
    short=0;
    // The lines are  F1
    poly F1=b0*(x-x1)-a0*(y-y1);
    // and the mover is on the circle c
    ideal C1=(x1-a1)^2+(y1-b1)^2-r^2;
    // The call is thus
    def E1=envelop(F1,C1,"numpar",5);
    E1;
    ==> [1]:
    ==>    [1]:
    ==>       _[1]=(a0^2*b1^2-2*a0^2*b1*y-a0^2*r^2+a0^2*y^2-2*a0*b0*a1*b1+2*a0*b0\
       *a1*y+2*a0*b0*b1*x-2*a0*b0*x*y+b0^2*a1^2-2*b0^2*a1*x-b0^2*r^2+b0^2*x^2)
    ==>    [2]:
    ==>       [1]:
    ==>          _[1]=(a1^2-2*a1*x+b1^2-2*b1*y+x^2+y^2)
    ==>          _[2]=(a0*b1-a0*y-b0*a1+b0*x)
    ==>          _[3]=(a0*a1-a0*x+b0*b1-b0*y)
    ==>          _[4]=(a0^2+b0^2)
    ==>       [2]:
    ==>          _[1]=(b0)
    ==>          _[2]=(a0)
    ==>    [3]:
    ==>       [1]:
    ==>          0
    ==>       [2]:
    ==>          Special
    ==>       [3]:
    ==>          _[1]=(a0^2+b0^2)*y1^2+(-2*a0^2*b1-2*b0^2*b1)*y1+(a0^2*b1^2-a0^2*\
       r^2+b0^2*b1^2)
    ==>          _[2]=(a0)*x1+(b0)*y1+(-a0*a1-b0*b1)
    ==> [2]:
    ==>    [1]:
    ==>       _[1]=(b0)
    ==>       _[2]=(a0)
    ==>    [2]:
    ==>       [1]:
    ==>          _[1]=1
    ==>    [3]:
    ==>       [1]:
    ==>          -1
    ==>       [2]:
    ==>          Accumulation
    ==> [3]:
    ==>    [1]:
    ==>       _[1]=(r)
    ==>       _[2]=(a1^2-2*a1*x+b1^2-2*b1*y+x^2+y^2)
    ==>       _[3]=(a0*b1-a0*y-b0*a1+b0*x)
    ==>       _[4]=(a0*a1-a0*x+b0*b1-b0*y)
    ==>       _[5]=(a0^2+b0^2)
    ==>    [2]:
    ==>       [1]:
    ==>          _[1]=1
    ==>    [3]:
    ==>       [1]:
    ==>          -1
    ==>       [2]:
    ==>          Accumulation
    // The interesting first component  EC1 is
    def EC1=E1[1][1][1];
    EC1;
    ==> (a0^2*b1^2-2*a0^2*b1*y-a0^2*r^2+a0^2*y^2-2*a0*b0*a1*b1+2*a0*b0*a1*y+2*a0*\
       b0*b1*x-2*a0*b0*x*y+b0^2*a1^2-2*b0^2*a1*x-b0^2*r^2+b0^2*x^2)
    // which corresponds to the product of two lines
    // parallel to the line AM and intercepting the circle
    // on the intersection of the line perpendicuar
    // to line AM passing through A

User manual for Singular version 4.4.1, 2025, generated by texi2html.