The elliptope is defined by

where means that matrix is positive semidefinite. Since the elliptope is defined by the linear matrix inequality (LMI) , we can conclude that  is a spectrahedron and, therefore, we have that is convex.

The elliptope (also known as “inflated tetrahedron”) is the yellow part (surface and interior) of the Cayley’s cubic surface plotted below

[ source ]

__________

is a semialgebraic set

Saying that is positive semidefinite is equivalent to saying that the principal minors of are nonnegative. If , then the three 1st order principal minors (which are the diagonal entries of ) lead to the following three (admittedly uninteresting) inequalities

,     ,    

which we can discard. The three 2nd order principal minors (determinants of submatrices of ) and the 3rd order principal minor (the determinant of ) can be computed using the following Python 2.5 + SymPy script:

from sympy import *

# symbolic variables
x1 = Symbol('x1')
x2 = Symbol('x2')
x3 = Symbol('x3')

# build matrix A(x)
A = Matrix([[1,x1,x2],
            [x1,1,x3],
            [x2,x3,1]])

print "\nMatrix A(x):"
print A

print "\n2nd order principal minors:"
print A.extract([0,1],[0,1]).det()
print A.extract([0,2],[0,2]).det()
print A.extract([1,2],[1,2]).det()

print "\n3rd order principal minor:"
print A.det()

which produces the following output:

Matrix A(x):
[ 1, x1, x2]
[x1,  1, x3]
[x2, x3,  1]

2nd order principal minors:
-x1**2 + 1
-x2**2 + 1
-x3**2 + 1

3rd order principal minor:
-x1**2 + 2*x1*x2*x3 - x2**2 - x3**2 + 1

Hence, the 2nd order principal minors yield the following inequalities

,     ,    

which define the -dimensional cube . The 3rd order principal minor (i.e., the determinant) yields the inequality

.

We can thus conclude that is a basic closed semialgebraic set.

__________

Deciding the convexity of

In my last post, I used quantifier elimination to decide the convexity of two semialgebraic sets in . Let us now decide the convexity of , which is of higher “complexity” than the sets I considered last time. What is the goal? The goal is to find out whether REDLOG can decide the convexity of in less than 10 minutes.

Based on the scripts in my previous post, we write the following REDUCE + REDLOG script to decide the convexity of :

% decide the convexity of the elliptope E3

load_package redlog;
rlset ofsf;

% define predicates in antecedent
p1 := (1-x1^2>=0) and (1-x2^2>=0) and (1-x3^2>=0) and 
      (1-x1^2-x2^2-x3^2+2*x1*x2*x3>=0);
p2 := (1-y1^2>=0) and (1-y2^2>=0) and (1-y3^2>=0) and 
      (1-y1^2-y2^2-y3^2+2*y1*y2*y3>=0);
p3 := (theta>=0) and (theta<=1);

% define predicate in the consequent
z1 := theta*x1+(1-theta)*y1;
z2 := theta*x2+(1-theta)*y2;
q  := (1-z1^2>=0) and (1-z2^2>=0) and (1-z3^2>=0) and 
      (1-z1^2-z2^2-z3^2+2*z1*z2*z3>=0);

% define universal formula
phi := all({x1,x2,x3,y1,y2,y3,theta}, (p1 and p2 and p3) impl q);

% perform quantifier elimination
rlqe phi;

end;

After 30 minutes (!!!) waiting for the decision procedure to terminate, I killed the reduce.exe process (which was eating all my machine’s CPU cycles and RAM memory). This is disappointing…

where and , how can one decide if set is convex? Can one use quantifier elimination?

__________

Convexity

Let us recall the definition of convexity [2]:

Definition: A set is convex if the line segment between any two points in lies in , i.e., if for any and any with , we have .

Let us introduce a predicate , defined by

so that we can write in the more parsimonious form

.

Hence, writing is equivalent to asserting that . From the definition above, it follows that set is convex if and only if the following universally quantified formula

