Overview of the RegularChains Package

Calling Sequence


RegularChains[command](arguments)
command(arguments)


Description


•

The RegularChains package is a collection of commands for solving systems of algebraic equations, inequations and inequalities symbolically. This package also allows the user to manipulate and study the solutions of such systems.

•

Now we can describe the shape of a regular chain by defining a more general concept, sometimes called an ascending chain or a triangular set. A finite set of nonconstant polynomials of is a triangular set if two different polynomials of have different main variables. For example, if consists of the two variables and such that holds, then is a triangular set, whereas is not. In broad words, a triangular set is a system of algebraic equations that is ready to be solved by evaluating the unknowns one after the other, just like a triangular linear system. However, there is a difference with the linear case: the back solving process may lead to some degenerated situation, or even to no solutions. Consider for example, for , the triangular set . The value leads to , but the value does not lead to a value of . In broad words, regular chains are a particular kind of triangular sets for which the back solving process succeeds in every case. A precise definition of a regular chain is given below, just before the examples.

•

The MatrixTools subpackage provides commands for solving linear systems of equations modulo the saturated ideal of a regular chain. Among other operations are computations of matrix inverses and lower echelon forms. These commands are considered here in a nonstandard context. Indeed, the coefficients of these matrices are polynomials and the computations are performed modulo (the saturated ideal of) a regular chain. Since this latter is not required to be a prime ideal, the commands of this subpackage allows you to do linear algebra computations over nonintegral domains.

•

The ConstructibleSetTools subpackage provides a large set of commands for manipulating constructible sets. Constructible sets are the fundamental objects of Algebraic Geometry, and they play there the role that ideals play in Polynomial Algebra. In broad terms, a constructible set is the solution set of a system of polynomial equations and inequations. Constructible sets appear naturally in many questions, from highschool problems to advanced research topics.

•

The SemiAlgebraicSetTools subpackage contains a collection of commands for isolating and counting real roots of zerodimensional semialgebraic systems or regular chains (that is regular chains with a finite number of complex solutions). It also offers various commands for studying the real solutions of polynomial systems of positive dimension or with parameters. In particular, commands for real root classification, cylindrical algebraic decomposition and partial cylindrical algebraic decomposition sampling are available. Several inspection functions on semialgebraic systems and their solution sets (namely, semialgebraic sets) are also provided. They are intended to support the command RealRootClassification, RealTriangularize and LazyRealTriangularize

•

The ChainTools subpackage provides advanced operations on regular chains. Most of these commands allow you to inspect, construct and transform regular chains, or to check the properties of a polynomial with respect to a regular chain. Some commands operate transformations on a set of regular chains; they can be used to analyze the results computed by the command Triangularize.

•

The FastArithmeticTools subpackage contains a collection of commands for computing with regular chains in prime characteristic using asymptotically fast algorithms. Most of the underlying polynomial arithmetic is performed at C level and relies on (multidimensional) Fast Fourier Transform (FFT). This imposes some constraints on the characteristic. One of the main purposes of this subpackage is to offer efficient basic routines in order to support the implementation of modular algorithms for computing with regular chains and algebraic numbers.

•

In addition to its main functions Triangularize and RealTriangularize, and its subpackages ChainTools, MatrixTools, ConstructibleSetTools, ParametricSystemTools, SemiAlgebraicSetTools, and FastArithmeticTools, the RegularChains package provides basic commands for computing with polynomials and regular chains. The commands PolynomialRing, DisplayPolynomialRing, MainVariable, Initial, MainDegree, Rank, Tail, and Separant allow the user to manipulate polynomials in the context of regular chains. The commands Equations and Inequations allow the user to inspect a regular chain. The commands RegularGcd, ExtendedRegularGcd, Inverse, IsRegular, RegularizeInitial, NormalForm, SparsePseudoRemainder, and MatrixCombine provide computations modulo regular chains. SuggestVariableOrder attempts to provide an optimal order of variables for speeding up the decomposition of polynomial systems.

•

The commands Display and Info allow the user to print the different types of objects that the RegularChains package. The former is a raw printer which gives direct access to the object encoding. The latter is a pretty printer.

•

Similarly, the command Intersect can be used to solve systems of polynomial equations incrementally (that is, one equation after another) and thus interactively. Therefore, it is also a useful command in complement to Triangularize.



List of the RegularChains Package Commands



The following is a list of available toplevel commands.



