🚀 go-pugleaf

In article <1990Mar9.095655.4191@bath.ac.uk>
ccsdgdc@gdr.bath.ac.uk (Douglas Clark) writes:
>A user has been asking me how to write synonyms in Prolog.
>Being ignorant I have no idea.
>It is obvious why the natural

>father(X) :- male(X).
>male(X) :- father(X).
>father(fred).

>fails.  But I cannot find a substitute that works.  Some way of eliminating
>the repetitive backtracking.  Help would be appreciated.

Er, what repetitive backtracking?  The code exhibited must go into an
infinite loop without ever delivering any answers:
	?- father(tom)
    =>	?- male(tom)
    =>	?- father(tom)
and away we go.  

Do you really believe that "father" and "male" are synonyms?  Strange world.

If you have two predicates p and q such that p iff and only if q, then all
you have to do is to pick one of them, say p, and decide to take it as basic.
What you do is include the axiom
	q(X) :- p(X).
If this is the only clause for q, then p and q cannot possibly differ at
any point.  YOU DON'T NEED TO DO ANYTHING TO P TO MAKE THIS SO.

It's a good idea to make the definition of p self-contained, so whenever
you would have called q in the definition of p, make it call p instead.
That isn't strictly necessary.

In this particular example, to make sure that father/1 and male/1 have
exactly the same set of answers, and that fred is a father, it suffices
to write

	male(X) :- father(X).		% make male, father equivalent

	father(fred).			% define father

In article <1990Mar10.120125.12992@Neon.Stanford.EDU>, 
feldman@Neon.Stanford.EDU (Todd J. Feldman) writes:
> How about:
 
> father(X):-
> 	not(tried(male(X))),
> 	assert(tried(male(X))),
> 	male(X).
> male(X):-
> 	not(tried(father(X))),
> 	assert(tried(father(X))),
> 	father(X).

This does not work at all if you ask a question with a variable in it.
Suppose I ask
	?- male(fred), male(X).
Given the fact father(fred), this should succeed with X = fred.

The greatest problem with Feldman's approach is its use of the data base.

	father(fred).
	father(X) :- subgoal_of(father(X)), !, fail.
	father(X) :- male(X).

	male(X) :- subgoal_of(male(X)), !, fail.
	male(X) :- father(X).

doesn't leave a lot of dangerous mess around behind it.  It has problems
of its own.  (See discussions of the "loop check problem".)  An approach
which might work rather nicely would be to use extension tables.

But the simplest approach is just not to put the loop there in the first
place.