where range over and ranges over , evaluates to . Since are polynomials, the formula above can be decided using quantifier elimination software like QEPCAD or REDLOG. Unfortunately, decidability does not imply that real quantifier elimination will decide the formula in an expedite manner. Let us now consider two instances of the decision problem under study.

__________

Example #1

Consider the following semialgebraic set

which we depict below

Visual inspection of the plot above allows us to conclude that set is convex. However, relying on the human visual system is extremely limiting. Therefore, we would like to automate the decision. We decide the convexity of via quantifier elimination using the following REDUCE + REDLOG script:

% decide the convexity of a semialgebraic set

load_package redlog;
rlset ofsf;

% define predicates in antecedent
p1 := (x1-x2^2+3>=0) and (-x1-x2^2+3>=0);
p2 := (y1-y2^2+3>=0) and (-y1-y2^2+3>=0);
p3 := (theta>=0) and (theta<=1);

% define predicate in the consequent
z1 := theta*x1+(1-theta)*y1;
z2 := theta*x2+(1-theta)*y2;
q  := (z1-z2^2+3>=0) and (-z1-z2^2+3>=0); 

% define universal formula
phi := all({x1,x2,y1,y2,theta}, (p1 and p2 and p3) impl q);

% perform quantifier elimination
rlqe phi;

end;

This script returns the truth value and, hence, is, indeed, convex. However, it took REDLOG approximately 60 seconds to decide the convexity of , which is considerably longer than any of my previous experiments with REDLOG. Since we are performing quantifier elimination on a formula with five universal quantifiers, I am not incredibly surprised that it takes a while to obtain an answer.

__________

Example #2

Consider now the following semialgebraic set

part of which we depict below

Visual inspection of the plot above allows us to conclude that set is not convex. We decide the convexity of using the following REDUCE + REDLOG script:

% decide the convexity of a semialgebraic set

load_package redlog;
rlset ofsf;

% define predicates in antecedent
p1 := (x1-x2^2+3>=0) and (x1-x2^2+1<=0);
p2 := (y1-y2^2+3>=0) and (y1-y2^2+1<=0);
p3 := (theta>=0) and (theta<=1);

% define predicate in the consequent
z1 := theta*x1+(1-theta)*y1;
z2 := theta*x2+(1-theta)*y2;
q  := (z1-z2^2+3>=0) and (z1-z2^2+1<=0); 

% define universal formula
phi := all({x1,x2,y1,y2,theta}, (p1 and p2 and p3) impl q);

% perform quantifier elimination
rlqe phi;

end;

This script returns the truth value and, hence, is, indeed, not convex. Interestingly, it took REDLOG less than one second to decide the formula. That is over two orders of magnitude faster than in example #1.

__________

References

[1] Markus Schweighofer, Describing convex semialgebraic sets by linear matrix inequalities, International Symposium on Symbolic and Algebraic Computation, Korea Institute for Advanced Study, Seoul, July 2009.

[2] Stephen Boyd, Lieven Vandenberghe, Convex Optimization.

In this post, we will restrict our attention to finite functions. For finite functions, we already know how to decide injectivity and surjectivity. Hence, deciding the bijectivity of finite functions is now trivial. In Haskell, we create the following three predicates:

isInjective :: (Eq a, Eq b) => (a -> b) -> [a] -> Bool
isInjective f xs = all phi [(x1,x2) | x1 <- xs, x2 <- xs]
                   where phi (x1,x2) = (f x1 /= f x2) || (x1 == x2)

isSurjective :: Eq b => (a -> b) -> [a] -> [b] -> Bool
isSurjective f xs ys = all psi ys
                       where psi y = or [(f x == y) | x <- xs]

isBijective :: (Eq a, Eq b) => (a -> b) -> [a] -> [b] -> Bool
isBijective f xs ys = (isInjective f xs) && (isSurjective f xs ys)

