# 10 Assigning and Testing Algebraic Properties

Sometimes algebraic expressions can be further simplified if there is additional information about the value ranges of its components. The following section describes how to inform REDUCE of such assumptions.

## 10.1 REALVALUED Declaration and Check

`Reduce.Algebra.realvalued`

— Function`realvalued(r...)`

The declaration `realvalued`

may be used to restrict variables to the real numbers. The syntax is:

` Algebra.realvalued(v1,...vn)`

For such variables the operator `impart`

gives the result zero. Thus, with

`julia> Algebra.realvalued(:x,:y)`

the expression `impart(x+sin(y))`

is evaluated as zero. You may also declare an operator as real valued with the meaning, that this operator maps real arguments always to real values. Example:

```
julia> Algebra.operator(:h); Algebra.realvalued(:h,:x)
julia> Algebra.impart(:(h(x)))
0
julia> Algebra.impart(:(h(w)))
:(impart(h(w)))
```

Such declarations are not needed for the standard elementary functions.

`Reduce.Algebra.notrealvalued`

— Function`notrealvalued(r...)`

To remove the `realvalued`

propery from a variable or an operator use the declaration `notrealvalued`

with the syntax:

`julia> Algebra.notrealvalued(v1,...vn)`

The boolean operator `realvaluedp`

allows you to check if a variable, an operator, or an operator expression is known as real valued. Thus,

```
julia> Algebra.realvalued(:x)
julia> R"write if realvaluedp(sin x) then ~yes~ else ~no~"
julia> R"write if realvaluedp(sin z) then ~yes~ else ~no~"
```

would print first yes and then no. For general expressions test the impart for checking the value range:

```
julia> Alebra.realvalued(:x,:y); R"w:=(x+i*y); w1:=conj w" |> rcall
julia> Algebra.impart(:(w*w1))
0
julia> Algebra.impart(:(w*w))
:(2x*y)
```

## 10.2 Declaring Expressions Positive or Negative

Detailed knowlege about the sign of expressions allows REDUCE to simplify expressions involving exponentials or `abs`

. You can express assumptions about the positivity or negativity of expressions by rules for the operator `sign`

. Examples:

```
julia> Algebra.abs(:(a*b*c))
:(abs(a*b*c))
julia> Algebra.rlet((:(sign(a))=>1,:(sign(b))=>1)); :(abs(a*b*c) |> rcall
:(abs(c) * a * b)
julia> Algebra.on(:precise); Algebra.sqrt(:(x^2-2x+1))
:(abs(x - 1))
reduce> ws where sign(x-1)=>1;
x - 1
```

Here factors with known sign are factored out of an `abs`

expression.

```
julia> Algebra.on(:precise); Algebra.on(:factor)
reduce> (q*x-2q)^w;
w
((x - 2)*q)
reduce> ws where sign(x-2)=>1;
w w
q *(x - 2)
```

In this case the factor $(x - 2)^w$ may be extracted from the base of the exponential because it is known to be positive.

Note that REDUCE knows a lot about sign propagation. For example, with $x$ and $y$ also $x + y$, $x + y + π$ and $(x + e)∕y^2$ are known as positive. Nevertheless, it is often necessary to declare additionally the sign of a combined expression. E.g. at present a positivity declaration of $x- 2$ does not automatically lead to sign evaluation for $x- 1$ or for $x$.