Although unification is mostly done implicitely while matching the
head of a predicate, it is also provided by the predicate =/2.
- [ISO]+Term1 = +Term2
Unify Term1 with Term2. True if the unification
succeeds. For behaviour on cyclic terms see the Prolog flag
acts as if defined by the following rule.
- [ISO]+Term1 \= +Term2
. See also dif/2.
\+Term1 = Term2
Comparison and unification of arbitrary terms. Terms are ordered in
the so called ``standard order''. This order is defined as follows:
- Variables < Numbers < Atoms
< Strings < Compound Terms26Strings
might be considered atoms in future versions. See also section
- Variables are sorted by address. Attaching attributes (see section
6.1) does not affect the ordering.
- Atoms are compared alphabetically.
- Strings are compared alphabetically.
- Numbers are compared by value. Mixed integer/float are
compared as floats. If the comparison is equal, the float is considered
the smaller value. If the Prolog flag iso
is defined, all floating point numbers precede all integers.
- Compound terms are first checked on their arity, then on
their functor-name (alphabetically) and finally recursively on their
arguments, leftmost argument first.
- [ISO]+Term1 == +Term2
True if Term1 is equivalent to Term2. A variable
is only identical to a sharing variable.
- [ISO]+Term1 \== +Term2
\+Term1 == Term2
- [ISO]+Term1 @< +Term2
True if Term1 is before Term2 in the standard
order of terms.
- [ISO]+Term1 @=< +Term2
True if both terms are equal (==/2)
or Term1 is before Term2 in the standard order of
- [ISO]+Term1 @> +Term2
True if Term1 is after Term2 in the standard order
- [ISO]+Term1 @>= +Term2
True if both terms are equal (==/2)
or Term1 is after Term2 in the standard order of
Determine or test the Order between two terms in the standard
order of terms. Order is one of
, with the obvious meaning.
This section describes special purpose variations on Prolog
unification. The predicate unify_with_occurs_check/2
provides sound unification and is part of the ISO standard. The
define `one-sided-unification' and are found in many Prolog systems.
is a `what-if' version of unification that is often qused a building
block in constraint reasoners.
As =/2, but using sound-unification.
That is, a variable only unifies to a term if this term does not contain
the variable itself. To illustrate this, consider the two goals below:
1 ?- A = f(A).
A = f(f(f(f(f(f(f(f(f(f(...))))))))))
2 ?- unify_with_occurs_check(A, f(A)).
I.e. the first creates a cyclic-term,
which is printed as an infinitely nested f/1 term (see the
option of write_term/2).
The second executes logically sound unification and thus fails. Note
that the behaviour of unification through
=/2 as well as implicit
unification in the head can be changed using the Prolog flag occurs_check.
- +Term1 =@= +Term2
True if Term1 is `structurally equal' to Term2.
Structural equivalence is weaker than equivalence (==/2),
but stronger than unification (=/2).
Two terms are structurally equal if their tree representation is
identical and they have the same `pattern' of variables. Examples:
The predicates =@=/2
and \=@=/2 are
cycle-safe. Attributed variables are considered structurally equal iff
their attributes are structurally equal. This predicate is known by the
name variant/2 in some other Prolog
- +Term1 \=@= +Term2
\+Term1 =@= Term2'
- subsumes(+Generic, @Specific)
A term is told to subsume another term if instantiation in the
generic term produces the specific term. The subsumption relation is
also called one sided unification or semi-unification.
It behaves as if defined by27This
implementation relies on the fact that term_variables/2
orders its variables based on depth-first left-to-right traversal of the
subsumes(General, Specific) :-
General = Specific,
SVars == SVars2.
- subsumes_chk(+Generic, @Specific)
\+ \+ subsumes(Generic, Specific).
- unifiable(@X, @Y,
If X and Y can unify, unify Unifier
with a list of
Var = Value, representing the bindings required to
make X and Y equivalent.28This
predicate was introduced for the implementation of dif/2
after discussion with Tom Schrijvers and Bart Demoen. None of us is
really happy with the name and therefore suggestions for a new name are
welcome. This predicate can handle cyclic terms. Attributed
variables are handles as normal variables. Associated hooks are not
- ?=(@Term1, @Term2)
Decide whether the equality of Term1 and Term2 can
be compared safely, i.e. whether the result of
Term1 == Term2
can change due to further instantiation of either term. It is defined as
?=(A,B) :- (A==B ; A \= B), !. See also