Constructing Dixon Matrix for Sparse Polynomial Equations Based on Hybrid and Heuristics Scheme

Abstract

Solving polynomial equations inevitably faces many severe challenges, such as easily occupying storage space and demanding prohibitively expensive computation resources. There has been considerable interest in exploiting the sparsity to improve computation efficiency, since asymmetry phenomena are prevalent in scientific and engineering fields, especially as most of the systems in real applications have sparse representations. In this paper, we propose an efficient parallel hybrid algorithm for constructing a Dixon matrix. This approach takes advantage of the asymmetry (i.e., sparsity) in variables of the system and introduces a heuristics strategy. Our method supports parallel computation and has been implemented on a multi-core system. Through time-complexity analysis and extensive benchmarks, we show our new algorithm has significantly reduced computation and memory overhead. In addition, performance evaluation via the Fermat–Torricelli point problem demonstrates its effectiveness in combinatorial geometry optimizations.

1. Introduction

As a basic tool in computer algebra and a built-in function of most computer algebra systems, the notion of a resultant is widely used in mathematical theory. A resultant is not only of significance to computer algebra [1], but also plays an important role in biomedicine [2], image processing [3], geographic information [4], satellite trajectory control [5], information security [6] and other scientific and engineering fields [7,8]. The most widely used techniques for solving polynomial systems are Sylvester and Dixon resultants. For example, applying a Dixon resultant to algebraic attacks can quickly solve multivariate polynomial quadratic equations over finite fields. Although these resultant techniques have been extensively studied and improved, they still face many severe challenges regarding their easy occupation of storage space and demand for prohibitively expensive computation resources.

Specifically, a successive Sylvester elimination technique has a shortcoming over a multivariate resultant in that the performance of successive resultant computations is very sensitive to the ordering of variables. Human intervention is required to determine the most efficient ordering, and so they are not automatic methods [9]. Inappropriate choices may cause the extreme intermediate expression to swell, consequently running out of memory before accomplishment [10]. In fact, this method is very inefficient, with the number of variables increasing. Moreover, this technique performs elimination variable by variable, which is inherently sequential.

In contrast, in most cases, the Dixon method is more efficient for directly computing resultant without eliminating variables one at a time. However, it is generally known that the entries of the Dixon matrix are more complicated than the entries of other resultant matrices. As a promising scheme, the fast recursive algorithm of the Dixon matrix (FRDixon for short) [11,12,13,14,15,16] can greatly improve the computation efficiency of the Dixon matrix. Recently, its effectiveness has been analyzed in detail and proven by [16]. Nevertheless, the size of the Dixon matrix and computational complexity by FRDixon explode exponentially as the number of variables increases. If the size of the Dixon matrix is relatively large, it directly leads to difficulty computing the final resultant.

To sum up, it is difficult to overcome such difficulties mentioned above, whatever the choices of resultants. Notice that the conventional resultants resort to general methods for solving polynomial systems. From another point of view, if we can make use of the features of given systems to design customized algorithms for constructing resultant matrices or computing resultants [10], instead of general-purpose methods, it can be expected that we can obtain a targetable method to solve some intractable problems efficiently. Therefore, the main objective of this article is to make use of the sparsity of systems and advantages of prevailing resultants to design a more suitable scheme according to the features of different systems.

Symmetry/asymmetry phenomena are prevalent in scientific and engineering fields. In computer algebra, especially most problems which arise in geometry, we observe the fact that in the real polynomial systems, variables always do not stand uniformly (i.e., with asymmetry features), such as the three combinatorial geometry problems posed in [10] for Heron’s formula in three and four dimensions [17], the problem of mapping of the topographical point to the standard ellipsoid [4], the Fermat–Torricelli point problem on a sphere with an Euclidean metric [18] and bifurcation points of the logistic map [17,19,20]. As we know, in the last decade, there has been considerable interest in employing sparsity to find the solutions in various fields, since most of the systems in real applications actually have sparse representations, such as finding sparse and low-rank solutions [21], parallel GCD algorithm for sparse multivariate polynomials [22], estimating the greatest common divisor (GCD) with sparse coefficients of noise-corrupted polynomials [23] and sparse multivariate interpolation [24].

However, researchers in symbolic computation mainly consider designing the methods to solve an arbitrary given polynomial system and are not aware of such sparse scenarios. In fact, similar studies on sparsity in other fields can go on in the field of solving polynomial systems. In this paper, we propose a new approach to construct a Dixon matrix for solving polynomial equations with sparsity. Through time-complexity analysis and extensive benchmarks, we show our new algorithm has significantly reduced computation and memory overhead.

1.1. Contributions

Our method is combined with Sylvester resultant and fast recursive algorithm FRDixon. It can be partitioned into two phases. In the first phase, we make use of the sparsity of systems to obtain a smaller polynomial system in fewer variables via a Sylvester resultant with fewer computational efforts. In the next step, we consider the multivariate algorithm FRDixon. Since the computational complexity of FRDixon exponentially depends on the number of variables, consequently, via Sylvester resultant elimination, the exported system with fewer variables than operated by FRDixon is more effective than single FRDixon that operates the original system directly. The idea is the genesis of our algorithm employing the Sylvester resultant and FRDixon simultaneously.

The main contributions of this paper are as follows.

• We take advantage of the sparsity of the system and present a heuristic strategy to determine the most effective elimination ordering and remove part of the variables via Sylvester resultant.
• We propose a method to improve the fast recursive algorithm of the Dixon matrix, which leads to reduced time and parallelism available.
• We present a hybrid algorithm employing the methods of 1 and 2 to overcome some computation problems arising in successive Sylvester resultant computations and FRDixon separately. Meanwhile, we apply parallel computation to speed up these two elimination processes.
• We implement our hybrid algorithm and parallel version on Maple. Through time-complexity analysis and extensive random benchmarks, we show our new algorithm has significantly reduced computation and memory overhead in the cases of systems with sparsity. In addition, performance evaluation via the Fermat–Torricelli point problem on sphere with Euclidean metric demonstrates our algorithm’s effectiveness in terms of the real combinatorial geometry optimization problems.

1.2. Related Work

It is well known that successive Sylvester resultant computations can be used to settle the problem of elimination of variables from a multivariate polynomial system to obtain a smaller polynomial system in fewer variables. Implementations of Sylvester resultants are supported in most of the computer algebra systems. With respect to so-called multivariate resultants, A.L. Dixon [25] proposed a method to simultaneously eliminate variables from multivariate systems, aiming at solving the polynomial equations system by constructing a Dixon matrix and computing its determinant.

Since then, Sylvester and Dixon approaches have been generalized and improved (see [9,11,12,16,17,20,26,27,28,29,30,31,32,33,34]). In [26], using the Cholesky decomposition, Zhi et al. proposed a method to compute the Sylvester resultant and reduced the time complexity to $O\left(r\right(m+n\left)\right)$, where $m+n$ and r represent the size and numerical rank of the Sylvester matrix, respectively. Kapur et al. [29] extended Dixon’s method for the case when Dixon matrix is singular and successfully proved many non-trivial algebraic and geometric identities. In order to improve the efficiency of computing the Dixon resultant, several methods came into existence, such as the Unknown-Order-Change [30], Fast-Matrix-Construction method [9,31], Corner-Cutting method [32], etc. Zhao et al. [11,12] extended Chionh’s algorithm [31] to the general case of $n+1$ polynomial equations in n variables by n-degree Sylvester resultant, and proposed the FRDixon algorithm, which initially constructed the Dixon matrix of nine Cyclic equations. In 2017, Qin et al. [16] gave a detailed analysis of the computational complexity of Zhao’s recurrence formula setting and applied parallel computation to speed up the recursive procedure [33,34]. To deal with the determinant raised in the Dixon matrix which is too large to compute or factor, some heuristic acceleration techniques were raised to accelerate computation in certain specific cases [17,20].

1.3. Organization

The rest of this article is organized as follows. Section 2 reviews the successive Sylvester resultant computations method and the FRDixon algorithm. In Section 3, a parallel hybrid algorithm which combines the Sylvester resultant and modified FRDixon is developed. Section 4 analyzes the time complexity of our proposed algorithm and conducts a series of numerical experiments. Three sets of random instances and one detailed example are presented to illustrate the application of our method. Finally, a conclusion is reported.

2. Review of Elimination Techniques

In this section, we first review the definition of a Sylvester resultant, which serves as the basis of successive Sylvester resultant computations for solving a system of polynomial equations. Then, we describe the fast recursive algorithm for construction of a Dixon matrix (FRDixon) [11].

