#### D.2.4.10 locus

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

Usage:
  locus(ideal F [,options])
  Special routine for determining the locus of points of a geometrical construction.

Input:
  The input ideal must be the ideal of the set equations defining the locus, defined in the ring
  ring Q(0,a1,..,ap,x1,..xn)(u1,..um,v1,..vn),lp;
  Calling sequence:
  locus(F [,options]);
  a=fixed parameters,x=tracer variables, u=auxiliary variables, v=mover variables. The parameters a are optative. If they are used, then the option "numpar\=,np must be declared, being np the number of fixed parameters. The tracer variables are x1,..xn, where n is the dimension of the space. By default, the mover variables are the last n variables. Its number can be forced by the user to the last
  k variables by adding the option "moverdim",k.
  Nevertheless, this option is recommended only
  to experiment, and can provide incorrect taxonomies.
  The remaining variables are auxiliary.

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:

  "numpar", np in order to consider the first np parameters of the ring to be fixed parameters of the locus, being the tracer variables the remaining parameters.
  To be used for a parametric locus. (New in release N12).

  "moverdim", k to force the mover-variables to be the last k variables. This determines the antiimage and its dimension. By defaulat k is equal to the last n variables,
  We can experiment with a different value,
  but this can produce an error in the character
  "Normal" or "Special" of a locus component.

  "grobcov", G, where G is the list of a previous computed grobcov(F). It is to be used when we modify externally the grobcov, for example to obtain the real grobcov.

  "comments", c: by default it is 0, but it can be set to 1.