Note that predicate isInjective takes as inputs a function and a list (the domain), whereas predicate isSurjective takes as inputs a function and two lists (the domain and the codomain). Both return either True or False. Predicate isBijective is defined using the conjunction of the other two predicates. In this implementation, we separated the decision procedure from the definition of .

__________

Example #1

Let us define . Consider the finite function

where denotes modulo 4 arithmetic. We know that this function is both injective and surjective. Hence, it is bijective. Here’s a GHCi session (after running the Haskell script above):

*Main> let f n = (3 * n) `mod` 4
*Main> isInjective f [0..3]
True
*Main> isSurjective f [0..3] [0..3]
True
*Main> isBijective f [0..3] [0..3]
True

__________

Example #2

Consider now the following finite function

We already know that function is neither injective nor surjective. Hence, it is not bijective. Here’s a GHCi session:

*Main> let g n = (2 * n) `mod` 4
*Main> isInjective g [0..3]
False
*Main> isSurjective g [0..3] [0..3]
False
*Main> isBijective g [0..3] [0..3]
False

where and range over sets and , respectively. We now introduce the surjectivity predicate , defined by so that function is surjective if and only if evaluates to .

Let and denote the cardinalities of sets and , respectively. Deciding should then require a total of evaluations of predicate . Let us write and , and introduce , a Boolean matrix defined as follows

Stating that is surjective, i.e., evaluates to , is equivalent to saying that every column of matrix contains at least one entry that evaluates to . We now introduce a new predicate, , defined by

so that can be rewritten in the form , where ranges over set . Note that can be viewed as the disjunction of the atoms , i.e.,

.

Note also that can be viewed as the conjunction of the atoms . Thus, we can decide surjectivity using the following procedure:

1. Compute for all .
2. Compute the conjunction . If its truth value is , then the function is surjective.

Let us now consider two simple examples and implement this decision procedure in Haskell.

__________

Example #1

Let us define . Consider the finite function

where denotes modulo 4 arithmetic. Note that , , , and . Hence, we easily conclude that is both injective and surjective (and, thus, is bijective). In Haskell:

Prelude> let f n = (3 * n) `mod` 4
Prelude> let xs = [0..3]
Prelude> let ys = [0..3]
Prelude> let psi y = or [(f x == y) | x <- xs]
Prelude> all psi ys
True

which allows us to conclude that is surjective. Note that we used function or to perform disjunction, and function all to perform universal quantification.

__________

Example #2

Consider now the following finite function

Note that and . Hence, function is neither injective nor surjective. In Haskell, we have the following:

Prelude> let g n = (2 * n) `mod` 4
Prelude> let xs = [0..3]
Prelude> let ys = [0..3]
Prelude> let psi y = or [(g x == y) | x <- xs]
Prelude> all psi ys
False

which allows us to conclude that is not surjective. Why? The following code returns a list of lists of Booleans where each sublist is a column of matrix (where each entry is )

Prelude> [[(g x == y) | x <- xs] | y <- ys]
[[True,False,True,False],[False,False,False,False],
[False,True,False,True],[False,False,False,False]]

Note that the 2nd and 4th sublists contain only truth values. Hence, it is not the case that every column of matrix contains at least one entry that evaluates to . Thus, is not surjective.

where  and denotes modulo 4 arithmetic. We know that function is injective if and only if

where and range over set . We introduce the injectivity predicate , defined by

so that function is injective if and only if the universally-quantified sentence evaluates to .

__________

A naive decision procedure

We can determine the truth value of by evaluating the predicate at all , which will require a total of evaluations. We implemented this decision procedure in Haskell last week. Here’s a rather brief GHCi session:

Prelude> let f n = (3 * n) `mod` 4
Prelude> let phi (x1,x2) = (f x1 /= f x2) || (x1 == x2)
Prelude> all phi [(x1,x2) | x1 <- [0..3], x2 <- [0..3]]
True

which allows us to conclude that is injective. Note that we used the following equivalence