All the discussions are stated for a general field $\mathcal{K}[X,A]$, where $X=\{x_1,\dots ,x_n\}$ denotes the set of variables and $A=\{a\mathrm{is}\mathrm{the}\mathrm{parameter},a\notin X\}$ denotes the set of parameters not belonging to X. Consider a system of $n+1$ polynomial equations

$$\mathrm{Sys}(f_1,\dots ,f_n)=\{f_j\left(x_1,\dots ,x_n\right)=\sum _{i_1=0}^{m_{j_1}}\dots \sum _{i_n=0}^{m_{j_n}}{a}_{j,i_1,\dots ,i_n}{x}_1^{i_1}\dots x_n^{i_n},j=1,\dots ,n+1\}$$

(1)

in n variables $x_i$ and a number of coefficients $a_{j,i_1,\dots ,i_n}\in \mathcal{K}\left[A\right]$, where $m_{j_i}$ is the degree of the polynomial $f_j(x_1,\dots ,x_n)$ with respect to $x_i$. The objective is to construct the resultant matrix of polynomial equation system (1).

2.1. Elimination via Sylvester Resultant

In this subsection, we introduce the elimination process variable by variable based on the Sylvester resultant. The classical Sylvester resultant is used to the elimination of systems of two polynomials in one variable. Consider the polynomials f and g:

$$\begin{array}{cc}& f=a_m{x}^m+a_{m-1}{x}^{m-1}+\cdots +a_0,\hfill \\ & g=b_l{x}^l+b_{l-1}{x}^{l-1}+\cdots +b_0,\hfill \end{array}$$

where $m(>0)$ and $l(>0)$ are the degrees of polynomials f and g in x, respectively. Recall that the Sylvester matrix of f and g in x is the matrix of the form

$$S=\left(\begin{array}{ccccccc}{a}_m& a_{m-1}& \dots & a_0& & & \\ & a_m& a_{m-1}& \dots & a_0& & \\ & & \dots & \dots & \dots & \dots & \\ & & & a_m& a_{m-1}& \dots & a_0\\ b_l& b_{l-1}& \dots & b_0& & & \\ & b_l& b_{l-1}& \dots & b_0& & \\ & & \dots & \dots & \dots & \dots & \\ & & & b_l& b_{l-1}& \dots & b_0\end{array}\right)$$

and the resultant of f and g in x is defined as the determinant of matrix S.

Let $\mathrm{res}(f_i,f_j,x_k)$ represent the Sylvester resultant of the polynomial $f_i$ and $f_j$ in $x_k$. By computing the Sylvester resultant of $f_i$ and other polynomials $f_2,\dots ,f_n$ with respect to $x_1$, respectively, we obtain the system $\mathrm{Sys}(x_2,\dots ,x_n)$ denoted by

