%%
%%  domain.pl:  Axiomatisation of the "Cooking Agents" domain for MIndiGolog
%%
%%  Copyright 2005, Ryan Kelly
%%
%%    This file contains an axiomatisation of the "Cooking Agents" domain
%%    in the Concurrent, Temporal Situation Calculus with Natural Actions.
%%
%%    The domain consists of several agents and inanimate objects of
%%    different types (indicated by prim_obj/2) which in turn may
%%    be part of super-types (indicated by super_type/2).
%%
%%    Agents may acquire objects, place them inside/on container objects,
%%    and transfer the contents of one container object to another.  There
%%    are also an unlimited supply of timers in the world which may be
%%    set to ring at a specified time in the future.
%%
%%    The agents may also perform several continuous tasks, which have
%%    durations and may span several situations.  Agents may only perform
%%    one task at a time.
%%
%%    Depending on the tasks being performed, the contents of container
%%    objects may evolve from one situation to another.  For example,
%%    if the task mix(bowl1,5) is being performed (mix the contents of
%%    bowl1 for five minutees) then the contents might evolve from
%%    [egg1,flour1,sugar1] to mixed([egg1,flour1,sugar1],5).
%%


%%  
%%  agent(Agt):  specify agents in the system
%%
%%  This predicate is true when Agt is the name of an agent in the world.
%%
agent(thomas).
agent(richard).
agent(harriet).


%% 
%%  task(T):  specify the tasks that can be performed
%%
%%  This predicate is true when T is a task that the agents in the system
%%  can perform.  Tasks are typically parameterised in terms of the
%%  objects on which they operate.
%%

%%  mix(Cont,Dur):  mix the contents of container Cont for duration Dur
task(mix(Cont,_)) :- 
    obj_is_type(Cont,container).

%%  chop(Cont):  chop the contents of container Cont
task(chop(Cont)) :-
    obj_is_type(Cont,container).

%%
%%  task_duration(Agt,Task,Dur):  specify duration of tasks
%%
%%  This predicate is true when Dur is the time taken by agent Agt
%%  to perform the task Task.
%%
task_duration(_,mix(_,D),D).
task_duration(Agt,chop(_),D) :-
    (Agt = richard ->
        D = 5
    ;
        D = 3
    ).


%%
%%  prim_obj(Obj,Type):  specify primitive objects in the world
%%
%%  This predicate is true when Obj is the name of a primitive object
%%  in the world, of type Type.
%%
%%  prim_obj(Obj):  shortcut to check object names
%%
%%  This predicate is true if Obj is the name of a primite object,
%%  regardless of its type.
%%

prim_obj(Obj) :-
    prim_obj(Obj,_).

prim_obj(Obj,knife) :-
    member(Obj,[knife1,knife2,knife3]).
prim_obj(Obj,bowl) :-
    member(Obj,[bowl1,bowl2,bowl3]).
prim_obj(Obj,board) :-
    member(Obj,[board1,board2]).
prim_obj(Obj,oven) :-
    member(Obj,[oven1]).
prim_obj(Obj,flour) :-
    member(Obj,[flour1,flour2,flour3,flour4,flour5]).
prim_obj(Obj,sugar) :-
    member(Obj,[sugar1,sugar2,sugar3,sugar4,sugar5,sugar6]).
prim_obj(Obj,egg) :-
    member(Obj,[egg1,egg2,egg3]).
prim_obj(Obj,tomato) :-
    member(Obj,[tomato1,tomato2]).
prim_obj(Obj,lettuce) :-
    member(Obj,[lettuce1,lettuce2,lettuce3]).
prim_obj(Obj,carrot) :-
    member(Obj,[carrot1,carrot2,carrot3]).


%%
%%  super_type(SubType,SuperType):  specify type hierarchy
%%
%%  This predicate is true when all objects of type SubType are
%%  also of type SuperType.
%%  
super_type(Type,cooking_appliance) :-
    member(Type,[oven]).
super_type(Type,container) :-
    member(Type,[bowl,board,cooking_appliance]).
super_type(Type,ingredient) :-
    member(Type,[flour,egg,tomato,lettuce,sugar]).

