a :- b, c.

a (is true) ifbandc (are true).

A less obvious problem is that, depending again on the rules and facts known to the Prolog interpreter, it may take a very long time to determine that the proposition cannot be proven. In certain cases, it might "take" infinite time.

Because of the problems of negation-as-failure, negation in Prolog is represented in modern Prolog interpreters using the symbol+, which is supposed to be a mnemonic for not provable with the standing for not and the + for provable. In practice, current Prolog interpreters tend to support the older operatornot as well, as it is present in lots of older Prolog code, which would break if not were not available.

Examples:

?- + (2 = 4).
true.
?- not(2 = 4).
true.

Arithmetic comparison operators in Prolog each come equipped with a negation which does not have a "negation as failure" problem, because it is always possible to determine, for example, if two numbers are equal, though there may be approximation issues if the comparison is between fractional (floating-point) numbers. So it is probably best to use the arithmeticcomparison operators if numeric quantities are being compared. Thus, a better way to do the comparisons shown above would be:

?- 2 == 4.
true.

number is also the name of a built-in predicate which tests its single argument and succeeds if that argument is a number. Examples:

?- number(2.1).
true.
?- number(-8).
true.
?- X = 7, number(X).
X = 7.
?- number(1+1).
false.

once(P) :- P, !.

See also !, call, backtracking.

:- op(+Precedence, +Type, :Name).

The Prolog built-in predicate op serves to define the Type and Precedence of infix and postfix, and prefix operators in Prolog terms. Prolog terms normally begin with the functor (e.g. likes, in likes(mary, pizza)) but exceptions exist - for example, arithmetic expressions are written in the usual infix way (i.e. as X + 1, rather than +(X, 1)), and negation can be written without parentheses, as a prefix operator: not P.

The table below lists the predefined infix operators in SWI-Prolog. You may wish to add infix operators of your own. For example, you might wish to define an infix and. This can be done as follows:

This declares and to be an operator with precedence 700 and type xfy.

Note two things: (1) the fact that these things are referred two as operators does not mean that an operation is performed when they are encountered. This is not usually the case; and (2) the declaration of an operator only affects the external appearance of the operator in your program - internally, the standard representation is used - for example X + 1 really is internally represented by Prolog as though it was +(X, 1).

Precedence is an integer between 0 and 1200. Precedence 0 removes the declaration. Type is one of: xf, yf, xfx, xfy, yfx, yfy, fy or fx. The f indicates the position of the functor, while x and y indicate the position of the arguments. Thus xfx, xfy, and yfx all indicate an infix operator. y should be interpreted as "in this position a term with precedence equal to or less than the precedence of the functor should occur". For x the precedence of the argument must be strictly less than that of the functor. The precedence of a term is 0, unless its principal functor is an operator, in which case the precedence is the precedence of this operator. A term enclosed in brackets (...) has precedence 0.

To see how this works, consider the arithmetic expression a - b - c. In normal maths, this is interpreted as (a - b) - c, rather than a - (b - c). To achieve this, the binary infix operator- must be declared as type yfx so that the first argument has precedence over the second. Then, internally, a - b - c will be represented as -(-(a, b), c) rather than -(a, -(b, c)).

Built-in Operators (SWI-Prolog)