Mathematical Definitions



Here is a precise definition of a regular chain and its saturated ideal.


First, recall that a nonzero element h of a ring R is called regular if h is not a zerodivisor; that is, for every f of R, if the product f*h is null, then f is null.


Now, let T be a triangular set. We define by induction what it means for T to be a regular chain. Also, we define the saturated ideal of T. If T is empty, then it is a regular chain and its saturated ideal is the trivial ideal (the ideal consisting only of zero). Assume now that T is not empty. Let p be the polynomial of T with greatest main variable and let C be the set of the other polynomials in T. If C is a regular chain with saturated ideal I, and if the initial h of p is regular with respect to I, then T is a regular chain. In addition, the saturated ideal of T is the set of the polynomials g such that there exists a power h^e of h such that h^e * g belongs to the ideal generated by I and p. An important property of a regular chain T is that a polynomial f belongs to the saturated ideal of T if and only if f reduces to zero by pseudodivision with respect to T. The pseudodivision of a polynomial with respect to a regular chain is implemented by the command SparsePseudoRemainder.


It follows from the previous definition that a set consisting of a single polynomial p is a regular chain whose saturated ideal is the ideal generated by the primitive part of p regarded as a univariate polynomial in its main variable.


Let T be a triangular set consisting of two polynomials p and q such that q is univariate in y and p is bivariate in x and y. Let h be the initial of p. Then T is a regular chain if the GCD of q and h is 1. This second example generalizes to regular chains with more than two variables or more than two polynomials. Verifying that a triangular set is a regular chain can be made by means of GCD computations.


These GCD computations take as input two polynomials p1 and p2 with the same main variable v and a regular chain T. Since these GCD computations rely on division (or pseudodivision), the initial of the intermediate remainders (or pseudoremainders) must be regular modulo the saturated ideal of T. As a consequence, the input polynomials p1 and p2 are required to have regular initials, and the output polynomial, if it has main variable v, also has an initial regular with respect to T. This explains the name of the command RegularGcd. You can check that the input polynomials are valid input by calling IsRegular on their initials. If one of the initials of the input polynomials p1 and p2 is not regular with respect to (the saturated ideal of) T, then you can split T into several regular chains such that RegularGcd can be called on p1 and p2 for each of T1,...,Ts. This splitting is obtained by using the RegularizeInitial command on p1 and p2.


Let K be a field and let R a polynomial ring over K obtained by the command PolynomialRing. When R has no parameters, the field K can be Q, the field of rational numbers, or a prime field. When R has parameters, the field K is a field of rational functions. For a set (or a list) F of polynomials of R, the command Triangularize computes the common roots of F in an algebraically closed field L containing K. If K is Q, then one can think of L as the field of the complex numbers. The command Triangularize returns a list of regular chains , which is called a triangular decomposition of the common roots of F.


There are two possible relations between the common roots of F and the regular chains C1, ...,Cs, leading to two notions of a triangular decomposition.


We say that C1, ...,Cs is a triangular decomposition of F in the sense of Kalkbrener if the following holds: a point is a root of F if and only if it is a root of one of the saturated ideals of C1,...,Cs.


To introduce the other notion of a triangular decomposition, we need a definition. A point P is a root of a regular chain T if P cancels every polynomial of T but does not cancel any of the initials of the polynomials of T. The commands Equations and Inequations applied to T return the list of its polynomials and the list of their initials, respectively.


We say that C1,...,Cs is a triangular decomposition of F in the sense of Lazard if the following holds: a point is a root of F if and only if it is a root of one of the regular chains C1,...,Cs. A triangular decomposition in the sense of Lazard is in particular a triangular decomposition in the sense of Kalkbrener. But the converse is false.


The command Triangularize is capable of computing both kinds of triangular decompositions. This is achieved by means of options. By default, the sense of Kalkbrener is used. The command Triangularize admits other options that allow the user to control the properties of the computed regular chains. One important property is that of being strongly normalized; see ChainTools for the definition of this notion. Indeed, if T is a strongly normalized regular chain, then you can compute the NormalForm of a polynomial with respect to T.


An irreducible univariate polynomial over K defines both a field extension of K and a regular chain. More generally, let L1 be a direct product of fields, and let p be a univariate polynomial over L1 that generates a radical ideal; then p defines an extension L2 of L1 which is another direct product of fields. It turns out that regular chains are a way to encode extensions of fields or extensions of direct products of fields. This idea is central to the algorithms that the commands IsRegular, Inverse, RegularizeInitial, RegularGcd, and ExtendedRegularGcd implement. The fact that direct products of fields admit zerodivisors is handled by the celebrated D5 principle, which allows us to extend algorithms working fields to direct products of fields.


