0

How do I define a rule that the user cannot query? I only want the program itself to call this rule through another rule.

Ex:

rule1():- rule2().

rule2():- 1<5.

?-rule1().

true

?-rule2().

(I don't know what the answer will be, I just want this query to fail!)

false
  • 10,264
  • 13
  • 101
  • 209
Andre Viau
  • 275
  • 2
  • 5
  • 17

3 Answers3

5

Use a Logtalk object to encapsulate your predicates. Only the predicates that you declare public can be called (from outside the object). Prolog modules don't prevent calling any predicate as using explcit qualification bypasses the list of explicitly exported predicates.

A simple example:

:- object(rules).

    :- public(rule1/1).
    rule1(X) :-
        rule2(X).

    rule2(X) :-
        X < 5.

:- end_object.

After compiling and loading the object above:

?- rules::rule1(3).
true.

?- rules::rule2(3).
error(existence_error(predicate_declaration,rule2(3)),rules::rule2(3),user)

If you edit the object code and explicitly declare rule2/1 as private you would get instead the error:

?- rules::rule2(3).
error(permission_error(access,private_predicate,rule2(3)),rules::rule2(3),user)

More information and plenty of examples at http://logtalk.org/

Paulo Moura
  • 18,373
  • 3
  • 23
  • 33
2

First, some notes:

  • I think you mean "predicate" instead of "rule". A predicate is a name/k thing such as help/0 (and help/1 is another) and can have multiple clauses, among them facts and rules, e.g. length([], 0). (a fact) and length([H|T], L) :- ... . (a rule) are two clauses of one predicate length/2.

  • Do not use empty parenthesis for predicates with no arguments – in SWI-Prolog at least, this will not work at all. Just use predicate2 instead of predicate2() in all places.

  • If you try to call an undefined predicate, SWI-Prolog will say
    ERROR: toplevel: Undefined procedure: predicate2/0 (DWIM could not correct goal) and Sicstus-Prolog will say
    {EXISTENCE ERROR: predicate2: procedure user:predicate2/0 does not exist}

Now, to the answer. Two ideas come to my mind.

(1) This is a hack, but you could assert the predicate(s) every time you need them and retract them immediately afterwards:

predicate1 :- 
      assert(predicate2), predicate2, retractall(predicate2).

If you want a body and arguments for predicate2, do assert(predicate2(argument1, argument2) :- (clause1, clause2, clause3)).

(2) Another way to achieve this would be to introduce an extra argument for the predicate which you do not want to be called by the user and use it for an identification that the user cannot possibly provide, but which you can provide from your calling predicate. This might be a large constant number which looks random, or even a sentence. This even enables you to output a custom error message in case the wrong identification was provided.

Example:

 predicate1 :- 
        predicate2("Identification: 2349860293587").

 predicate2(Identification) :- 
        Identification = "Identification: 2349860293587", 
        1 < 5.
 predicate2(Identification) :- Identification \= "Identification: 2349860293587",
        write("Error: this procedure cannot be called by the user. Use predicate1/0 instead."), 
        fail.

I don't use the equivalent predicate2("Identification: 2349860293587") for the first clause of predicate2/0, because I'm not sure where the head of the clause might appear in Prolog messages and you don't want that. I use a fail in the end of the second clause just so that Prolog prints false instead of true after the error message. And finally, I have no idea how to prevent the user from looking up the source code with listing(predicate2) so that will still make it possible to simply look up the correct identification code if s/he really wants to. If it's just to keep the user from doing accidental harm, it should however suffice as a protection.

Felix Dombek
  • 13,664
  • 17
  • 79
  • 131
1

This reminds me to facility found in Java. There one can query the curent call stack, and use this to regulate permissions of calling a method. Translated to Prolog we find in the old DEC-10 Prolog the following predicate:

ancestors(L)
Unifies L with a list of ancestor goals for the current clause. The list starts with the parent goal and ends with the most recent ancestor coming from a call in a compiled clause. The list is printed using print and each entry is preceded by the invocation number in parentheses followed by the depth number (as would be given in a trace message). If the invocation does not have a number (this will occur if Debug Mode was not switched on until further into the execution) then this is marked by "-". Not available for compiled code.

Since the top level is usually a compiled predicate prolog/0, this could be used to write a predicate that inspects its own call stack, and then decides whether it wants to go into service or not.

rule2 :- ancestors(L), length(L,N), N<2, !, write('Don't call me'), fail.
rule2 :- 1<5.

In modern Prologs we don't find so often the ancestors/1 predicate anymore. But it can be simulated along the following lines. Just throw an error, and in case that the error is adorned with a stack trace, you get all you need:

ancestors(L) :- catch(sys_throw_error(ignore),error(ignore,L),true).

But beware stack eliminiation optimization might reduce the stack and thus the list returned by ancestors/1.

Best Regards

P.S.: Stack elimination optimization is already explained here: [4] Warren, D.H.D. (1983): An Abstract Prolog Instruction Set, Technical Note 309, SRI International, October, 1983

A discussion for Jekejeke Prolog is found here: http://www.jekejeke.ch/idatab/doclet/prod/en/docs/10_pro08/13_press/03_bench/05_optimizations/03_stack.html