to implement . Can we do better than this? In fact, we can.

__________

A better decision procedure

We introduce matrix , defined by

Stating that is injective, i.e., evaluates to , is equivalent to saying that all the entries of matrix evaluate to . Note, however, that the four entries on the main diagonal of will always evaluate to , as the implication

evaluates to for every . Moreover, from the equivalence

we can conclude that for all and , which tells us that matrix is symmetric (i.e., ). Therefore, we do not need to evaluate all entries of matrix , only the ones above the main diagonal, as illustrated below

where the symbol denotes “don’t care”, i.e., entries we do not need to evaluate. Hence, instead of evaluating the predicate a total of times, we now only need to evaluate it times, which is of the original total. We can generate all pairs with using the following Haskell code:

Prelude> [(x1,x2) | x1 <- [0..3], x2 <- [(x1+1)..3]]
[(0,1),(0,2),(0,3),(1,2),(1,3),(2,3)]

We thus implement a more efficient decision procedure as follows:

Prelude> let f n = (3 * n) `mod` 4
Prelude> let phi (x1,x2) = (f x1 /= f x2) || (x1 == x2)
Prelude> all phi [(x1,x2) | x1 <- [0..3], x2 <- [(x1+1)..3]]
True

which requires less than half of the number of evaluations required by the previous (naive) procedure.

__________

Conclusions

Given a finite function , we introduce the injectivity predicate , defined by

so that (finite) function is injective if and only if evaluates to . Let denote the cardinality of set . Deciding using the naive procedure will require a total of   evaluations of the predicate . Since for every , and taking into account that , using the improved procedure we can decide injectivity at a cost of only evaluations of the predicate . As approaches infinity, the ratio approaches . Hence, for “large” problems, the improved procedure will require approximately half the number of evaluations required by the naive procedure.

where and range over set . We now introduce the injectivity predicate , defined by

so that function is injective if and only if is true. In this post we will restrict our attention to finite functions, for which it is fairly straightforward to devise a decision procedure to decide injectivity. Let denote the cardinality of set . Then, determining the truth value of will require a total of   evaluations of the predicate .

__________

Example

Let us define . Consider the finite function

where denotes modulo 4 arithmetic. Is injective? Note that , , , and . Hence, we easily conclude that is injective. Suppose that we do not want to enumerate the images of the elements of under ; in that case, we can use the following Haskell script to decide that is injective:

-- define function f
f :: Integral a => a -> a
f n = (3 * n) `mod` 4 

-- define disjunction
(\/) :: Bool -> Bool -> Bool
p \/ q = p || q

-- define implication
(==>) :: Bool -> Bool -> Bool
p ==> q = (not p) \/ q

-- define injectivity predicate
phi :: Integral a => (a,a) -> Bool
phi (x1,x2) = (f x1 == f x2) ==> (x1 == x2)

where we used the fact that is semantically equivalent to . Let us carry out some testing:

*Main> -- test function f
*Main> [ f n | n <- [0..3]]
[0,3,2,1]
*Main> -- test disjunction
*Main> [ p \/ q | p <-[True, False], q <- [True, False]]
[True,True,True,False]
*Main> -- test implication
*Main> [ p ==> q | p <-[True, False], q <- [True, False]]
[True,False,True,True]

So far, so good. Finally, we can determine the truth value of the sentence using function all, as follows:

*Main> all phi [(x1,x2) | x1 <- [0..3], x2 <- [0..3]]
True

which allows us to conclude that is injective.

An alternative procedure would be to use function nub from library Data.List to remove duplicates from a given list. Note that is injective if and only if the list of the images of the elements of under contains no duplicates. Hence, we obtain:

*Main> let images = [ f n | n <- [0..3]]
*Main> import Data.List
*Main Data.List> length (nub images) == length images
True

What a hack! This second procedure might seem much terser than the first one. But if we do away with type declarations and refrain from re-defining disjunction and defining implication, the first procedure can be made quite succinct as well:

