 IntersectionMultiplicity - Maple Help

RegularChains[AlgebraicGeometryTools]

 IntersectionMultiplicity
 compute the intersection multiplicity at a point or regular chain Calling Sequence IntersectionMultiplicity(P, F, V, options) IntersectionMultiplicity(P, rc1, R, options) IntersectionMultiplicity(rc2, F, R, options) Parameters

 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 Returns

 • The calling sequence IntersectionMultiplicity(P, F, V) returns either the intersection multiplicity of $F$ at $P$ as a nonnegative integer, or $\mathrm{FAIL}$ if the algorithm cannot determine the intersection multiplicity.
 • The calling sequence IntersectionMultiplicity(P, rc1, R) returns the intersection multiplicity of the regular chain $\mathrm{rc1}$ at $P$.
 • The calling sequence IntersectionMultiplicity(rc2, F, R) returns a list of pairs, $\left[m,t\right]$, such that $m$ is either the intersection multiplicity of all points in the vanishing set of the regular chain $t$, or $m=\mathrm{FAIL}$. Moreover, the regular chains, $t$, contained in the output list, form a triangular decomposition of the zero set of $\mathrm{rc2}$. Assumptions

 • 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 $\mathrm{rc2}$.
 • The local ring at a point $P$ is the set of all polynomial fractions defined at $P$.
 • Let ${f}_{1},\dots ,{f}_{d}$ be elements in the local ring at some point $P$. We say ${f}_{1},\dots ,{f}_{d}$ is a regular sequence in the local ring at $P$, or a regular sequence for short, when no ${f}_{i}$ is zero or a zero-divisor modulo the ideal generated by any subset of the remaining elements of ${f}_{1},\dots ,{f}_{d}$. Moreover, we require ${f}_{1},\dots ,{f}_{d}$ 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. Options

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 , 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 $\mathrm{rc2}$, an error is returned rather then a list of pairs.
 – When method=hybrid, IntersectionMultiplicity first calls the algorithm described in , and if it did not succeed in computing the intersection multiplicity at every point in $\mathrm{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 $\mathrm{rc2}$, the output of the first algorithm is returned, namely, a list of pairs (which may contain $\mathrm{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  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  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 $\mathrm{\infty }$, 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 ${f}_{i}$ in $F$ and remove any primary components which do not vanish on $P$. If any two ${f}_{i}$ 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. Description

 • 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 $\mathrm{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](..). Examples

 > $\mathrm{with}\left(\mathrm{RegularChains}\right):$$\mathrm{with}\left(\mathrm{ChainTools}\right):$$\mathrm{with}\left(\mathrm{AlgebraicGeometryTools}\right):$
 > $V≔\left[x,y,z,w\right]:$
 > $P≔\left[0,0,0,0\right]:$

Compute the intersection multiplicity of four polynomials in four variables at the origin.

 > $\mathrm{IntersectionMultiplicity}\left(P,\left[1,y,z,w\right],V\right)$
 ${0}$ (1)
 > $\mathrm{IntersectionMultiplicity}\left(P,\left[x,y,z,w\right],V\right)$
 ${1}$ (2)
 > $\mathrm{IntersectionMultiplicity}\left(P,\left[{x}^{2},y,{z}^{3},w\right],V\right)$
 ${6}$ (3)
 > $\mathrm{IntersectionMultiplicity}\left(P,\left[z{y}^{2},{y}^{5}-{z}^{2},{x}^{5}-{y}^{2},w\right],V\right)$
 ${45}$ (4)
 > $\mathrm{IntersectionMultiplicity}\left(P,\left[xy-z,{x}^{2}{y}^{3}-z,{x}^{4}-y,{w}^{2}\right],V\right)$
 ${10}$ (5)
 > $\mathrm{IntersectionMultiplicity}\left(P,\left[{y}^{2},{y}^{3}+x,{y}^{5}+z,{y}^{5}+w\right],V\right)$
 ${2}$ (6)
 > $\mathrm{IntersectionMultiplicity}\left(P,\left[{x}^{3},-{x}^{2}+{y}^{2},{z}^{4}-wy,{w}^{2}\right],V\right)$
 ${48}$ (7)

The point at which we compute the intersection multiplicity need not be the origin.

 > $Q≔\left[1,2,-1,3\right]:$
 > $\mathrm{IntersectionMultiplicity}\left(Q,\left[{\left(x-1\right)}^{3},{\left(y-2\right)}^{2}-{\left(x-1\right)}^{6},{\left(z+1\right)}^{4}-\left(x-1\right),w-3\right],V\right)$
 ${24}$ (8)

When the first argument is a point, we can also use algebraic number coefficients and coordinates, specified by RootOfs.

 > $\mathrm{alias}\left(\mathrm{α}=\mathrm{RootOf}\left({u}^{2}+2\right)\right):$
 > $P≔\left[\mathrm{α},0,\mathrm{α},0\right]$
 ${P}{≔}\left[{\mathrm{\alpha }}{,}{0}{,}{\mathrm{\alpha }}{,}{0}\right]$ (9)
 > $F≔\left[\left(x-\mathrm{α}\right)y-\left(z-\mathrm{α}\right),{\left(x-\mathrm{α}\right)}^{2}{y}^{3}-\left(z-\mathrm{α}\right),{\left(x-\mathrm{α}\right)}^{4}-y,{w}^{2}\right]$
 ${F}{≔}\left[\left({x}{-}{\mathrm{\alpha }}\right){}{y}{-}{z}{+}{\mathrm{\alpha }}{,}{\left({x}{-}{\mathrm{\alpha }}\right)}^{{2}}{}{{y}}^{{3}}{-}{z}{+}{\mathrm{\alpha }}{,}{\left({x}{-}{\mathrm{\alpha }}\right)}^{{4}}{-}{y}{,}{{w}}^{{2}}\right]$ (10)
 > $\mathrm{IntersectionMultiplicity}\left(P,F,V\right)$
 ${10}$ (11)

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.

 > $P≔\left[0,0,0,0\right]:$
 > $F≔\left[x,y,z,0\right]:$
 > $G≔\left[x,16w,z,12{w}^{2}\right]:$
 > $H≔\left[xy+z,2{w}^{2},{y}^{2}+z,x{y}^{2}\right]:$
 > $\mathrm{IntersectionMultiplicity}\left(P,F,V\right)$
 > $\mathrm{IntersectionMultiplicity}\left(P,G,V\right)$
 > $\mathrm{IntersectionMultiplicity}\left(P,H,V\right)$

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≔{x}^{2}\left(x+1\right):$
 > $G≔y\left(y+1\right):$
 > $H≔x\left(z+1\right)-{y}^{2}\left(x+1\right)-{y}^{2}{z}^{3}\left(y+1\right):$
 > $\mathrm{IntersectionMultiplicity}\left(\left[0,0,-1\right],\left[F,G,H\right],\left[x,y,z\right],\mathrm{maxdepth}=100\right)$

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.

 > $\mathrm{with}\left(\mathrm{PolynomialIdeals}\right):$
 > $Q≔\left[\mathrm{PrimaryDecomposition}\left(⟨F,G⟩\right)\right]$
 ${Q}{≔}\left[⟨{y}{,}{{x}}^{{2}}{,}{{x}}^{{2}}{}\left({x}{+}{1}\right){,}{y}{}\left({y}{+}{1}\right)⟩{,}⟨{{x}}^{{2}}{,}{{x}}^{{2}}{}\left({x}{+}{1}\right){,}{y}{}\left({y}{+}{1}\right){,}{y}{+}{1}⟩{,}⟨{y}{,}{{x}}^{{2}}{}\left({x}{+}{1}\right){,}{y}{}\left({y}{+}{1}\right){,}{x}{+}{1}⟩{,}⟨{{x}}^{{2}}{}\left({x}{+}{1}\right){,}{y}{}\left({y}{+}{1}\right){,}{x}{+}{1}{,}{y}{+}{1}⟩\right]$ (12)
 > $Q≔\mathrm{select}\left(\mathrm{IdealContainment},Q,⟨x,y,z+1⟩\right)$
 ${Q}{≔}\left[⟨{y}{,}{{x}}^{{2}}{,}{{x}}^{{2}}{}\left({x}{+}{1}\right){,}{y}{}\left({y}{+}{1}\right)⟩\right]$ (13)
 > $\mathrm{RadicalMembership}\left(H,{Q}_{[]}\right)$
 ${\mathrm{true}}$ (14)

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.

 > $\mathrm{kernelopts}\left(\mathrm{stacklimit}=50000\right):$
 > $F≔\left[{x}_{1}^{4},{x}_{2}^{4}-{x}_{1},{x}_{3}^{4}-{x}_{2},{x}_{4}^{4}-{x}_{3},{x}_{5}^{4}-{x}_{4},{x}_{6}^{4}-{x}_{5},{x}_{7}^{4}-{x}_{6}\right]:$
 > $P≔\left[0,0,0,0,0,0,0\right]:$
 > $V≔\left[{x}_{1},{x}_{2},{x}_{3},{x}_{4},{x}_{5},{x}_{6},{x}_{7}\right]:$
 > $\mathrm{IntersectionMultiplicity}\left(P,F,V,'\mathrm{maxdepth}'=\mathrm{∞}\right)$
 > $\mathrm{kernelopts}\left(\mathrm{stacklimit}=100000\right):$
 > $\mathrm{IntersectionMultiplicity}\left(P,F,V,\mathrm{maxdepth}=\mathrm{∞}\right)$
 ${16384}$ (15)

The underlying algorithm used to compute intersection multiplicities is a partial algorithm, and hence, may not always succeed. In such a case, $\mathrm{FAIL}$ is returned to indicate the procedure was not successful. See the references for more details.

 > $V≔\left[x,y,z,w\right]:$
 > $P≔\left[0,0,0,0\right]:$
 > $\mathrm{IntersectionMultiplicity}\left(P,\left[yz-w,{z}^{3}-w,{y}^{4}-z,x\right],V\right)$
 ${\mathrm{FAIL}}$ (16)

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$.

 > $\mathrm{IntersectionMultiplicity}\left(P,\left[yz-w,{z}^{3}-w,{y}^{4}-z,x\right],\left[w,x,y,z\right]\right)$
 ${5}$ (17)

Setting maxshift=2 is equivalent to calling IntersectionMultiplicity with $V≔\left[x,y,z,w\right]$, then $V≔\left[y,z,w,x\right]$, then $V≔\left[z,w,x,y\right]$, where $V≔\left[z,w,x,y\right]$ is the ordering which succeeds.

 > $\mathrm{IntersectionMultiplicity}\left(P,\left[yz-w,{z}^{3}-w,{y}^{4}-z,x\right],V,\mathrm{maxshift}=2\right)$
 ${5}$ (18)

When the system of polynomials is in fact given by a regular chain, the intersection multiplicity can always be computed.

 > $P≔\left[0,0,0\right]$
 ${P}{≔}\left[{0}{,}{0}{,}{0}\right]$ (19)
 > $R≔\mathrm{PolynomialRing}\left(\left[x,y,z\right]\right):$
 > $\mathrm{rc}≔\mathrm{Chain}\left(\left[{z}^{5},{y}^{3}+z{y}^{2},{x}^{2}+x{y}^{4}+yz\right],R\right):$
 > $\mathrm{IntersectionMultiplicity}\left(P,\mathrm{rc},R\right)$
 ${30}$ (20)

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, $\mathrm{rc}$, encodes just one point, the IntersectionMultiplicity command behaves analogously to when the first argument is a point. Here $\mathrm{rc}$ encodes just the origin.

 > $R≔\mathrm{PolynomialRing}\left(\left[x,y,z,w\right]\right):$
 > $\mathrm{rc}≔\mathrm{Chain}\left(\left[w,z,y,x\right],R\right):$
 > $\mathrm{out}≔\mathrm{IntersectionMultiplicity}\left(\mathrm{rc},\left[x,y,z,1\right],R\right)$
 ${\mathrm{out}}{≔}\left[\left[{0}{,}{\mathrm{regular_chain}}\right]\right]$ (21)
 > $\mathrm{Display}\left(\mathrm{out},R\right)$
 $\left[\left[{0}{,}\left\{\begin{array}{cc}{x}{=}{0}& {}\\ {y}{=}{0}& {}\\ {z}{=}{0}& {}\\ {w}{=}{0}& {}\end{array}\right\\right]\right]$ (22)
 > $\mathrm{out}≔\mathrm{IntersectionMultiplicity}\left(\mathrm{rc},\left[x,y,z,w\right],R\right)$
 ${\mathrm{out}}{≔}\left[\left[{1}{,}{\mathrm{regular_chain}}\right]\right]$ (23)
 > $\mathrm{Display}\left(\mathrm{out},R\right)$
 $\left[\left[{1}{,}\left\{\begin{array}{cc}{x}{=}{0}& {}\\ {y}{=}{0}& {}\\ {z}{=}{0}& {}\\ {w}{=}{0}& {}\end{array}\right\\right]\right]$ (24)
 > $\mathrm{out}≔\mathrm{IntersectionMultiplicity}\left(\mathrm{rc},\left[{x}^{2},{y}^{3},{z}^{4},w\right],R\right)$
 ${\mathrm{out}}{≔}\left[\left[{24}{,}{\mathrm{regular_chain}}\right]\right]$ (25)
 > $\mathrm{Display}\left(\mathrm{out},R\right)$
 $\left[\left[{24}{,}\left\{\begin{array}{cc}{x}{=}{0}& {}\\ {y}{=}{0}& {}\\ {z}{=}{0}& {}\\ {w}{=}{0}& {}\end{array}\right\\right]\right]$ (26)
 > $\mathrm{out}≔\mathrm{IntersectionMultiplicity}\left(\mathrm{rc},\left[{x}^{3},-{x}^{2}+{y}^{2},{z}^{4}-wy,{w}^{2}\right],R\right)$
 ${\mathrm{out}}{≔}\left[\left[{48}{,}{\mathrm{regular_chain}}\right]\right]$ (27)
 > $\mathrm{Display}\left(\mathrm{out},R\right)$
 $\left[\left[{48}{,}\left\{\begin{array}{cc}{x}{=}{0}& {}\\ {y}{=}{0}& {}\\ {z}{=}{0}& {}\\ {w}{=}{0}& {}\end{array}\right\\right]\right]$ (28)
 > $\mathrm{out}≔\mathrm{IntersectionMultiplicity}\left(\mathrm{rc},\left[z{y}^{2},{y}^{5}-{z}^{2},{x}^{5}-{y}^{2},w\right],R\right)$
 ${\mathrm{out}}{≔}\left[\left[{45}{,}{\mathrm{regular_chain}}\right]\right]$ (29)
 > $\mathrm{Display}\left(\mathrm{out},R\right)$
 $\left[\left[{45}{,}\left\{\begin{array}{cc}{x}{=}{0}& {}\\ {y}{=}{0}& {}\\ {z}{=}{0}& {}\\ {w}{=}{0}& {}\end{array}\right\\right]\right]$ (30)
 > $\mathrm{out}≔\mathrm{IntersectionMultiplicity}\left(\mathrm{rc},\left[xy-z,{x}^{2}{y}^{3}-z,{x}^{4}-y,{w}^{2}\right],R\right)$
 ${\mathrm{out}}{≔}\left[\left[{10}{,}{\mathrm{regular_chain}}\right]\right]$ (31)
 > $\mathrm{Display}\left(\mathrm{out},R\right)$
 $\left[\left[{10}{,}\left\{\begin{array}{cc}{x}{=}{0}& {}\\ {y}{=}{0}& {}\\ {z}{=}{0}& {}\\ {w}{=}{0}& {}\end{array}\right\\right]\right]$ (32)

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.

 > $R≔\mathrm{PolynomialRing}\left(\left[x,y,z\right]\right):$
 > $\mathrm{rc}≔\mathrm{Chain}\left(\left[\left({z}^{2}+2z-1\right)z,\left(y-z\right)y,x-z\right],R\right):$
 > $F≔\left[\left({x}^{2}+y+z-1\right)z,x\left({y}^{2}+x+z-1\right),\left({z}^{2}+x+y-1\right){y}^{3}\right]:$
 > $\mathrm{dec}≔\mathrm{IntersectionMultiplicity}\left(\mathrm{rc},F,R\right)$
 ${\mathrm{dec}}{≔}\left[\left[{0}{,}{\mathrm{regular_chain}}\right]{,}\left[{1}{,}{\mathrm{regular_chain}}\right]{,}\left[{3}{,}{\mathrm{regular_chain}}\right]\right]$ (33)
 > $\mathrm{Display}\left(\mathrm{dec},R\right)$
 $\left[\left[{0}{,}\left\{\begin{array}{cc}{x}{-}{z}{=}{0}& {}\\ {y}{=}{0}& {}\\ {{z}}^{{2}}{+}{2}{}{z}{-}{1}{=}{0}& {}\end{array}\right\\right]{,}\left[{1}{,}\left\{\begin{array}{cc}{x}{-}{z}{=}{0}& {}\\ {y}{-}{z}{=}{0}& {}\\ {{z}}^{{2}}{+}{2}{}{z}{-}{1}{=}{0}& {}\end{array}\right\\right]{,}\left[{3}{,}\left\{\begin{array}{cc}{x}{=}{0}& {}\\ {y}{=}{0}& {}\\ {z}{=}{0}& {}\end{array}\right\\right]\right]$ (34)

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  $\left(-1+\sqrt{2},0,-1+\sqrt{2}\right)$ and  $\left(-1-\sqrt{2},0,-1-\sqrt{2}\right)$, which both have intersection multiplicity $0$. The second regular chain encodes the points  $\left(-1+\sqrt{2},-1+\sqrt{2},-1+\sqrt{2}\right)$ and $\left(-1-\sqrt{2},-1-\sqrt{2},-1-\sqrt{2}\right)$ 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  succeeds whereas the criterion described in [1,2] does not apply.

 > $R≔\mathrm{PolynomialRing}\left(\left[x,y,z\right]\right):$
 > $\mathrm{rc}≔\mathrm{Chain}\left(\left[z,y,x\right],R\right):$
 > $\mathrm{out}≔\mathrm{IntersectionMultiplicity}\left(\mathrm{rc},\left[z{y}^{2},{y}^{5}-{z}^{2},{x}^{5}-{y}^{2}\right],R,\mathrm{method}='\mathrm{fulton}'\right)$
 ${\mathrm{out}}{≔}\left[\left[{45}{,}{\mathrm{regular_chain}}\right]\right]$ (35)
 > $\mathrm{Display}\left(\mathrm{out},R\right)$
 $\left[\left[{45}{,}\left\{\begin{array}{cc}{x}{=}{0}& {}\\ {y}{=}{0}& {}\\ {z}{=}{0}& {}\end{array}\right\\right]\right]$ (36)

Similarly, the algorithm described in [1,2] can be used to compute some examples the algorithm described in  cannot. Here, the algorithm described in  fails for the given variable ordering but the algorithm described in [1,2] succeeds.

 > $\mathrm{rc}≔\mathrm{Chain}\left(\left[z-10,y,x\right],R\right):$
 > $F≔\left[-3{y}^{4}{z}^{3}+6{x}^{4}{z}^{2}-3{x}^{2}{y}^{2}{z}^{2}-{x}^{2}{z}^{2}+2{y}^{2}{z}^{2}+28{x}^{2}z+7{y}^{2}z+{z}^{2}-11z+10,{x}^{3}z+x{y}^{2}z-xz+x,-2{x}^{2}yz-{y}^{3}z-yz+10y\right]:$
 > $\mathrm{IntersectionMultiplicity}\left(\mathrm{rc},F,R,\mathrm{method}='\mathrm{fulton}'\right)$
 $\left[\left[{\mathrm{FAIL}}{,}{\mathrm{regular_chain}}\right]\right]$ (37)
 > $\mathrm{IntersectionMultiplicity}\left(\mathrm{rc},F,R,\mathrm{method}='\mathrm{tangentcone}'\right)$
 $\left[\left[{3}{,}{\mathrm{regular_chain}}\right]\right]$ (38)

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 $\left[\mathrm{FAIL},t\right]$ in the output list.

Here we see a failure occur in the regular chain encoding the origin.

 > $R≔\mathrm{PolynomialRing}\left(\left[x,y,z,w\right]\right):$
 > $\mathrm{rc}≔\mathrm{Chain}\left(\left[w,z,y,x\left(x+1\right)\right],R\right):$
 > $\mathrm{out}≔\mathrm{IntersectionMultiplicity}\left(\mathrm{rc},\left[xy-z,{y}^{3}-z,\left(x+1\right){x}^{4}-y,w\right],R,\mathrm{method}='\mathrm{fulton}'\right)$
 ${\mathrm{out}}{≔}\left[\left[{1}{,}{\mathrm{regular_chain}}\right]{,}\left[{\mathrm{FAIL}}{,}{\mathrm{regular_chain}}\right]\right]$ (39)
 > $\mathrm{Display}\left(\mathrm{out},R\right)$
 $\left[\left[{1}{,}\left\{\begin{array}{cc}{x}{+}{1}{=}{0}& {}\\ {y}{=}{0}& {}\\ {z}{=}{0}& {}\\ {w}{=}{0}& {}\end{array}\right\\right]{,}\left[{\mathrm{FAIL}}{,}\left\{\begin{array}{cc}{x}{=}{0}& {}\\ {y}{=}{0}& {}\\ {z}{=}{0}& {}\\ {w}{=}{0}& {}\end{array}\right\\right]\right]$ (40)

When method=tangentcone, the algorithm will instead return an error when it cannot compute the intersection multiplicity of every point in the regular chain $\mathrm{rc}$.

 > $R≔\mathrm{PolynomialRing}\left(\left[x,y,z\right]\right):$
 > $\mathrm{rc}≔\mathrm{Chain}\left(\left[z,y,x\right],R\right):$
 > $\mathrm{out}≔\mathrm{IntersectionMultiplicity}\left(\mathrm{rc},\left[z{y}^{2},{y}^{5}-{z}^{2},{x}^{5}-{y}^{2}\right],R,\mathrm{method}='\mathrm{tangentcone}'\right)$ References

  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.
  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.
  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. Compatibility

 • The method=tangentcone corresponds to the algorithm in Maple 2020 and 2021.
 • The RegularChains:-AlgebraicGeometryTools:-IntersectionMultiplicity command was introduced in Maple 2020.