Algebraic - Maple Programming Help

Online Help

All Products    Maple    MapleSim


Home : Support : Online Help : Mathematics : Algebra : Algebraic Numbers : Algebraic/Reduce

Algebraic

  

Reduce

  

reduce powers of algebraic numbers and algebraic functions

 

Calling Sequence

Parameters

Options

Description

Examples

Calling Sequence

Reduce(p, options)

Parameters

p

-

any Maple object; typically an expression containing algebraic numbers.

options

-

(optional) equation(s) of the form keyword = value, where keyword is one of 'symbolic', 'expanded', 'characteristic', 'makeindependent', or 'recursive'.

Options

• 

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 ringp 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.

Description

• 

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 RootOff&comma;...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 sinx 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.

Examples

withAlgebraic&colon;

Introductory examples:

Reducesqrt2+sqrt33

112+93

(1)

R1RootOf_Z3_Z1

R1RootOf_Z3_Z1

(2)

ReduceR13

RootOf_Z3_Z1+1

(3)

R3RootOf_Z24

R3RootOf_Z24

(4)

ReduceR338

4RootOf_Z248

(5)

ReduceRootOfx5x4+x3x2+x16

1

(6)

p1xRootOf_Z22+1x+RootOf_Z22

p1xRootOf_Z22+1x+RootOf_Z22

(7)

Reducep

2xx+RootOf_Z22x+RootOf_Z22

(8)

Reducep&comma;expanded

2xx22

(9)

Nested and mixed radicals / RootOfs are handled as well:

Reducesqrt2+RootOfx233

9RootOf_Z23+112

(10)

pRootOfx2x15+2RootOfx2x13&comma;1RootOfx22&comma;1sqrt2

pRootOf_Z2_Z15+2RootOf_Z2_Z13&comma;22RootOf_Z22&comma;1

(11)

Reducep

9RootOf_Z2_Z1+5&comma;12

(12)

Reduce1+sqrt254

1+214+1+2142

(13)

ReduceRootOfx22&comma;index=1sqrt2

0

(14)

ReduceRootOfx2x+RootOfx222

RootOf_Z2_Z+RootOf_Z22RootOf_Z22

(15)

ReduceRootOfx2x+sqrt22

RootOf_Z2_Z+22

(16)

Algebraic functions in the coefficients are not accepted:

ReducesqrtyRootOfx2y&comma;x&comma;index=1

Error, (in Algebraic:-Reduce) ratpoly(s) with radalgnum coefficients expected

Floats are not accepted:

ReduceRootOfx2x0.52

Error, (in Algebraic:-Reduce) ratpoly(s) with radalgnum coefficients expected

Leading coefficients and denominators are not rationalized:

Reducesqrt2x+sqrt3y1+sqrt5

2x+3y5+1

(17)

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:

Reducex2RootOf_Z222x+RootOf_Z22

xRootOf_Z22

(18)

Reducex2RootOf_Z242x+2

x2

(19)

Reducex22x+RootOf_Z22

x22x+RootOf_Z22

(20)

Normalx22x+RootOf_Z22

xRootOf_Z22

(21)

Non-algebraic subexpressions are first handled recursively (unless option 'recursive'=false is present) and then temporarily replaced by new variables:

qRootOfx22

qRootOf_Z22

(22)

Reducefooq2+q2

foo2+2

(23)

ReducefooRootOfx222+RootOfx222&comma;recursive=false

fooRootOf_Z222+2

(24)

Non-algebraic subexpressions may evaluate to something algebraic after recursive treatment:

Reducex+cosI+RootOf_Z2+1&comma;index=2

x+1

(25)

Partial factorizations in the inputs are preserved, unless option 'expanded'=true is given:

Reduce1+RootOfx222a1+RootOfx232b

2a+13b+1

(26)

Reduceexpand1+RootOfx222a1+RootOfx232b

6ab+2a+3b+1

(27)

Reduce1+RootOfx222a1+RootOfx232b&comma;expanded=true

6ab+2a+3b+1

(28)

If there is a zero divisor in the denominator, it will be reduced, if possible:

Reduce1RootOf_Z22_Z5

116RootOf_Z22_Z

(29)

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:

ReduceRootOfRootOf_Z2_Zx212

RootOfRootOf_Z2_Z_Z212

(30)

ReduceRootOfRootOf_Z2_Z&comma;index=2x212

1

(31)

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:

ReduceRootOfRootOf_Z2_Zx212&comma;symbolic=true

1

(32)

Using option characteristic, powers can be reduced over finite fields:

ReduceRootOf_Z253&comma;characteristic=3

2RootOf_Z2+1

(33)

Reducesqrt53&comma;characteristic=3

25

(34)

The polynomial defining a RootOf will also be reduced modulo the characteristic:

ReduceRootOf_Z23&comma;characteristic=7

RootOf_Z2+4

(35)

Reductions can sometimes, but not always, be computed in composite characteristic:

ReduceRootOfIx232&comma;characteristic=4

I

(36)

ReduceRootOfIx232&comma;characteristic=6

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:

CubeRootOf4RootOf_Z3+4&comma;index=1

CubeRootOf−4RootOf_Z3+4&comma;index=1

(37)

CubeRootOf2RootOf_Z3+2&comma;index=1

CubeRootOf−2RootOf_Z3+2&comma;index=1

(38)

CubeRootOf2RootOf_Z32&comma;index=1

CubeRootOf2RootOf_Z32&comma;index=1

(39)

CubeRootOf3RootOf_Z33&comma;index=1

CubeRootOf3RootOf_Z33&comma;index=1

(40)

CubeRootOf4RootOf_Z34&comma;index=1

CubeRootOf4RootOf_Z34&comma;index=1

(41)

CubeRootOf6RootOf_Z36&comma;index=1

CubeRootOf6RootOf_Z36&comma;index=1

(42)

ReduceCubeRootOf4CubeRootOf2CubeRootOf3CubeRootOf4CubeRootOf6

RootOf_Z3+2&comma;index=1RootOf_Z33&comma;index=1RootOf_Z34&comma;index=1RootOf_Z3+4&comma;index=1RootOf_Z36&comma;index=1

(43)

ReduceCubeRootOf4CubeRootOf2CubeRootOf3CubeRootOf4CubeRootOf6&comma;makeindependent=true

0

(44)

With option 'makeindependent'=false, the input will never be checked for algebraic dependencies:

ReduceCubeRootOf2CubeRootOf3CubeRootOf6&comma;makeindependent=false

RootOf_Z32&comma;index=1RootOf_Z33&comma;index=1RootOf_Z36&comma;index=1

(45)

See Also

Algebraic

Algebraic[Expand]

Algebraic[GreatestCommonDivisor]

Algebraic[Normal]

evala,Reduce