Prelude> let f n = (3 * n) `mod` 4
Prelude> let phi (x1,x2) = not (f x1 == f x2) || (x1 == x2)
Prelude> all phi [(x1,x2) | x1 <- [0..3], x2 <- [0..3]]
True

which includes the definition of function . Three lines only! Three!

where and range over sets and , respectively. Equivalently, is surjective if and only if the image of under is itself.

In this post, we will restrict our attention to functions from to . For polynomial functions from reals to reals, we can use quantifier elimination to determine the truth values of the quantified formula above, thus deciding surjectivity.

__________

Example

We would like to decide the surjectivity of the following functions

Instead of using the horizontal line test to determine whether these functions are surjective, we use the REDUCE + REDLOG script:

% decide the surjectivity of f(x) = x^2 and g(x) = x^3

load_package redlog;
rlset ofsf;

% define quantified formulas
phi := all(y, ex(x, x**2=y));
psi := all(y, ex(x, x**3=y));

% perform quantifier elimination
rlqe phi;
rlqe psi;

end;

which decides that is not surjective and that is surjective.

__________

References

[1] David Makinson, Sets, Logic and Maths for Computing, Springer, 2008.

where and range over set . Note that the inequations and are equivalent to and , respectively. The universally-quantified formula above can be rewritten as follows

which looks a bit messy. Contrapositively,

.

In this post, we will restrict our attention to real-valued functions of a real variable (i.e., functions from to ). For polynomial functions from reals to reals, we can use quantifier elimination to determine the truth values of the universally-quantified formulas above, thereby deciding injectivity.

__________

Example

We would like to decide the injectivity of the following functions

which we plot below (using Wolfram Alpha)

In high school we all learned to use the infamous horizontal line test to determine whether a function is injective. Let us use something more powerful this time, namely, the following REDUCE + REDLOG script:

% decide the injectivity of f(x) = x^2 and g(x) = x^3

load_package redlog;
rlset ofsf;

% define universally-quantified formulas
phi := all({x1,x2}, x1**2=x2**2 impl x1=x2);
psi := all({x1,x2}, x1**3=x2**3 impl x1=x2);

% perform quantifier elimination
rlqe phi;
rlqe psi;

end;

which decides that is not injective and that is injective.

__________

References

[1] David Makinson, Sets, Logic and Maths for Computing, Springer, 2008.

where is the state trajectory, and is a known vector field [1]. We now introduce the following definition:

Definition: A point is an equilibrium point of the given dynamical system if the state being at  at some time  implies that the state will remain at for all future time, i.e., for all . In other words, an equilibrium point  is a point of zero flow, i.e., .

If you happen to dislike the word “flow”, feel free to replace it with the word “velocity”. A point of zero velocity is thus a stationary one. Like a properly-trained poodle, it stays put.

One can find the equilibrium points of a given dynamical system by computing the real roots of the vector equation . However, suppose that we are not interested in computing the equilibrium points; instead, all we would like to know is whether any such points exist. Thus, we arrive at the following decision problem:

Problem: Given a vector field , we would like to decide whether the dynamical system has at least one equilibrium point. This is equivalent to determining the truth value of the formula , where .

Since both and are -dimensional vectors, and , we can rewrite the existentially-quantified formula above in the following form

.

Can one even determine the truth value of the existentially-quantified formula above? In order to avoid colliding against the brick wall of undecidability, let us restrict our attention to polynomial dynamical systems (i.e., dynamical systems in which the vector field is polynomial). For such systems, one can use quantifier elimination to decide the existence of equilibrium points.

__________

Example

Consider the following polynomial dynamical system

taken from section 2.7 in Khalil’s book [1]. Note that the two first-order ordinary differential equations above are decoupled, i.e., they are of the form . Note also that we have a free parameter .

