how to solve when the number of variables in the goal/query varies - Prolog Constrain Solver

Question

Here's a snippet on the classic SENDMORY crypt-arithmetic problem solutiong using prolog constraint solving mechanism-

:- lib(ic).
sendmore(Digits) :-
Digits = [S,E,N,D,M,O,R,Y],
Digits :: [0..9],
alldifferent(Digits),
S #\= 0,
M #\= 0,
1000*S + 100*E + 10*N + D 
+ 1000*M + 100*O + 10*R + E
#= 10000*M + 1000*O + 100*N + 10*E + Y,
labeling(Digits).

Now, to execute this, I would send a goal/query like this:

?- sendmore(Digits).

And that would return me the possible solutions for the digits.

Now, my question is, I do not want to sort of "hard-code" the variables (like S,E,N,...) this way, but the goal/query would give the number of variables. For example, if the query I pass is something like:

?- sendmore(S,E,N,D,M).

then, it should compute only the values of SENDM and assume that the other variables are not applicable, and hence assign 0 to those variables and then proceed with the computation. And the next time I query, I may pass a different number of variables in the query.. like example:

?- sendmore(S,N,D,M,O,Y).

and the program should compute likewise.

What I am trying to achieve is a more generalised problem solver for the above scenario. Any directions on this is really appreciated. I am quite new to prolog,and am using ECLIPSE constraint solver. Thank You.

Answer 1

Here are 2 ideas:

1. You can define sendmore() with different numbers of parameters, which would call the "real" version with the missing ones filled in. But you couldn't have different versions with the same NUMBER of parameters but DIFFERENT ones (since Prolog matches args to parameters by position).
2. You could expand/complicate your list format to allow the specification of which parameters you are passing; something line [(s,S),(e,E),(n,N),(d,D),(m,M)] for your middle example. A little tedious, but gives you the flexibility you seem to want.

Answer 2

Normally, variables in a goal and variables in a clause head are matched by their positions, not their names. So a call ?- sendmore0([S,E,N,D,M]). should be implemented as:

sendmore0([S,E,N,D,M]) :- sendmore([S,E,N,D,M,_,_,_]).

However, this would mean that you would need to implement this for every possible combination.

If you really want to implement what you describe, then you need to give the variable stable names. In ECLiPSe, you can do this with the library var_name. It's quite a hack, though...

:- lib(var_name).

sendmore0(L) :-
   build_arg(["S","E","N","D","M',"O","R","Y"], L, A),
   sendmore(A).

build_arg([], _, []) :- !.
build_arg([H|T], L, [HA|HT]) :-
   match_arg(L, H, HA),
   build_arg(T, L, HT).

match_arg([], _, _). % or use 0 as last argument if you want
match_arg([H|T], Base, A) :-
   (
      get_var_name(H, S),
      split_string(S,"#","",[Base,_])
   ->
      A = H
   ;
      match_arg(T, Base, A)
   ).

Then you can call sendmore0/1 with a shorter list of variables. Don't forget to set the variable names!

?- set_var_name(S, "S"), set_var_name(E, "E"), sendmore0([S, E]).
S = 9
E = 5
Yes (0.00s cpu, solution 1, maybe more)

Disclaimer: this is not what stable names are for. They are meant for debugging purposes. If Joachim ever sees this, he'll give me a sharp clip round the ears...