The theory of regular chains is based on a recursive and univariate vision of polynomials which reduces computations with multivariate polynomials to series of computations with univariate polynomials. The commands MainVariable, Initial, MainDegree, Rank, Tail, and Separant are the basic operations in this recursive and univariate vision of multivariate polynomials.



Examples


Presented here is an overview of the RegularChains library by means of a series of examples. The first ones are for nonexperts in symbolic computations, whereas the last ones require some familiarity with this area.

Solving polynomial systems by means of regular chains



The first example shows how the RegularChains library can solve systems of algebraic equations symbolically. Start by loading the library.


First, define the ring of the polynomials of the system to be solved. Indeed, most operations of the RegularChains library require such a polynomial ring as a parameter. This is how to specify the variable ordering. See PolynomialRing for more details.

>


 (1) 

Define a set of polynomials of R.

>


 (2) 

Ideally, we would like to decompose the solutions of this system into a list of points. In broad terms, this is what the command Triangularize does. However, some of these points are grouped because they share some properties. These groups are described by regular chains.

>


 (3) 

Because these points may involve large expressions, you need to ask to see them! The command Equations displays the list of polynomials of a regular chain.

>


 (4) 

The last three regular chains are very simple: each of them clearly corresponds to a point in the space. Have a closer look at the first one. The polynomial in z has two solutions. To each of them corresponds a point in the space. You can retrieve these five points by using the solve command.

>


 (5) 

Consider again the regular chain above that corresponds to two points. Since these two points are grouped together, you can check whether each of them is a solution of the input system. This can be achieved by means of the command IsInRadical from the ChainTools subpackage by using the following fact: a regular chain T encodes a subset of the solution set of the input system S if and only if every polynomial of S belongs to the radical of the saturated ideal of T.

>


 (6) 

Note that Triangularize can also take inequations among its input. Below, impose the condition that must be different from .

>


 (7) 

Observe that two points from the original decomposition have been removed.


If you are solving with the lazard option, then the output is a constructible set, rather than a list of regular chains. Such a distinction matters, if the input system is in positive dimension.

>


 (8) 
>


 (9) 

By default, Triangularize gives generic solutions. With the lazard option, it outputs all solutions, which generally form a constructible set.



Computing inverses modulo a regular chain



The second example illustrates an important feature of the RegularChains library: computations modulo a regular chain. To do so, consider a second system.

>


 (10) 
>


 (11) 
>


 (12) 
>


 (13) 
>


 (14) 
>


 (15) 

The polynomial py gives y as a rational function in z. You may ask if you could express y as a polynomial function in z. In other words, can we replace py by a polynomial with 1 as its Initial? Indeed, the polynomial in z defines a field extension K of the field Q of the rational numbers. In the field K, you can compute the Inverse of the initial of py.

>


 (16) 
>


 (17) 
>


 (18) 

The help page for Inverse explains how to read the output of this command. In this example, this output means that the inverse of lcy is a fraction with numerator nilcy and denominator dilcy. To check that ilcy is the inverse of lcy modulo newrc, use the command NormalForm to simplify the product nilcy*lcy. Regular chains have a notion of normal form attached to them, just like Groebner bases.

>


 (19) 

You obtain dilcy as expected. Now you can make the polynomial py look better by multiplying it by ilcy and removing its content.

>


 (20) 
>


 (21) 

The same treatment can be applied to the polynomial px.

>


 (22) 
>


 (23) 
>


 (24) 
>


 (25) 
>


 (26) 

Then you obtain a new regular newrc chain which encodes the same solution set as rc.

>


 (27) 
>


 (28) 
>


 (29) 
>


 (30) 
>


 (31) 

This new regular newrc has an additional property with respect to rc: it is strongly normalized. See IsStronglyNormalized for the definition of strongly normalized. Being strongly normalized is a requirement in order to use the command NormalForm.


You could have obtained this regular chain from the input system by using an option of Triangularize.

>


 (32) 
>


 (33) 

The Triangularize command does not always return the normalized decomposition so that it can handle the most general cases, including very large examples. Indeed, observe that the first regular chain rc has smaller coefficients than the strongly normalized regular chain newrc.



