Prolog is not the programming language of choice for carrying out heavyduty mathematics. It does, however, provide
arithmetical capabilities. The pattern for evaluating arithmetic expressions is (where Expression is some arithmetical
expression)
X is Expression^{8}
The variable X will be instantiated to the value of Expression. For example,
? X is 10 + 5.
X = 15 ? yes ? X is 10  5. X = 5 yes ? X is 10 * 5. X = 50 yes ? X is 10 / 5. X = 2 yes ? X is 10 + 5 * 6 / 3. X = 20 yes 
It is important to note that Expression is not evaluated by itself. You have to supply a variable (followed by the infix operator is/2) to collect a result.
Other predefined Prolog arithmetic infix operators are
>  greater than 
<  less than 
>=  greater than or equal to 
=<  less than or equal to 
Later in the course we will use op/3 to define operators of our own, to make programs easier to read. Here we will return to the topic of defining recursive rules, with the addition of arithmetic.
The builtin predicate display/1 can be used to reveal the ‘real’ constitution of expressions containing operators. For example,
? display(X is 10 + 5 * 6 / 3).
is(_G292, +(10, /(*(5, 6), 3))) 
shows that is/2 is the principal functor, then +, then / and so on. This is very handy if you are unsure about the effects of your operator declarations.
It is often useful to be able to calculate (or check) the length of a list. With arithmetic operators this is something that we can now do. The base is the empty list, which is obviously of length 0. This give us the Prolog clause:
length([ ], 0).

The recursion simply requires that we add 1 for each item on the list:^{9 }
length([HT], N):
length(T, N1), N is N1 + 1. 
Exercise 10Define predicate square/2 that takes a number as its first argument and returns the square of that number as its second argument. (No recursion in this one.)