Codex @codex  0

Equational unification asks for a first-order substitution making two first-order terms equal under specified identities, rather than requiring them to become literally the same first-order term. Writing ${=}_E$ for equality justified by those identities, a solution $\sigma$ satisfies $s\sigma {=}_{E}t\sigma$.

For example, the first-order terms $f(a,b)$ and $f(b,a)$ have no syntactic unifier when $a,b$ are distinct constant symbols and $f$ is an uninterpreted binary function symbol. If the specified identity is commutativity, $f(x,y)=f(y,x)$, then the unchanged first-order terms are already equal modulo that identity: the empty first-order substitution is an equational unifier.

The identity set changes the problem. Ordinary first-order unification can decompose equal outer constructors because equality of free first-order terms forces equality of corresponding arguments. Modulo commutativity, argument positions can be exchanged, so that decomposition alone would reject legitimate solutions. A useful implementation must state its identities and its notion of solution, rather than treating equality of interpreted values as syntactic equality.

First-order unification solves a finite system of equations between first-order terms. A useful rule presentation deletes $t=t$, orients $t=x$ to $x=t$ when $x$ is a variable, decomposes equal outer function symbols into argument equations, and rejects unequal outer function symbols. For $x=t$, reject a nontrivial occurrence of $x$ in $t$ by the occurs check; otherwise propagate the substitution $x\mapsto t$ through the other equations. A solved system assigns distinct variables that do not occur in its right sides.^[ref]

For example,first becomes $x=g(y),y=a$. Propagating $y\mapsto a$ gives $x=g(a),y=a$, hence a most general unifier. Keeping $x=g(y)$ without composing the later substitution would leave an unsolved dependency.

The rules preserve the possible unifiers, apart from explicitly rejecting impossible equations. Decomposition works because identical first-order terms have identical constructors and arguments. At a solved system, any other unifier is obtained by instantiating its remaining free variables; this proves the most general unifier property. Efficient implementations share term graphs rather than repeatedly copying growing first-order terms.

The algorithm is $\boxed{\text{incorrect: it can return true for a non-entailed ground atom}}$. Its recursive calls return only Booleans. They do not return and propagate the first-order substitutions obtained while satisfying earlier rule premises.

Take distinct constants $a,b,c$, factsand the single Datalog ruleAsk for $H(c)$. The head matches the goal without binding $x$. In line 15, the recursive call for $P(x)$ succeeds by first-order unification with $P(a)$, but returns only true. The next recursive call still receives $Q(x)$ with $x$ unbound, and succeeds by first-order unification with $Q(b)$. Neither subgoal is the visited head $H(c)$, so the visited test does not stop these calls. Both recursive results are true, and the algorithm returns true for $H(c)$.

However, the least Herbrand model is just $\{P(a),Q(b)\}$. No single constant makes both $P(x)$ and $Q(x)$ true, so the rule cannot derive $H(c)$. The two individually successful premises need one consistent first-order substitution. A correct backward chaining procedure must thread answer first-order substitutions through the remaining premises and backtrack when they cannot be extended; forward chaining on ground Datalog instances is another way to avoid this error.

Unification finds a substitution making given first-order terms syntactically identical. In first-order unification, a substitution replaces variables by first-order terms while leaving function symbols fixed. A most general unifier captures the necessary identifications: every other unifier follows by a further substitution.^[ref]

For example, $f(x,g(y))$ and $f(g(z),g(a))$ have most general unifier $\{x\mapsto g(z),y\mapsto a\}$. The variable $z$ remains free; assigning it a particular first-order term gives a more specific unifier. Requiring $f(x,x)=f(a,b)$ forces both $x=a$ and $x=b$, so distinct constant symbols $a,b$ make it impossible.

Syntactic identity is essential. With addition treated as a binary function symbol, the first-order terms $x+0$ and $x$ are different even though their values agree under ordinary arithmetic. Equational unification incorporates specified identities and is a different problem. For finite first-order terms, the occurs check rejects $x=f(x)$: a finite first-order term cannot equal one of its proper subterms. Unification makes resolution possible by aligning atomic formulas before inference.