Automatic case discussion



The next example shows that RegularChains can handle automatic case discussion. Start by trying to answer the following question. Why does the above output of Inverse look complicated? Because RegularChains can handle automatic case discussion! To illustrate this, consider two variables y and z; assume that they are solutions of the regular chain below.

>


 (34) 
>


 (35) 
>


>


 (36) 

Compute the inverse of the following matrix modulo the relations of the regular chain rc.

>


 (37) 

Clearly, the result depends on whether y and z are equal or not.

>


 (38) 
>


 (39) 
>


 (40) 
>


 (41) 
>


 (42) 

Consider now the other matrix.

>


 (43) 
>


 (44) 
>


 (45) 
>


 (46) 
>


 (47) 
>


 (48) 
>


 (49) 
>


 (50) 

Can you get a "generic" answer that would hold both cases? Yes, you can.

>


 (51) 
>


 (52) 


Recombining the results from a case discussion



The overview of the RegularChains library continues with more advanced examples, extending on the topic of automatic case discussion.


Can you have several cases in the output of MatrixCombine? Yes, this can happen. Reuse the first polynomial system above.

>


 (53) 
>


 (54) 
>


 (55) 

Generate four random matrices.

>


>


 (56) 

Now ask for the recombination of the four cases.

>


 (57) 

It turns out that you cannot obtain a unique case. This is surprising, since the saturated ideals of the four regular chains are pairwise relatively prime.


Check why the recombination into a single regular chain is not possible.

>


 (58) 
>


 (59) 
>


 (60) 
>


 (61) 

The two ideals generated by rc1 and rc2 are obviously relatively prime (no common roots in z). But if you try to recombine them, you create a polynomial qy in y with a zerodivisor as initial; this is forbidden by the properties of a regular chain. Construct the polynomial qy and check if its initial is a zerodivisor.

>


 (62) 
>


 (63) 
>


 (64) 
>


 (65) 
>


 (66) 
>


 (67) 
>


 (68) 
>


 (69) 
>


 (70) 


Solving systems with an infinite number of solutions



The next example in the overview of RegularChains is a second round for experts. All previous automatic case discussions involve discussions with algebraic numbers only. Can the RegularChains library handle automatic case discussion with parameters? Yes, this is possible. Consider the following system.

>


 (71) 
>


 (72) 

This new system has a property that the previous examples do not have. Clearly, this new system has an infinite number of solutions, if we view its 8 variables as unknowns. There are two ways of solving such systems. First, by describing its generic solutions, which is done by computing a triangular decomposition in the sense of Kalkbrener.

>


 (73) 

Computing triangular decompositions in the sense of Kalkbrener is the default mode of Triangularize. Observe that the output does not provide explicitly the solutions of the system that cancel the determinant . Now compute all the solutions (generic or not); that is, find a triangular decomposition in the sense of Lazard.

>


 (74) 
>


 (75) 
>


 (76) 
>


 (77) 
>


 (78) 
>


 (79) 

Similarly, Triangularize can solve polynomial systems in prime characteristic.

>


 (80) 
>


 (81) 
>


 (82) 


Controlling the size of the coefficients



Solving systems of equations by means of regular chains can help reduce the size of the coefficients, even when no splitting arises.


In the example below, compare the size of the output of Triangularize with the lexicographical Groebner basis for the same variable ordering. Do not print this Groebner basis since it is quite large; print its size (number of characters) only.

>


 (83) 
>


 (84) 
 (85) 
>


 (86) 
>


>


 (87) 

The commands below illustrate the fact that the RegularChains library provides tools to reduce the size of the coefficients of an output. To see this, use the previous system again, starting from a large output. Indeed, it turns out that for the above system, the lexicographical Groebner basis can be obtained also by using Triangularize with the option normalize=yes. This is because every strongly normalized regular chain T is a lexicographical Groebner basis over the field of the rational functions in the variables that are not algebraic in T. In this example, each variable IsAlgebraic in the output regular chain.

>


 (88) 
>


 (89) 

Then, the command DahanSchostTransform can be applied to reduce this large regular chain (which is also a lexicographical Groebner basis) into a smaller one.

>


 (90) 
>


 (91) 

Check that the two regular chains define the same (saturated) ideal by means of the command EqualSaturatedIdeals.

>


 (92) 


Splitting for solving



