reduce powers of algebraic numbers and algebraic functions
any Maple object; typically an expression containing algebraic numbers.
(optional) equation(s) of the form keyword = value, where keyword is one of 'symbolic', 'expanded', 'characteristic', 'makeindependent', or 'recursive'.
If the option 'symbolic'=true is given, and a RootOf whose minimal polynomial factors nontrivially is detected, it will be reduced it to a RootOf of lower degree by picking one of the factors arbitrarily. The default is 'symbolic'=false.
If the option 'expanded'=true is given, the result will be a quotient of two expanded polynomials, with the following properties:
The variables will be sorted according to a block-lexicographic ordering, where all global variables are considered larger than all local variables.
If there is a denominator, it is non-constant.
The default is 'expanded'=false.
If the option 'characteristic'=p is given, where p is a nonnegative integer, the reduced form is computed over an extension of the ringℤp of integers modulo p. The default is characteristic=0 and means that the reduced form is computed over an extension of the rational numbers.
Note that if p is positive but not a prime, then ℤp is not a field. Reduce will attempt to compute a reduced form anyway. If it does not succeed because it encounters an integer that has no inverse modulo p, it issues the error "zero divisor modulo p detected".
If the option 'makeindependent'=true is given, then Reduce will always try to find a field representation for algebraic numbers in the input, regardless of how many algebraic objects the input contains. If the input contains many RootOfs, then this can be a very expensive calculation. If 'makeindependent'=false is given, then no independence checking is performed. The default is 'makeindependent'=FAIL, in which case algebraic dependencies will only be checked for if there are 4 or fewer algebraic objects in the input.
If the option 'recursive'=false is given, then Reduce will not map itself recursively over non-algebraic subexpressions. The default is 'recursive'=true.
The Reduce command will take powers of algebraic numbers in an expression and reduce the powers to the lowest possible non-negative power, modulo their defining polynomials.
Algebraic numbers may be represented by radicals or with the RootOf notation. In general, they will be returned in the same representation as they were received. (see type,algnum, type,radnum).
The result will have the form P/Q, where P and Q are polynomials over the extension field.
Powers of radicals will be reduced to the form ar, where 0<r<1 is a rational number.
The powers of the RootOfs appearing in the coefficients are positive and lower than the degree of the defining polynomials. Formally, every integer exponent in a power of the form RootOf⁡f,...n satisfies 0<n<degf .
By default, this function attempts to preserve partial factorization of polynomials, but algebraic numbers and functions are always expanded. If the option 'expanded'=true is specified, then polynomials are also expanded (see below).
This function does not rationalize algebraic numbers and does not rationalize leading coefficients of rational functions and polynomials. However, this function will perform a limited amount of simplification on the result by freezing algebraic numbers and canceling the greatest common divisor of the numerator and denominator of the result. For complete normalization of the output, use Normal instead.
Non-algebraic subexpressions such as sin⁡x that are neither variables, rational numbers, or algebraic objects will first be mapped over recursively (unless the option 'recursive'=false is given; see below). Then they are frozen and temporarily replaced by new local variables, which are not considered to be constant in what follows.
If the set of radicals and RootOfs appearing in the input are independent (and thus define a field) then Reduce will return 0 if and only if the input is mathematically equal to 0. It may not do so if the RootOfs are dependent or if the polynomial defining a RootOf is reducible.
If p is an array, a table, a set, a list, a range, a Matrix, a relation, or a series, then Reduce is mapped over the object.
This function does not support input containing floats or algebraic functions such as x.
R1 ≔ RootOf⁡_Z3−_Z−1
R3 ≔ RootOf⁡_Z2−4
p ≔ 1x−RootOf⁡_Z2−2+1x+RootOf⁡_Z2−2
Nested and mixed radicals / RootOfs are handled as well:
p ≔ RootOf⁡x2−x−15+2⁢RootOf⁡x2−x−13,1RootOf⁡x2−2,1⁢2
Algebraic functions in the coefficients are not accepted:
Error, (in Algebraic:-Reduce) ratpoly(s) with radalgnum coefficients expected
Floats are not accepted:
Leading coefficients and denominators are not rationalized:
An attempt is made to simplify the expression by freezing algebraic numbers and canceling the greatest common divisor of the numerator and denominator of the result. To fully simplify the output, use Normal instead:
Non-algebraic subexpressions are first handled recursively (unless option 'recursive'=false is present) and then temporarily replaced by new variables:
q ≔ RootOf⁡x2−2
Non-algebraic subexpressions may evaluate to something algebraic after recursive treatment:
Partial factorizations in the inputs are preserved, unless option 'expanded'=true is given:
If there is a zero divisor in the denominator, it will be reduced, if possible:
In this example, there is a RootOf whose leading coefficient is not invertible, so it is not possible to reduce a positive power of of it. This is because there is no way for Reduce to know whether RootOf⁡_Z2−_Z without an index represents 0 or 1:
However, if option 'symbolic'=true, then it chooses one possibility. Here, option 'symbolic'=true picks 1, so the leading coefficient of the outer RootOf no longer contains a zero divisor, and its power can be reduced:
Using option characteristic, powers can be reduced over finite fields:
The polynomial defining a RootOf will also be reduced modulo the characteristic:
Reductions can sometimes, but not always, be computed in composite characteristic:
Error, (in Algebraic:-Reduce) zero divisor modulo 6 detected
With option 'makeindependent'=true, the input will be checked for algebraic dependencies even if there are more than 4 algebraic objects in the input:
CubeRootOf−4 ≔ RootOf⁡_Z3+4,index=1
CubeRootOf−2 ≔ RootOf⁡_Z3+2,index=1
CubeRootOf2 ≔ RootOf⁡_Z3−2,index=1
CubeRootOf3 ≔ RootOf⁡_Z3−3,index=1
CubeRootOf4 ≔ RootOf⁡_Z3−4,index=1
CubeRootOf6 ≔ RootOf⁡_Z3−6,index=1
With option 'makeindependent'=false, the input will never be checked for algebraic dependencies:
Download Help Document
What kind of issue would you like to report? (Optional)