RegularChains[AlgebraicGeometryTools]
IntersectionMultiplicity
compute the intersection multiplicity at a point or regular chain
Calling Sequence
Parameters
Returns
Assumptions
Options
Description
Examples
References
Compatibility
IntersectionMultiplicity(P, F, V, options)
IntersectionMultiplicity(P, rc1, R, options)
IntersectionMultiplicity(rc2, F, R, options)
P
-
list of algebraic numbers; the point
F
list of polynomials with algebraic number coefficients in variables V
V
list of names; the variables
rc1,rc2
regular chains of dimension zero
R
polynomial ring of characteristic zero
options
sequence of optional equations of the form keyword=value, where keyword is maxdepth, maxshift, or method
The calling sequence IntersectionMultiplicity(P, F, V) returns either the intersection multiplicity of F at P as a nonnegative integer, or FAIL if the algorithm cannot determine the intersection multiplicity.
The calling sequence IntersectionMultiplicity(P, rc1, R) returns the intersection multiplicity of the regular chain rc1 at P.
The calling sequence IntersectionMultiplicity(rc2, F, R) returns a list of pairs, m,t, such that m is either the intersection multiplicity of all points in the vanishing set of the regular chain t, or m=FAIL. Moreover, the regular chains, t, contained in the output list, form a triangular decomposition of the zero set of rc2.
The system is square. That is, when the first argument is a point and the second is a list, #F=#V=#P is required. When the second argument is a regular chain, P must have as many elements as there are variables in R. When the first argument is a regular chain, F must have as many equations as there are variables in R.
For the calling sequence IntersectionMultiplicity(P, F, V) it is assumed F is a regular sequence in the local ring at P.
For the calling sequence IntersectionMultiplicity(rc2, F, R) it is assumed F is a regular sequence in the local ring at all points encoded by rc2.
The local ring at a point P is the set of all polynomial fractions defined at P.
Let f1,…,fd be elements in the local ring at some point P. We say f1,…,fd is a regular sequence in the local ring at P, or a regular sequence for short, when no fi is zero or a zero-divisor modulo the ideal generated by any subset of the remaining elements of f1,…,fd. Moreover, we require f1,…,fd generates a proper ideal in the local ring at P.
When the elements of F do not generate a proper ideal, i.e. the ideal generated contains 1, the intersection multiplicity is trivially zero. Hence, the assumption that F is a regular sequence is only required when the intersection multiplicity at P is positive.
The behavior of IntersectionMultiplicity differs depending on whether it is used to compute the intersection multiplicity at a point or a regular chain. The different optional arguments reflect this change in behavior.
For the calling sequence where the second argument is a regular chain, all optional arguments are ignored.
method : either fulton, tangentcone, or hybrid (default); specifies the method used to compute intersection multiplicities. This option is ignored when the first argument is a point.
When the first argument is a regular chain, IntersectionMultiplicity calls up to two partial algorithms. Each of these algorithms can be accessed individually using the keyword method, in which case IntersectionMultiplicity would invoke only the algorithm corresponding to the value of the keyword method.
The first partial algorithm, described in [3], uses a generalization of Fulton's bivariate intersection multiplicity algorithm to more than 2 variables. This algorithm is also the one used by IntersectionMultiplicity when the first argument is a point. When the first argument is a regular chain this algorithm can be invoked directly by specifying method=fulton.
The second partial algorithm, described in [1,2], uses a criterion based on tangent cones to reduce to Fulton's bivariate intersection multiplicity algorithm. This algorithm can be invoked directly using method=tangentcone. Additionally, when method=tangentcone is given and the algorithm does not succeed in computing the intersection multiplicity at every point in rc2, an error is returned rather then a list of pairs.
When method=hybrid, IntersectionMultiplicity first calls the algorithm described in [3], and if it did not succeed in computing the intersection multiplicity at every point in rc2, the algorithm described in [1,2] will be called as well. If neither algorithm succeeds in computing the intersection multiplicity at every point in rc2, the output of the first algorithm is returned, namely, a list of pairs (which may contain FAIL).
For strict backwards compatibility with Maple versions 2021 and earlier, method=tangentcone can be used.
maxshift : nonnegative integer; maximum number of variable reorderings to be applied
The algorithm described in [3] and its generalization for regular chains assign an arbitrary variable ordering to the input. This can be changed manually by giving the variables in V or R in a different order. When this occurs, the corresponding point or regular chain must also be reordered accordingly.
It is possible the algorithm described in [3] fails for one ordering but succeeds for another. Moreover, it is impractical to try all possible variable orderings. Upon detecting a failure, IntersectionMultiplicity will apply a left, circular shift to the variables, when written in decreasing order, up to maxshift many times. The user can also reorder variables manually to work past a failure.
When the first argument is a point, maxshift is set to 1 by default. When the first argument is a regular chain, maxshift is set to 0 as default.
maxdepth : nonnegative integer,pos_infinity; the maximum number of recursive calls
When F is not a regular sequence, IntersectionMultiplicity may not always terminate. In this case the maxdepth option can be used to control the maximum allowable amount of recursive calls made by IntersectionMultiplicity.
The default value of maxdepth is proportional to the number of variables times the product of the total degree of all polynomials in F. When the number of recursive calls made exceeds maxdepth it is likely that F is not a regular sequence, and hence an error is returned.
When this error occurs there are several ways to proceed. This error suggests it is likely F is not a regular sequence, and hence this constraint should be checked. Alternatively, if F is believed to be a regular sequence, one could try increasing the value of maxdepth.
Setting maxdepth=infinity disables this option, removing the limit on the number of allowable recursive calls. This may be desirable for long computations. When maxdepth is set to ∞, or when maxdepth is much lower than the stacklimit kernel option, an error may occur if the number of recursive calls made exceeds the stacklimit. In this case, if kernelopts(stacklimit) is less than the hard limit set by Maple, one can try increasing kernelopts(stacklimit).
To check whether F is a regular sequence in the local ring at P, compute the primary decomposition of each fi in F and remove any primary components which do not vanish on P. If any two fi share a primary component through P, F is not a regular sequence in the local ring at P.
When the first argument is a regular chain, this must be repeated for each point encoded in the regular chain.
Both the maxdepth and maxshift options are ignored when method=tangentcone is specified.
The IntersectionMultiplicity command computes the intersection multiplicity of a system of equations at a point or at a group of points encoded by a zero-dimensional regular chain. See the references for a formal definition of the intersection multiplicity.
Unless #F=2 or the second argument is a regular chain, the underlying algorithms to the IntersectionMultiplicity command may fail, in which case FAIL is returned.
This command is part of the RegularChains[AlgebraicGeometryTools] package, so it can be used in the form IntersectionMultiplicity(..) only after executing the command with(RegularChains[AlgebraicGeometryTools]). However, it can always be accessed through the long form of the command by using RegularChains[AlgebraicGeometryTools][IntersectionMultiplicity](..).
with⁡RegularChains:with⁡ChainTools:with⁡AlgebraicGeometryTools:
V≔x,y,z,w:
P≔0,0,0,0:
Compute the intersection multiplicity of four polynomials in four variables at the origin.
IntersectionMultiplicity⁡P,1,y,z,w,V
0
IntersectionMultiplicity⁡P,x,y,z,w,V
1
IntersectionMultiplicity⁡P,x2,y,z3,w,V
6
IntersectionMultiplicity⁡P,z⁢y2,y5−z2,x5−y2,w,V
45
IntersectionMultiplicity⁡P,x⁢y−z,x2⁢y3−z,x4−y,w2,V
10
IntersectionMultiplicity⁡P,y2,y3+x,y5+z,y5+w,V
2
IntersectionMultiplicity⁡P,x3,−x2+y2,z4−w⁢y,w2,V
48
The point at which we compute the intersection multiplicity need not be the origin.
Q≔1,2,−1,3:
IntersectionMultiplicity⁡Q,x−13,y−22−x−16,z+14−x−1,w−3,V
24
When the first argument is a point, we can also use algebraic number coefficients and coordinates, specified by RootOfs.
alias⁡α=RootOf⁡u2+2:
P≔α,0,α,0
F≔x−α⁢y−z−α,x−α2⁢y3−z−α,x−α4−y,w2
F≔x−α⁢y−z+α,x−α2⁢y3−z+α,x−α4−y,w2
IntersectionMultiplicity⁡P,F,V
When the intersection multiplicity is non-zero, it is required that F forms a regular sequence in the local ring R at P for the algorithm to succeed. When a non-regular sequence is detected, an error will be thrown.
F≔x,y,z,0:
G≔x,16⁢w,z,12⁢w2:
H≔x⁢y+z,2⁢w2,y2+z,x⁢y2:
Error, (in RegularChains:-AlgebraicGeometryTools:-IntersectionMultiplicity) input is not a regular sequence
IntersectionMultiplicity⁡P,G,V
IntersectionMultiplicity⁡P,H,V
The IntersectionMultiplicity command cannot always detect non-regular sequences. Often, a non-regular sequence which is not detected will lead to excessive recursive calls. When this is so, the IntersectionMultiplicity command will return an error which warns the input received may not be a regular sequence.
This bound on the recursive calls can be controlled by the maxdepth option. The default for maxdepth is proportional to the both the number of variables and total degrees of the input polynomials. Moreover, the default is set quite high to mitigate the risk of this warning being given when the input is indeed a regular sequence.
F≔x2⁢x+1:
G≔y⁢y+1:
H≔x⁢z+1−y2⁢x+1−y2⁢z3⁢y+1:
IntersectionMultiplicity⁡0,0,−1,F,G,H,x,y,z,maxdepth=100
Error, (in RegularChains:-AlgebraicGeometryTools:-IntersectionMultiplicity) maximum recursion depth reached; try using the maxdepth option. See ?IntersectionMultiplicity for details
When this error occurs it is likely the input is not a regular sequence. This can be checked by using primary decomposition and considering only those components in the maximal ideal of the local ring.
with⁡PolynomialIdeals:
Q≔PrimaryDecomposition⁡F,G
Q≔y,x2,x2⁢x+1,y⁢y+1,x2,x2⁢x+1,y⁢y+1,y+1,y,x2⁢x+1,y⁢y+1,x+1,x2⁢x+1,y⁢y+1,x+1,y+1
Q≔select⁡IdealContainment,Q,x,y,z+1
Q≔y,x2,x2⁢x+1,y⁢y+1
RadicalMembership⁡H,Q
true
Here we can see that H is contained in a prime component of the ideal generated by F and G in the local ring at P, which proves that F,G,H is not a regular sequence.
Sometimes, it may be desirable to disable the maxdepth option by setting maxdepth=infinity. In this case, it is possible that IntersectionMultiplicity exceeds the maximum amount of recursive calls set by kernelopts(stacklimit). In some cases, it can therefore help to increase kernelopts(stacklimit) to avoid this error.
kernelopts⁡stacklimit=50000:
F≔x14,x24−x1,x34−x2,x44−x3,x54−x4,x64−x5,x74−x6:
P≔0,0,0,0,0,0,0:
V≔x1,x2,x3,x4,x5,x6,x7:
IntersectionMultiplicity⁡P,F,V,maxdepth=∞
kernelopts⁡stacklimit=100000:
16384
The underlying algorithm used to compute intersection multiplicities is a partial algorithm, and hence, may not always succeed. In such a case, FAIL is returned to indicate the procedure was not successful. See the references for more details.
IntersectionMultiplicity⁡P,y⁢z−w,z3−w,y4−z,x,V
FAIL
Often, reordering the variables can help to work around a failure. This can be done manually by changing the order of variables in V or by using the maxshift option. Note in this case P is the origin so we do not need to reorder P.
IntersectionMultiplicity⁡P,y⁢z−w,z3−w,y4−z,x,w,x,y,z
5
Setting maxshift=2 is equivalent to calling IntersectionMultiplicity with V≔x,y,z,w, then V≔y,z,w,x, then V≔z,w,x,y, where V≔z,w,x,y is the ordering which succeeds.
IntersectionMultiplicity⁡P,y⁢z−w,z3−w,y4−z,x,V,maxshift=2
When the system of polynomials is in fact given by a regular chain, the intersection multiplicity can always be computed.
P≔0,0,0
R≔PolynomialRing⁡x,y,z:
rc≔Chain⁡z5,y3+z⁢y2,x2+x⁢y4+y⁢z,R:
IntersectionMultiplicity⁡P,rc,R
30
IntersectionMultiplicity can also be used to compute the intersection multiplicity at a group of points encoded by a zero-dimensional regular chain.
When the regular chain, rc, encodes just one point, the IntersectionMultiplicity command behaves analogously to when the first argument is a point. Here rc encodes just the origin.
R≔PolynomialRing⁡x,y,z,w:
rc≔Chain⁡w,z,y,x,R:
out≔IntersectionMultiplicity⁡rc,x,y,z,1,R
out≔0,regular_chain
Display⁡out,R
0,x=0y=0z=0w=0
out≔IntersectionMultiplicity⁡rc,x,y,z,w,R
out≔1,regular_chain
1,x=0y=0z=0w=0
out≔IntersectionMultiplicity⁡rc,x2,y3,z4,w,R
out≔24,regular_chain
24,x=0y=0z=0w=0
out≔IntersectionMultiplicity⁡rc,x3,−x2+y2,z4−w⁢y,w2,R
out≔48,regular_chain
48,x=0y=0z=0w=0
out≔IntersectionMultiplicity⁡rc,z⁢y2,y5−z2,x5−y2,w,R
out≔45,regular_chain
45,x=0y=0z=0w=0
out≔IntersectionMultiplicity⁡rc,x⁢y−z,x2⁢y3−z,x4−y,w2,R
out≔10,regular_chain
10,x=0y=0z=0w=0
Often, a regular chain will encode several points with different intersection multiplicities, in which case several regular chains, and the intersection multiplicity corresponding to every point encoded in each regular chain, will be returned.
rc≔Chain⁡z2+2⁢z−1⁢z,y−z⁢y,x−z,R:
F≔x2+y+z−1⁢z,x⁢y2+x+z−1,z2+x+y−1⁢y3:
dec≔IntersectionMultiplicity⁡rc,F,R
dec≔0,regular_chain,1,regular_chain,3,regular_chain
Display⁡dec,R
0,x−z=0y=0z2+2⁢z−1=0,1,x−z=0y−z=0z2+2⁢z−1=0,3,x=0y=0z=0
Here, calling IntersectionMultiplicity returns 3 regular chains, encoding 5 points, and the intersection multiplicity corresponding to all points in encoded in each regular chain. The first regular chain encodes the points −1+2,0,−1+2 and −1−2,0,−1−2, which both have intersection multiplicity 0. The second regular chain encodes the points −1+2,−1+2,−1+2 and −1−2,−1−2,−1−2 which have intersection multiplicity 1. Finally, the origin, encoded by the last regular chain, has intersection multiplicity 3.
When the first argument is a regular chain, the method option can be used to control which partial algorithm IntersectionMultiplicity should invoke.
Here the algorithm described in [3] succeeds whereas the criterion described in [1,2] does not apply.
rc≔Chain⁡z,y,x,R:
out≔IntersectionMultiplicity⁡rc,z⁢y2,y5−z2,x5−y2,R,method=fulton
45,x=0y=0z=0
Similarly, the algorithm described in [1,2] can be used to compute some examples the algorithm described in [3] cannot. Here, the algorithm described in [3] fails for the given variable ordering but the algorithm described in [1,2] succeeds.
rc≔Chain⁡z−10,y,x,R:
F≔−3⁢y4⁢z3+6⁢x4⁢z2−3⁢x2⁢y2⁢z2−x2⁢z2+2⁢y2⁢z2+28⁢x2⁢z+7⁢y2⁢z+z2−11⁢z+10,x3⁢z+x⁢y2⁢z−x⁢z+x,−2⁢x2⁢y⁢z−y3⁢z−y⁢z+10⁢y:
IntersectionMultiplicity⁡rc,F,R,method=fulton
FAIL,regular_chain
IntersectionMultiplicity⁡rc,F,R,method=tangentcone
3,regular_chain
As was the case previously, the underlying algorithm used to compute intersection multiplicities is a partial algorithm, and hence, may not always succeed. When method=hybrid or method=fulton is given, a failure in the branch denoted by the regular chain t, will be represented by the pair FAIL,t in the output list.
Here we see a failure occur in the regular chain encoding the origin.
rc≔Chain⁡w,z,y,x⁢x+1,R:
out≔IntersectionMultiplicity⁡rc,x⁢y−z,y3−z,x+1⁢x4−y,w,R,method=fulton
out≔1,regular_chain,FAIL,regular_chain
1,x+1=0y=0z=0w=0,FAIL,x=0y=0z=0w=0
When method=tangentcone, the algorithm will instead return an error when it cannot compute the intersection multiplicity of every point in the regular chain rc.
out≔IntersectionMultiplicity⁡rc,z⁢y2,y5−z2,x5−y2,R,method=tangentcone
Error, (in RegularChains:-AlgebraicGeometryTools:-IntersectionMultiplicity) h top is singular
[1] Steffen Marcus, Marc Moreno Maza, Paul Vrbik, On Fulton's Algorithm for Computing Intersection Multiplicities. Computer Algebra in Scientific Computing (CASC 2012), Lecture Notes in Computer Science 7442, (2012), 198-211.
[2] Parisa Alvandi, Marc Moreno Maza, Eric Schost, Paul Vrbik, A Standard Basis Free Algorithm for Computing the Tangent Cones of a Space Curve. Computer Algebra in Scientific Computing (CASC 2015), Lecture Notes in Computer Science 9301, (2015), 45-60.
[3] M. Moreno Maza and R. Sandford. Towards Extending Fulton's Intersection Multiplicity Algorithm Beyond the Bivariate Case. Computer Algebra in Scientific Computing (CASC 2021), Lecture Notes in Computer Science 12865, (2021), 232-251.
The method=tangentcone corresponds to the algorithm in Maple 2020 and 2021.
The RegularChains:-AlgebraicGeometryTools:-IntersectionMultiplicity command was introduced in Maple 2020.
For more information on Maple 2020 changes, see Updates in Maple 2020.
The RegularChains:-AlgebraicGeometryTools:-IntersectionMultiplicity command was updated in Maple 2022.
The P parameter was introduced in Maple 2022.
The method, maxshift and maxdepth options were introduced in Maple 2022.
For more information on Maple 2022 changes, see Updates in Maple 2022.
See Also
Display
PolynomialRing
RegularChains
Triangularize
Download Help Document