We now compute the equilibrium points of the dynamical system by solving the (scalar) polynomial equations . We thus obtain and . For , we have two equilibrium points at and . For , we have one equilibrium point at . Finally, for , we have no equilibrium points, as the equation has no real roots when . The existence of equilibrium points depends on parameter . Stating that this dynamical system has at least one equilibrium point is the same as saying that the following existentially-quantified formula

evaluates to . By visual inspection of the formula, we conclude that the formula (which has two bound variables, and , and one free variable ) evaluates to when . Let us confirm this using the following REDUCE + REDLOG script:

% decide the existence of equilibrium points

load_package redlog;
rlset ofsf;

% define polynomial vector field
f1 := mu - x1**2;
f2 := -x2; 

% define existentially quantified formula
phi := ex({x1,x2}, f1=0 and f2=0);

% perform quantifier elimination
rlqe phi;

end;

which outputs . Hence, if the parameter is nonnegative, then there will always exist at least one equilibrium point.

__________

References

[1] Hassan K. Khalil, Nonlinear Systems, 3rd edition, Prentice Hall.

– Arnab Bhattacharyya (2011)

We would like to decide whether a given (finite) set of vectors is linearly independent. Let us first recall the definition of linear independence. From Dym’s book [1], we have:

Definition: A set of vectors in a vector space over is said to be linearly independent over if the only scalars for which

are . This is just another way of saying that you cannot express one of these vectors in terms of the others.

_____

In this post we are interested in sets of real vectors and, thus, we shall restrict our attention to the case where . Asserting that a given (finite) set of vectors is linearly independent is the same as stating that the set of vectors under study is not linearly dependent. Therefore, we now recall Dym’s definition [1] of linear dependence:

Definition: A set of vectors in a vector space over is said to be linearly dependent over if there exists a set of scalars , not all of which are zero, such that

.

Notice that this permits you to express one or more of the given vectors in terms of the others.

_____

From this definition it follows that saying that a given (finite) set of vectors is linearly dependent is the same as stating that the following existentially quantified formula

evaluates to . Please do note that is a vector equation encapsulating scalar equations of the form

where is the -th component of vector . Finally, we conclude that a given (finite) set of vectors being linearly independent is equivalent to the following formula

evaluating to . We can determine the truth value of the formula above using quantifier elimination.

__________

Example

Consider the three following vectors in

,    ,    .

Is the set of vectors linearly independent (over )? It is not, as . However, we would like to arrive at this conclusion using quantifier elimination. Note that in this example we have (number of vectors), and (dimensionality).

The vector equation then becomes

which yields two (scalar) equations: and . Note that the vector equation above also yields two redundant equations of the form , which we happily discard.

The set of vectors is linearly independent (over ) if and only if the following existentially quantified formula

evaluates to . Using the following REDUCE + REDLOG script, we can determine the truth value of the formula above:

% decide the linear independence of a set of vectors

load_package redlog;
rlset ofsf;

% define linear functions
f1 := alpha1;
f2 := alpha2;
f3 := alpha3;
f4 := alpha1 + alpha3;
f5 := alpha2 + alpha3; 

% define existentially quantified formula
phi := not ex({alpha1,alpha2,alpha3}, 
           not (f1=0 and f2=0 and f3=0) and f4=0 and f5=0);

% perform quantifier elimination
rlqe phi;

end;

This script returns , which allows us to conclude that the set of vectors is, indeed, not linearly independent.

__________

Acknowledgements

This post was inspired by Arnab Bhattacharyya’s recent blog post on quantifier elimination.

__________

References

[1] Harry Dym, Linear algebra in action, American Mathematical Society, 2006.

For instance, consider a graph whose vertex set is and whose edge set is . A pictorial representation of this graph is depicted below

Note that this graph is complete. We can assign two distinct colors to any two vertices, but we cannot assign a color to the third vertex that will yield a proper coloring. Therefore, the graph is not 2-colorable. To illustrate, we use the color set and generate all possible vertex 2-colorings, as depicted below

Notice that none of these 2-colorings is proper, as expected.