Return:
  The output is a list of the components:
  ((p1,(p11,..p1s_1),tax_1), .., (pk,(pk1,..pks_k),tax_k) Elements 1 and 2 of a component represent the
  P-canonical form of the component.
  The third element tax is:
  for normal point components,
  tax=(d,taxonomy,anti-image) being
  d=dimension of the anti-image on the mover variables, taxonomy="Normal" or "Special" and
  anti-image=ideal of the anti-image over the mover
  variables.
  for non-normal point components,
  tax =(d,taxonomy) being
  d=dimension of the component and
  taxonomy="Accumulation" or "Degenerate".
  The components are given in canonical P-representation. The normal locus has two kind of components:
  Normal and Special.
  Normal component:
  - each point in the component has 0-dimensional
  anti-image.
  - the anti-image in the mover coordinates is equal
  to the dimension of the component
  Special component:
  - each point in the component has 0-dimensional
  anti-image.
  - the anti-image in the mover coordinates has dimension smaller than the dimension of the component
  The non-normal locus has two kind of components:
  Accumulation and Degenerate.
  Accumulation component:
  - each point in the component has anti-image of
  dimension greater than 0.
  - the component has dimension less than n-1.
  Degenerate components:
  - each point in the component has anti-image
  of dimension greater than 0.
  - the component has dimension n-1.
  When a normal point component has degree greater than 9, then the taxonomy is not determined, and (n,'normal', 0) is returned as third element of the component. (n is the dimension of the tracer space).

  Given a parametric ideal F representing the system F
  determining the locus of points (x) which verify certain properties, the call to locus(F) determines the different classes of locus components, following the taxonomy
  defined in the book:
  A. Montes. "The Groebner Cover"
  A previous paper gives particular definitions
  for loci in 2d.
  M. Abanades, F. Botana, A. Montes, T. Recio,
  "An Algebraic Taxonomy for Locus Computation
  in Dynamic Geometry",
  Computer-Aided Design 56 (2014) 22-33.

Note:
  The input must be the locus system.

Example:

    LIB "grobcov.lib";
    // EXAMPLE 1
    // Conchoid, Pascal's Limacon.
    //  1. Given a circle: x1^2+y1^2-4
    //  2. and a mover point M(x1,y1) on it
    //  3. Consider the fix point P(0,2) on the circle
    //  4. Consider the line l passing through M and P
    //  5. The tracer T(x,y) are the points on l at fixed distance 1 to M.
    if(defined(R)){kill R;}
    ring R=(0,x,y),(x1,y1),dp;
    short=0;
    // Concoid
    ideal S96=x1 ^2+y1 ^2-4,(x-2)*x1 -x*y1 +2*x,(x-x1 )^2+(y-y1 )^2-1;
    locus(S96);
    ==> [1]:
    ==>    [1]:
    ==>       _[1]=(x^4+2*x^3+x^2*y^2-3*x^2-2*x*y^2-8*x*y-6*x+2*y^2+8*y+6)
    ==>    [2]:
    ==>       [1]:
    ==>          _[1]=(y^2+2*y+2)
    ==>          _[2]=(x-y-2)
    ==>    [3]:
    ==>       [1]:
    ==>          1
    ==>       [2]:
    ==>          Normal
    ==>       [3]:
    ==>          _[1]=x1^2+y1^2-4
    ==> [2]:
    ==>    [1]:
    ==>       _[1]=(x^2+y^2-4*y+3)
    ==>    [2]:
    ==>       [1]:
    ==>          _[1]=1
    ==>    [3]:
    ==>       [1]:
    ==>          0
    ==>       [2]:
    ==>          Special
    ==>       [3]:
    ==>          _[1]=65*y1^5-86*y1^4-180*y1^3+120*y1^2+256*y1-256
    ==>          _[2]=-2015*y1^4+5916*y1^3+5700*y1^2+9216*x1-14400*y1-9088
    // EXAMPLE 2
    // Consider two parallel planes z1=-1 and z1=1, and two orthogonal parabolas on them.
    // Determine the locus generated by the lines that rely the two parabolas
    // through the points having parallel tangent vectors.
    if(defined(R)){kill R;}
    ring R=(0,x,y,z),(x2,y2,z2,z1,y1,x1,lam), lp;
    short=0;
    ideal L=z1+1,
    x1^2-y1,
    z2-1,
    y2^2-x2,
    4*x1*y2-1,
    x-x1-lam*(x2-x1),
    y-y1-lam*(y2-y1),
    z-z1-lam*(z2-z1);
    locus(L);  // uses "moverdim",3
    ==> [1]:
    ==>    [1]:
    ==>       _[1]=(2048*x^3*z+2048*x^3-4096*x^2*y^2+1152*x*y*z^2-1152*x*y-2048*y\
       ^3*z+2048*y^3+27*z^4-54*z^2+27)
    ==>    [2]:
    ==>       [1]:
    ==>          _[1]=(z+1)
    ==>          _[2]=(y)
    ==>       [2]:
    ==>          _[1]=(z-1)
    ==>          _[2]=(x)
    ==>    [3]:
    ==>       [1]:
    ==>          2
    ==>       [2]:
    ==>          Normal
    ==>       [3]:
    ==>          _[1]=y1-x1^2
    // Observe the choose of the mover variables: the last 3 variables y1,x1,lam
    // If we choose x1,y1,z1 instead, the taxonomy becomes "Special" because
    // z1=-1 is fix and do not really correspond to the mover variables.
    // EXAMPLE 3 of parametric locus:
    // Determining the equation of a general ellipse;
    // Uncentered elipse;
    // Parameters  (a,b,a0,b0,p):
    //   a=large semiaxis, b=small semiaxis,
    //   (a0,b0) = center of the ellipse,
    //   (a1,b1) and (2*a0-a1,2*b0-b1) the focus,
    //   p the slope of the line of the a-axis of the ellipse.
    // Determine the equation of the ellipse.
    // We must use the option "numpar",5 in order to consider
    // the first 5 parameters as free parameters for the locus
    // Auxiliary variabes:
    //  d1=distance from focus (a1,b1) to the mover point M(x1,y1),
    //  d2=distance from focus (a2,b2) to the mover point M(x1,y1),
    //  f=focus distance= distance from (a0,b0) to (a1,b1).
    // Mover point (x1,y1) = tracer point (x,y).
    if(defined(R1)){kill R1;}
    ring R1=(0,a,b,a0,b0,p,x,y),(d1,d2,f,a1,b1,x1,y1),lp;
    ideal F3=b1-b0-p*(a1-a0),
    //b2-b0+p*(a1-a0),
    //a1+a2-2*a0,
    //b1+b2-2*b0,
    f^2-(a1-a0)^2-(b1-b0)^2,
    f^2-a^2-b^2,
    (x1-a1)^2+(y1-b1)^2-d1^2,
    (x1-2*a0+a1)^2+(y1-2*b0+b1)^2-d2^2,
    d1+d2-2*a,
    x-x1,
    y-y1;
    def G3=grobcov(F3);
    def Loc3=locus(F3,"grobcov",G3,"numpar",5); Loc3;
    ==> [1]:
    ==>    [1]:
    ==>       _[1]=(a^2*b^2*p^2+a^2*b^2+a^2*a0^2*p^2-2*a^2*a0*b0*p-2*a^2*a0*p^2*x\
       +2*a^2*a0*p*y+a^2*b0^2+2*a^2*b0*p*x-2*a^2*b0*y+a^2*p^2*x^2-2*a^2*p*x*y+a^\
       2*y^2-b^2*a0^2-2*b^2*a0*b0*p+2*b^2*a0*p*y+2*b^2*a0*x-b^2*b0^2*p^2+2*b^2*b\
       0*p^2*y+2*b^2*b0*p*x-b^2*p^2*y^2-2*b^2*p*x*y-b^2*x^2)
    ==>    [2]:
    ==>       [1]:
    ==>          _[1]=(p^2+1)
    ==>          _[2]=(a0+b0*p-p*y-x)
    ==>    [3]:
    ==>       [1]:
    ==>          1
    ==>       [2]:
    ==>          Normal
    ==>       [3]:
    ==>          _[1]=(a^2*p^2-b^2)*x1^2+(-2*a^2*p-2*b^2*p)*x1*y1+(-2*a^2*a0*p^2+\
       2*a^2*b0*p+2*b^2*a0+2*b^2*b0*p)*x1+(a^2-b^2*p^2)*y1^2+(2*a^2*a0*p-2*a^2*b\
       0+2*b^2*a0*p+2*b^2*b0*p^2)*y1+(a^2*b^2*p^2+a^2*b^2+a^2*a0^2*p^2-2*a^2*a0*\
       b0*p+a^2*b0^2-b^2*a0^2-2*b^2*a0*b0*p-b^2*b0^2*p^2)
    ==> [2]:
    ==>    [1]:
    ==>       _[1]=(p^2+1)
    ==>       _[2]=(a0+b0*p-p*y-x)
    ==>       _[3]=(b)
    ==>       _[4]=(a)
    ==>    [2]:
    ==>       [1]:
    ==>          _[1]=1
    ==>    [3]:
    ==>       [1]:
    ==>          -1
    ==>       [2]:
    ==>          Accumulation
    // General ellipse:
    def C=Loc3[1][1][1];
    C;
    ==> (a^2*b^2*p^2+a^2*b^2+a^2*a0^2*p^2-2*a^2*a0*b0*p-2*a^2*a0*p^2*x+2*a^2*a0*p\
       *y+a^2*b0^2+2*a^2*b0*p*x-2*a^2*b0*y+a^2*p^2*x^2-2*a^2*p*x*y+a^2*y^2-b^2*a\
       0^2-2*b^2*a0*b0*p+2*b^2*a0*p*y+2*b^2*a0*x-b^2*b0^2*p^2+2*b^2*b0*p^2*y+2*b\
       ^2*b0*p*x-b^2*p^2*y^2-2*b^2*p*x*y-b^2*x^2)
    // Centered ellipse of semiaxes (a,b):
    def C0=subst(C,a0,0,b0,0,p,0);
    C0;
    ==> (a^2*b^2+a^2*y^2-b^2*x^2)

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