A query succeeds if each of its goals succeeds.

In general, a term of arity n can be an atom (the functor) followed by narguments, which will be enclosed in parentheses ( ) and separated by commas. Note that the arity might be 0, in which case there are no parentheses, commas, or arguments. A term can also be a number. Sometimes the term can use an infix operator like <, in which case the functor appears between the arguments (if the arity is 2) or before the argument but without parentheses (if the arity is 1).

For + and – (and occasionally?) signs in front of arguments, in procedure header comments, see comments.

It may be useful to be able to test if a term is an number or a variable or something else. Prolog provides several such tests:

To turn on tracing in Prolog, execute the "goal"

?- trace.true.

When you are finished with tracing, turn it off using the "goal"

?- notrace.

Here is an example of trace in action. First some code, which computes factorial N - the product of the numbers from 1 to N. By convention, factorial 0 is 1. Factorial N is often written N!, where the exclamation mark signifies the "factorial operator". Here is the code:

prolog -s factorial.pl
blah blah blah ...
?- trace.true.
[trace]  ?- factorial(3, X).   Call: (7) factorial(3, _G284) ? creep*
^  Call: (8) 3>0 ? creep
^  Exit: (8) 3>0 ? creep
^  Call: (8) _L205 is 3-1 ? creep
^  Exit: (8) 2 is 3-1 ? creep
   Call: (8) factorial(2, _L206) ? creep
^  Call: (9) 2>0 ? creep
^  Exit: (9) 2>0 ? creep
^  Call: (9) _L224 is 2-1 ? creep
^  Exit: (9) 1 is 2-1 ? creep
   Call: (9) factorial(1, _L225) ? creep
^  Call: (10) 1>0 ? creep
^  Exit: (10) 1>0 ? creep
^  Call: (10) _L243 is 1-1 ? creep
^  Exit: (10) 0 is 1-1 ? creep
   Call: (10) factorial(0, _L244) ? creep
   Exit: (10) factorial(0, 1) ? creep
^  Call: (10) _L225 is 1*1 ? creep
^  Exit: (10) 1 is 1*1 ? creep
   Exit: (9) factorial(1, 1) ? creep
^  Call: (9) _L206 is 1*2 ? creep
^  Exit: (9) 2 is 1*2 ? creep
   Exit: (8) factorial(2, 2) ? creep
^  Call: (8) _G284 is 2*3 ? creep
^  Exit: (8) 6 is 2*3 ? creep
   Exit: (7) factorial(3, 6) ? creep
X = 6 ;   Redo: (10) factorial(0, _L244) ? creep
^  Call: (11) 0>0 ? creep
^  Fail: (11) 0>0 ? creep
   Fail: (9) factorial(1, _L225) ? creep
   Fail: (8) factorial(2, _L206) ? creep
   Fail: (7) factorial(3, _G284) ? creep
false.
[debug]  ?- notrace. % turn off tracing
true.
[debug]  ?- 

Invoke prolog, loading code for factorial
Greeting from Prolog
Turn on tracing
Call factorial
Trace echoes query, replacing X with a unique variable
Rule 2, Goal 1 (N > 0) is invoked
Goal 1 succeeds immediately
Rule 2, Goal 2 invoked to compute 3 - 1
and succeeds
Rule 2, Goal 3 is invoked: level 2 call to factorial(2, ...)
Goal 1 again for new call to factorial
Goal 1 succeeds
New version of goal 2
succeeds
Rule 2, Goal 3 is invoked: level 3 call to factorial(1, ...)
Goal 1 again
succeeds
Goal 2 again
successfully
Rule 2, Goal 3 is invoked: recursive call to factorial(0, ...)
This time, Rule 1 succeeds at once.
This is Goal 4 of level 3
Compute 1 * 1 without trouble
so the level 3 factorial call succeeds
This is goal 4 of level 2
Compute 1 * 2 without trouble
so the level 2 factorial call succeeds
This is goal 4 of level 1
Compute 2 * 3 without trouble
so the level 1 factorial call succeeds
... with this binding of X - type ";" to find more solutions
Prolog backtracks looking for another solution
without success
Turn off tracing.

There are further tracing facilities in SWI Prolog. Do

?- help(trace).

Built-in Prolog functions are not traced - that is, the internals of calls to things like member are not further explained by tracing them.

See also fail, repeat.

bad(Dog) :- bites(Dog, _).

says that something (Dog) is bad if Dog bites anything. The "anything" is represented by _. Unlike other variables in Prolog, a bare _ can match different things in the same rule. So, for example, if gives(From, To, Gift) is a three-place procedure that is true if From gives Gift to To, then

giver(X) :- gives(X, _, _).

signifies that someone (X) is a "giver" if X gives something to anybody - the two _ s don't have to match the same thing. So if gives(fred, john, black_eye). is stored in the Prolog database, then the rule above allows us to infer that fred is a giver.

To be more explicit about the meaning of your rule, you could instead write:

bad(Dog) :- bites(Dog, _Anybody).

The rule

bad(Dog) :- bites(Dog, _Anybody).

bad(Dog) :-
    bites(Dog, Something),
    is_person(Something).
% add your own list of prohibitions - shoes, cats, ...

Prolog systems make internal use of variable names beginning with an underscore, e.g. _G157. These are not "don't-care" variables, but are chosen to not clash with any variable name a Prolog programmer is likely to use.

Underscores may also be used in the middle of variable or atom names, as in Intermediate_solution, likes_person - again, these are not "don't-care" variables. The idea is to make the variable or atom name more readable.