Monotonic predicate rewrite collect_vars

[jjtolton]

I am rewriting a GRAPHPLAN algorithm from a text book. There is one predicate I have not been able to fix at all, collect_vars/2.

Big picture, there are terms with the shape f(_)/_, such as go(a,1,4)/1, persist(~at(a,1))/0 in a list, and this predicate is used to assign labeling/2 to the 0s and 1s to the second argument of the (/)/2 functor after removing everything with the shape persist(_)/_.

Here's how it's used:

extract_plan( [ _ ], []).
extract_plan( [ _, ActionLevel | RestOfGraph], Plan) :-
        collect_vars( ActionLevel, AVars),
        labeling([], AVars),
        nonpersist_actions(ActionLevel, Actions),
        extract_plan(RestOfGraph, RestOfPlan),
        append( RestOfPlan, [Actions], Plan).

% book version
collect_vars( [], []).
collect_vars( [ X/V | Rest], Vars) :-
        (   X \= persist(_), var( V), !, Vars = [V | RestVars ]
        ; Vars = RestVars
        ),
        collect_vars( Rest, RestVars). % Collect rest of variables

I thought I would have enough to do it from this discussion, but when I apply that, some examples do not terminate.

/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
   See https://github.com/mthom/scryer-prolog/discussions/2539#discussioncomment-10579547
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
% T = true if either the functor indicator or arity are different
different_functor_t(A, B, T) :-
    functor(A, AFunctor, AArity),
    functor(B, BFunctor, BArity),
    ';'(dif(AFunctor, BFunctor), dif(AArity, BArity), T).

% my attempted rewrite
collect_vars([], []).
collect_vars([X/V|Rest], Vars) :-
        if_(different_functor_t(a(_), X),
            Vars=[V|RestVars],
            Vars=RestVars
           ),
        collect_vars(Rest, Vars).

I have also tried:

collect_vars([], []).
collect_vars([X/V|Rest], Vars) :-
        (   
            var(V),
            different_functor_t(a(_), X, true),
            Vars=[V|RestVars]
        ;   Vars=RestVars
        ),
        collect_vars(Rest, Vars).

I've also tried:

collect_vars(MixedActions, Vars) :-
        findall(A, (member(A/_, MixedActions), A=persist(_)), PersistActions),
        xs_ys_setdiff(MixedActions, PersistActions, NonPersistActions),
        findall(V, (member(_/V, NonPersistActions), var(V)), Vars).

but that doesn't terminate either.

I must be overlooking something obvious, but I can't spot it.

Here's the full context, in case anyone that's important to anyone:

https://gist.github.com/jjtolton/38382379e1c5ad58ebfdba561d68e5fc

(it's an in-progress rewrite, please consider it a draft)

[jjtolton]

@UWN sometimes I wonder if you get tired of answering the same question over and over again 🙄

I reviewed my notes, found your previous answer, combined it with @bakaq 's answer, and it solved many of the problems in the code I'm working.

collect_vars([],[]).
collect_vars([X/V|Rest], Vars) :-
        functor(X, F, _),
        if_(F=persist, Vars=NonPersistVars, Vars=[V|NonPersistVars]),
        collect_vars(Rest,NonPersistVars).

@triska also already answered this question in his video essay on Writing Prolog Code. The functor part of it really just made me forget everything, apparently!

[jjtolton]

This will select terms with different arities, like persist, persist(nix), persist(n,importe).

Ah, great points. I know from the domain that arrity does not matter, but it is not communicated explicitly here.

And really everything else is now a variable?

I'm not following this last point? "Variable" is perhaps a bad name, here. The original author included a var(V) goal in the original definition, which I omitted because I wasn't immediately sure how to form a monotonic var_t/1 predicate for use with if_/3 (although this may be orthogonal to the point you were making), and the algorithm still "worked" (if you define "terminated" as "worked").

[bakaq]

I think there is no way to make a (useful) monotonic var_t/1, because nonvar/1 is not monotonic.

[UWN]

Generally speaking, any reified predicate should get its meaning just from the ground instances it is true for. If this is not possible, then we have some impure code, where reif will probably be not very helpful.

[jjtolton]

Ok. In these circumstances, is it still good to use if_/3, or should if_/3 only be used when you are trying to deliberately communicate that this is monotonic code? My temptation would be to use it anyway and just write a nonmonotonic predicate for var_t/2 because it would keep the code consistent and I like the aesthetics.

[UWN]

It is probably best to reserve if_/3 to monotonic code. Otherwise there is If -> Then ; Else