The Golog Elevator

June 28, 2019

TO GRASP the nitty-gritty of this program, I’m going to refer you to “Knowledge In Action” by Raymond Reiter, from which this example is taken (minus the graphics). I’ve not altered the Golog portion of the code with the exception of adding an execute/1 predicate that takes a situation as its argument and proceedes to call the appropriate JavaScript functions to animate the graphical elevator. This is built with P5.js providing the graphics and Tau-Prolog providing the Prolog that interacts with the JavaScript.

The Golog Elevator

SOME ADDITIONAL suggested queries to play with:

do(open_doors : close_doors, s0, S). Sequence with no execution.
do(control, s0, S), holds(currentFloor(N), S). Check what floor the elevator is on at completion.
do(down(1), s0, S), execute(S). Execute primitive actions
primitive_action(A), poss(A, s0), do(A, s0, S), execute(S). Find a possible action and execute it.
do(up(2) # down(2), s0, S), execute(S). Non-deterministic choice of up or down to floor 2.
do(control, s0, S), execute(S). Run the main control loop.

The Elevator Program

THERE’S PLENTY to parse and play with in here. Firstly there’s some limitations, only the primitive actions declared will have any effect on the graphical elevator when executed as these are the only actions encoded in the JavaScript. This is also the simplest elevator program from the book, with no online planning or exogenous events.

To start playing, start by altering the initial situation (s0): Look for the predicates on(X, s0), these you can add, remove and change. Also currentFloor(X, s0), you can change this one too. From there how about we make the elevator safe?

do(up(7), s0, S). should fail, the top floor is number 6. Try adding a constraint to poss.
do(down(0), s0, S). should also fail, the bottom floor is number 1.
do(open_doors: down(1) # up(6), s0, S). should fail! You’ll need a new fluent for doors and new conditions.
do(open_doors : down(1), s0, do(down(1), do(close_doors, do(open_doors, s0)))). Would be nice, an if in the right proc can achieve this.

/*
  Actions: a thing that is done by the elevator
*/

% Declaring to Golog that these actions exist
%! primitive_action(Action).
primitive_action(turnoff(_)).
primitive_action(open_doors).
primitive_action(close_doors).
primitive_action(up(_)).
primitive_action(down(_)).

% Defining in what situation an action is possible
%! poss(Action, Situation)
% eg poss(up(N), S) if the current floor is less than N
poss(up(N), S) :- currentFloor(M, S), M < N.
poss(down(N), S) :- currentFloor(M, S), M > N.
% open/close doors is defined as always possible
poss(open_doors, _S).
poss(close_doors, _S).
poss(turnoff(N), S) :- on(N, S).

/*
  Processes: an algorithm performed by the elevator
*/

% Declaring Processes (proc/2) to Golog.
% proc(Process, Algorithm)
% These are very Golog... when we ask Golog to do a Process
% it will unpack this to find the Algorithm and execute that.
% some syntax: ?(F) = is F true? A : B = do A then B,
% pi(n, Stuff) = make n a variable in Stuff, A # B do A or B
% if(Condition, Then, Else), while(Condition, Do).
proc(goFloor(N), ?(currentFloor(N)) # up(N) # down(N)).
proc(serve(N), goFloor(N) : turnoff(N) : open_doors : close_doors).
proc(serveAfloor, pi(n, ?(nextFloor(n)) : serve(n))).
proc(park, if(currentFloor(1), open_doors, down(1) : open_doors)).

% main control process
proc(control, while(some(n, on(n)), serveAfloor) : park).

/*
  Fluents: something that is true (holds) in a situation
*/

% In s0 (initial situation), the elevator is on floor 4
currentFloor(4, s0).
% In any other situation the currentFloor is the result
% of doing the action up or down, if the most recent action
% is neither up nor down, then the current floor is whatever
% it was prior to doing the most recent action.
currentFloor(M, do(A, S)) :-
    A = up(M) ; A = down(M) ;
    \+ A = up(_), \+ A = down(_), currentFloor(M, S).

% In s0 the buttons for floor 3 and 5 are on.
on(3, s0).
on(5, s0).
% In any other situation, the button is on if
% it was on previously and the action is not to
% turn it off.
on(M, do(A, S)) :-
    on(M, S), \+ A = turnoff(M).

% utility, using on/2 as a super simple proxy to
% determine the next floor to serve.
nextFloor(N, S) :-
    on(N, S).

% restore situation args for fluents, this let's us
% use reification, so we can say on(N, S) ≡ holds(on(N), S)
% it's necessary for Golog to interpret a do/3 or holds/2.
restoreSitArg(on(N), S, on(N, S)).
restoreSitArg(nextFloor(N), S, nextFloor(N, S)).
restoreSitArg(currentFloor(N), S, currentFloor(N, S)).

/** <module> Golog

# A GOLOG INTERPRETER IN SWI-PROLOG

(Adapted to work with Tau-Prolog by Paul Brown)

This software was developed by the Cognitive Robotics Group under the
direction of Hector Levesque and Ray Reiter.

Do not distribute without permission.
Include this notice in any copy made.

@license Permission to use, copy, and modify, this software and its
documentation for research purpose is hereby granted without fee,
provided that the above copyright notice appears in all copies and
that both the copyright notice and this permission notice appear in
supporting documentation, and that the name of The University of
Toronto not be used in advertising or publicity pertaining to
distribution of the software without specific, written prior
permission.  The University of Toronto makes no representations about
the suitability of this software for any purpose.  It is provided "as
is" without express or implied warranty.

THE UNIVERSITY OF TORONTO DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS, IN NO EVENT SHALL THE UNIVERSITY OF TORONTO BE LIABLE FOR ANY
SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

@author Hector Levesque
@author Ray Reiter
@see "Knowledge in Action" by Ray Reiter, published by MIT Press, 2001, ISBN-10: 0262182181
@see [Knowledge in Action: Resources](http://www.cs.toronto.edu/cogrobo/kia/)

:- dynamic([ (&)/2
           , (-)/1
           , some/2
           , v/2
           ]).

%! do(+Events, +StartSituation, -EndSituation) is nondet.
%  go to a new EndSituation from the StartSituation by doing the Event(s).
%
%## Events: Cases
%
% * `E1 : E2`  a sequence of events, do(E2, do(E1, S))
% * `?(P)`  test action, P must be a condition, does P hold in S?
% * `E1 # E2` nondeterministic choice, do(E1, S) if possible, or do(E2, S).
% * `if(P, E1, E2)` conditional branching, if P holds, do(E1, S), else do(E2, S)
% * `star(E)` nondeterministic repetition, do E until StartSituation is the same as EndSituation
% * `while(P, E)` iteration, while P is true, do E
% * `pi(V, S)` nondeterministic assignment, uses a lowercase variable (V = v) and E is an event using it.
% * `E` where `ako(E, process)` unpack the process
% * `E` where E is a `primative_action/1` in Golog terms, or `ako(E, event)` in ontological.
%
%## Args
%
% @arg Events an expression of events using the above cases
% @arg StartSituation either s0 or do(E, S)
% @arg EndSituation the result of do(Events, StartSituation)
do(E1 : E2,S,S1) :- do(E1,S,S2), do(E2,S2,S1).  % sequence, E1 then E2
do(?(P),S,S) :- holds(P,S).  % Test action, P is a condition
do(E1 # E2,S,S1) :- do(E1,S,S1) ; do(E2,S,S1).  % nondeterministic choice, either E1 or E2
do(if(P,E1,E2),S,S1) :- do((?(P) : E1) # (?(-P) : E2),S,S1).  %  conditional, if(p, then, else)
do(star(E),S,S1) :- S1 = S ; do(E : star(E),S,S1).  % nondeterministic repetition
do(while(P,E),S,S1):- do(star(?(P) : E) : ?(-P),S,S1).  % iteration
do(pi(V,E),S,S1) :- sub(V,_,E,E1), do(E1,S,S1).  % nondeterministic assignment:
                                                 % v is lowercase golog variable, E is an event that uses v
do(E,S,S1) :- proc(E,E1), do(E1,S,S1).  % process, unpacking
do(E,S,do(E,S)) :- primitive_action(E), poss(E, S). % do a single event

%! sub(Name,New,Term1,Term2) is det.
% Term2 is Term1 with Name replaced by New..
% used in nondeterministic assignment, `pi/2`
sub(_,_,T1,T2) :- var(T1), T2 = T1.
sub(X1,X2,T1,T2) :- \+ var(T1), T1 = X1, T2 = X2.
sub(X1,X2,T1,T2) :- \+ T1 = X1, T1 =..[F|L1], sub_list(X1,X2,L1,L2),
                    T2 =..[F|L2].
sub_list(_,_,[],[]).
sub_list(X1,X2,[T1|L1],[T2|L2]) :- sub(X1,X2,T1,T2), sub_list(X1,X2,L1,L2).

%! holds(?Condition, ?Situation) is nondet.
% The holds predicate implements the revised Lloyd-Topor
% transformations on test conditions. It tests to see
% if Condition is true in Situation.
%
%## Condition Operators
%
% Using `F`, `F1`, and `F2` as example conditions.
%
% * `F1 & F2` conjunction
% * `F1 v F2` disjunction
% * `F1 => F2` implication
% * `F1 <=> F2` equivalency
% * `-F` negation
% * `all(V, F)` lowercase Golog variable (V = v), F must use v.
% * `some(V, F)` lowercase Golog variable (V = v), F must use v.
%
%*Note*:
% `all` and `some` are buggy due to interface between ontology and Golog
%
%## Args
%
% @arg Condition an expression using the above condition operators and fluents.
% @arg Situation either s0 or do(E, S).
%
holds(P & Q,S) :- holds(P,S), holds(Q,S).
holds(P v Q,S) :- holds(P,S); holds(Q,S).
holds(P => Q,S) :- holds(-P v Q,S).
holds(P <=> Q,S) :- holds((P => Q) & (Q => P),S).
holds(-(-P),S) :- holds(P,S).
holds(-(P & Q),S) :- holds(-P v -Q,S).
holds(-(P v Q),S) :- holds(-P & -Q,S).
holds(-(P => Q),S) :- holds(-(-P v Q),S).
holds(-(P <=> Q),S) :- holds(-((P => Q) & (Q => P)),S).
holds(-all(V,P),S) :- holds(some(V,-P),S).
holds(-some(V,P),S) :- \+ holds(some(V,P),S).  /* Negation */
holds(-P,S) :- isAtom(P), \+ holds(P,S).     /* by failure */
holds(all(V,P),S) :- holds(-some(V,-P),S).
holds(some(V,P),S) :- sub(V,_,P,P1), holds(P1,S).

/* The following clause treats the holds predicate for non fluents, including
   Prolog system predicates. For this to work properly, the GOLOG programmer
   must provide, for all fluents, a clause giving the result of restoring
   situation arguments to situation-suppressed terms, for example:
         restoreSitArg(ontable(X),S,ontable(X,S)).             */

holds(A,S) :- restoreSitArg(A,S,F), call(F) ;
              \+ restoreSitArg(A, S, _), isAtom(A), call(A).

%! isAtom(+A) is det.
%  distinguish between Golog and Prolog terms.
isAtom(A) :- \+ (A = -_ ; A = (_ & _) ; A = (_ => _) ;
    A = (_ <=> _) ; A = (_ v _) ; A = some(_,_) ; A = all(_,_)).

restoreSitArg(poss(A), S, poss(A, S)).

:- use_module(library(js)).

execute(s0) :-
    currentFloor(CF, s0),
    findall(N, on(N, s0), Ons),
    prop(situation0, Sit0),
    apply(Sit0, [CF, Ons], _).
execute(do(A, S)) :-
    execute(S),
    execute_action(A).

execute_action(down(N)) :-
    prop(down, F),
    apply(F, [N], _).
execute_action(up(N)) :-
    prop(up, F),
    apply(F, [N], _).
execute_action(turnoff(N)) :-
    prop(turnoff, F),
    apply(F, [N], _).
execute_action(open_doors) :-
    prop(open_doors, F),
    apply(F, [], _).
execute_action(close_doors) :-
    prop(close_doors, F),
    apply(F, [], _).

More demo than explanation, but I hope you’ll enjoy playing with a little bit of Golog and consider investigating this fascinating language further.

Until next time, happy gologing. Paul