In this library, almost every operation takes a regular chain as a parameter. A regular chain encodes a tower of simple extensions of the underlying field. This tower is a direct product of fields and may contain zerodivisors, so splitting may be needed.

>


 (93) 
>


 (94) 
>


 (95) 
>


 (96) 
>


 (97) 
>


 (98) 
>


 (99) 
>


 (100) 

As a consequence, every operation (taking a regular chain as a parameter) needs to manage tasks, where a task is [somethingtocompute, aregularchain].



Manipulating Constructible Sets



This example demonstrates how to manipulate constructible sets, which usually encode the solution set of a polynomial system with both equations and inequations.

>


>


 (101) 

Define a polynomial system with equations F and inequations H.

>


 (102) 

Use the GeneralConstruct command to create a constructible set cs to encode its solutions.

>


 (103) 

In the RegularChains library, cs is represented by a list of regular systems.

>


 (104) 

Each regular system is a pair consisting of a regular chain and an inequation given by one or more polynomials.

>


 (105) 
>


 (106) 
>


 (107) 

The library provides the basic settheoretic operations on constructible sets, including complementation, union, intersection, difference, inclusion test, and more.

>


 (108) 
>


 (109) 
>


 (110) 
>


 (111) 
>


 (112) 
>


 (113) 
>


 (114) 


Solving Parametric Polynomial Systems



This tour d'horizon concludes with an illustration of how to solve parametric polynomial systems with comprehensive triangular decomposition.

>


 (115) 
>


 (116) 

A comprehensive triangular decomposition of F with respect to parameter is as follows.

>


>


 (117) 

The first part of the output is the precomprehensive triangular decomposition of F, which consists of three regular chains.

>


 (118) 

The projection of onto the parameter space has been partitioned into two disjoint constructible sets.

>


>


 (119) 
>


 (120) 



References



The theory of regular chains was introduced independently by M. Kalkbrener in his PhD Thesis: "Three contributions to elimination theory." and by L. Yang and J. Zhang in the paper "Searching dependency between algebraic equations: an algorithm." Regular chains and their related concepts (triangular sets and saturated ideals) are discussed in the paper "On the theories of triangular sets," coauthored by P. Aubry, D. Lazard, and M. Moreno Maza. The paper "When does T equal Sat(T)?" by F. Lemaire, M. Moreno Maza, W. Pan and Y. Xie, contains a more uptodate summary of these ideas.


The algorithms implemented in the RegularChains package are mainly taken from the paper "On Triangular Decompositions of Algebraic Varieties" by M. Moreno Maza, available at the author's web page. The other algorithms are taken from the papers "Lifting techniques for triangular decompositions" (X. Dahan, M. Moreno Maza, E. Schost, W. Wu, and Y. Xie), "Change of ordering for regular chains in positive dimension" (X. Dahan, X. Jin, M. Moreno Maza, and E. Schost, 2007), "Comprehensive Triangular Decomposition" (C. Chen, F. Lemaire, O. Golubitsky, M. Moreno Maza, and W. Pan, 2007), "Efficient Computations of Irredundant Triangular Decompositions with the RegularChains Library" (C. Chen, F. Lemaire, M. Moreno Maza, W. Pan, and Y. Xie, 2007), "Computations modulo regular chains" (X. Li, M. Moreno Maza, W. Pan, 2009), "Cylindrical Algebraic Decomposition via Triangular Decomposition" (C. Chen, M. Moreno Maza, B. Xia and L. Yang, 2009) and "Triangular Decomposition of Semialgebraic Systems" (C. Chen, J.H. Davenport, J.P. May, M. Moreno Maza, B. Xia and R. Xiao, 2010)


The RegularChains library was originally designed and integrated into Maple by F. Lemaire (Univ. of Lille, France) M. Moreno Maza (Univ. of Western Ontario, Canada) and Y. Xie (Univ. of Western Ontario, Canada). Today, the design, implementation, and maintenance is mainly the work of C. Chen, M. Moreno Maza and R. Xiao (all of them from the Univ. of Western Ontario, Canada). Large contributions have been made by X. Jin, L. Li, X. Li, E. Schost, W. Pan, and W. Wu (all of them from the Univ. of Western Ontario, Canada) and by B. Xia (Peking University, China). X. Dahan (Kyushu University, Japan) and H. Ding, N. Islam, Y. Li, A. Shakoori, W. Zhou, and J. Zhao (Univ. of Western Ontario, Canada) have also participated in the development of the RegularChains package.


