# Predicate functions

A predicate function takes an expression and returns Boolean values `true`

or `false`

.

The convention in Maxima is to end predicate functions with the letter "p". Many predicate functions exist already within Maxima. Some of the more useful to us are listed below. STACK defines an additional range of predicate functions. Some are described here, others are in the relevant specific sections of the documentation, such as numbers.

Since establishing mathematical properties are all about predicates they are particularly important for STACK.

You can use predicate functions directly in the potential response tree by comparing the result with `true`

using the
answer test AlgEquiv.

# Maxima type predicate functions

The following are a core part of Maxima, but there are many others. Notice, predicate functions end in the letter "p".

Function | Predicate |
---|---|

`floatnump(ex)` |
Determines if is a float. |

`numberp(ex)` |
Determines if is a number. NOTE `numberp` returns `false` if its argument is a symbol, even if the argument is a symbolic number such as , or , or declared to be even, odd, integer, rational, irrational, real, imaginary, or complex. This function also does not work when `simp:false` , so see the dedicated page on numbers. |

`setp(ex)` |
Determines if is a set. |

`listp(ex)` |
Determines if is a list. |

`matrixp(ex)` |
Determines if is a matrix. |

`polynomialp(ex,[v])` |
Determines if is a polynomial in the list of variables v. |

# STACK type predicate functions

The following type predicates are defined by STACK.

Function | Predicate |
---|---|

`variablep(ex)` |
Determines if is a variable, that is an atom but not a real number, or a string. |

`equationp(ex)` |
Determines if is an equation. |

`functionp(ex)` |
Determines if is a function definition, using the operator `:=` . |

`inequalityp(ex)` |
Determines if is an inequality. |

`expressionp(ex)` |
Determines if is not a matrix, list, set, equation, function or inequality. |

`polynomialpsimp(ex)` |
Determines if is a polynomial in its own variables. |

`simp_numberp(ex)` |
Determines if is a number when `simp:false` . |

`simp_integerp(ex)` |
Determines if is an integer when `simp:false` . |

`real_numberp(ex)` |
Determines if is a real number. |

`rational_numberp(ex)` |
Determines if is written as a fraction. For a true mathematical rational number use `rational_numberp(ex) or simp_integerp(ex)` |

`lowesttermsp(ex)` |
Determines if a fraction is in lowest terms. |

`complex_exponentialp(ex)` |
Determines if is written in complex exponential form, . Needs `simp:false` . |

`imag_numberp(ex)` |
Determines if is a purely imaginary number. |

# STACK general predicates

The following are defined by STACK.

Function | Predicate |
---|---|

`element_listp(ex,l)` |
`true` if `ex` is an element of the list . (Sets have `elementp` , but lists don't) |

`all_listp(p,l)` |
`true` if all elements of satisfy the predicate . |

`any_listp(p,l)` |
`true` if any elements of satisfy the predicate . |

`sublist(l,p)` |
Return a list containing only those elements of the list for which the predicate p is true |

(The last of these is core Maxima and is not, strictly speaking, a predicate function)

# STACK other predicate functions

Function | Predicate |
---|---|

`expandp(ex)` |
true if equals its expanded form. |

`factorp(ex)` |
true if equals its factored form. Note, if you would like to know if an expression is factored you need to use the FacForm answer test. Prime integers equal their factored form, composite integers do not. |

`continuousp(ex,v,xp)` |
true if is continuous with respect to at (unreliable). |

`diffp(ex,v,xp,[n])` |
true if is (optionally times) differentiable with respect to at (unreliable). |

The last two functions rely on Maxima's `limit`

command and hence are not robust.

# Establishing form

A lot of what teachers do is try to establish if a student's answer "looks right" that is, in an appropriate form.

`linear_term_p(ex, p)`

establishes that the expression `ex`

is a simple product of one expression for which the predicate `p`

is true and zero or more real numbers.

`linear_combination_p(ex, p)`

establishes that the expression `ex`

is a linear combination of terms for which `p`

is true.

The teacher can then use this function to build more complex predicates such as the following

```
fouriertermp(ex) := if ((safe_op(ex)="cos" or safe_op(ex)="sin") and linear_term_p(first(args(ex)), variablep)) then true else false$
```

This predicate function decides if we have a term of the form or where is any product of real numbers (e.g. ) and is any variable. A teacher might prefer to specify a particular variable.

```
fouriertermp(ex) := if ((safe_op(ex)="cos" or safe_op(ex)="sin") and linear_term_p(first(args(ex)), lambda([ex2], ex2=t))) then true else false$
```

So, if you want to decide if the student's answer looks like the combined predicate `linear_combination_p(ex, fouriertermp)`

can be used.

Testing for form in this way is probably more reliable that the `substequiv`

answer test which fails to match up expressions like with . As every, the minus sign is a problem. However, the following predicate will work.

```
simpletrigp(ex) := if (ex=cos(t) or ex=sin(t)) then true else false$
```

and the test `linear_combination_p(ex, simpletrigp)`

will be able to do this.

# Related functions

This is not, strictly speaking, a predicate function. It is common to want to ensure that a student's expression is free of things like , or in the denominator. This include any complex numbers.

`rationalized(ex)`

searches across the whole expression `ex`

and looks in the denominators of any fractions. If the denominators are free of such things the function returns `true`

otherwise the function returns the list of offending expressions. This design allows efficient feedback of the form ``the denominator in your expression should be free of the following: ...".