%%
%%  obj_is_type(Obj,Type):  check object types
%%
%%  This predicate is true when the object named Obj is of type
%%  Type according to the hierarchy of super-types.
%%
obj_is_type(Obj,Type) :-
    prim_obj(Obj,Type)
    ;
    super_type(SubType,Type), obj_is_type(Obj,SubType).


%%
%%  prim_action(Act):  specify primitive actions
%%
%%  This predicate is true when Act is the name of a primitive action
%%  in the world.  Actions are typically parameterised in terms of the
%%  objects they act on.  See the details of the MIndiGolog situation
%%  calculus for further information.
%%

%%  acquire_object(Agt,Obj):  agent acquires control of an object
prim_action(acquire_object(Agt,Obj)) :-
    agent(Agt), prim_obj(Obj).

%%  release_object(Agt,Obj):  agent releases an object it has acquired
prim_action(release_object(Agt,Obj)) :-
    agent(Agt), prim_obj(Obj).

%%  set_timer(Agt,ID,Dur):  agent sets timer with name ID to ring Dur
%%  minutes in the future
prim_action(set_timer(Agt,_,_)) :-
    agent(Agt).

%%  ring_timer(ID):  timer with name ID rings, a natural action
prim_action(ring_timer(_)).
natural(ring_timer(_)).

%%  place_in(Agt,Conts,Dest):  agent places object Conts in container Dest
prim_action(place_in(Agt,Conts,Dest)) :-
    agent(Agt), prim_obj(Conts), obj_is_type(Dest,container).

%%  transfer(Agt,Source,Dest):  agent transfers contents of container Source
%%  to container Dest
prim_action(transfer(Agt,Source,Dest)) :-
    agent(Agt), obj_is_type(Source,container),
    obj_is_type(Dest,container).

%%  begin_task(Agt,Task):  agent starts performing task Task
prim_action(begin_task(Agt,Task)) :-
    agent(Agt), task(Task).

%%  end_task(Agt,Task):  agent finishes performing task, a natural action
prim_action(end_task(Agt,Task)) :-
    agent(Agt), task(Task).
natural(end_task(_,_)).


%%
%%  poss(A,T,S):  possibility of performing an action
%%
%%  This predicate is true when it is possible to perform action
%%  A at time T in situation S.
%%

%%  Agents can only acquire an object if no agent already has it,
%%  they arent doing a task, and the object hasnt been used.
poss(acquire_object(Agt,Obj),_,S) :-
    \+ has_object(_,Obj,S), \+ doing_task(Agt,_,_,S), \+ used(Obj,S).

%%  Agents may only release objects that they have, when they arent
%%  currently performing a task
poss(release_object(Agt,Obj),_,S) :-
    has_object(Agt,Obj,S), \+ doing_task(Agt,_,_,S).

%%  Agents may set a timer as long as it hasnt already been set, and
%%  they arent currently performing a task
poss(set_timer(Agt,ID,_),_,S) :-
    \+ timer_set(ID,_,S), \+ doing_task(Agt,_,_,S).

%%  It is only possible for a timer to ring once its remaining time
%%  has precisely elapsed
poss(ring_timer(ID),T,S) :-
    timer_set(ID,Dur,S),
    start(S,SStart), {T = SStart + Dur}.

%%  Agents may place an object in a container provided they have possession
%%  of both, and arent currently doing a task
poss(place_in(Agt,Conts,Dest),_,S) :-
    has_object(Agt,Conts,S), has_object(Agt,Dest,S),
    \+ obj_is_type(Conts,cooking_appliance),
    \+ doing_task(Agt,_,_,S).

%%  Agents may transfer contents from one container to another as long
%%  as they have possession of both, and arent doing a task
poss(transfer(Agt,Source,Dest),_,S) :-
    has_object(Agt,Source,S), has_object(Agt,Dest,S),
    \+ doing_task(Agt,_,_,S).

%%  Agents may begin the mix() task as long as they arent doing another
%%  task, and have possession of the container to be mixed in
poss(begin_task(Agt,mix(Obj,_)),_,S) :-
    has_object(Agt,Obj,S), \+ doing_task(Agt,_,_,S).

%%  Agents may begin the chop() task as long as they arent doing another
%%  task, and have possession of the container whose contents to chop
poss(begin_task(Agt,chop(Obj)),_,S) :-
    has_object(Agt,Obj,S), \+ doing_task(Agt,_,_,S).