Aubry, P.; Lazard, D. and Moreno Maza, M. "On the theories of triangular sets." J. Symb. Comp., Vol. 28 (1999): 105124.


F. Boulier, C. Chen, F. Lemaire, M. Moreno Maza "Real root isolation of regular chains." ASCM'09, MathforIndustry, Lecture Note Series Vol. 22 (2009):1529.


Boulier, F. and Lemaire, F. "Computing canonical representatives of regular differential ideals." In Proc. ISSAC 2000. St Andrews, Scotland, 2000.


Boulier, F.; Lemaire, F. and Moreno Maza, M. "Well known theorems on triangular systems and the D5 Principle." In Proceedings of Transgressive Computing 2006. Edited by J.G. Dumas. Spain: University of Granada, 2006.


Chen. C.; Lemaire, F.; Golubitsky, O.; Moreno Maza, M. and Pan, W. "Comprehensive Triangular Decomposition." Proceedings of CASC 2007, Lecture Notes in Computer Science, Vol. 4770. Springer, 2007.


Chen, C.; Lemaire, F.; Moreno Maza, M.; Pan, W. and Xie, Y. "Efficient Computations of Irredundant Triangular Decompositions with the RegularChains Library." Proceedings of CASA 2007, Lecture Notes in Computer Science, Vol. 4488. Springer, 2007.


C. Chen, J.H. Davenport, J. May, M. Moreno Maza, B. Xia, R. Xiao "Triangular decomposition of semialgebraic systems." ISSAC'10, ACM Press, 2010.


C. Chen, M. Moreno Maza, B. Xia, L. Yang "Computing cylindrical algebraic decomposition via triangular decomposition." ISSAC'09, ACM Press, 2009.


Dahan, X.; Moreno Maza, M.; Schost, E. and Xie, Y. "On the complexity of the D5 Principle." In Proceedings of Transgressive Computing 2006, Edited by J.G. Dumas. Spain: University of Granada, 2006.


Dahan, X.; Jin, X.; Moreno Maza, M. and Schost, E. "Change of ordering for regular chains in positive dimension." J. of Theoretical Computer Science, Vol. 392 (2008): 3765.


Della Dora, J.; Discrescenzo, C. and Duval, D. "About a new method for computing in algebraic number fields." In Proc. EUROCAL 85 Vol. 2. 1985.


Kalkbrener, M. "A generalized Euclidean algorithm for computing triangular representations of algebraic varieties." J. Symb. Comp., Vol. 15 (1993): 143167.


Kalkbrener, M. "Three contributions to elimination theory." PhD Thesis, University of Linz, Austria, 1991.


Lazard, D. "Solving zerodimensional algebraic systems." J. Symb. Comp., Vol. 13 (1992): 117133.


Lemaire, F.; Moreno Maza, M. and Xie, Y. "The RegularChains library." In Proceedings of Maple Conference' 05, pp. 355368. Edited by I. Kotsireas. 2005.


Lemaire, F.; Moreno Maza, M.; Pan, W. and Xie, Y. "When does T equal Sat(T)?" In Proc. ISSAC 2008. Linz, Austria, 2008.


Moreno Maza, M. "On Triangular Decompositions of Algebraic Varieties." MEGA2000 conference. Bath, UK, England.


Moreno Maza, M. and Rioboo, R. "Polynomial GCD computations over towers of algebraic extensions" In proc. of AAECC11, Lecture Notes in Comput. Sci, Vol. 948. Springer, 1995.


Moreno Maza, M. and Xie, Y. "Componentlevel parallelization of triangular decompositions." In Proceedings of Parallel Symbolic Computation'07, pp. 6977, ACM Press, NY, USA, 2007.


Schost, E. "Complexity results for triangular sets." J. Symb. Comp., Vol. 36 No. 34 (2003): 555594.


Wang, D. M. "An elimination method for polynomial systems." J. Symb. Comp., Vol. 16 (1993): 83114.


Wang, D. M. Elimination Methods. Wein, New York: Springer, 2000.


Wu, W. T. "Basic principles of mechanical theorem proving in elementary." J. Sys. Sci. and Math. Scis, Vol. 4 (1984): 207235.


Yang, L. and Zhang, J. "Searching dependency between algebraic equations: an algorithm." Artificial intelligence in mathematics. Oxford University Press, 1994.