$$\left\{\begin{array}{c}{f}_{1,2}=\mathrm{res}(f_1,f_2,x_1)\hfill \\ f_{1,3}=\mathrm{res}(f_1,f_3,x_1)\hfill \\ \dots \hfill \\ f_{1,n+1}=\mathrm{res}(f_1,f_{n+1},x_1)\hfill \end{array}\right.$$

which contains n equations in $n-1$ variables $x_2,\dots ,x_n$, i.e., the variable $x_1$ is removed from the original system (1). This procedure may be repeated until we have determined the sequence of polynomial systems $\mathrm{Sys}(x_3,\dots ,x_n)$, $\mathrm{Sys}(x_4,\dots ,x_n),\dots ,\mathrm{Sys}\left(x_n\right)$. Obviously, the above elimination procedure yields the final resultant $\mathrm{Sys}\left(x_n\right)$ for system (1).

Similar to the procedure above, we can eliminate $x_1,\dots ,x_{i-1},x_{i+1},\dots ,x_n$ in any order by successive Sylvester resultant computations and finally have a resultant in variable $x_i(i\in \{1,\dots ,n\})$. In the worst cases, this method requires $O\left(n^2\right)$ times Sylvester resultant computations.

2.2. Fast Recursive Algorithm of the Dixon Matrix (FRDixon)

We now give the key technique of the fast recursive algorithm for constructing the Dixon matrix in [11]. To avoid the computation of polynomial division, the technique of truncated formal power series (see [31]) is employed in the FRDixon algorithm.

Let $a_i\left(y\right)(i=0,1,\dots ,n)$ be the polynomial in y. It is obvious that ${\sum }_{i=0}^n{a}_i\left(y\right)x^i=0$ when $x=y$. Therefore, the quotient ${\sum }_{i=0}^n{a}_i\left(y\right)x^i/\phantom{{\sum }_{i=0}^n{a}_i\left(y\right)x^i(x-y)}(x-y)$ is a polynomial in y. We denote $1/\phantom{1(x-y)}(x-y)$ by series form ${\sum }_{u=1}^{\infty }{x}^{-u}{y}^{u-1}$. Hence,

$$\frac{{\sum }_{i=0}^n{a}_i\left(y\right)x^i}{x-y}=\sum _{i=0}^n{a}_i\left(y\right)x^i\sum _{u=1}^i{x}^{-u}{y}^{u-1}+\sum _{i=0}^n{a}_i\left(y\right)x^i\sum _{u=i+1}^{\infty }{x}^{-u}{y}^{u-1},$$

(2)

here ${\sum }_{u=1}^0{x}^{-u}{y}^{u-1}$ is taken as zero. Since the powers of x of the second term are all negatives, the left side of Equation (2) is a polynomial if, and only if, the second term of the right side in (2) is equal to zero. Hence, the equation

$$\frac{{\sum }_{i=0}^n{a}_i\left(y\right)x^i}{x-y}=\sum _{i=1}^n{a}_i\left(y\right)x^i\sum _{k=1}^{i-1}{x}^k{y}^{i-1-k}$$

(3)

holds.

The FRDixon algorithm is based on the following ideas: employing the technique of truncated formal power series for reducing the Dixon matrix construction problem into a set of sub-Dixon matrix construction problems with fewer variables, and using the Sylvester resultant matrix and the Dixon matrix with $k-1$ ($3\le k\le n$) variables to represent the Dixon matrix with k variables via matrix block computation. A recursive process for constructing the Dixon matrix is then proposed. For more details, one can refer to [11,12,16].

3. A Hybrid Algorithm for Constructing a Dixon Matrix

In this section, we will propose a new method to construct the Dixon matrix. Additionally, our proposed scheme is a parallel hybrid approach utilizing both the Sylvester resultant and the modified FRDixon algorithm, and making our algorithm applicable in either random polynomial systems or problems in reality.

The time complexity of our algorithm for construction of the Dixon matrix of $\mathrm{Sys}(f_1,\dots ,f_{n+1})$ defined by (1) is $O({\overline{m}}^3(n^2-t^2+n+t)+{{\tilde{m}}_1}^{2}t{!}^3{\prod }_{i=2}^t{{\tilde{m}}_i}^3)$ (numerical type determinant) or $O(\overline{m}!(n^2-t^2+n+t)+{{\tilde{m}}_1}^{2}t{!}^3{\prod }_{i=2}^t{{\tilde{m}}_i}^3)$ (symbolic type determinant), where $\overline{m}$ is the degree bound of the polynomial, ${\tilde{m}}_i$ denotes the maximum degree of $x_i$ in all polynomials $f_1,\dots ,f_{n+1}$, n denotes the number of variables and t denotes the number of variables in the polynomial system after the Sylvester resultant eliminates some variables. See Section 4.1 for details of the proof. In comparison, our method is more efficient than the existing methods for solving sparse polynomial systems.

Our method can be partitioned into two phases. In the first phase, we eliminate part of variables by Sylvester resultant from the original system, and then in the second phase, we construct the resultant matrix of the system derived from the first phase by a variant version of FRDixon.

3.1. Sylvester Elimination by Heuristic Strategy

A successive Sylvester elimination technique requires $n-1$ computations to remove a variable for a non-sparse system. If the sparse condition is satisfied, we can obtain a smaller system with the least computation costs.

In this subsection, we describe a heuristic strategy to determine which variable should be eliminated first. According to the degrees of this variable in each polynomial of the system, we can give the optimal combinational relationships of polynomials for removing it by Sylvester resultant.

If there are some variables only appearing in a few equations of system (1), the computation cost of eliminating such variables from (1) will be relatively small. In such a case, our approach to decide the elimination ordering and then remove them via Sylvester resultant in the first phase is fairly straightforward.

Let $d_{j_i}$ represent whether the variable $x_i$ appears in polynomial $f_j$. That is,

$$d_{j_i}=\left\{\begin{array}{c}1\mathrm{if}{x}_i\mathrm{is}\mathrm{in}\mathrm{variable}\mathrm{set}\mathrm{of}{f}_j\hfill \\ 0\mathrm{otherwise}\hfill \end{array}\right.$$

For each $x_i$, we compute the sum of $d_{j_i}$ for $j=1,\dots ,n+1$ denoted by

$$e_i=\sum _{j=1}^{n+1}{d}_{j_i},i=1,2,\dots ,n.$$

(4)

Assume $x_k$ denotes the first variable to be eliminated from system (1). Then, for $j=1,\dots ,k-1,k+1,\dots ,n$, it satisfies

$$(e_k<e_j)\mathrm{or}(e_k=e_j\mathrm{and}{m}_k\le m_j)$$

(5)

$m_i$ means the maximum degree of $x_i$ in all polynomials $f_1,\dots ,f_{n+1}$. Once $x_k$ is picked, we move to adjust the ordering of $f_1,\dots ,f_{n+1}$. Let $\mathrm{ord}\left(f_j\right)$ for $j=1,2,\dots ,n+1$ be the order of $f_j$ after rearrangement. We require that if $m_{j_k}<m_{i_k}$, then $\mathrm{ord}\left(f_j\right)<\mathrm{ord}\left(f_i\right)$. At this stage, the ordering of polynomials is rearranged according to the degree $m_{j_k}$; we denote the rearrangement system by $\mathrm{Sys}(p_1,\dots ,p_{n+1})$.

From now on, the technique of successive Sylvester resultant computations is operated on the newly adjusted system $\mathrm{Sys}(p_1,\dots ,p_{n+1})$. Assume the first l polynomials do not contain variable $x_k$. In such a case, we only need to eliminate $x_k$ from the last $(n+1-l)$ polynomials $p_{l+1},\dots ,p_{n+1}$ by computing the resultants $\mathrm{res}(p_{l+1},p_{l+2},x_k),\dots ,$$\mathrm{res}(p_{l+1},p_{n+1},x_k)$. Let

$$p_{l+1,j}=\mathrm{res}(p_{l+1},p_j,x_k),l+2\le j\le n+1.$$

Then, a new polynomial system

$$\{p_1,\dots ,p_l,p_{l+1,l+2},\dots ,p_{l+1,n+1}\}$$

(6)

with $n-1$ variables is obtained.

We can proceed with eliminating a variable from (6) in way similar to that shown above. This approach in the first phase is illustrated in Example 1.

Example 1.

Given a system

$$\begin{array}{c}{f}_1=-3{x_3}^2-x_1{x}_2{x}_3+x_1^2{x}_2+9x_2{x}_3\hfill \\ f_2=x_2{x_3}^2-3x_2^2-x_3+5x_2+11\hfill \\ f_3=-x_2^2{x}_3-7x_1{x}_2-x_3^2+2x_2-9\hfill \\ f_4=-x_2{x}_3^2-x_2{x}_3-x_2^2+x_3\hfill \end{array}$$

we want to eliminate a variable with the least computation cost. For each variable $x_i$, count the number of times of $x_i$ appearing in $\mathrm{Sys}(f_1,\dots ,f_4)$ according to (4). We find that the minimum of $\{e_1,e_2,e_3\}$ is 2 corresponding to $x_1$. Therefore, $x_1$ is chosen to be eliminated first and $\{f_1,f_2,f_3,f_4\}$ can be rearranged by $m_{j_1}(j=1,\dots ,4)$. The rearranged system is

$$\{p_1=f_2,p_2=f_4,p_3=f_3,p_4=f_1\}.$$

Since $x_1$ does not appear in $p_1$ and $p_2$, eliminating $x_1$ by computing $\mathrm{res}(p_3,p_4,x_1)$, we obtain the system of 3 equations and 2 variables as

$$\begin{array}{cc}& p_1=f_2=x_2{x_3}^2-3x_2^2-x_3+5x_2+11,p_2=f_4=-x_2{x}_3^2-x_2{x}_3-x_2^2+x_3,\hfill \\ & p_{3,4}=x_2^5{x}_3^2+7x_2^4{x}_3^2+2x_2^3{x}_3^3-4x_2^4{x}_3+7x_2^2{x}_3^3+x_2{x}_3^4+445x_2^3{x}_3-151x_2^2{x}_3^2+4x_2^3\hfill \\ & +63x_2^2{x}_3+18x_2{x}_3^2-36x_2^2+81x_2\hfill \end{array}.$$

Note that if $x_3$ is chosen to be eliminated first instead of $x_1$, this yields a much larger system:

$$\begin{array}{cc}\hfill f_{1,2}=& \mathrm{res}(f_1,f_2,x_3)=x_1^4{x}_2^4-3x_1^2{x}_2^5-x_1^3{x}_2^3-13x_1^2{x}_2^4+54x_1{x}_2^5+50x_1^2{x}_2^3-90x_1{x}_2^4-\hfill \\ & 243x_2^5+66x_1^2{x}_2^2-207x_1{x}_2^3+486x_2^4-3x_1^2{x}_2+15x_1{x}_2^2+702x_2^3+33x_1{x}_2-\hfill \\ & 504x_2^2+693x_2+1089,\hfill \\ \hfill f_{1,3}=& \mathrm{res}(f_1,f_3,x_3)=x_1^3{x}_2^4-3x_1^2{x}_2^5+x_1^4{x}_2^2+7x_1^3{x}_2^3-30x_1^2{x}_2^4+42x_1^3{x}_2^2-128x_1^2{x}_2^3+\hfill \\ & 195x_1{x}_2^4+438x_1^2{x}_2^2+576x_1{x}_2^3-54x_2^4+54x_1^2{x}_2-414x_1{x}_2^2+81x_2^3+1134x_1{x}_2\hfill \\ & +765x_2^2-324x_2+729,\hfill \\ \hfill f_{1,4}=& \mathrm{res}(f_1,f_4,x_3)=x_2(x_1^4{x}_2^3+x_1^3{x}_2^3+x_1^2{x}_2^4-x_1^3{x}_2^2-3x_1^2{x}_2^3-18x_1{x}_2^4+6x_1^2{x}_2^2-\hfill \\ & 3x_1{x}_2^3+81x_2^4+6x_1^2{x}_2+3x_1{x}_2^2+36x_2^3-3x_1^2-27x_2^2).\hfill \end{array}$$

Remark 1.

An attractive feature of the hybrid algorithm is that it reflects the polynomial sparsity of the system. Hence, our overall algorithm is sensitive to the sparsity of variables appearing in its original representation of a given system.

3.2. Construction of Dixon Matrix by Improved FRDixon

At this stage, assume that we have eliminated $n-t$ variables via successive Sylvester elimination techniques by making use of a heuristic strategy. The derived system is denoted by $\mathrm{Sys}(q_1,\dots ,q_{t+1})$,

$$\mathrm{Sys}(q_1,\dots ,q_{t+1})=\{q_j\left({\tilde{x}}_1,\dots ,{\tilde{x}}_t\right)=\sum _{i_1=0}^{{\tilde{m}}_{j_1}}\dots \sum _{i_t=0}^{{\tilde{m}}_{j_t}}{\tilde{a}}_{j,i_1,\dots ,i_t}{{\tilde{x}}_1}^{i_1}\dots {{\tilde{x}}_t}^{i_t},j=1,\dots ,t+1\},$$

(7)

where ${\tilde{m}}_{j_i}$ denotes the degree of variable ${\tilde{x}}_i$ in $\{q_1,q_2,\dots ,q_t+1\}$. ${\tilde{a}}_{j,i_1,\dots ,i_t}$ denotes the coefficients of monomial.

The rest of the work constructs a Dixon matrix using an improved FRDixon algorithm. In our new version, we replace the computations of the product of Sylvester matrix $S_i(i=0,\dots ,{\tilde{m}}_1-1)$ and block matrix $F_j(j=0,\dots ,t{\tilde{m}}_1-1)$ to the sum of products of a set of matrices with smaller size, which leads to reduced time and parallelism available.

Specifically, $S_i$ is expressed by

$$S_i=\left(\begin{array}{ccccccc}{\tilde{a}}_{1,i,0,\dots ,0}& \dots & {\tilde{a}}_{t+1,i,0,\dots ,0}& & & & \\ {\tilde{a}}_{1,i,0,\dots ,1}& \dots & {\tilde{a}}_{t+1,i,0,\dots ,1}& \ddots & & & \\ ⋮& \dots & ⋮& \ddots & {\tilde{a}}_{1,i,0,\dots ,0}& \dots & {\tilde{a}}_{t+1,i,0,\dots ,0}\\ {\tilde{a}}_{1,i,{\tilde{m}}_2,\dots ,{\tilde{m}}_t}& \dots & {\tilde{a}}_{t+1,i,{\tilde{m}}_2,\dots ,{\tilde{m}}_t}& \ddots & ⋮& \dots & ⋮\\ & & & \ddots & {\tilde{a}}_{1,i,{\tilde{m}}_2,\dots ,{\tilde{m}}_t-1}& \dots & {\tilde{a}}_{t+1,i,{\tilde{m}}_2,\dots ,{\tilde{m}}_t-1}\\ & & & & {\tilde{a}}_{1,i,{\tilde{m}}_2,\dots ,{\tilde{m}}_t}& \dots & {\tilde{a}}_{t+1,i,{\tilde{m}}_2,\dots ,{\tilde{m}}_t}\end{array}\right),$$

where ${\tilde{a}}_{j,i,i_2,\dots ,i_t}$ is exacted from the coefficients of polynomials $q_1,\dots ,q_{t+1}$. The order of $S_i$ is $t!{\prod }_{l=2}^t{\tilde{m}}_l\times (t+1)(t-1)!{\prod }_{l=2}^t{\tilde{m}}_l$.

The block matrix $F_j$ is constructed by

$$F_j=\left(\begin{array}{c}D{D}_{1,j+1}(1,:)\\ ⋮\\ D{D}_{t+1,j+1}(1,:)\\ ⋮\\ D{D}_{1,j+1}((t-1)!{\Pi }_{l=2}^t{\tilde{m}}_l,:)\\ ⋮\\ D{D}_{t+1,j+1}((t-1)!{\Pi }_{l=2}^t{\tilde{m}}_l,:)\end{array}\right),$$

where $D{D}_{k,j+1}(l,:)$ denotes the l-row of $D{D}_{k,j+1}$ defined by (14). The order of $F_j$ is $(t+1)$$(t-1)!{\prod }_{l=2}^t{\tilde{m}}_l\times (t-1)!{\prod }_{l=2}^t{\tilde{m}}_l$.

In the original version, $S_i$ and $F_j$ are computed, respectively. The improved algorithm considers $S_i·F_j$ as the sum of products of a set of $P_{k,i}·D{D}_{k,j+1}$; that is

$$S_i·F_j=\sum _{k=1}^{t+1}{P}_{k,i}·D{D}_{k,j+1},0\le i\le {\tilde{m}}_1-1,0\le j\le t{\tilde{m}}_1-1,$$

(8)

where $P_{k,i}$ is the $t!{\prod }_{l=2}^t{\tilde{m}}_l\times (t-1)!{\prod }_{l=2}^t{\tilde{m}}_l$ matrix defined by (13).

In our theoretical analysis in Theorem 1 with an improved FRDixon algorithm, we find that the key advantages to this matrix decomposition are as follows.

• There is no need to construct matrix $F_j$ for $j=0,\dots ,t{\tilde{m}}_1-1$ explicitly. This is in contrast with the original FRDixon, which requires computing matrix $F_j$ from $D{D}_{k,j+1}$ one by one.
• Compared to $S_i$, matrix $P_{k,j}$ with a smaller size can be computed independently and, consequently, has the advantage of working in parallel.
• Decomposition of (8) leads to reduced time.

Based on above analysis, we now give a description of Algorithm 1.

Algorithm 1: Improved FRDixon algorithm.

Input:    $\mathrm{Sys}(q_1,\dots ,q_{t+1})$: multivariate polynomial system with $t+1$       equations and t variables ${\tilde{x}}_1,\dots ,{\tilde{x}}_t$. Output:  $\mathrm{Dixon}(q_1,\dots ,q_{t+1})$: Dixon matrix of $\mathrm{Sys}(q_1,\dots ,q_{t+1})$. Step 1. (Decompose Dixon polynomial $\delta (q_1,\dots ,q_{t+1})$ into a set of sub-Dixon polynomials.) By introducing the new variables ${\overline{x}}_1,\dots ,{\overline{x}}_t$ to $q_j({\tilde{x}}_1,\dots ,{\tilde{x}}_t)$, we form the Dixon polynomial $\delta (q_1,\dots ,q_{t+1})$ defined as $$\delta (q_1,\dots ,q_{t+1})=\prod _{i=1}^t\frac{1}{{\overline{x}}_i-{\tilde{x}}_i}\left|\begin{array}{cccc}{q}_1({\tilde{x}}_1,\dots ,{\tilde{x}}_t)& q_2({\tilde{x}}_1,\dots ,{\tilde{x}}_t)& \dots & q_{t+1}({\tilde{x}}_1,\dots ,{\tilde{x}}_t)\\ q_1({\overline{x}}_1,\dots ,{\tilde{x}}_t)& q_2({\overline{x}}_1,\dots ,{\tilde{x}}_t)& \dots & q_{t+1}({\overline{x}}_1,\dots ,{\tilde{x}}_t)\\ ⋮& ⋮& ⋮& ⋮\\ q_1({\overline{x}}_1,\dots ,{\overline{x}}_t)& q_2({\overline{x}}_1,\dots ,{\overline{x}}_t)& \dots & q_{t+1}({\overline{x}}_1,\dots ,{\overline{x}}_t)\end{array}\right|$$ (9) By comparing the form of the left side in Equation (3), we conclude that Dixon polynomial $\delta (q_1,\dots ,q_{t+1})$ has a structure identical to (3). Hence, we can use the technique of truncated formal power series to split (9) into several sub-Dixon polynomials: $$\begin{array}{cc}\hfill \delta (q_1,\dots ,q_{t+1})=& {\displaystyle \sum _{u_1=0}^{t{\tilde{m}}_1-1}}{\displaystyle \sum _{i=u_1+1}^{t{\tilde{m}}_1}}{{\tilde{x}}_1}^{i-1-u_1}{{\overline{x}}_1}^{u_1}({(-1)}^0{q}_1{\displaystyle \sum _{i_1+\dots +i_t=i}}\delta (q_{2,i_1},q_{3,i_2},\dots ,q_{t+1,i_t})\hfill \\ & +{(-1)}^1{q}_2{\displaystyle \sum _{i_1+\dots +i_t=i}}\delta (q_{1,i_1},q_{3,i_2},\dots ,q_{t+1,i_t})+\dots \hfill \\ & +{(-1)}^t{q}_{t+1}{\displaystyle \sum _{i_1+\dots +i_t=i}}\delta (q_{1,i_1},q_{2,i_2},\dots ,q_{t,i_t})),\hfill \end{array}$$ (10) where ${\tilde{m}}_i=\max \{{\tilde{m}}_{j_i},j=1,\dots ,t+1\}$ for $i=1,\dots ,t$. If terms of $q_j$ are collected with respect to ${\tilde{x}}_k$, $q_j$ can be written as a univariate polynomial in ${\tilde{x}}_k$, $$q_j=\sum _{i=0}^{{\tilde{m}}_{j_k}}{q}_{j,i}({\tilde{x}}_1,\dots ,{\tilde{x}}_{k-1},{\tilde{x}}_{k+1},\dots ,{\tilde{x}}_t){{\tilde{x}}_k}^i,$$ then $q_{j,i}({\tilde{x}}_1,\dots ,{\tilde{x}}_{k-1},{\tilde{x}}_{k+1},\dots ,{\tilde{x}}_t)$ is regarded as the coefficient polynomial from $\mathcal{K}[{\tilde{x}}_1,\dots ,{\tilde{x}}_{k-1}$, ${\tilde{x}}_{k+1},\dots ,{\tilde{x}}_t]$ with respect to ${{\tilde{x}}_k}^i$. This procedure reduces the original Dixon polynomial $\delta (q_1,\dots ,q_{t+1})$ into several sub-Dixon polynomials $\delta (q_{1,i_1},\dots ,q_{k-1,i_{k-1}},q_{k+1,i_k},\dots ,q_{t+1,i_t})$ with fewer variables and fewer polynomials. Step 2. (Express the Dixon polynomial in terms of Dixon matrix.) Deduce the recursive formula for Dixon matrix, express sub-Dixon polynomials in Dixon matrix from $$\begin{array}{cc}\hfill & {\displaystyle \sum _{i_1+\dots +i_t=i}}\delta (q_{1,i_1},\dots ,q_{k-1,i_{k-1}},q_{k+1,i_k},\dots ,q_{t+1,i_t})\hfill \\ \hfill & =[1,\dots ,{\displaystyle \prod _{l=2}^t}{{\tilde{x}}_l}^{(l-1){\tilde{m}}_l-1}]\times {\displaystyle \sum _{i_1+\dots +i_t=i}}\mathrm{Dixon}(q_{1,i_1},\dots ,q_{k-1,i_{k-1}},q_{k+1,i_k},\dots ,q_{t+1,i_t})\times \hfill \\ \hfill & {[1,\dots ,{\displaystyle \prod _{l=2}^t}{{\tilde{x}}_l}^{(t-l+1){\tilde{m}}_l-1}]}^T,\hfill \end{array}$$ (11) for $k=1,\dots ,t+1$ and $i=1,\dots ,t{\tilde{m}}_1$. Then, substitute (11) into (10); we can obtain the Dixon matrix representation of (10) as follows, $$\begin{array}{cc}\hfill & \delta (q_1,\dots ,q_{t+1})\hfill \\ \hfill & ={\displaystyle \sum _{u_1=0}^{t{\tilde{m}}_1-1}}{\displaystyle \sum _{i=u_1+1}^{t{\tilde{m}}_1}}{{\tilde{x}}_1}^{i-1-u_1}{\overline{x}}_1^{u_1}(q_1·[1,\dots ,{\displaystyle \prod _{l=2}^t}{{\tilde{x}}_l}^{(l-1){\tilde{m}}_l-1}]·{\displaystyle \sum _{i_1+\dots +i_t=i}}\mathrm{Dixon}(q_{2,i_1},\dots ,q_{t+1,i_t})\hfill \\ \hfill & +\dots +{(-1)}^t{q}_{t+1}·[1,\dots ,{\displaystyle \prod _{l=2}^t}{{\tilde{x}}_l}^{(l-1){\tilde{m}}_l-1}]·{\displaystyle \sum _{i_1+\dots +i_t=i}}\mathrm{Dixon}(q_{1,i_1},\dots ,q_{t,i_t}))\hfill \\ \hfill & \times {[1,\dots ,{\displaystyle \prod _{l=2}^t}{{\tilde{x}}_l}^{(t-l+1){\tilde{m}}_l-1}]}^T.\hfill \end{array}$$ (12) Step 3. (Construct the matrix $P_{k,i}$.) Extract the coefficients of $q_1,\dots ,q_{t+1}$ to construct the matrix $$P_{k,i}=\left(\begin{array}{cccc}{\tilde{a}}_{k,i,0,\dots ,0}& & & \\ {\tilde{a}}_{k,i,0,\dots ,1}& \ddots & \\ ⋮& \ddots & \ddots & {\tilde{a}}_{k,i,0,\dots ,0}\\ {\tilde{a}}_{k,i,{\tilde{m}}_2,\dots ,{\tilde{m}}_t}& \ddots & \ddots & ⋮\\ & & \ddots & {\tilde{a}}_{k,i,{\tilde{m}}_2,\dots ,{\tilde{m}}_t-1}\\ & & & {\tilde{a}}_{k,i,{\tilde{m}}_2,\dots ,{\tilde{m}}_t}\end{array}\right),$$ (13) where $k=1,\dots ,t+1$ and $i=0,\dots ,{\tilde{m}}_1-1$. From (13), it is easy to see that $P_{k,i}$ is a block matrix. The order of $P_{k,i}$ is $t!{\prod }_{l=2}^t{\tilde{m}}_l\times (t-1)!{\prod }_{l=2}^t{\tilde{m}}_l$. Step 4. (Construct the matrix $D{D}_{k,j+1}$.) Compute the sum of sub-Dixon matrices corresponding to sub-Dixon polynomials in (12), denoted by $$D{D}_{k,j+1}=\sum _{i_1+\dots +i_t=j+1}\mathrm{Dixon}(q_{1,i_1},\dots ,q_{k-1,i_{k-1}},q_{k+1,i_k},\dots ,q_{t+1,i_t}).$$ (14) where $k=1,\dots ,t+1$ and $j=0,\dots ,t{\tilde{m}}_1-1$. The order of $D{D}_{k,j+1}$ is $(t-1)!{\prod }_{l=2}^t{\tilde{m}}_l\times (t-1)!{\prod }_{l=2}^t{\tilde{m}}_l$. Step 5. (Compute $S_i·F_j$.) From (13) and (14), compute the product of $S_i·F_j$ by (8). Step 6. (Construct $\mathrm{Dixon}(q_1,\dots ,q_{t+1})$ using $S_i·F_j$.) From the evaluations of $S_i·F_j$ for $0\le i\le {\tilde{m}}_1-1$ and $0\le j\le t{\tilde{m}}_1-1$, construct Dixon matrix, $$\begin{array}{cc}\hfill \mathrm{Dixon}(q_1,\dots ,q_{t+1})& =\left(\begin{array}{ccc}{D}_{0,0}& \dots & D_{0,t{\tilde{m}}_{1-1}}\\ ⋮& ⋮& ⋮\\ D_{{\tilde{m}}_1-1,0}& \dots & D_{{\tilde{m}}_1-1,t{\tilde{m}}_1-1}\end{array}\right)\hfill \\ & =\left(\begin{array}{ccc}{S}_0& & \\ ⋮& \ddots & \\ S_{{\tilde{m}}_1-1}& \dots & S_0\end{array}\right)·\left(\begin{array}{ccccc}{F}_0& \dots & F_{(t-1){\tilde{m}}_1}& \dots & F_{t{\tilde{m}}_1-1}\\ ⋮& ⋰& ⋰& ⋰& \\ F_{{\tilde{m}}_1-1}& \dots & F_{t{\tilde{m}}_1-1}& & \end{array}\right)\hfill \end{array}$$ where $$\begin{array}{c}\hfill D_{i,j}=\sum _{k=0}^{\min \{i,t{\tilde{m}}_1-1-j\}}{S}_{i-k}·F_{j+k}\end{array}$$ (15) is a block matrix of order $t!{\prod }_{l=2}^t{\tilde{m}}_l\times (t-1)!{\prod }_{l=2}^t{\tilde{m}}_l$.

3.3. The Parallel Hybrid Algorithm

In Section 3.1 and Section 3.2, we describe the two phases involved in our hybrid algorithm. Now, the overall algorithm is presented.

Remark 2.

The Algorithm 2 presented corresponds to our sequential implementation. Further parallel is available. In particular,

• In step 2, once $x_k$ is determined to be eliminated, we simultaneously have at our disposal the computations $p_{l+1,l+2},\dots ,p_{l+1,n+1}$. Hence, $\mathrm{res}(p_{l+1},p_j,x_k)$ can be obtained in parallel.
• In step 3 and step 4, $P_{k,i}$ and $D{D}_{k,j+1}$ can each be obtained independently. Hence, the computations of $P_{k,i}$ and $D{D}_{k,j+1}$ can be carried out in parallel.
• In step 5, once $P_{k,i}$ and $D{D}_{k,j+1}$ are known to us, we can compute $D_{i,j}$ immediately. Hence, the initialization of $D_{i,j}$ can be performed in parallel.
• In step 6, recursive operation is carried out on each anti-diagonal line as $\mathrm{Dixon}(q_1,\dots ,q_{t+1})$ can also be performed in parallel.

Algorithm 2: Hybrid algorithm.

Input:   $\mathrm{Sys}(f_1,\dots ,f_{n+1})$: multivariate polynomial system with $n+1$            equations and n variables $x_1,\dots ,x_n$ over $\mathcal{K}[X,A]$. Output:  $\mathrm{Dixon}(f_1,\dots ,f_{n+1})$: Dixon matrix of $\mathrm{Sys}(f_1,\dots ,f_{n+1})$. Step 1. (Select variable $x_k$ to be eliminated from $\mathrm{Sys}(f_1,\dots ,f_{n+1})$ by applying heuristic scheme.) Select the variable $x_k$ to be eliminated according to (5). Then, rearrange the polynomial $f_j$ in terms of the degrees of $f_j(j=1,\dots ,n+1)$ in $x_k$. Denote the rearranged polynomial system as $\mathrm{Sys}(p_1,\dots ,p_{n+1})$. Step 2. (Eliminate $x_k$ from $\mathrm{Sys}(p_1,\dots ,p_{n+1})$.) Assume the polynomials $p_1,\dots ,p_l$ do not contain variable $x_k$. Eliminate $x_k$ from $\{p_{l+1},\dots ,p_{n+1}\}$ by Sylvester resultant: $$p_{l+1,j}=\mathrm{res}(p_{l+1},p_j,x_k),j=l+2,\dots ,n+1$$ According to the size and feature of given system (1), the process of selection and elimination can be continued until $n-t$ variables are removed from $\mathrm{Sys}(f_1,\dots ,f_{n+1})$. Assume the derived system is denoted by $\mathrm{Sys}(q_1,\dots ,q_{t+1})$. Step 3. (Construct the matrix $P_{k,i}$.) for$i=0,\dots ,{\tilde{m}}_1-1$do    for $k=1,\dots ,t+1$ do       Construct the $P_{k,i}$ by (13) in Algorithm 1.    end k for; endifor; Step 4. (Construct the matrix $D{D}_{k,j+1}$.) for$j=0,\dots ,t{\tilde{m}}_1-1$do    for $k=1,\dots ,t+1$ do        Construct the $D{D}_{k,j+1}$ by (14) recursively in Algorithm 1.    end k for; endjfor; Step 5. (Initialize the elements $D_{i,j}$ of $\mathrm{Dixon}(q_1,\dots ,q_{t+1})$.) From step 3 and step 4, compute the product of $S_i·F_j$ by (8) and then initialize the elements $D_{i,j}=S_i·F_j$ of $\mathrm{Dixon}(q_1,\dots ,q_{t+1})$. Step 6. (Construct the $\mathrm{Dixon}(q_1,\dots ,q_{t+1})$.) Observing (15), we find that the following relationship holds, $$D_{i,j}=D_{i-1,j+1}+S_i·F_j,1\le i\le {\tilde{m}}_1-1,0\le j\le t{\tilde{m}}_1-2,$$ then recursive operation is carried out on each anti-diagonal line. Hence, constructing the $\mathrm{Dixon}(q_1,\dots ,q_{t+1})$ as follows $$\mathrm{Dixon}(q_1,\dots ,q_{t+1})=\left(\begin{array}{cccccc}{S}_0·F_0& \dots & S_0·F_{{\tilde{m}}_1-1}& S_0·F_{{\tilde{m}}_1}& \dots & S_0·F_{t{\tilde{m}}_1-1}\\ \swarrow & ⋰& \swarrow & \swarrow & ⋰& S_1·F_{t{\tilde{m}}_1-1}\\ ⋰& ⋰& ⋰& ⋰& ⋰& ⋮\\ \swarrow & ⋰& \swarrow & \swarrow & ⋰& S_{{\tilde{m}}_1-2}·F_{t{\tilde{m}}_1-1}\\ \swarrow & ⋰& \swarrow & \swarrow & ⋰& S_{{\tilde{m}}_1-1}·F_{t{\tilde{m}}_1-1}\end{array}\right)$$ (16) can avoid a mount of repeated computations.

Our method exploits the sparsity in variables of the system and introduces heuristics strategy. Parts of the variables are chosen to be eliminated from the original system via successive Sylvester resultant computations. Next, the exported system with fewer variables is operated by improved FRDixon. Meanwhile, these two elimination processes can be paralleled.

4. Analysis and Evaluation

We first analyze the time complexity of the hybrid algorithm in Section 4.1, and then evaluate the performance of our algorithm. In Section 4.2, we discuss implementations in random instances. Section 4.3 reports on our approach in a real problem. The effectiveness and practicality of our method are illustrated in these examples.

4.1. Time Complexity Analysis

We now give the sequential complexity of the hybrid algorithm in terms of the number of arithmetic operations, and use big-O notation to simplify expressions and asymptotically estimate the number of operations algorithm used as the input grows.

Theorem 1.

The time complexity of the hybrid algorithm (Algorithm 2) for construction of Dixon matrix of $\mathrm{Sys}(f_1,\dots ,f_{n+1})$ defined by (1) is $O({\overline{m}}^3(n^2-t^2+n+t)+{{\tilde{m}}_1}^{2}t{!}^3{\prod }_{i=2}^t{{\tilde{m}}_i}^3)$ (numerical type determinant) or $O(\overline{m}!(n^2-t^2+n+t)+{{\tilde{m}}_1}^{2}t{!}^3{\prod }_{i=2}^t{{\tilde{m}}_i}^3)$ (symbolic type determinant).

Proof. 

Similar to the framework of a hybrid algorithm, we partition two phases to analyze the sequential complexity of our new method.

In the first phase, we consider successive Sylvester resultant computations. The most expensive component of this part is to compute a set of Sylvester resultants. It can be shown that evaluation of a $m\times m$ numerical determinant using row operations requires about $2m^3/3$ arithmetic operations ([35]). If symbolic determinant needs to be computed, a cofactor expansion requires over $m!$ multiplications in general. Suppose that $n-t$ variables are eliminated in the whole successive Sylvester resultant computations. When the ith elimination process is performed, we let $l_i(\le n+1-i)$ for $1\le i\le n-t$ denote the number of Sylvester resultant computations and $\overline{m}$ denote the degree bound of polynomials.

In terms of the complexity of determinant computation, the first phase requires $\frac{2}{3}{\overline{m}}^3{\sum }_{i=1}^{n-t}{l}_i$ arithmetic operations for numerical determinant or $\frac{\overline{m}!}{2}{\sum }_{i=1}^{n-t}{l}_i$ arithmetic operations for the symbolic determinant. Hence, the complexity of this part is $O\left({\overline{m}}^3(n^2-t^2+n+t)\right)$ or $O(\overline{m}!(n^2-t^2+n+t))$ using big-O notation.

In the second phase, we consider improved FRDixon for system (7). The main cost is calculation of (8). Each of these $P_{k,i}·D{D}_{k,j+1}$’s requires

$$[{((t-1)!{\prod }_{l=2}^t{\tilde{m}}_l)}^3+(t-1){((t-1)!{\prod }_{l=2}^t{\tilde{m}}_l)}^2]$$

multiplications and

$$[{((t-1)!{\prod }_{l=2}^t{\tilde{m}}_i)}^3-(t-2){((t-1)!{\prod }_{l=2}^t{\tilde{m}}_l)}^2]+(t-2)(t-1)!{\prod }_{l=2}^t{\tilde{m}}_l)$$

additions. The $t{{\tilde{m}}_1}^2$ calls to compute $S_i·F_j$ cost

$$(t^2-1)t{{\tilde{m}}_1}^2[{((t-1)!{\prod }_{l=2}^t{\tilde{m}}_l)}^3+(t-1){((t-1)!{\prod }_{l=2}^t{\tilde{m}}_l)}^2]$$

multiplications and

$$\begin{array}{cc}\hfill (t^2-1)t{{\tilde{m}}_1}^2[& {((t-1)!{\prod }_{l=2}^t{\tilde{m}}_l)}^3-(t-2){((t-1)!{\prod }_{l=2}^t{\tilde{m}}_l)}^2+(t-2)(t-1)!{\prod }_{l=2}^t{\tilde{m}}_l+\hfill \\ & {(t!{\prod }_{l=2}^t{\tilde{m}}_l)}^2]\hfill \end{array}$$

additions. The $\mathrm{Dixon}(q_1,\dots ,q_{t+1})$ can be constructed in ${(t{\tilde{m}}_1-1)}^2$ additions using the method given in (16). Hence, the complexity of improved FRDixon is

$$(t^2-1)t{{\tilde{m}}_1}^2[{((t-1)!{\prod }_{l=2}^t{\tilde{m}}_l)}^3+(t-1){((t-1)!{\prod }_{l=2}^t{\tilde{m}}_l)}^2]$$

multiplications and

$$(t^2-1)t{{\tilde{m}}_1}^2[{\tilde{T}}^3-(t-2){\tilde{T}}^2+(t-2)\tilde{T}+{(t!{\prod }_{l=2}^t{\tilde{m}}_l)}^2]+{(t{\tilde{m}}_1-1)}^2$$

additions, where $\tilde{T}=(t-1)!{\prod }_{l=2}^t{\tilde{m}}_l$. If we use big-O notation, the complexity of improved FRDixon is $O\left({{\tilde{m}}_1}^2{t!}^3{\prod }_{l=2}^t{{\tilde{m}}_l}^3\right)$.

Hence, the complexity of hybrid algorithm is $O({\overline{m}}^3(n^2-t^2+n+t)+{{\tilde{m}}_1}^2{t!}^3{\prod }_{i=2}^t{{\tilde{m}}_i}^3)$ for numerical type or $O(\overline{m}!(n^2-t^2+n+t)+{{\tilde{m}}_1}^2{t!}^3{\prod }_{i=2}^t{{\tilde{m}}_i}^3)$ for symbolic type. □

4.2. Random Systems

To compare the performance of our hybrid algorithm, successive Sylvester resultant elimination method and FRDixon ([11,16]), we have implemented these algorithms on three benchmark sets with different sizes. All timings reported are in CPU seconds and were obtained using Maple 18 on Intel Core i5 3470 @ 3.20 GHz running Windows 10, involving basic operations such as matrix multiplication and determinant calculations.

4.2.1. Timings

Each polynomial of systems S1–S30 in Table 1, Table 2 and Table 3 is generated at random using the Maple command ‘randpoly’. To guarantee the sparsity of the system, remove one variable randomly from each polynomial in every system of S1–S30. One hundred instances are contained in each system and the average running time is reported. The timings for columns 4, 5 and 6 of Table 1, Table 2 and Table 3 are for the successive Sylvester resultant elimination method (SylRes for short), FRDixon and hybrid algorithm (Hybrid for short), respectively. To better assess the parallel implementation of our algorithm, we report timings and speed-ups for four cores listed in column 7 in Table 1, Table 2 and Table 3. ’—’ indicates that the program went on for more than 2000s, or ran out of space.

Benchmark$\#1$

This set of benchmarks consists of 10 groups of systems. Every system of S1–S10 contains five polynomial equations in four variables.

The data in Table 1 show that for systems S1–S10, our new algorithm has a better performance compared to FRDixon. For systems S1–S4, SylRes has fewer timings than the hybrid algorithm. As terms and degrees increase, systems become more complex. Our hybrid algorithm is superior to SylRes. Considering test instances S9 and S10, we tried successive resultant computations using the existing implementations of Sylvester’s resultant in Maple for various variable orderings, but most of the time, the computations run out of memory. We also tried to compute Dixon matrix by FRDixon. The program ran for up to 2000s in these examples.

Table 1. Benchmark $\#1$: variables = 4.

System	Term	Degree	Average Time (s)
			SylRes	FRDixon	Hybrid	Hybrid (in Parallel)
S1	4	2	0.43	11.575	2.283	0.771
S2	5	2	0.93	19.274	2.673	0.879
S3	6	3	11.40	216.115	40.398	11.481
S4	7	3	36.02	234.975	49.641	13.264
S5	8	4	234.51	558.974	94.813	24.813
S6	9	4	265.42	568.757	105.221	28.952
S7	10	5	1469.08	906.224	287.381	73.475
S8	11	5	1564.15	921.901	297.517	76.837
S9	12	6	—	—	764.242	195.073
S10	13	6	—	—	773.361	197.019

Table 1. Benchmark $\#1$: variables = 4.

System	Term	Degree	Average Time (s)
			SylRes	FRDixon	Hybrid	Hybrid (in Parallel)
S1	4	2	0.43	11.575	2.283	0.771
S2	5	2	0.93	19.274	2.673	0.879
S3	6	3	11.40	216.115	40.398	11.481
S4	7	3	36.02	234.975	49.641	13.264
S5	8	4	234.51	558.974	94.813	24.813
S6	9	4	265.42	568.757	105.221	28.952
S7	10	5	1469.08	906.224	287.381	73.475
S8	11	5	1564.15	921.901	297.517	76.837
S9	12	6	—	—	764.242	195.073
S10	13	6	—	—	773.361	197.019

Benchmark$\#2$

This set of systems differs from the first benchmark in that the degree of each polynomial is set to be four in the second set. The number of terms and variables varies from small to large.

In the experimentation of benchmark $\#2$ in Table 2, we found that our new hybrid algorithm is faster than FRDixon for computing the Dixon matrix. Notice that when the number of variables increases up to 7 and the terms of polynomials reach 12 or more, the FRDixon was not successfully terminated after 2000s. There were similar results for benchmark $\#1$. Successive Sylvester resultant computations cost less than our method in simple systems S11 and S12. However, for complicated systems, the successive technique shows its inefficiency.

Table 2. Benchmark $\#2$: degrees = 4.

System	Term	Variable	Average Time (s)
			SylRes	FRDixon	Hybrid	Hybrid (in Parallel)
S11	4	3	0.23	6.391	0.507	0.187
S12	5	3	0.21	5.330	0.847	0.223
S13	6	4	203.74	524.672	89.325	23.492
S14	7	4	219.53	533.013	98.321	26.398
S15	8	5	564.12	760.180	279.945	70.447
S16	9	5	596.09	781.112	299.864	76.106
S17	10	6	1759.25	1265.803	594.381	151.093
S18	11	6	—	1301.021	617.829	155.479
S19	12	7	—	—	1359.986	346.983
S20	13	7	—	—	1505.042	382.271

Table 2. Benchmark $\#2$: degrees = 4.

System	Term	Variable	Average Time (s)
			SylRes	FRDixon	Hybrid	Hybrid (in Parallel)
S11	4	3	0.23	6.391	0.507	0.187
S12	5	3	0.21	5.330	0.847	0.223
S13	6	4	203.74	524.672	89.325	23.492
S14	7	4	219.53	533.013	98.321	26.398
S15	8	5	564.12	760.180	279.945	70.447
S16	9	5	596.09	781.112	299.864	76.106
S17	10	6	1759.25	1265.803	594.381	151.093
S18	11	6	—	1301.021	617.829	155.479
S19	12	7	—	—	1359.986	346.983
S20	13	7	—	—	1505.042	382.271

Benchmark$\#3$

This set of benchmarks consists of 10 groups of systems of terms $=6$ polynomial equations with varying numbers of variables and degrees. See Table 3. As analysis of the complexity of the hybrid algorithm, the number of arithmetic operations is mainly affected by variables and degrees. With the increase in these two parameters, three algorithms need more computation time for completion. Facing intractable systems S27–S30, SylRes and FRDixon are both powerless.

In all experiments listed in Table 1, Table 2 and Table 3, our hybrid algorithm always takes advantage of the sparsity of a given system and combines successive Sylvester resultant computations with improved FRDixon. The average running time is never more than the original FRDixon. Except for some “simple” instances, the new algorithm has a better performance compared to successive Sylvester resultant computations.

Table 3. Benchmark $\#3$: terms = 6.

System	Degree	Variable	Average Time (s)
			SylRes	FRDixon	Hybrid	Hybrid (in Parallel)
S21	2	3	0.02	2.640	0.207	0.072
S22	3	3	0.12	5.639	0.440	0.134
S23	3	4	11.01	223.527	34.568	9.007
S24	4	4	125.03	516.969	87.380	22.043
S25	4	5	532.52	727.617	271.239	69.971
S26	5	5	844.64	1106.289	478.947	122.307
S27	5	6	—	—	851.086	215.152
S28	6	6	—	—	987.602	249.005
S29	6	7	—	—	1823.056	460.764
S30	7	7	—	—	1909.443	483.125

Table 3. Benchmark $\#3$: terms = 6.

System	Degree	Variable	Average Time (s)
			SylRes	FRDixon	Hybrid	Hybrid (in Parallel)
S21	2	3	0.02	2.640	0.207	0.072
S22	3	3	0.12	5.639	0.440	0.134
S23	3	4	11.01	223.527	34.568	9.007
S24	4	4	125.03	516.969	87.380	22.043
S25	4	5	532.52	727.617	271.239	69.971
S26	5	5	844.64	1106.289	478.947	122.307
S27	5	6	—	—	851.086	215.152
S28	6	6	—	—	987.602	249.005
S29	6	7	—	—	1823.056	460.764
S30	7	7	—	—	1909.443	483.125

4.2.2. Matrix Dimension

According to the definition of the resultant (determinant of resultant matrix), one can notice that the dimension of resultant matrix is the key factor affecting the computational complexity on the target resultant. In order to compare the matrix dimension generated by FRDixon and the hybrid algorithm, we record the matrix sizes of systems S1–S30, as shown in

Table 4. Matrix dimensions corresponding to systems in Table 1.

Algorithm	Matrix Dimension
	S1	S2	S3	S4	S5
Hybrid	$48\times 48$	$48\times 48$	$480\times 480$	$720\times 720$	$1008\times 1008$
FRDixon	$192\times 192$	$192\times 192$	$864\times 864$	$864\times 864$	$1944\times 1944$
	S6	S7	S8	S9	S10
Hybrid	$1440\times 1440$	$1260\times 1260$	$1296\times 1296$	$2592\times 2592$	$3402\times 3402$
FRDixon	$2304\times 2304$	$2800\times 2800$	$2800\times 2800$	—	—

,

Table 5. Matrix dimensions corresponding to systems in Table 2.

Algorithm	Matrix Dimension
	S11	S12	S13	S14	S15
Hybrid	$72\times 72$	$96\times 96$	$864\times 864$	$1008\times 1008$	$1296\times 1296$
FRDixon	$144\times 144$	$144\times 144$	$1944\times 1944$	$1944\times 1944$	$5760\times 5760$
	S16	S17	S18	S19	S20
Hybrid	$1944\times 1944$	$2970\times 2970$	$3168\times 3168$	$6336\times 6336$	$7128\times 7128$
FRDixon	$5760\times 5760$	$8640\times 8640$	$8640\times 8640$	—	—

and

Table 6. Matrix dimensions corresponding to systems in Table 3.

Algorithm	Matrix Dimension
	S21	S22	S23	S24	S25
Hybrid	$12\times 12$	$18\times 18$	$480\times 480$	$840\times 840$	$1440\times 1440$
FRDixon	$24\times 24$	$48\times 48$	$864\times 864$	$1944\times 1944$	$5760\times 5760$
	S26	S27	S28	S29	S30
Hybrid	$2160\times 2160$	$5760\times 5760$	$7128\times 7128$	$8640\times 8640$	$9072\times 9072$
FRDixon	$6480\times 6480$	—	—	—	—

.

From Table 4, Table 5 and Table 6, we can see that the size of the Dixon matrix produced by hybrid algorithm is much smaller than FRDixon for any system.

4.3. Real Problems

In order to measure the comprehensive performance of the hybrid algorithm in the real problems, we implement our new algorithm on an open optimization problem in combinatorial geometry.

Given a spherical triangle $△ABC$ whose length of sides are a, b and c, respectively, the problem is to find a point P on the sphere such that the sum of distances L between the point P and the vertexes of $△ABC$ reaches the minimum.

As illustrated in Figure 1, let $AB=c$, $BC=a$, $AC=b$, $PA=u$, $PB=v$, $PC=w$ and $L=u+v+w$. All distances are measured by an Euclidean metric. If we can find the relationship between a, b, c and L, the original minimum problem is solved.

By applying the Lemma $42.1$ in [36] and the compactness of the sphere, we can prove that a point P on sphere is such that the Cayley–Menger determinant equals to zero. That is, the distances between the center point O of the sphere and A, B, C, P should satisfy

$$V(a,b,c,u,v,w)=\left|\begin{array}{cccccc}0& 1& 1& 1& 1& 1\\ 1& 0& u^2& v^2& w^2& 1\\ 1& u^2& 0& c^2& b^2& 1\\ 1& v^2& c^2& 0& a^2& 1\\ 1& w^2& b^2& a^2& 0& 1\\ 1& 1& 1& 1& 1& 0\end{array}\right|=0.$$

(17)

Now, we transform the relationship between a, b, c and L into an optimization problem of the following form

$$\begin{array}{c}minL=u+v+w\hfill \\ s.t.V(a,b,c,u,v,w)=0.\hfill \end{array}$$

(18)

Consequently, the Fermat–Torricelli point P on the sphere is such that the polynomial system

$$\left\{\begin{array}{c}L-u-v-w=0\hfill \\ \frac{\partial G}{\partial \lambda }=0,\frac{\partial G}{\partial u}=0,\frac{\partial G}{\partial v}=0,\frac{\partial G}{\partial w}=0.\hfill \end{array}\right.$$

(19)

where

$$G=u+v+w+\lambda ·V(a,b,c,u,v,w).$$

(20)

From (17)–(20), we obtain the polynomial system

$$\left\{\begin{array}{c}{f}_1(u,v,w,\lambda )=L-u-v-w\hfill \\ f_2(u,v,w,\lambda )=-a^4{u}^4+2a^2{b}^2{u}^2{v}^2+\dots -4c^2{v}^2{w}^2+4c^2{w}^4\left(28\mathrm{terms}\right)\hfill \\ f_3(u,v,w,\lambda )=\left(-4a^4{u}^3+4a^2{b}^{2}u{v}^2+\dots +8c^{2}u{v}^2-8c^{2}u{w}^2\right)\lambda +1\left(14\mathrm{terms}\right)\hfill \\ f_4(u,v,w,\lambda )=\left(4a^2{b}^2{u}^{2}v-4b^4{v}^3+\dots +8c^2{u}^{2}v-8c^{2}v{w}^2\right)\lambda +1\left(14\mathrm{terms}\right)\hfill \\ f_5(u,v,w,\lambda )=\left(4a^2{c}^2{u}^{2}w+4b^2{c}^2{v}^{2}w+\dots -8c^2{v}^{2}w+16c^2{w}^3\right)\lambda +1\left(14\mathrm{terms}\right).\hfill \end{array}\right.$$

(21)

It is easy to know that this geometry problem is equivalent to solving the polynomial system (21) with five equations and four variables.

We first report the result that (21) solved by successive Sylvester resultant computation techniques. The order of elimination is $\lambda$, u, v and w. Starting with computing $\mathrm{res}(f_3,f_5,\lambda )$ and $\mathrm{res}(f_4,f_5,\lambda )$, the variable $\lambda$ is eliminated from (21),

$$\left\{\begin{array}{c}{f}_1(u,v,w)=L-u-v-w\hfill \\ f_2(u,v,w)=-a^4{u}^4+2a^2{b}^2{u}^2{v}^2+\dots -4c^2{v}^2{w}^2+4c^2{w}^4\left(28\mathrm{terms}\right)\hfill \\ f_{3,5}(u,v,w)=-4a^4{u}^3-4a^2{b}^2{u}^{2}v+\dots -8c^{2}u{w}^2+8c^{2}v{w}^2\left(26\mathrm{terms}\right)\hfill \\ f_{4,5}(u,v,w)=-4a^4{u}^3+4a^2{b}^{2}u{v}^2+\dots +8c^2{v}^{2}w-16c^2{w}^3\left(26\mathrm{terms}\right).\hfill \end{array}\right.$$

(22)

This is followed by computing

$$\begin{array}{c}{p}_1=\mathrm{res}(f_1,f_2,u),p_2=\mathrm{res}(f_1,f_{3,5},u),p_3=\mathrm{res}(f_1,f_{4,5},u);\hfill \end{array}$$

(23)

and

$$p_4=\mathrm{res}(p_1,p_2,v),p_5=\mathrm{res}(p_1,p_3,v);$$

to eliminate u and v, respectively. Finally, w is eliminated by computing

$$p_6=\mathrm{res}(p_4,p_5,w).$$

It was found that the elimination process of $\mathrm{res}(p_4,p_5,w)$ could not be completed due to the memory overflows after 7961.3 s.

Now, we discuss the trace of our algorithm on this system. First, $\lambda$ was eliminated by computing $\mathrm{res}(f_3,f_5,\lambda )$ and $\mathrm{res}(f_4,f_5,\lambda )$. This took 0.85 s. This was followed by the construction of a Dixon matrix of system (22), which turned out to be $384\times 384$, and this took 40.127 s. The total computational cost took 40.977 s. Another scheme was to eliminate two variables $\lambda$ and u by proceeding with (22) and (23). This took 1.48 s. Then, FRDixon was used to compute the target Dixon matrix. After 1.626 s, a $32\times 32$ Dixon matrix was obtained. The total computations took 3.106 s. The second scheme, in contrast, works better than the first.

Lastly, let us look at the FRDixon. It took 895.013 s to compute the Dixon matrix of $1536\times 1536$. The results of these methods are summarized in

Table 7. Comparing the timings and the dimensions of Fermat–Torricelli problem on sphere with Euclidean metric.

	SylRes	FRDixon	Hybrid
			Scheme 1	Scheme 2
Timings	>7961.3	895.013	40.977	3.106
Dimension of matrix	—	$1536\times 1536$	$384\times 384$	$32\times 32$

.

5. Conclusions

In this paper, we proposed a hybrid algorithm which combines the Sylvester resultant elimination based on heuristic strategy and the improved fast recursive Dixon matrix construction algorithm. Our hybrid algorithm can construct a Dixon matrix efficiently, and the dimension is smaller than other existing algorithms. Moreover, we can achieve reasonable robustness through randomization cases over different sizes of systems and a real problem.

To conclude, we point out that the polynomial systems are sparse in many applications. Our hybrid method seems to be very suitable for such a scenario. We have demonstrated some prospects of our approach through a great example. These preliminary findings are very encouraging and suggest that further studies are needed to examine methods based on hybrid algorithms. We are therefore planning to explore different and specific applications. For instance, we are planning to apply a Dixon resultant as an algebraic attack method to solve multivariate polynomial quadratic systems over finite fields.