Given any ring R, the ring of the Integer-linear operators over R is called Operator(R). To create an operator over R, first create a basic operator using the operation operator, and then convert it to Operator(R) for the R you want.
We choose R to be the two by two matrices over the integers.
Create the operator tilde on R.
Since Operator is unexposed we must either package-call operations from it, or expose it explicitly. For convenience we will do the latter.
Expose Operator.
To attach an evaluation function (from R to R) to an operator over R, use evaluate(op, f) where op is an operator over R and f is a function R -> R. This needs to be done only once when the operator is defined. Note that f must be Integer-linear (that is, f(ax+y) = a f(x) + f(y) for any integer a, and any x and y in R).
We now attach the transpose map to the above operator t.
Operators can be manipulated formally as in any ring: + is the pointwise addition and * is composition. Any element x of R can be converted to an operator over R, and the evaluation function of is left-multiplication by x.
Multiplying on the left by this matrix swaps the two rows.
Can you guess what is the action of the following operator?
Hint: applying rho four times gives the identity, so rho**4-1 should return 0 when applied to any two by two matrix.
Now check with this matrix.
As you have probably guessed by now, rho acts on matrices by rotating the elements clockwise.
Do the swapping of rows and transposition commute? We can check by computing their bracket.
Now apply it to m.
Next we demonstrate how to define a differential operator on a polynomial ring.
This is the recursive definition of the n-th Legendre polynomial.
Create the differential operator on polynomials in x over the rational numbers.
Now attach the map to it.
This is the differential equation satisfied by the n-th Legendre polynomial.
Now we verify this for n = 15. Here is the polynomial.
Here is the operator.
Here is the evaluation.
The domain OrderedVariableList provides symbols which are restricted to a particular list and have a definite ordering. Those two features are specified by a List Symbol object that is the argument to the domain.
This is a sample ordering of three symbols.
Let's build the domain
How many variables does it have?
They are (in the imposed order)
Check that the ordering is right
Many systems of differential equations may be transformed to equivalent systems of ordinary differential equations where the equations are expressed polynomially in terms of the unknown functions. In Axiom, the domain constructors OrderlyDifferentialPolynomial (abbreviated ODPOL) and SequentialDifferentialPolynomial (abbreviation SDPOL) implement two domains of ordinary differential polynomials over any differential ring. In the simplest case, this differential ring is usually either the ring of integers, or the field of rational numbers. However, Axiom can handle ordinary differential polynomials over a field of rational functions in a single indeterminate.
The two domains ODPOL and SDPOL are almost identical, the only difference being the choice of a different ranking, which is an ordering of the derivatives of the indeterminates. The first domain uses an orderly ranking, that is, derivatives of higher order are ranked higher, and derivatives of the same order are ranked alphabetically. The second domain uses a sequential ranking, where derivatives are ordered first alphabetically by the differential indeterminates, and then by order. A more general domain constructor, DifferentialSparseMultivariatePolynomial (abbreviation DSMP) allows both a user-provided list of differential indeterminates as well as a user-defined ranking. We shall illustrate ODPOL(FRAC INT), which constructs a domain of ordinary differential polynomials in an arbitrary number of differential indeterminates with rational numbers as coefficients.
A differential indeterminate w may be viewed as an infinite sequence of algebraic indeterminates, which are the derivatives of w. To facilitate referencing these, Axiom provides the operation makeVariablemakeVariableOrderlyDifferentialPolynomial to convert an element of type Symbol to a map from the natural numbers to the differential polynomial ring.
The fifth derivative of w can be obtained by applying the map w to the number 5. Note that the order of differentiation is given as a subscript (except when the order is 0).
The first five derivatives of z can be generated by a list.
The usual arithmetic can be used to form a differential polynomial from the derivatives.
The operation DDOrderlyDifferentialPolynomial computes the derivative of any differential polynomial.
The same operation can compute higher derivatives, like the fourth derivative.
The operation makeVariablemakeVariableOrderlyDifferentialPolynomial creates a map to facilitate referencing the derivatives of f, similar to the map w.
The fourth derivative of f may be referenced easily.
The operation orderorderOrderlyDifferentialPolynomial returns the order of a differential polynomial, or the order in a specified differential indeterminate.
The operation differentialVariablesdifferentialVariablesOrderlyDifferentialPolynomial returns a list of differential indeterminates occurring in a differential polynomial.
The operation degreedegreeOrderlyDifferentialPolynomial returns the degree, or the degree in the differential indeterminate specified.
The operation weightsweightsOrderlyDifferentialPolynomial returns a list of weights of differential monomials appearing in differential polynomial, or a list of weights in a specified differential indeterminate.
The operation weightweightOrderlyDifferentialPolynomial returns the maximum weight of all differential monomials appearing in the differential polynomial.
A differential polynomial is isobaric if the weights of all differential monomials appearing in it are equal.
To substitute differentially, use evalevalOrderlyDifferentialPolynomial. Note that we must coerce 'w to Symbol, since in ODPOL, differential indeterminates belong to the domain Symbol. Compare this result to the next, which substitutes algebraically (no substitution is done since w.0 does not appear in g).
Since OrderlyDifferentialPolynomial belongs to PolynomialCategory, all the operations defined in the latter category, or in packages for the latter category, are available.
The next three operations are essential for elimination procedures in differential polynomial rings. The operation leaderleaderOrderlyDifferentialPolynomial returns the leader of a differential polynomial, which is the highest ranked derivative of the differential indeterminates that occurs.
The operation separantseparantOrderlyDifferentialPolynomial returns the separant of a differential polynomial, which is the partial derivative with respect to the leader.
The operation initialinitialOrderlyDifferentialPolynomial returns the initial, which is the leading coefficient when the given differential polynomial is expressed as a polynomial in the leader.
Using these three operations, it is possible to reduce f modulo the differential ideal generated by g. The general scheme is to first reduce the order, then reduce the degree in the leader. First, eliminate z.3 using the derivative of g.
Find its leader.
Differentiate f partially with respect to this leader.
Compute the partial remainder of f with respect to g.
Note that high powers of lg still appear in prf. Compute the leading coefficient of prf as a polynomial in the leader of g.
Finally, continue eliminating the high powers of lg appearing in prf to obtain the (pseudo) remainder of f modulo g and its derivatives.
A partial fraction is a decomposition of a quotient into a sum of quotients where the denominators of the summands are powers of primes.Most people first encounter partial fractions when they are learning integral calculus. For a technical discussion of partial fractions, see, for example, Lang's Algebra. For example, the rational number 1/6 is decomposed into 1/2-1/3. You can compute partial fractions of quotients of objects from domains belonging to the category EuclideanDomain. For example, Integer, Complex Integer, and UnivariatePolynomial(x, Fraction Integer) all belong to EuclideanDomain. In the examples following, we demonstrate how to decompose quotients of each of these kinds of object into partial fractions. Issue the system command )show PartialFraction to display the full list of operations defined by PartialFraction.
It is necessary that we know how to factor the denominator when we want to compute a partial fraction. Although the interpreter can often do this automatically, it may be necessary for you to include a call to factor. In these examples, it is not necessary to factor the denominators explicitly.
The main operation for computing partial fractions is called partialFractionpartialFractionPartialFraction and we use this to compute a decomposition of 1 / 10!. The first argument to partialFractionpartialFractionPartialFraction is the numerator of the quotient and the second argument is the factored denominator.
Since the denominators are powers of primes, it may be possible to expand the numerators further with respect to those primes. Use the operation padicFractionpadicFractionPartialFraction to do this.
The operation compactFractioncompactFractionPartialFraction returns an expanded fraction into the usual form. The compacted version is used internally for computational efficiency.
You can add, subtract, multiply and divide partial fractions. In addition, you can extract the parts of the decomposition. numberOfFractionalTermsnumberOfFractionalTermsPartialFraction computes the number of terms in the fractional part. This does not include the whole part of the fraction, which you get by calling wholePartwholePartPartialFraction. In this example, the whole part is just 0.
The operation nthFractionalTermnthFractionalTermPartialFraction returns the individual terms in the decomposition. Notice that the object returned is a partial fraction itself. firstNumerfirstNumerPartialFraction and firstDenomfirstDenomPartialFraction extract the numerator and denominator of the first term of the fraction.
Given two gaussian integers (see ComplexXmpPage ), you can decompose their quotient into a partial fraction.
To convert back to a quotient, simply use a conversion.
To conclude this section, we compute the decomposition of
The polynomials in this object have type UnivariatePolynomial(x, Fraction Integer).
We use the primeFactorprimeFactorFactored operation (see FactoredXmpPage ) to create the denominator in factored form directly.
These are the compact and expanded partial fractions for the quotient.
All see FullPartialFractionExpansionXmpPage for examples of factor-free conversion of quotients to full partial fractions.
The package Permanent provides the function permanentpermanentPermanent for square matrices. The permanentpermanentPermanent of a square matrix can be computed in the same way as the determinant by expansion of minors except that for the permanent the sign for each element is 1, rather than being 1 if the row plus column indices is positive and -1 otherwise. This function is much more difficult to compute efficiently than the determinantdeterminantMatrix. An example of the use of permanentpermanentPermanent is the calculation of the -th derangement number, defined to be the number of different possibilities for n couples to dance but never with their own spouse.
Consider an n by n matrix with entries 0 on the diagonal and 1 elsewhere. Think of the rows as one-half of each couple (for example, the males) and the columns the other half. The permanent of such a matrix gives the desired derangement number.
Here are some derangement numbers, which you see grow quite fast.
The domain constructor Polynomial (abbreviation: POLY) provides polynomials with an arbitrary number of unspecified variables.
It is used to create the default polynomial domains in Axiom. Here the coefficients are integers.
Here the coefficients have type Float.
And here we have a polynomial in two variables with coefficients which have type Fraction Integer.
The representation of objects of domains created by Polynomial is that of recursive univariate polynomials.The term univariate means ``one variable.'' multivariate means ``possibly more than one variable.''
This recursive structure is sometimes obvious from the display of a polynomial.
In this example, you see that the polynomial is stored as a polynomial in y with coefficients that are polynomials in x with integer coefficients. In fact, you really don't need to worry about the representation unless you are working on an advanced application where it is critical. The polynomial types created from DistributedMultivariatePolynomial and NewDistributedMultivariatePolynomial (discussed in DistributedMultivariatePolynomialXmpPage ) are stored and displayed in a non-recursive manner.
You see a ``flat'' display of the above polynomial by converting to one of those types.
We will demonstrate many of the polynomial facilities by using two polynomials with integer coefficients.
By default, the interpreter expands polynomial expressions, even if they are written in a factored format.
See FactoredXmpPage to see how to create objects in factored form directly.
The fully factored form can be recovered by using factorfactorPolynomial.
This is the same name used for the operation to factor integers. Such reuse of names is called overloading and makes it much easier to think of solving problems in general ways. Axiom facilities for factoring polynomials created with Polynomial are currently restricted to the integer and rational number coefficient cases. There are more complete facilities for factoring univariate polynomials: see ugProblemFactorPage in Section ugProblemFactorNumber .
The standard arithmetic operations are available for polynomials.
The operation gcdgcdPolynomial is used to compute the greatest common divisor of two polynomials.
In the case of p and q, the gcd is obvious from their definitions. We factor the gcd to show this relationship better.
The least common multiple is computed by using lcmlcmPolynomial.
Use contentcontentPolynomial to compute the greatest common divisor of the coefficients of the polynomial.
Many of the operations on polynomials require you to specify a variable. For example, resultantresultantPolynomial requires you to give the variable in which the polynomials should be expressed.
This computes the resultant of the values of p and q, considering them as polynomials in the variable z. They do not share a root when thought of as polynomials in z.
This value is 0 because as polynomials in x the polynomials have a common root.
The data type used for the variables created by Polynomial is Symbol. As mentioned above, the representation used by Polynomial is recursive and so there is a main variable for nonconstant polynomials.
The operation mainVariablemainVariablePolynomial returns this variable. The return type is actually a union of Symbol and "failed".
The latter branch of the union is be used if the polynomial has no variables, that is, is a constant.
You can also use the predicate ground?ground?Polynomial to test whether a polynomial is in fact a member of its ground ring.
The complete list of variables actually used in a particular polynomial is returned by variablesvariablesPolynomial. For constant polynomials, this list is empty.
The degreedegreePolynomial operation returns the degree of a polynomial in a specific variable.
If you give a list of variables for the second argument, a list of the degrees in those variables is returned.
The minimum degree of a variable in a polynomial is computed using minimumDegreeminimumDegreePolynomial.
The total degree of a polynomial is returned by totalDegreetotalDegreePolynomial.
It is often convenient to think of a polynomial as a leading monomial plus the remaining terms.
The reductumreductumPolynomial operation returns a polynomial consisting of the sum of the monomials after the first.
These have the obvious relationship that the original polynomial is equal to the leading monomial plus the reductum.
The value returned by leadingMonomialleadingMonomialPolynomial includes the coefficient of that term. This is extracted by using leadingCoefficientleadingCoefficientPolynomial on the original polynomial.
The operation evalevalPolynomial is used to substitute a value for a variable in a polynomial.
This value may be another variable, a constant or a polynomial.
Actually, all the things being substituted are just polynomials, some more trivial than others.
Derivatives are computed using the DDPolynomial operation.
The first argument is the polynomial and the second is the variable.
Even if the polynomial has only one variable, you must specify it.
Integration of polynomials is similar and the integrateintegratePolynomial operation is used.
Integration requires that the coefficients support division. Consequently, Axiom converts polynomials over the integers to polynomials over the rational numbers before integrating them.
It is not possible, in general, to divide two polynomials. In our example using polynomials over the integers, the operation monicDividemonicDividePolynomial divides a polynomial by a monic polynomial (that is, a polynomial with leading coefficient equal to 1). The result is a record of the quotient and remainder of the division.
You must specify the variable in which to express the polynomial.
The selectors of the components of the record are quotient and remainder. Issue this to extract the remainder.
Now that we can extract the components, we can demonstrate the relationship among them and the arguments to our original expression qr := monicDivide(p,x+1,x).
If the / operator is used with polynomials, a fraction object is created. In this example, the result is an object of type Fraction Polynomial Integer.
If you use rational numbers as polynomial coefficients, the resulting object is of type Polynomial Fraction Integer.
This can be converted to a fraction of polynomials and back again, if required.
To convert the coefficients to floating point, map the numeric operation on the coefficients of the polynomial.
For more information on related topics, see UnivariatePolynomialXmpPage , MultivariatePolynomialXmpPage , and DistributedMultivariatePolynomialXmpPage . You can also issue the system command )show Polynomial to display the full list of operations defined by Polynomial.
The domain constructor Quaternion implements quaternions over commutative rings. For information on related topics see ComplexXmpPage and OctonionXmpPage . You can also issue the system command )show Quaternion to display the full list of operations defined by Quaternion.
The basic operation for creating quaternions is quaternquaternQuaternion. This is a quaternion over the rational numbers.
The four arguments are the real part, the i imaginary part, the j imaginary part, and the k imaginary part, respectively.
Because q is over the rationals (and nonzero), you can invert it.
The usual arithmetic (ring) operations are available
In general, multiplication is not commutative.
There are no predefined constants for the imaginary i, j, and k parts, but you can easily define them.
These satisfy the normal identities.
The norm is the quaternion times its conjugate.
It possible to expand numbers in general bases.
Here we expand 111 in base 5. This means
You can expand fractions to form repeating expansions.
For bases from 11 to 36 the letters A through Z are used.
For bases greater than 36, the ragits are separated by blanks.
The RadixExpansion type provides operations to obtain the individual ragits. Here is a rational number in base 8.
The operation wholeRagitswholeRagitsRadixExpansion returns a list of the ragits for the integral part of the number.
The operations prefixRagitsprefixRagitsRadixExpansion and cycleRagitscycleRagitsRadixExpansion return lists of the initial and repeating ragits in the fractional part of the number.
You can construct any radix expansion by giving the whole, prefix and cycle parts. The declaration is necessary to let Axiom know the base of the ragits.
If there is no repeating part, then the list [0] should be used.
If you are not interested in the repeating nature of the expansion, an infinite stream of ragits can be obtained using fractRagitsfractRagitsRadixExpansion.
Of course, it's possible to recover the fraction representation:
More examples of expansions are available in DecimalExpansionXmpPage , BinaryExpansionXmpPage , and HexadecimalExpansionXmpPage .
The Real Closure 1.0 package provided by Renaud Rioboo (Renaud.Rioboo@lip6.fr) consists of different packages, categories and domains :
Since real algebraic expressions are stored as depending on ``real roots'' which are managed like variables, there is an ordering on these. This ordering is dynamical in the sense that any new algebraic takes precedence over older ones. In particular every creation function raises a new ``real root''. This has the effect that when you type something like sqrt(2) + sqrt(2) you have two new variables which happen to be equal. To avoid this name the expression such as in s2 := sqrt(2) ; s2 + s2
Also note that computing times depend strongly on the ordering you implicitly provide. Please provide algebraics in the order which seems most natural to you.
These packages use algorithms which are published in [1] and [2] which are based on field arithmetics, in particular for polynomial gcd related algorithms. This can be quite slow for high degree polynomials and subresultants methods usually work best. Beta versions of the package try to use these techniques in a better way and work significantly faster. These are mostly based on unpublished algorithms and cannot be distributed. Please contact the author if you have a particular problem to solve or want to use these versions.
Be aware that approximations behave as post-processing and that all computations are done exactly. They can thus be quite time consuming when depending on several ``real roots''.
[1] R. Rioboo : Real Algebraic Closure of an ordered Field : Implementation in Axiom. In proceedings of the ISSAC'92 Conference, Berkeley 1992 pp. 206-215.
[2] Z. Ligatsikas, R. Rioboo, M. F. Roy : Generic computation of the real closure of an ordered field. In Mathematics and Computers in Simulation Volume 42, Issue 4-6, November 1996.
We shall work with the real closure of the ordered field of rational numbers.
Some simple signs for square roots, these correspond to an extension of degree 16 of the rational numbers. Examples provided by J. Abbot.
These produce values very close to zero.
This should give three digits of precision
The sum of these 4 roots is 0
Check that they are all roots of the same polynomial
We can see at a glance that they are separate roots
Check the sum and product
A more complicated test that involve an extension of degree 256. This is a way of checking nested radical identities.
Some more examples from J. M. Arnaudies
This should be null
A quartic polynomial
Add some cubic roots
this should be null
A quintic polynomial
Add some cubic roots
this should be null
Finally, some examples from the book Computer Algebra by Davenport, Siret and Tournier (page 77). The last one is due to Ramanujan.
The RegularTriangularSet domain constructor implements regular triangular sets. These particular triangular sets were introduced by M. Kalkbrener (1991) in his PhD Thesis under the name regular chains. Regular chains and their related concepts are presented in the paper ``On the Theories of Triangular sets'' By P. Aubry, D. Lazard and M. Moreno Maza (to appear in the Journal of Symbolic Computation). The RegularTriangularSet constructor also provides a new method (by the third author) for solving polynomial system by means of regular chains. This method has two ways of solving. One has the same specifications as Kalkbrener's algorithm (1991) and the other is closer to Lazard's method (Discr. App. Math, 1991). Moreover, this new method removes redundant component from the decompositions when this is not too expensive. This is always the case with square-free regular chains. So if you want to obtain decompositions without redundant components just use the SquareFreeRegularTriangularSet domain constructor or the LazardSetSolvingPackage package constructor. See also the LexTriangularPackage and ZeroDimensionalSolvePackage for the case of algebraic systems with a finite number of (complex) solutions.
One of the main features of regular triangular sets is that they naturally define towers of simple extensions of a field. This allows to perform with multivariate polynomials the same kind of operations as one can do in an EuclideanDomain.
The RegularTriangularSet constructor takes four arguments. The first one, R, is the coefficient ring of the polynomials; it must belong to the category GcdDomain. The second one, E, is the exponent monoid of the polynomials; it must belong to the category OrderedAbelianMonoidSup. the third one, V, is the ordered set of variables; it must belong to the category OrderedSet. The last one is the polynomial ring; it must belong to the category RecursivePolynomialCategory(R,E,V). The abbreviation for RegularTriangularSet is REGSET. See also the constructor RegularChain which only takes two arguments, the coefficient ring and the ordered set of variables; in that case, polynomials are necessarily built with the NewSparseMultivariatePolynomial domain constructor.
We shall explain now how to use the constructor REGSET and how to read the decomposition of a polynomial system by means of regular sets.
Let us give some examples. We start with an easy one (Donati-Traverso) in order to understand the two ways of solving polynomial systems provided by the REGSET constructor.
Define the coefficient ring.
Define the list of variables,
and make it an ordered set;
then define the exponent monoid.
Define the polynomial ring.
Let the variables be polynomial.
Now call the RegularTriangularSet domain constructor.
Define a polynomial system.
First of all, let us solve this system in the sense of Kalkbrener.
And now in the sense of Lazard (or Wu and other authors).
We can see that the first decomposition is a subset of the second. So how can both be correct ?
Recall first that polynomials from a domain of the category RecursivePolynomialCategory are regarded as univariate polynomials in their main variable. For instance the second polynomial in the first set of each decomposition has main variable y and its initial (i.e. its leading coefficient w.r.t. its main variable) is t z.
Now let us explain how to read the second decomposition. Note that the non-constant initials of the first set are and . Then the solutions described by this first set are the common zeros of its polynomials that do not cancel the polynomials and . Now the solutions of the input system lp satisfying these equations are described by the second and the third sets of the decomposition. Thus, in some sense, they can be considered as degenerated solutions. The solutions given by the first set are called the generic points of the system; they give the general form of the solutions. The first decomposition only provides these generic points. This latter decomposition is useful when they are many degenerated solutions (which is sometimes hard to compute) and when one is only interested in general informations, like the dimension of the input system.
We can get the dimensions of each component of a decomposition as follows.
Thus the first set has dimension one. Indeed t can take any value, except 0 or any third root of 1, whereas z is completely determined from t, y is given by z and t, and finally x is given by the other three variables. In the second and the third sets of the second decomposition the four variables are completely determined and thus these sets have dimension zero.
We give now the precise specifications of each decomposition. This assume some mathematical knowledge. However, for the non-expert user, the above explanations will be sufficient to understand the other features of the RSEGSET constructor.
The input system lp is decomposed in the sense of Kalkbrener as finitely many regular sets T1,...,Ts such that the radical ideal generated by lp is the intersection of the radicals of the saturated ideals of T1,...,Ts. In other words, the affine variety associated with lp is the union of the closures (w.r.t. Zarisky topology) of the regular-zeros sets of T1,...,Ts.
N. B. The prime ideals associated with the radical of the saturated ideal of a regular triangular set have all the same dimension; moreover these prime ideals can be given by characteristic sets with the same main variables. Thus a decomposition in the sense of Kalkbrener is unmixed dimensional. Then it can be viewed as a lazy decomposition into prime ideals (some of these prime ideals being merged into unmixed dimensional ideals).
Now we explain the other way of solving by means of regular triangular sets. The input system lp is decomposed in the sense of Lazard as finitely many regular triangular sets T1,...,Ts such that the affine variety associated with lp is the union of the regular-zeros sets of T1,...,Ts. Thus a decomposition in the sense of Lazard is also a decomposition in the sense of Kalkbrener; the converse is false as we have seen before.
When the input system has a finite number of solutions, both ways of solving provide similar decompositions as we shall see with this second example (Caprasse).
Define a polynomial system.
First of all, let us solve this system in the sense of Kalkbrener.
And now in the sense of Lazard (or Wu and other authors).
Up to the ordering of the components, both decompositions are identical.
Let us check that each component has a finite number of solutions.
Let us count the degrees of each component,
and compute their sum.
We study now the options of the zeroSetSplit operation. As we have seen yet, there is an optional second argument which is a boolean value. If this value is true (this is the default) then the decomposition is computed in the sense of Kalkbrener, otherwise it is computed in the sense of Lazard.
There is a second boolean optional argument that can be used (in that case the first optional argument must be present). This second option allows you to get some information during the computations.
Therefore, we need to understand a little what is going on during the computations. An important feature of the algorithm is that the intermediate computations are managed in some sense like the processes of a Unix system. Indeed, each intermediate computation may generate other intermediate computations and the management of all these computations is a crucial task for the efficiency. Thus any intermediate computation may be suspended, killed or resumed, depending on algebraic considerations that determine priorities for these processes. The goal is of course to go as fast as possible towards the final decomposition which means to avoid as much as possible unnecessary computations.
To follow the computations, one needs to set to true the second argument. Then a lot of numbers and letters are displayed. Between a [ and a ] one has the state of the processes at a given time. Just after [ one can see the number of processes. Then each process is represented by two numbers between < and >. A process consists of a list of polynomial ps and a triangular set ts; its goal is to compute the common zeros of ps that belong to the regular-zeros set of ts. After the processes, the number between pipes gives the total number of polynomials in all the sets ps. Finally, the number between braces gives the number of components of a decomposition that are already computed. This number may decrease.
Let us take a third example (Czapor-Geddes-Wang) to see how this information is displayed.
Define a polynomial system.
Let us try the information option. N.B. The timing should be between 1 and 10 minutes, depending on your machine.
Between a sequence of processes, thus between a ] and a [ you can see capital letters W, G, I and lower case letters i, w. Each time a capital letter appears a non-trivial computation has be performed and its result is put in a hash-table. Each time a lower case letter appears a needed result has been found in an hash-table. The use of these hash-tables generally speed up the computations. However, on very large systems, it may happen that these hash-tables become too big to be handle by your AXIOM configuration. Then in these exceptional cases, you may prefer getting a result (even if it takes a long time) than getting nothing. Hence you need to know how to prevent the RSEGSET constructor from using these hash-tables. In that case you will be using the zeroSetSplit with five arguments. The first one is the input system lp as above. The second one is a boolean value hash? which is true iff you want to use hash-tables. The third one is boolean value clos? which is true iff you want to solve your system in the sense of Kalkbrener, the other way remaining that of Lazard. The fourth argument is boolean value info? which is true iff you want to display information during the computations. The last one is boolean value prep? which is true iff you want to use some heuristics that are performed on the input system before starting the real algorithm. The value of this flag is true when you are using zeroSetSplit with less than five arguments. Note that there is no available signature for zeroSetSplit with four arguments.
We finish this section by some remarks about both ways of solving, in the sense of Kalkbrener or in the sense of Lazard. For problems with a finite number of solutions, there are theoretically equivalent and the resulting decompositions are identical, up to the ordering of the components. However, when solving in the sense of Lazard, the algorithm behaves differently. In that case, it becomes more incremental than in the sense of Kalkbrener. That means the polynomials of the input system are considered one after another whereas in the sense of Kalkbrener the input system is treated more globally.
This makes an important difference in positive dimension. Indeed when solving in the sense of Kalkbrener, the Primeidealkettensatz of Krull is used. That means any regular triangular containing more polynomials than the input system can be deleted. This is not possible when solving in the sense of Lazard. This explains why Kalkbrener's decompositions usually contain less components than those of Lazard. However, it may happen with some examples that the incremental process (that cannot be used when solving in the sense of Kalkbrener) provide a more efficient way of solving than the global one even if the Primeidealkettensatz is used. Thus just try both, with the various options, before concluding that you cannot solve your favorite system with zeroSetSplit. There exist more options at the development level that are not currently available in this public version.
The Roman numeral package was added to Axiom in MCMLXXXVI for use in denoting higher order derivatives.
For example, let f be a symbolic operator.
This is the seventh derivative of f with respect to x.
You can have integers printed as Roman numerals by declaring variables to be of type RomanNumeral (abbreviation ROMAN).
This package now has a small but devoted group of followers that claim this domain has shown its efficacy in many other contexts. They claim that Roman numerals are every bit as useful as ordinary integers.
In a sense, they are correct, because Roman numerals form a ring and you can therefore construct polynomials with Roman numeral coefficients, matrices over Roman numerals, etc..
Was Fibonacci Italian or ROMAN?
You can also construct fractions with Roman numeral numerators and denominators, as this matrix Hilberticus illustrates.
Note that the inverse of the matrix has integral ROMAN entries.
Unfortunately, the spoil-sports say that the fun stops when the numbers get big---mostly because the Romans didn't establish conventions about representing very large numbers.
You work it out!
Issue the system command )show RomanNumeral to display the full list of operations defined by RomanNumeral.