%%  Agents may end a task only when precisely the remaining amount of
%%  time has elapsed
poss(end_task(Agt,Task),T,S) :-
    doing_task(Agt,Task,Remain,S),
    start(S,SStart), {T = SStart + Remain}.


%%
%%  conflicts(C,T,S):  concurrent actions conflict
%%
%%  This predicate must be true when concurrent actions in C conflict
%%  and cannot be performed at time T in situation S.
%%

%%  Agents cannot do more than one action at a time
conflicts(C,_,_) :-
    member(A1,C), actor(A1,Agt),
    member(A2,C), actor(A2,Agt),
    A2 \= A1.

%%  Two agents cannot acquire the same object
conflicts(C,_,_) :-
    member(acquire_object(A1,Res),C),
    member(acquire_object(A2,Res),C),
    A1 \= A2.
    
%%
%%  Fluents in the Domain
%%
%%  The fluents are specified in terms of their successor state axioms,
%%  of the form "a fluent is true if it became true, or was previously
%%  true did not become false".
%%
%%    fluent_holds(Args,do(A,T,S)) :-
%%        fluent_becomes_true(Args,do(A,T,S))
%%        ;
%%        (
%%          fluent_holds(Args,S),
%%          \+ fluent_becomes_false(Args,do(A,T,S))
%%        )
%%

%%
%%  has_object(Agt,Obj,S):  agent has an object
%%
%%  This fluent is true when agent Agt has possession of the object Obj
%%  in situation S.  It can become true by acquiring the object, and
%%  false by releasing the object or if it has become used.
%%
has_object(Agt,Obj,do(C,T,S)) :-
    member(acquire_object(Agt,Obj),C)
    ;
    has_object(Agt,Obj,S),
    \+ (
       member(release_object(Agt,Obj),C)
       ;
       used(Obj,do(C,T,S))
    ).

%%
%%  used(Obj,S):  object is used in situation S
%%
%%  This fluent is true when an object has been used - for example,
%%  an ingredient has been placed in a container.  Once an object has
%%  been used, it cannot be used again.
%%
used(Obj,do(C,_,S)) :-
    prim_obj(Obj), obj_is_type(Obj,ingredient),
    (
      used(Obj,S)
      ;
      member(place_in(_,Obj,_),C)
    ).

%%
%%  timer_set(ID,Dur,S):  timer is set in situation S
%%
%%  This fluent indicates that the timer named ID is set to ring in Dur
%%  minutes in situation S.  It becomes true as a result of a set_timer()
%%  action, and is updated from situation to situation to reflect
%%  the amount of time remaining.
%%
timer_set(ID,Dur,do(C,T,S)) :-
    member(set_timer(_,ID,Dur),C)
    ;
    timer_set(ID,OldDur,S), start(S,SStart), {Dur = OldDur-(T-SStart)},
    \+ member(ring_timer(ID),C).