As discussed by De Loera et alia [1], the graph vertex-coloring problem can be modeled using polynomial equations. We introduce variables , where if vertex is assigned the color , and if vertex is assigned the color . Given an edge , we have that:

• if both vertices are pink, we get .

• if both vertices are blue, we get .

• if the vertices have distinct colors, we get .

Thus, stating that adjacent vertices must be assigned distinct colors is equivalent to imposing the constraints for all . We thus obtain a system of three equations

where . This is still a combinatorial problem, though. We can transform it into an algebraic-geometric problem. Here is a truly beautiful trick [1]: the constraint can be encoded as with . How quaint!! We then obtain a system of six equations with polynomials in

whose solution set, which we denote by , is algebraic [2]. The given graph is 2-colorable if and only if the system of polynomial equations above is feasible, i.e., if set is nonempty [1]. The following REDUCE + REDLOG script uses quantifier elimination to decide if is nonempty:

% feasibility via quantifier elimination

load_package redlog;
rlset ofsf;

% define polynomial functions
f1 := x1+x2;
f2 := x1+x3;
f3 := x2+x3;
f4 := x1^2-1;
f5 := x2^2-1;
f6 := x3^2-1;

% define existential formula
phi := ex({x1,x2,x3}, f1=0 and f2=0 and f3=0 and
                      f4=0 and f5=0 and f6=0);

% perform quantifier elimination
rlqe phi;

end;

This script produces the truth value false. Thus, the solution set is empty, which means that the system of polynomial equations is infeasible. We conclude that the given graph is not 2-colorable.

__________

References

[1] Jesús De Loera, Jon Lee, Susan Margulies, Shmuel Onn, Expressing Combinatorial Optimization Problems by Systems of Polynomial Equations and the Nullstellensatz, 2007.

[2] Jacek Bochnak, Michel Coste, Marie-Françoise Roy, Real Algebraic Geometry, Springer, 1998.

is nonempty. This is the same as determining whether the following system of polynomial inequalities

is feasible. We now define , and . Set is depicted below

and set is depicted below

Note that . We depict this intersection below

Visual inspection of the plot of the intersection allows us to conclude that in nonempty. Asserting that is nonempty is the same as stating that the proposition

is true. We can determine the truth value of this proposition via quantifier elimination using the following REDUCE + REDLOG script:

% feasibility via quantifier elimination

load_package redlog;
rlset ofsf;

% define polynomial functions
g1 :=  x-y^2+1;
g2 := -x-y^2+1;

% define existential formula
phi := ex({x,y}, g1>=0 and g2>=0);

% perform quantifier elimination
rlqe phi;

end;

which produces the truth value true. This means that there exists a that satisfies the polynomial inequalities, i.e., is nonempty.

__________

Remark: the plots in this post were generated by Wolfram Alpha.

whose solution set is the following semialgebraic set

Parrilo showed in [1] that this system is infeasible, i.e., set is empty, using the Positivstellensatz [2]. Alternatively, one could use quantifier elimination to conclude infeasibility.

Consider the following proposition

.

If this proposition is true, then the system is feasible and is nonempty. If the proposition is false, then the system is infeasible and is empty. We can determine the truth value of the proposition using REDUCE + REDLOG to perform quantifier elimination:

% feasibility via quantifier elimination

load_package redlog;
rlset ofsf;

% define polynomial functions
f1 := x1^2+x2^2-1;
g1 := 3*x2-x1^3-2;
g2 := x1-8*x2^3;

% define existential formula
phi := ex({x1,x2}, f1=0 and g1>=0 and g2>=0);

% perform quantifier elimination
rlqe phi;

end;

The output of this script is the following:

The proposition is false and, thus, the system is infeasible.

__________

References

[1] Pablo Parrilo, Sum of Squares Programs and Polynomial Inequalities.

[2] Jacek Bochnak, Michel Coste, Marie-Françoise Roy, Real Algebraic Geometry, Springer, 1998.