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 occurs_check. It acts as if defined by the following rule.=(Term, Term).

- [ISO]
`+Term1`**\=**`+Term2` -
Equivalent to

. 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 Terms`^{26Strings might be considered atoms in future versions. See also section 4.23}- 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` -
Equivalent to

.`\+`

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 terms. - [ISO]
`+Term1`**@>**`+Term2` -
True if
`Term1`is after`Term2`in the standard order of terms. - [ISO]
`+Term1`**@>=**`+Term2` -
True if both terms are equal (==/2)
or
`Term1`is after`Term2`in the standard order of terms. **compare**(`?Order, +Term1, +Term2`)-
Determine or test the
`Order`between two terms in the standard order of terms.`Order`is one of

,`<`

or`>`

, 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 predicates subsumes/2 and subsumes_chk/2 define `one-sided-unification' and are found in many Prolog systems. Finally, unifiable/3 is a `what-if' version of unification that is often qused a building block in constraint reasoners.

- [ISO]
**unify_with_occurs_check**(`+Term1, +Term2`) -
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)). No

I.e. the first creates a

*cyclic-term*, which is printed as an infinitely nested f/1 term (see the`max_depth`

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:`a``=@=``A`false `A``=@=``B`true `x(A,A)``=@=``x(B,C)`false `x(A,A)``=@=``x(B,B)`true `x(A,B)``=@=``x(C,D)`true 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 systems.

`+Term1`**\=@=**`+Term2`-
Equivalent to
```

.`\+`

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 by^{27This implementation relies on the fact that term_variables/2 orders its variables based on depth-first left-to-right traversal of the term.}subsumes(General, Specific) :- term_variables(Specific, SVars), General = Specific, term_variables(SVars, SVars2), SVars == SVars2.

**subsumes_chk**(`+Generic, @Specific`)-
Equivalent to
`\+ \+ subsumes(Generic, Specific)`

. **unifiable**(`@X, @Y, -Unifier`)-
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 and when/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*executed. **?=**(`@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 by`?=(A,B) :- (A==B ; A \= B), !.`

See also dif/2.