%%
%%  contents(Obj,Conts,S):  object contents in a situation
%%
%%  This fluent indicates that object Obj contains the contents Conts
%%  in situation S.  It can become true, become false, and change value
%%  in a variety of ways, each of which is documented with its
%%  implementation.
%%
contents(Obj,Conts,do(C,T,S)) :-
    start(S,SStart),
    ((
      %% --- All the ways it can become true
      %% It was previously empty, and contents were placed or transfered in
      (member(place_in(_,Conts,Obj),C)
         ; member(transfer(_,Obj2,Obj),C), contents(Obj2,Conts,S)),
      \+ contents(Obj,_,S)
      ;
      %% It previously had contents, and more contents were placed or
      %% transfered in.  Contents is then a list.
      (member(place_in(_,NewConts,Obj),C)
         ; member(transfer(_,Obj2,Obj),C), contents(Obj2,NewConts,S)),
      contents(Obj,OldConts,S),
      ( OldConts = [_|_] -> OldContsL = OldConts ; OldContsL = [OldConts]),
      ( NewConts = [_|_] -> NewContsL = NewConts ; NewContsL = [NewConts]),
      union(OldContsL,NewContsL,Conts)
      ;
      %% An agent is mixing the contents.  If they were previously
      %% unmixed, they are encased in a mixed(conts,time) indicator.
      %% If they were previously mixed, the mixing time is increased.
      doing_task(_,mix(Obj,_),_,do(C,T,S)), contents(Obj,OldConts,S),
      (  OldConts = mixed(MixConts,OldP) ->
             {NewP = OldP+(T-SStart)}, Conts = mixed(MixConts,NewP)
         ;
             Conts = mixed(OldConts,0)
      )
      ;
      %% An agent just completed mixing the contents.  The mixing time
      %% must be modified to take its final value.
      member(end_task(_,mix(Obj,_)),C), contents(Obj,mixed(MixConts,OldP),S),
      {NewP = OldP+(T-SStart)}, Conts = mixed(MixConts,NewP)
      ;
      %% An agent just completed chopping the contents.  They are
      %% encased in a chopped() indicator.
      member(end_task(_,chop(Obj)),C), contents(Obj,OldConts,S),
      Conts = chopped(OldConts)
      ;
      %% If the container is in an oven, its contents are baked.
      %% If they are not encapsulated in a baked() indicator then do
      %% so, otherwise update the baking time.
      \+ obj_is_type(Obj,cooking_appliance), obj_is_type(Oven,oven),
      contents(Oven,Obj,do(C,T,S)), contents(Obj,OldConts,S),
      (  OldConts = baked(BakedConts,OldP) ->
             {NewP = OldP+(T-SStart)}, Conts = baked(BakedConts,NewP)
         ;
             Conts = baked(OldConts,0)
      )
      ;
      %% If the container was just taken out of the oven, updated
      %% the content to reflect the total baking time.
      \+ obj_is_type(Obj,cooking_appliance), obj_is_type(Oven,oven),
      contents(Oven,Obj,S), member(transfer(_,Oven,_),C),
      contents(Obj,baked(BakedConts,OldP),S),
      {NewP = OldP+(T-SStart)}, Conts = baked(BakedConts,NewP)
    )
    ;
    %% Or it was true, and didnt become false...
    contents(Obj,Conts,S), \+ (
        %% --- All the ways it can become false
        %% The contents were transfered out
        member(transfer(_,Obj,_),C)
        ;
        %% New contents were transfered in
        member(transfer(_,Obj2,Obj),C), contents(Obj2,_,S)
        ;
        %% New contents were placed in
        member(place_in(_,_,Obj),C)
        ;
        %% The contents are being mixed, hence will change
        doing_task(_,mix(Obj,_),_,do(C,T,S))
        ;
        %% The contents just finished being mixed, hence will change
        member(end_task(_,mix(Obj,_)),C)
        ;
        %% The contents just finished being chopped, hence will change
        member(end_task(_,chop(Obj)),C)
        ;
        %% The object is in an oven, hence will change
        \+ obj_is_type(Obj,cooking_appliance), obj_is_type(Oven,oven),
        contents(Oven,Obj,do(C,T,S))
        ;
        %% The object was just taken out of an oven, hence will change
        \+ obj_is_type(Obj,cooking_appliance), obj_is_type(Oven,oven),
        contents(Oven,Obj,S), member(transfer(_,Oven,_),C)
    )).


%%
%%  doing_task(Agt,Task,Remain,S):  agent is performing a task
%%
%%  This fluent is true when agent Agt is performing task Task in situation
%%  S, and has Remain minutes left before it is completed.  It becomes
%%  true when an agent begins a task, becomes false when an agent
%%  completes a task, and its value is updated from situation to situation
%%  to reflect the remianing time till completion.
%%
doing_task(Agt,Task,Remain,do(C,T,S)) :-
    member(begin_task(Agt,Task),C), task_duration(Agt,Task,Remain)
    ;
    doing_task(Agt,Task,OldRem,S), start(S,SStart),
    {OldRem = Remain-(T-SStart)}, \+ member(end_task(Agt,Task),C).
    

%%
%%  history_length(N,S):  length of the action histoy in a situation
%%
%%  This simple fluent encodes in N the number of actions that have
%%  taken place in the history of situation S.  It is used to make this
%%  information easily available to agents.
%%
history_length(N,do(_,_,S)) :-
    history_length(N1,S),
    N is N1 + 1.
history_length(0,s0).

%%
%%  Intial Conditions for the domain
%%
%%  The initial conditions are specified by additional clauses for
%%  each fluent, with the situation term set to the atom s0.  For
%%  the most part no fluents hold in the initial situation, so 
%%  there arent many clauses here.
%%
start(s0,0).