Unification not commutative

?- X = s(1), X = s(X).
false.
?- X = s(X), X = s(1).
X = 1 ; 

Expected: While the second is STO (subject to occurs check) and thus undefined, it is still highly desirable if this fails. Either,

1. because X = s(X) fails due to the occurs check, or

2. because X = s(X) creates an “infinite term” and X = s(1) fails thereafter, or finally

3. because X = s(X) produces an error - well that’s not failure …

I have never seen a system with this behavior, but very strictly speaking, that is still conforming. But I really cringe: “Why??”. I very much suspect that this is not intended.

[ghost]

I don’t know. I didn’t implement rational term unification in my system. But algorithms for this problem should be around. Like for example Colmerauer was writing about them:

P R O L O G IN 10 F I G U R E S - Alain Colmerauer 4. INFINITE T R E E S https://www.ijcai.org/Proceedings/83-1/Papers/117a.pdf

SWI-Prolog has implemented such an algorithm. I guess if you do something along bisimulation, you might develop also such an algorithm. You need bisimulation for cases like this:

?- A = s(s(A)), B = s(B), A = B.
true

But making it efficient and not using a lot of extra data structures is the challenge here. SWI-Prolog has not only treated predicates such as (=)/2, but also predicate such as ground/1 and (==)/2.

I did recently something for term_variables/2, by a simple visited list:

public void safeVars(Object t, Display d) { https://github.com/jburse/jekejeke-devel/blob/master/jekrun/headless/jekpro/reference/structure/EngineVars.java#L299

I started using a separate name space, like safe_term_variables/2. I needed this to make the top-level a little safer, like GNU Prolog, I wanted to display <cyclic term> for cyclic terms and not crash.

[jariazavalverde]

Interesting. And how do you avoid the infinite loop in case Y = s(s(Y)), Y = s(Y).?

<(Y = s(s(Y)), Y = s(Y)), id> =>
<s(s(Y)) = s(s(s(Y))), {Y/s(s(Y))}> =>
<s(Y) = s(s(Y)), {Y/s(s(Y))}> =>
<Y = s(Y), {Y/s(s(Y))}> =>
<s(s(Y)) = s(Y), {Y/s(s(Y))}> =>
<s(Y) = Y, {Y/s(s(Y))}> =>
<Y = s(Y), {Y/s(s(Y))}> =>
<s(s(Y)) = s(Y), {Y/s(s(Y))}> =>
...