![Table 1. A comparison of the sizes of important computation steps performed by solvers generated using our new method with that of the solvers generated based on our attempted extensions of the algorithm by Heikkilä [6] as well as the solvers generated using an u-resultant based method. Missing entry is for the case where we failed to generate a solver.](/figures/table-1-a-comparison-of-the-sizes-of-important-computation-2g82h1ib.webp)
![Table 3. A comparison of stability for solvers generated by our proposed resultant-based method, solvers generated using [11] and heuristicbased solvers [13] on some more minimal problems. Mean and median are computed from Log10 of normalized equation residuals. Missing entries are when we failed to extract solutions to all variables. (†): Input polynomials were eliminated using G-J elimination before generating a solver using our resultant method as well as solvers based on [11] and the heuristic-based solver [13]. (‡): Alternate eigenvalue formulation used for generating the solver based on our proposed method(see Proposition 3.1 in our main paper).](/figures/table-3-a-comparison-of-stability-for-solvers-generated-by-1nr4i1f4.webp)
![Table 4. Errors for the real Rotunda dataset. The errors are relative to the ground truth for all except rotation which is shown in degrees. The results for the P4Pfr solver (40× 50) [12] are taken from [12]](/figures/table-4-errors-for-the-real-rotunda-dataset-the-errors-are-jotvsy91.webp)
A sparse resultant based method for efficient minimal solvers
Snehal Bhayani
Center for Machine Vision and Signal Analysis
University of Oulu, Finland
snehal.bhayani@oulu.fi
Zuzana Kukelova
Center for Machine Perception
Czech Technical University, Prague
kukelova@cmp.felk.cvut.cz
Janne Heikkil
¨
a
Center for Machine Vision and Signal Analysis
University of Oulu, Finland
janne.heikkila@oulu.fi
Abstract
Many computer vision applications require robust and effi-
cient estimation of camera geometry. The robust estimation
is usually based on solving camera geometry problems from
a minimal number of input data measurements, i.e. solving
minimal problems in a RANSAC framework. Minimal prob-
lems often result in complex systems of polynomial equa-
tions. Many state-of-the-art efficient polynomial solvers to
these problems are based on Gr
¨
obner bases and the action-
matrix method that has been automatized and highly opti-
mized in recent years. In this paper we study an alternative
algebraic method for solving systems of polynomial equa-
tions, i.e., the sparse resultant-based method and propose
a novel approach to convert the resultant constraint to an
eigenvalue problem. This technique can significantly im-
prove the efficiency and stability of existing resultant-based
solvers. We applied our new resultant-based method to a
large variety of computer vision problems and show that
for most of the considered problems, the new method leads
to solvers that are the same size as the the best available
Gr
¨
obner basis solvers and of similar accuracy. For some
problems the new sparse-resultant based method leads to
even smaller and more stable solvers than the state-of-the-
art Gr
¨
obner basis solvers. Our new method can be fully
automatized and incorporated into existing tools for auto-
matic generation of efficient polynomial solvers and as such
it represents a competitive alternative to popular Gr
¨
obner
basis methods for minimal problems in computer vision.
1. Introduction
Computing camera geometry is one of the most important
tasks in computer vision [16] with many applications e.g.
in structure from motion [38], visual navigation [37], large
scale 3D reconstruction [18] and image localization [36].
The robust estimation of camera geometry is usually
based on solving so-called minimal problems [34, 23, 22],
i.e. problems that are solved from minimal samples of in-
put data, inside a RANSAC framework [13, 8, 35]. Since
the camera geometry estimation has to be performed many
times in RANSAC [13], fast solvers to minimal problems
are of high importance. Minimal problems often result in
complex systems of polynomial equations in several vari-
ables. A popular approach for solving minimal problems is
to design procedures that can efficiently solve only a spe-
cial class of systems of equations, e.g. systems resulting
from the 5-pt relative pose problem [34], and move as much
computation as possible from the “online” stage of solving
equations to an earlier pre-processing “offline” stage.
Most of the state-of-the-art specific minimal solvers are
based on Gr
¨
obner bases and the action-matrix method [9].
The Gr
¨
obner basis method was popularized in computer vi-
sion by Stewenius [39]. The first efficient Gr
¨
obner basis
solvers were mostly handcrafted [40, 41] and sometimes
very unstable [42]. However, in the last 15 years much ef-
fort has been put into making the process of constructing
the solvers more automatic [23, 28, 29] and the solvers sta-
ble [5, 6] and more efficient [28, 29, 27, 4, 31]. There are
now powerful tools available for the automatic generation
of efficient Gr
¨
obner basis solvers [23, 28].
While the Gr
¨
obner basis method for generating efficient
minimal solvers was deeply studied in computer vision and
all recently generated Gr
¨
obner basis solvers are highly op-
timized in terms of efficiency and stability, little attention
has been paid to an alternative algebraic method for solving
systems of polynomial equations, i.e. the resultant-based
method. The resultant-based method was manually applied
to several computer vision problems [24, 15, 15, 19, 22, 24].
However in contrast to the Gr
¨
obner basis method, there is
1
arXiv:1912.10268v1 [cs.CV] 21 Dec 2019
no general method for automatically generating efficient
resultant-based minimal solvers. The most promising re-
sults in this direction were proposed by Emiris [11] and
Heikkil
¨
a [17], where methods based on sparse resultants
were proposed and applied to camera geometry problems.
While these methods can be extended for general minimal
problems that appear in computer vision and can be autom-
atized, they usually lead (due to linearizations) to larger and
less efficient solvers than Gr
¨
obner basis solvers.
In this paper, we propose a novel approach to generat-
ing minimal solvers using sparse resultants, which is based
on adding an extra equation of a special form to the in-
put system. Our algorithm is inspired by the ideas ex-
plored in [17, 11], but thanks to the special form of added
equation and by solving the resultant as a small eigenvalue
problem, in contrast to a polynomial eigenvalue problem
in [17], the new approach achieves significant improve-
ments over [17, 11] in terms of efficiency of the generated
solvers. Specifically our contributions include,
• A novel sparse resultant-based approach to generating
polynomial solvers based on adding an extra equation
of a special form and transforming the resultant matrix
constraint to a regular eigenvalue problem.
• Two procedures to reduce the size of resultant matrix
that lead to faster solvers than the best available state-
of-the-art solvers for some minimal problems.
• A general method for automatic generation of efficient
resultant-based polynomial solvers for many impor-
tant minimal problems that achieves competitive per-
formance in terms of speed and stability with respect
to the best available state-of-the-art solvers generated
by highly optimized Gr
¨
obner basis techniques [28, 31].
The automatic generator of resultant-based solvers will
be made publicly available.
2. Theoretical background and related work
In this paper we use notation and basic concepts from the
book by Cox et al. [9]. Our objective is to solve m polyno-
mial equations,
{f
1
(x
1
, . . . , x
n
) = 0, . . . , f
m
(x
1
, . . . , x
n
) = 0} (1)
in n unknowns, X = {x
1
, . . . , x
n
}. Let C[X] denote the
set of all polynomials in unknowns X with coefficients in C.
The ideal I = hf
1
, . . . , f
m
i ⊂ C[X] is the set of all poly-
nomial combinations of our generators f
1
, . . . , f
m
. The set
V of all solutions of the system (1) is called the affine va-
riety. Each polynomial f ∈ I vanishes on the solutions of
(1). Here we assume that the ideal I generates a zero di-
mensional variety, i.e. the system (1) has a finite number of
solutions. Using the ideal I we can define the quotient ring
A = C[X]/I which is the set of equivalence classes over
C[X] defined by the relation a ∼ b ⇐⇒ (a − b) ∈ I.
If I has a zero-dimensional variety then the quotient ring
A = C[X]/I is a finite-dimensional vector space over C.
For an ideal I there exist special sets of generators called
Gr
¨
obner bases which have the nice property that the remain-
der after division is unique. Using a Gr
¨
obner basis we can
define a linear basis for the quotient ring A = C[X]/I.
2.1. Gr
¨
obner Basis method
Gr
¨
obner bases can be used to solve our system of polyno-
mial equations (1). One of the popular approaches for solv-
ing systems of equations using Gr
¨
obner bases is the multi-
plication matrix method, known also as the action matrix
method [9, 43]. This method was recently used to effi-
ciently solve many of the minimal problems in computer
vision [22, 23, 28, 31]. The goal of this method is to trans-
form the problem of finding the solutions to (1) to a prob-
lem of eigendecomposition of a special multiplication ma-
trix [10]. Let us consider the mapping T
f
: A → A of the
multiplication by a polynomial f ∈ C[X]. T
f
is a linear
mapping for which T
f
= T
g
iff f − g ∈ I. In our case A is
a finite-dimensional vector space over C and therefore we
can represent T
f
by its matrix with respect to some linear
basis B of A. For a basis B = ([b
1
], . . . , [b
k
]) consisting of
k monomials, T
f
can be represented by k ×k multiplication
(action) matrix M
f
:= (m
ij
) such that T
f
([b
j
]) = [f b
j
] =
P
k
i=1
m
ij
[b
i
]. It can be shown [10] that λ ∈ C is an eigen-
value of the matrix M
f
iff λ is a value of the function f on
the variety V . In other words, if f is e.g. x
n
then the eigen-
values of M
f
are the x
n
-coordinates of the solutions of (1).
The solutions to the remaining variables can be obtained
from the eigenvectors of M
f
. This means that after finding
the multiplication matrix M
f
, we can recover the solutions
by solving the eigendecompostion of M
f
for which efficient
algorithms exist. Moreover, if the ideal I is a radical ideal,
i.e. I =
√
I, [10], then k is equal to the number of solutions
to the system (1). Therefore, Gr
¨
obner basis methods usu-
ally solve an eigenvalue problem of a size that is equivalent
to the number of solutions of the problem. For more details
and proofs we refer the reader to [9].
The coefficients of the multiplication matrix M
f
are poly-
nomial combinations of coefficients of the input polynomi-
als (1). For computer vision problems these polynomial
combinations are often found “offline“ in a pre-processing
step. In this step, a so-called elimination template is gener-
ated, which is actually an expanded set of equations con-
structed by multiplying original equations with different
monomials. This template matrix is constructed such that
after filling it with coefficients from the input equations and
performing Gauss-Jordan(G-J) elimination of this matrix,
the coefficients of the multiplication matrix M
f
can be ob-
tained from this eliminated template matrix.
The first automatic approach for generating elimination
templates and Gr
¨
obner basis solvers was presented in [23].
Recently an improvement to the automatic generator [23]
was proposed in [28] to exploit the inherent relations be-
tween the input polynomial equations and it results in more
efficient solvers than [23]. The automatic method from [28]
was later extended by a method for dealing with saturated
ideals [29] and a method for detecting symmetries in poly-
nomial systems [27].
In general, the answer to the question “What is the
smallest elimination template for a given problem?” is not
known. In [31] the authors showed that the method [28],
which is based on the grevlex ordering of monomials and
the so-called standard bases of the quotient ring A is not
optimal in terms of template sizes. The authors of [28]
proposed two methods for generating smaller elimination
templates. The first is based on enumerating and test-
ing all Gr
¨
obner bases w.r.t. different monomial order-
ings, i.e., the so-called Gr
¨
obner fan. By generating solvers
w.r.t. all these Gr
¨
obner bases and using standard bases
of the quotient ring A, smaller solvers were obtained for
many problems. The second method goes “beyond Gr
¨
obner
bases” and it uses a manually designed heuristic sampling
scheme for generating “non-standard” monomial bases B
of A = C[X]/I. This heuristic leads to more efficient
solvers than the Gr
¨
obner fan method in many cases. While
the Gr
¨
obner fan method will provably generate at least as
efficient solvers as the grevlex-based method from [28],
no proof can be in general given for the “heuristic-based”
method. The proposed heuristic sampling scheme uses
only empirical observations on which basis monomials will
likely result in small templates and it samples a fixed num-
ber (1000 in the paper) of candidate bases consisting of
these monomials. Even though, e.g. the standard grevlex
monomial basis will most likely be sampled during the sam-
pling, it is in general not clear how large templates it will
generate for a particular problem. The results will also de-
pend on the number of bases tested inside the heuristic.
2.2. Sparse Resultants
An alternate approach towards solving polynomial equa-
tions is that of using resultants. Simply put, a re-
sultant is an irreducible polynomial constraining co-
efficients of a set of n + 1 polynomials, F =
{f
1
(x
1
, . . . , x
n
), . . . , f
n+1
(x
1
, . . . , x
n
}) in n variables to
have a non-trivial solution. One can refer to Cox et al. [9]
for a more formal theory on resultants. We have n+1 equa-
tions in n variables because resultants were initially devel-
oped to determine whether a system of polynomial equa-
tions has a common root or not. If a coefficient of mono-
mial x
α
in the i
th
polynomial of F is denoted as u
i,α
the
resultant is a polynomial Res([u
i,α
]) with u
i,α
as variables.
Using this terminology, the basic idea for a resultant
based method is to expand F to a set of linearly independent
polynomials which can be linearised as M([u
i,α
])b, where
b is a vector of monomials of form x
α
and M([u
i,α
]) has
to be a square matrix that has full rank for generic val-
ues of u
i,α
, i.e. det M([u
i,α
]) 6= 0. The determinant of
the matrix M([u
i,α
]) is a non-trivial multiple of the resultant
Res([u
i,α
]) [9]. Thus det M([u
i,α
]) must vanish, if the resul-
tant vanishes, i.e. Res([u
i,α
]) = 0 =⇒ det M([u
i,α
]) = 0.
It is known that Res([u
i,α
]) vanishes iff the polynomial sys-
tem F has a solution [9]. This gives us the necessary condi-
tion for the existence of roots of F = 0. Hence the equation
det M([u
i,α
]) = 0 gives us those values of u
i,α
such that
F = 0 have a common root.
Resultants can be used to solve n polynomial equations
in n unknowns. The most common approach used for this
purpose is to hide a variable by considering it as a constant.
By hiding, say x
n
, we obtain n polynomials in n−1 vari-
ables, so we can use the concept of resultants and compute
Res([u
i,α
], x
n
) which now becomes a function of u
i,α
as
well as x
n
. Algorithms based on hiding a variable attempt
to expand F to a linearly independent set of polynomials
that can be re-written in a matrix form as
M([u
i,m
], x
n
)b = 0, (2)
where M([u
i,α
], x
n
) is a square matrix whose elements are
polynomials in x
n
and coefficients u
i,α
and b is the vec-
tor of monomials in x
1
, . . . , x
n−1
. For simplicity we will
denote the matrix M([u
i,α
], x
n
) as M(x
n
) in the rest of this
section. Here we actually estimate a multiple of the actual
resultant via the determinant of the matrix M(x
n
) in (2).
This resultant is known as a hidden variable resultant and
it is a polynomial in x
n
whose roots are the x
n
-coordinates
of the solutions of the system of polynomial equations. For
theoretical details and proofs see [9]. Such a hidden variable
approach has been used in the past to solve various minimal
problems [15, 19, 22, 24].
The most common way to solve the original system of
polynomial equations is to transform (2) to a polynomial
eigenvalue problem (PEP) [10] that transforms (2) as
(M
0
+ M
1
x
n
+ ... + M
l
x
l
n
)b = 0, (3)
where l is the degree of the matrix M(x
n
) in the hidden vari-
able x
n
and matrices M
0
, ..., M
l
are matrices that depend only
on the coefficients u
i,α
of the original system of polynomi-
als. The PEP (3) can be easily converted to a generalized
eigenvalue problem (GEP):
Ay = x
n
By, (4)
and solved using standard efficient eigenvalue algorithms.
Basically, the eigenvalues give us the solution to x
n
and the
rest of the variables can be solved from the corresponding
eigenvectors, y [9]. But this transformation to a GEP re-
laxes the original problem of finding the solutions to our
input system and computes eigenvectors that do not satisfy
the monomial dependencies induced by the monomial vec-
tor b. And many times it also introduces extra parasitic
(zero) eigenvalues leading to slower polynomial solvers.
Alternately, we can add a new polynomial
f
n+1
= u
0
+ u
1
x
1
+ ··· + u
n
x
n
(5)
to F and compute a so called u-resultant [9] by hiding
u
0
, . . . , u
n
. In general random values are assigned to
u
1
, . . . , u
n
. The u-resultant matrix is computed from these
n + 1 polynomials in n variables in a way similar to the one
explored above. For more details about u-resultant one can
refer to [9].
For sparse polynomial systems it is possible to ob-
tain more compact resultants using specialized algorithms.
Such resultants are commonly referred to as Sparse Re-
sultants. A sparse resultant would mostly lead to a more
compact matrix M(x
n
) and hence a smaller eigendecom-
position problem. Emiris et al. [12, 7] have proposed a
generalised approach for computing sparse resultants using
mixed-subdivision of polytopes. Based on [12, 7] Emiris
proposed a method for generating a resultant-based solver
for sparse systems of polynomial equations, that was di-
vided in “offline” and “online” computations. The resulting
solvers were based either on the hidden-variable trick (2) or
the u-resultant of the general form (5). As such the result-
ing solvers were usually quite large and not very efficient.
More recently Heikkil
¨
a [17] have proposed an improved
approach to test and extract smaller M(x
n
). This method
transforms (2) to a GEP (4) and solves for eigenvalues and
eigenvectors to compute solutions to unknowns. The meth-
ods [7, 11, 12, 17] suffer from the drawback that they re-
quire the input system to have as many polynomials as un-
knowns to be able to compute a resultant. Additionally, the
algorithm [17] suffers from other drawbacks and can not be
directly applied to most of the minimal problems. These
drawbacks can be overcome, as we describe in the supple-
mentary material. However, even with our proposed im-
provements the resultant-based method [17], which is based
on hiding one of the input variables in the coefficient field,
would result in a GEP with unwanted eigenvalues and in
turn unwanted solutions to original system (1). This leads
to slower solvers for most of the studied minimal problems.
Therefore, we investigate an alternate approach where
instead of hiding one of the input variables [11, 17] or us-
ing u-resultant of a general form (5) [11], we introduce an
extra variable λ and a new polynomial of a special form,
i.e., x
i
− λ. The augmented polynomial system is solved
by hiding λ and reducing a constraint similar to (2) into
a regular eigenvalue problem that leads to smaller solvers
than [11, 17]. Next section lays the theoretical foundation
of our approach and outlines the algorithm along with the
steps for computing a sparse resultant matrix M(λ).
3. Sparse resultants using an extra equation
We start with a set of m polynomials from (1) in n vari-
ables x
1
, . . . , x
n
to be solved. Introducing an extra variable
λ we define x
0
= [x
1
, . . . , x
n
, λ] and an extra polynomial
f
m+1
(x
0
) = x
i
− λ. Using this, we propose an algorithm
inspired by [17] and [11] to solve the following augmented
polynomial system for x
0
,
f
1
(x
0
) = 0, . . . , f
m
(x
0
) = 0, f
m+1
(x
0
) = 0. (6)
Our idea it to compute its sparse resultant matrix M(= M(λ))
by hiding λ in a way that allows us to solve (6) by reducing
its linearization (similar to (2)) to an eigenvalue problem.
3.1. Sparse resultant and eigenvalue problem
Our algorithm computes the monomial multiples of
the polynomials in (6) in the form of a set T =
{T
1
, . . . , T
m
, T
m+1
} where each T
i
denotes the set of
monomials to be multiplied by f
i
(x
0
). We may order mono-
mials in each T
i
to obtain a vector form, T
i
= vec(T
i
) and
stack these vectors as T = [T
1
, . . . , T
m
, T
m+1
] . The set
of all monomials present in the resulting extended set of
polynomials {x
α
i
f
i
(x
0
), ∀x
α
i
∈ T
i
, i = 1, . . . m + 1} is
called the monomial basis and is denoted as B = {x
α
|
α ∈ Z
n
≥0
}. The vector form of B w.r.t. some monomial
ordering is denoted as b. Then the extended set of polyno-
mials can be written in a matrix form,
M b = 0, (7)
The coefficient matrix M is a function of λ as well as the
coefficients of input polynomials (6). Let ε = |B|. Then
by construction [17] M is a tall matrix with p ≥ ε rows. We
can remove extra rows and form an invertible square matrix
which is the sparse resultant matrix mentioned in previous
section. While Heikkil
¨
a [17] solve a problem similar to (7)
as a GEP, we exploit the structure of newly added polyno-
mial f
m+1
(x
0
) and propose a block partition of M to reduce
the matrix equation of (7) to a regular eigenvalue problem.
Proposition 3.1. Let f
m+1
(x
0
) = x
i
− λ, then there exists
a block partitioning of M in (7) as:
M =
M
11
M
12
M
21
M
22
, (8)
such that (7) can be converted to an eigenvalue problem of
the form X b
0
= λb
0
.
Proof: In order to block partition the columns in (8) we
need to partition B as B = B
λ
t B
c
where
B
λ
= B ∩ T
m+1
, B
c
= B − B
λ
. (9)
Let us order the monomials in B, such that b = vec(B) =
vec(B
λ
) vec(B
c
)
T
=
b
1
b
2
T
. Such a partition of b in-
duces a column partition of M (7). We row partition M such
that the lower block is row-indexed by monomial multiples
of f
m+1
(x
0
) which are linear in λ (i.e. x
α
j
(x
i
− λ), x
α
j
∈
T
m+1
) while the upper block is indexed by monomial mul-
tiples of f
1
(x
0
), . . . , f
m
(x
0
). Such a row and column parti-
tion of M gives us a block partition as in (8). As
M
11
M
12
contains polynomials independent of the λ and
M
21
M
22
contains polynomials of the form x
α
j
(x
i
− λ) we obtain
M
11
= A
11
, M
12
= A
12
M
21
= A
21
+ λB
21
, M
22
= A
22
+ λB
22
, (10)
where A
11
, A
12
, A
21
and A
22
are matrices dependent only on
the coefficients of input polynomials in (6). We assume here
that A
12
has full column rank. Substituting (10) in (8) gives
M =
M
11
M
12
M
21
M
22
=
A
11
A
12
A
21
A
22
+ λ
0 0
B
21
B
22
(11)
We can order monomials so that T
m+1
= b
1
. Now chosen
partition of M implies that M
21
is column indexed by b
1
and
row indexed by T
m+1
. As
M
21
M
22
has rows of form
x
α
j
(x
i
−λ), x
α
j
∈ T
m+1
=⇒ x
α
j
∈ B
λ
. This gives us,
B
21
= −I, where I is an identity matrix of size |B
λ
| and
B
22
is a zero matrix of size |B
λ
| × |B
c
|. This also means
that A
21
is a square matrix of same size as B
21
. Thus we
have a decomposition as
M = M
0
+ λM
1
=
A
11
A
12
A
21
A
22
+ λ
0 0
−I 0
, (12)
where M is a p × ε matrix. If M is a tall matrix, so is A
12
from which we can eliminate extra rows to obtain a square
invertible matrix
ˆ
A
12
while preserving the above mentioned
structure, as discussed in Section 3.3. Let b =
b
1
b
2
T
.
Then from (7) and (12) we have
A
11
ˆ
A
12
A
21
A
22
b
1
b
2
+ λ
0 0
−I 0
b
1
b
2
= 0
=⇒ A
11
b
1
+
ˆ
A
12
b
2
= 0,
A
21
b
1
+ A
22
b
2
− λb
1
= 0 (13)
Eliminating b
2
from the above pair of equations we obtain
X
z }| {
(A
21
− A
22
ˆ
A
−1
12
A
11
) b
1
= λb
1
. (14)
If A
12
does not have full column rank, we change the par-
titioning of columns of M by changing the partitions, B
λ
=
{x
m
∈T
m+1
| x
i
x
m
∈ B} and B
c
= B −B
λ
by exploiting
the form of f
m+1
(x
0
). This gives us A
21
=I and A
22
=0. It
also results in a different A
12
which would have full column
rank. Hence from (12) we have
M = M
0
+ λM
1
=
A
11
A
12
I 0
+ λ
0 0
B
21
B
22
,(15)
which is substituted in (7) to get A
11
b
1
+ A
12
b
2
= 0 and
λ(B
21
b
1
+ B
22
b
2
) + b
1
= 0. Eliminating b
2
from these
equations we get an alternate eigenvalue formulation:
(B
21
− B
22
ˆ
A
−1
12
A
11
)b
1
= −(1/λ)b
1
. (16)
We note that (14) defines our proposed solver. Here we can
extract solutions to x
1
, . . . , x
n
by computing eigenvectors
of X. If in case
ˆ
A
12
is not invertible, we can use the al-
ternate formulation (16) and extract solutions in a similar
manner. It is worth noting that the speed of execution of
the solver depends on the size of b
1
(=|B
λ
|) as well the size
of
ˆ
A
12
while the accuracy of the solver largely depends on
the matrix to be inverted i.e.
ˆ
A
12
. Hence, in next section
we outline a generalized algorithm for computing a set of
monomial multiples T as well as the monomial basis B that
leads to matrix M satisfying Proposition 3.1.
3.2. Computing a monomial basis
Our approach is based on the algorithm explored in [17] for
computing a monomial basis B for a sparse resultant.
We briefly define the basic terms related to convex poly-
topes used for computing a monomial basis B. A New-
ton polytope of a polynomial NP(f) is defined as a con-
vex hull of the exponent vectors of the monomials occur-
ring in the polynomial (also known as the support of the
polynomial). Hence, we have NP(f
i
) = Conv(A
i
) where
A
i
= {α|α ∈ Z
n
≥0
} is the set of all integer vectors that are
exponents of monomials with non-zero coefficients in f
i
.
A Minkowski sum of any two convex polytopes P
1
, P
2
is
defined as P
1
+ P
2
= {p
1
+ p
2
| ∀p
1
∈ P
1
, p
2
∈ P
2
}.
An extensive treatment of polytopes can be found from
[9]. The algorithm by Heikkil
¨
a [17] basically computes the
Minkowski sum of the Newton polytopes of a subset of in-
put polynomials, Q = Σ
i
NP(f
i
(x)). The set of integer
points in the interior of Q defined as B = Z
n−1
∩(Q + δ),
where δ is a small random displacement vector, can pro-
vide a monomial basis B satisfying the constraint (2). Our
proposed approach computes B as a prospective monomial
basis in a similar way, albeit for a modified polynomial sys-
tem (6). Next we describe our approach and provide a de-
tailed algorithm for the same in the supplementary material.
Given a system of m(≥ n) polynomials (1) in n vari-
ables X = {x
1
, . . . , x
n
} we introduce a new variable λ and
create n augmented systems F
0
= {f
1
, . . . , f
m
, x
i
−λ} for
each variable x
i
∈ X. Then we compute the support A
j
=
supp(f
j
) and the Newton polytope NP(f
j
) = conv(A
j
) for
each polynomial f
j
∈ F
0
. The unit simplex NP
0
⊂ Z
n
is
also computed. For each polynomial system F
0
, we con-
sider each subset of polynomials F
sub
⊂ F
0
and compute its
Minkowski sum, Q = NP
0
+ Σ
f∈F
sub
NP(f). Then for var-
ious displacement vectors δ we try to compute a candidate
monomial basis B as the set of integer points inside Q + δ.