Actions representation in a 4-D space

Int. J. Man-Machine Studies (1991) 35, 825-841

Actions representation in a 4-D space GIOVANNI ADORN1 AND AGOSTINO POGGI

DIST-Uniuersity of Genoa, Genoa, Italy (Received 3 October 1989 and accepted in revised form 14 October 1990) In this paper a frame-based model is presented for.the representation of actions in four dimensions (space + time). This model, called Action Net, allows the composition of different actions descriptions and the representations at different levels of detail: an action is represented by a tree of frames which degenerates in a single frame at the lowest level, and a new higher level description can be built expanding some leaf frames. The model is based on a formal representation of time and concurrency taken from Petri Net theory.

1. Introduction Computer science researches have examined the problems of time much less than the problems of space. Time has generally been considered as an ordering schema similar, but simpler than that of space, simpler because it has only one dimension. Some researchers in philosophy have believed that a philosophical clarification of space also provides solutions to the problem of time. Kant (1781), for example, presented space and time as analogous forms of visualization and treated then in a common chapter in his major epistemological work. Time, therefore, seems to be much less problematic since it has none of the difficulties resulting from the multi-dimensionality of space. The three-dimensionality of space has often been looked upon as a function of the human perceptual apparatus, which can visualize spatial relations only in this fashion. Poincar~ (1952), for example, tried to find a physiological foundation of this number; according to him two of the dimensions are due to the retinal image, the third to the "effort of accommodation which must be made, and to a sense of convergence of the two eyes". Even if this physiological explanation were tenable, it completely overlooks the fact that the number " 3 " of dimensions represents primarily a fact concerning the objective world and that the function of the visual apparatus is due to a developmental adaptation to the physical environment. There are instances in physics where researchers work with space of a higher dimensionality, the so called " p a r a m e t e r space". Let us think, for example, of the state of a cloud of molecules as it occurs in a gas. T h e state of the gas is determined at any time t when the three coordinates of each of the n molecules are known, i.e. by the specification of n points in the three dimensional "coordinate space". Instead, we may consider all of the coordinates as dimensions of a 3n-dimensional space, which is called the " p a r a m e t e r space". T h e state of the gas is then given by one point in this 3n space. These descriptions are evidently equivalent: either of them can always be translated into the other. In spite of this fact, we consider the parameter space merely a mathematical tool with no objective reference, whereas we regard the three-dimensional space as the "real space". 825 0020-7373/91]120825 + 16503.00/0

9 1991 Academic Press Limited

826

G. A D O R N I A N D A . P O G G I

All properties of a four-dimensional real space may be inferred from this illustration. The collision of two billiard balls, for instance, would occur as follows: two balls approach the same three-dimensional point; if and only if they are close not only in space, but also in time, will there be the sound of collision. We may therefore regard the following statement as the most general assertion about a space + time order: everywhere and at all times there exists a space-time coordinate system. The fact that an ordering of all events is possible within the three dimensions of space and the one dimension of time is the most fundamental aspect of a theory of space and time. In the following work, we do not plan to develop a general theory of space + time representations, but we discuss a model to represent real actions in a real world, that is time-varying actions in a dynamic, possibly not completely known, world. We call such a model a space + time model, and hence it is a four-dimensional (4-D) model. The problem of representing actions and reasoning about them has been investigated by several researchers. The early works (see, for example, McCarthy & Hayes (1969) and Fikes & Nilsson (1971)) assumed the presence of a single agent which worked in a static world whose description was given by one of a set of infinite states and the action of the agent was considered as a mapping between two states. Nevertheless this type of description did not allow simultaneous actions and was inadequate for dealing with time-varying environments. Some steps forward were taken by McDermott (1982) and Allen (1984) who introduced a temporal logic for representing and reasoning about actions, and by Georgeff (1987) who presented an action theory where action descriptions were based on the concepts of event and process and whose interactions are defined by the causality law. These models allowed simultaneous actions and the treatment of time-varying environments, but they were inadequate because they do not deal with incomplete knowledge, and because these models are (only) suited for modelling simple problems. Morgenstern (1987) indicates that in order to tackle with incomplete knowledge and problem complexity a theory of action should meet the following five requirements: (1) fidelity of temporal representation: it is described what is true in a particular moment and how the world changes over time; (2) granularity: actions are described with varying degrees of granularity; (3) interval dependent actions: there are many actions whose very descriptions depend on the time during which they take place; (4) composability: most actions are formed by composing simpler actions in various ways; (5) multiple agents: many of the actions are inter-agent actions, which involve at least two agents. This paper presents a model, called Action Net (A-Net Adorni et al. (1988a), for the representation of real-world actions (actions in a 4-D space), based on two entities: events and processes. In such a model, an event is a special mark on the time axis, which links two "sub-models" or processes. This is analogous to what happens in a three-dimensional (3-D) model, where an object can be thought of as two sub-objects geometrically related in some way. However, in the real world, 3-D models can never be decomposed into "absolutely independent" sub-models; in the same manner, two processes connected through events are usually only an approximation of reality. Nevertheless processes and events seem to be appropriate in many cases. From another point of view, the whole system can be considered as a

ACTIONS REPRESENTATION IN A 4-D SPACE

827

set of possible, continuous (quantitative or qualitative), partial representations, only one subset of which is simultaneously active. Therefore, a formal representation for an action requires not only the description of its "processes", but also the set of "events" relevant to its behaviour, related to the world's state and/or to other cooperating actions. A-Net is a frame-based model which takes advantage of Petri Net theory, Peterson (1981), for the representation of time and concurrency. In particular, this model meets, as it will be illustrated through the paper, the previous five Morgernstern's requirements. The next section introduces Petri Nets, Section 3 presents and discusses the A-Net model, Section 4 illustrates the way of using A-Net for spatial representation of objects, Section 5 describes the architecture of an implemented system based on A-Net; finally, some concluding remarks are made.

2. Petri Nets A Petri Net (PN) (Petri, 1962), is a graph which Can contain two types of nodes: (i) places, represented by circles; (ii) transitions, represented by bars. These nodes are connected by arcs and an arc cannot connect two nodes of the same type. if an arc is directed from a place (transition) to a transition (place), then the place (transition) is an input to the transition (place) and the transition (place) is an output to the place (transition). Places may contain tokens (a place which contains tokens is called a "marked" place); when all the input places of a transition have (at least) one token, then the transition fires. A transition fires by removing tokens from the input places (one token for each input place) and generating new tokens which are put in the output places (one token for each output place). The execution of a PN starts putting tokens in some places; these tokens are propagated by the transitions which are able to fire. The execution terminates when all the transitions are unable to fire. The major features of PNs are" asynchronous, non-determinism, concurrency, causality and hierarchy. Furthermore, PNs allow the description of conflict structures and time-dependent relationships and it follows that they are suitable to model systems which are deterministic (or not) and synchronous (or asynchronous). Besides, in the last decade, new formal extensions to the original PN model played and are still playing a fundamental role in the diffusion of PN into many fields. In particular, Timed PNs and Stochastic PNs (Pagnoni, 1987), Colored PNs (Jensen, 1981), and Predicate/Transition Nets (Genrich & Lautenbach, 1981) are among the most significant extensions.

3. Action Net An Action Net (A-Net) is an abstract, symbolic representation of actions based on PNs. A-Nets are organized in a knowledge base structure in frame-based multipleinheritance semantic networks (Woods, 1985; Stefik & Bobrow, 1986). The term A-Net indicates both an atomic action representation, called process, and a more complex action model, called action. A process is encoded in a single frame and its performance is described by the execution of a procedural code. An action is encoded in a tree of frames, based on a combination of its process

828

6. ADORNI AND A. POGGI

/

,CONTROLLER

._..-'-"

..ARM COLLISION AVOIDER -

_

/,,...,MANIPULATOR . . ~ - ~ A R M _ M O V E R f//t"f" NAV--V'fITH--O RA SP~'k .

"'~-ARM_PLANNER ..,C'OLLISION_ AVOIDER

""-,.~'R STEP~-.~____~.-CURVF --

"~"--'PI_STEP t ~""-'~TRAIGHT LINE

FIGURE 1. The "Nay_with_grasp" knowledge base.

descriptions (the leaf frames) and its performance is described 'by the execution of the procedural codes of its processes synchronized by a PN. Figure 1 shows a graphical representation of a knowledge base containing the A-Nets which describe the actions performable by a robot; in this figure, "Arm_moves" is a process, while "Navigator" is an action. Each frame of the knowledge base is an A-Net, but can, in its turn, be part of another A-Net; in fact, a process can behave as a sub-action expanding its frame in a tree of frames (for example, in Figure 1, "R_step" is a sub-action) and can be involved in several actions (this means that we can compose some A-Nets for building new A-Nets). Each frame of an A-Net can contain both a process description (represented by the slot P R I M I T I V E _ C O D E containing the procedural code of the action) and the information (the slots PROCESSES, SENSORS and WIRES) for building the PN which synchronizes the processes of the action; for this purpose, each frame has a slot B E H A V I O U R , whose value (process/action) allows the selection of the current aspect of the A-Net (see Figure 2 as an example of the action "Navigator" of Figure 1). The structure of an A - N e t can be synthesized by the following phrase structure grammar (where § stands for positive closure, * is the Kleene operator): (a-net) ::= (process) ] (action) (process) ::=process (primitive_code) (variables) (primitive_code) ::= "procedural code of the action" (variables) ::= "local variables of the action" (action) ::=action (processes) (sensors) (wires) (pn_code) (processes) :: = {process_name } § (sensors) ::= {(condition) sensor_place_name}* (condition) ::= "condition on the values of an external data" (wires) ::= {(firing_rule) {wire}+} + (firing_rule) ::= "condition on the marking of the PN's places" (pn_code) ::= "Petri Net code of the action" In an A-Net model, the PN plays the fundamental role of a system for representing the temporal relations among processes. For this reason, the PN model used is

AUF1ONS REPRESENTATION IN A 4-D SPACE

829

Navigator BEHAVIOUR action PROCESSES (Off_line_planner Collision_avoider WIRES ; connections of the Petri Net describing the action (((is-marked Start_place) (link Off_line_planner)) ((all-marked Off_line_planner Reachable_target) (link Collision_avoider)) ((all-marked Off_line_planner (not Reachable_target)) (link Failure_place)) ((is-marked Collision_avoider) (link R_step)) ((all-marked R._step (not Reached_goal)) (link Collision_avoider)) ((all-marked R_step Reached_goal) (link End_place))) SENSORS (((equal robot.position target_position) Reached_goal) (Off_line_planner.plan reachable_target)) PRIMITIVE_CODE : l o w level description of the action performance TIME ; duration of the performance computed during the action ROBOT ; robot name TARGET_POSITION; value of the target point ENVIRONMENT ; name of the environment description FIGURE 2. F r a m e structure of an action.

based on High Level Timed Petri Nets (Jensen, 1987), with delays associated with places. This model gives temporal restrictions to the firing of transitions; it is very important for describing actions because time is a fundamental component of an action and, in the case of an action which is composed by some sub-parts, its sub-parts must be temporally ordered. In particular, in a PN describing an A-Net, transitions perform synchronization among processes; transitions are not timeconsuming, but they are fired as soon as their firing rule becomes true and immediately produce the output tokens. Their firing rule is the following: "the firing of a transition occurs as soon as all its input places are marked, and the possible marking of the output places does not exceed their capacity. A place is marked iff it contains one token whose value is equal or less than the world's system time, "WorldTime", which represents the time during an action and whose value is set to zero at the beginning of any action". So, a token has a numeric value representing the time from which it is able to feed a transition. In particular, a PN describing an A-Net has always three predefined places to identify the beginning of an action "Start_place", a correct termination "End_place" or a failed action "Failure_place". An action starts when "Start_ place" is fed with a token; a successful action execution terminates with one token on the "End_place"; a token in the "Failure_place" stands for the failure of the execution of the action. In this PN, the other places can represent: (i) simple conditions, predicates or counters with a given capacity; (ii) processes. In the first case, places have no time associated; predicates are places representing sensors whose state (marking) is given by the evaluation of logic expressions operating on external data represented by slot values (properties) of particular frames. These places are represented by the value of the slot SENSORS, which are a list of elements, each of them representing a boolean place which is marked when (condition) is true (see, for example, Figure 2).

830

O. A D O R N I A N D A . P O G G I

In the second case, places represent processes and are characterized by a time interval, corresponding to the duration of performance of the processes, 'whose value either is fixed (stored in the slot TIME) or is computed during each execution of the process code. When a process/place is marked, the process code (PRIMITIVE_CODE) is activated and a token is generated to the output transitions after the process termination. These places are defined by the value of the slot PROCESSES (if an element of the slot PROCESSES is a process, it corresponds to a place, if it is a sfib-action, it is recursively expanded to the processes which correspond to the places). Places and transitions are connected by arcs; to enhance the expressive power of it, inhibitory arcs have been included in the model. An inhibitory arc allows a transition to fire only if the input place connected by this arc to it does not contain tokens. When the place "Failure_place" is disconnected from all the transitions, this means that the action cannot fail. Transitions and arcs are represented by the slot WIRES which is a list of elements, each of them representing a transition and its input and output connections. The (firing_rule) is a boolean expression based on boolean operators: "and", "or", "not", and on the predicates "is-marked", all-marked" and "one-marked" which are applied to places and sensors. The n-ary predicate "is-marked" is true if the performance of its parameter/process ended or the (condition) which is associated with the parameter/sensor is true. The n-ary predicate "all-marked" is true if all the performances of its parameters/processes are ended and all the parameters/sensors (condition) are true. The n-ary predicate "one-marked" is true if either one of the performances of its parameters/processes is ended or one of the parameters/sensors (condition) is true. When (firing_rule) is true, then the corresponding (wire)s are activated. A (wire) can perform: (i) a connection with a process/place (a connection to a sub-action is replaced by connections to its starting processes); (ii) the passing of data. In the first case, a (wire) has the structure (link (Process_name)), in the second case, it has the structure (send (frame. slot) (value)). The way of using A-Nets for composing and building action descriptions at different levels of detail can be shown through an example. Let us consider the action representing the movement of a robot that goes from a position A to a target position B in a certain environment. If the robot has a full and global knowledge of the environment, then a low-level action representation is given by the single process "Navigator" which plans the trajectory and moves the robot to the target position B. If the robot has an incomplete knowledge of the environment, then we can refine the process "Navigator" as an action where the process "Off_line_planner" plans a tentative trajectory on the basis of the initial and prototypical knowledge of the environment and the process "R_step" performs a single step on the basis of the local information about the environment derived from the process "Collision_avoider" (see Figure 1). If it is not possible to define a plan to reach the target B, then the action fails. When the goal is reached, the action ends. Figure 3 shows the PN of this action, while Figure 2 shows its frame structure. A robot model should have some cinematic constraints, then, for a more precise representation, we must refine the process "R-step" as an action where: the process "Straight-line" plans the rectilinear pieces of the trajectory, the process "Curve" plans curvilinear pieces of trajectory, the process "Backtrack_manoeuvre" plans

831

ACTIONS REPRESENTATION IN A 4-D SPACE START_PLACE

(}

OFF_LINE_PLANNER

(

REACHED_GOAL

END_PLACE FIGURE 3. The "Navigator" Petri Net.

backtracking manoeuvres and the process " R _ s t e p l " performs a single step of the planned trajectory. Figure 4 shows the PN of the A-Net of "R_step"; Figure 5 shows the PN of the A-Net "Navigator" expanding "R_Step" as a sub-action. Figure 6 shows the frame structure of "R_step". Let us now suppose that the robot has an arm and can use it for grasping and moving some objects. In this case, we can change the strategy for moving the robot from A to the target B. A new possible strategy can be the following: "if the robot finds an object on its planned trajectory and it can remove the object, the robot does not modify its trajectory, but removes the object". We can model the action performing this strategy with an A-Net called "Nav_with_grasp"; this A-Net composes the A-Net "Navigator" with the two A-Nets "Manipulator" and "Controller"; "Manipulator" manages the arm movement and "Controller" synchronizes the arm and the robot fiaOvements. The A-Net model is then able to tak~e into account problem with high complexity as well as handle incomplete knowledge. In fact, A-Net meets the five Morgerstern's requirements: (1) fidelity of temporal representation; (2) granularity; (3) interval dependent actions; (4) composability; and (5) multiple agents. With reference to the first requirement, time is described by the flow of tokens along the PN of the action and in each instant the state of the world is given by the values of the frames representing the world and the actions. Due to its tree structure, the A-Net model

832

G. ADORNI AND A. POGG1

START_PLACE STRAIGHT_LINE

RECTILINEAR_PATH

CURVE R_STEPI BACKTRACHING_MANOEUVER

RACK_MAN_PATH

FAILURE_PLACE END_PLACE~ FIGURE 4. The " R - s t e p " Petri Net.

allows representations of actions with varying degrees of granularity. The performance of an action is given by the flow of tokens along its PN model driven by the firing of transitions. The firing of each transition can depend on the current state of the world (the "sensors" are the interface of the action toward the external world), and so the action modelled by the PN can be interval-dependent. Each A - N e t can be combined with other A-Nets to compose a new A-Net. Finally, the PN's property of representing concurrency and parallelism allows the management of the interactions among different agents.

4. Modelling 3-D entities Objects, volumes and shapes can be represented using a symbolic multi-level resolution. The low level representation is a single frame (it contains parameters and all other information on the object). The high-level model is a tree of frames: the root frame contains the global features of the object, the other frames describe its constituents. The leaf frames of the tree are the representation of the atomic elements composing the whole object (i.e. elementary solids). We can view, in fact, an object as an A-Net: the whole object corresponding to a n action frame, its sub-parts corresponding to processes; in this case, the message semantics is a set of "operations to assemble the elements into the whole object". The set of operations we implemented are basically Constructive Solid Geometry (CSG) primitives (Requicha, 1980), that act on a geometric modeler based on

833

ACTIONS REPRESENTATION 1N A 4-D SPACE

('~-~START_PLACE

OFF_LINE_PLANNER REACHABLE_TARGET

FAILURE_PLACE

SION_AVOIDER

STRAIGHT_LINE

CURVE

"($3 RECTILINEAR_PATH

CURVE_PATH

R_STEPI

BACKTRACHING _MANOEUVRE

\

BACK_MAN_PATH

REACHED_GOAL

L._..) END_PLACE/

FIGURE 5. T h e " N a v i g a t o r " Petri Net expanding the actor " R - s t e p " as a sub-action.

the octree representation of volumes (Jackins & Tanimoto, 1980). Besides usual CGS functions (like displacement, scaling, rotation, sum, difference, intersection, cutting and so on), other primitives are available for generating objects at the Variable Level of Resolution, given a symbolic frame representation. This is useful for representation purposes when rough general information is needed, and it is not necessary to retrieve a detailed description of shapes. For a 3-D entity, the PN code "generates" the object, in the sense that it transforms the symbolic description of the CSG tree into analogical form (the octree). The concept of time is not significant in this kind of action, because the

O. ADORNI AND A. POGGI

834

R_step BEHAVIOUR action PROCESSES (Straight_line Curve Backtracking_manoeuvre R_step 1) WIRES ; connections of the Petri Net describing the action (((is-marked Startp]ace) (link Straight_line)) ((all-marked Straight_line Rectilinear_path) (link R-step 1)) ((all-marked Straight_line (not Rectilinear_path)) (link Curve)) ((all-marked Curve Curvilinear_path) (link R_step 1)) ((all-marked Curve (not Curvilinear_path)) (link Backtracking_manoeuvre)) ((all-marked Backtracking_manoeuvre Back_man_path) (link R_step 1)) ((all-marked Backtracking_manoeuvre (not Back_man_path)) (link Failure_place)) ((all-marked R_step 1) (link End_place)) SENSORS ((Straight_line.path Rectilinear_path) (Curve.path Curvilinear_path) (Backtracking_manoeuvre.path Back_man_path)) PRIMITIVE_CODE ; low level description of the action performance TIME ; duration of the performance compututed during the action execution ROBOT ; robot name ENVIRONMENT ; name of the environment description FIGURE6. Frame structure of "R-step".

ACK

j . ~ A C K "BODY /,~BACK-CRt3SS-,BAR

/

/ CHAIR'

/

.....

/

"~A-'~

~.\,"CHAIR1~-

\',,~

"~--.,..~

x,.

',mrrn \ ' ~ m--'-''J ~ ,

""SBACK -I~ROSS-BAR .,/~_.~-C LEG-CROSS..~BAI:i

\-'-LEGSI-~-~_

~

~

:

",., "SLEG-CROS$-BAR

T,~BLE __...~--~'~

FIGURE7. The "Furniture" knowledge base.

835

ACTIONS REPRESENTATION IN A 4-D SPACE

creation of an analogical representation of an object is out of the temporal domain of real actions. Let us consider the representation of some pieces of furniture. Chairs, tables and desks can be divided into parts (e.g. a table is divided into board and legs); some of these parts can be shared by different pieces of furniture (legs have the same structure for a table, chair and desk), and hence they are represented by the same process (see Figure 7). An object can be represented at different levels of detail: a chair, at a low level, is composed of legs, seat and back. At a higher level, legs and back can be sub-actions, just like actions could be processes or sub-actions (see Figures 7 and 8). Situations do exist where performing an action requires the modification of the spatial location of certain objects: in the path-planning problem. For example, some objects, location must be modified, either because a save-path cannot be performed or because such a path would follow a long, winding or "non-economical" way. As a consequence, some information about the objects involved may be modified during the action. In this context, object description plays a particular role, in the sense that it must be specialized in order to achieve a high integration with action description. Physical attributes such as weight and material and spatial relations with the other objects of the environment must be introduced for aiming at achieving that integration. In our frames there are some slots that represent physical properties and other slots (on, over, under-with-contact, under-with-suspension, in, container) that represent the possible spatial relations among objects (Di Manzo et al., 1986), and are filled during the environment analysis for building its prototypical description. Besides, in an object description, some properties depend on the action which operates on it. For example, given a hammer, its grasp point is on the handle if the agent wants to drive a nail, but it is the head if the agent wants to hand it over to

J t

~lt" "

N

FIGURE 8. Three octree models of a chair built with A-Net at different levels of detail.

836

G. ADORNI AND A. POGG

DI~LC~ SYSTE~

LTMMS

I

WMMS

!i tTM I WM'

FIGURE 9. Architecture of the system.

another agent which must drive the nail (Adorni et al., 1987). In our frames, these slots have a list of values depending on the action which operates on the object.

5. Dedalus: A system for action modelling A-Nets are organized in a frame-based system, D E D A L U S (Adorni et al., 1988b), and implemented in KEE on an E X P L O R E R Lisp machine. The architecture ol the system is shown in Figure 9. The Long Term Memory (LTM) of the system maintains the world knowledge in terms of A-Nets. The Long Term Memor) Management Subsystem (LTMMS) fills and updates the LTM through the Dialogue Management Sub-system (DMS). Every time an action (whose representation i., stored in the LTM) is simulated, an instance is built in WM by means of the Working Memory Management Sub-system (WMMS). The WMMS is the kernel ol the system. Its duty is to create instances of A-Nets, to build their codes and te execute them according to the particular problem to be solved. The main task of the system is to generate the Petri Net code representing the performance of the action. A proper algorithm allows passing from a frame description (A-Net level) to a corresponding Petri Net code (Camurri et al., 1988). This algorithm starts from the slots PROCESSES, SENSORS and WIRES of the A-Net root frame and builds the Petri Net code expanding each sub-action up to the leaf frames. This algorithm can be described as follows: generate_pn(action)/*Generation of places and their marking*/ begin world_time = 0/*reset current time slice*/ Start_place = MARKED/*start_place is marked from time = 0"/ End_place = N O T _ M A R K E D Failure_place = N O T _ M A R K E D place_list = {Start_place End_place Failure_place} find_process(PROCESSES(action))/*searching for processes*/ /*PROCESSES(action) is the slot PROCESSES of action*/

ACTIONS REPRESENTATION IN A 4-D SPACE

837

places_list = place_list + SENSORS(action) /*Generation of net topology (wiring) and code*/ for each sensor in SENSORS(action) do (generation of the external conditions code) generate_transitions(WIRES(action) PROCESSES(action)) /*Generation of the time updating and termination code*/ world_time = world_time + 1/*next time slice*/ if (End_place/s MARKED) or (Failure_pl~ce/s MARKED) then (action termination management) end find_process (processes)

begin for each process in processes do if BEHAVIOUR(process)/s action then find_process(PROCESSES(process)) else begin place_list = place_list + process process = NOT_MARKED end end generate_transitions (wires, processes) begin for each wire in wires do (generation of the transition code (condition, consume input tokens, produce output tokens)) for each proc in processes do if BEHAVIOUR(proc)/s action then generate_transitions (WIRES(proc), PROCESSES(proc)) end The code generated is essentially a loop where all transitions are scheduled in measurable time slices. After the initialization, all the PN's transitions are scheduled until 'End_place" or "Failure_place" is marked. This code has a simple but powerful structure. In fact, it allows the simulation of parallelism: transitions, which are firable at the same time, are activated in the same quantum of time. Each transition scheduling can be described as follows: if firing_rule/s true then begin (consume one token of its input places) for each place in "its output places" do if place BEHAVIOUR(place)/s process then begin (performance of the code of place) (produce a token for place) end end

838

G. A D O R N 1 A N D A . P O G G I

6. Conclusions Since the time of Aristotle, the notion of time has been associated with the idea of an arrow which flows uniformly from the past to the future, which imposes an absolute ordering among all the phenomena at any level of scale. A universal master clock is the epistemological device which implements this idea and gives an unambiguous meaning to relations like before, after, simultaneously, etc. In physics, we know that thi~ kind of assumption is constrained by the speed of light: the universal description of physical phenomena is acceptable if the relative speeds which are involved are much smaller than the speed of light. Therefore, the physics involved in the human experience of every day is far from the conditions in which the relativist Einsteinian effects become significant and indeed the old Newtonian mechanisms are the universal tool for describing our mechanical experience. Nevertheless, it is not the speed of light which destroys p e r s e the universality of the Newtonian time, but the role of light as the medium with which different observers can exchange messages. Light, however, is not the only possible medium. For example, in the brain messages travel along neurons at an insignificant fraction of the speed of light, and in computer networks messages are transmitted according to "slow" transmission protocols. So, the time scale varies widely, but it is easy to understand that what matters are not absolute values but ratios. If we focus on the distinction between communication and operation, we recognize that the master clock paradigm is feasible only when the time spent communicating is much smaller than the time spent computing. When the messagepassing activity becomes "significant", the universal time breaks down and each individual unit tends to acquire an individual time structure (individual clock). In the first case (master clock), we have a closed system: it cannot communicate with anything else except itself. In a closed system the order imposed by time is an illusion, there is no reason why the order of events cannot be reversed. In the latter case (individual clock), we have open systems (Hewitt & de Jong, 1983). In an open system, time is not an illusion, it is an irreversible partial ordering of events which can be modeled, for example, by the nature of message-passing among the actors in Actor system (Agha, 1986). In this paper, we present an open system, called A-Net, which integrates the one dimension of time with the three dimensionality of space. The combination of procedural and declarative knowledge, the use of "Sensors" as the interface with the external world and the management of concurrency and parallelism through PNs makes this model suited for handling incomplete knowledge and complex real world problems. In particular, PN's play the fundamental role for representing the temporal relations among processes. Time is associated to the PN places which are divided in two different classes. The first class contains the places which do not consume time: the three predefined places (Start_place, End_place and Failure_ place) and the "sensor" places. The second one contains the places which consume time and which are associated to the action's processes; in this case, the time interval corresponds to the duration of the performance of the process. The A-Net model seems to be a good means, comparable to the Actor model, for describing open systems. In fact, the management of concurrency and parallelism through message-passing in Actor model is replaced by the PN management in the A-Net

839

ACTIONS REPRESENTATION IN A 4-D SPACE

model; the changing of local state, which is performed by actors through the "become" command, is performed in the A-Net model, switching the A-Net behaviour from "processes" to "action". Moreover, as explained through the paper, it meets the five Morgenstern's requirements: (1) fidelity of temporal representation; (2) granularity; (3) interval dependent actions; (4) composability; and (5) multiple agents. A-Nets are organized in a frame-based system, D E D A L U S , which is used as the development environment for distributed systems. In particular, an off-line/on-line car navigation system has been developed (Adorni & Poggi, 1989). This system has a multi-agent structure where each agent has a multi-levels structure (Figure 10 shows the PN corresponding to the low-level A-Net of the system.) The system is based on two main agents: the off-line and the on-line planners. The off-line planner plans a route, given by a sequence of roads to follow, on the basis of information road map knowledge base and on the basis of data which are acquired by another agent, called "radio-data-acquirer", which receives information from "traffic monitoring" centres. The on-line planner plans the car's trajectory on the basis of the plan generated by the off-line planner and on the basis of data received by a "sensors-data-acquirer" which acquires data from a set of "on-board" sensors. In this system, the two planners work in parallel because the state which determined a route plan at the beginning of a trip can change during the

START_PLACE

RADIO-OATA-ACQUIRER SENSORS-DATA-A CQU I RER

0FF-LINE-PLANNER

ON-LINE-PLANNER

AR-MOVER

END_PLACE

FIOURE 10.

The car navigation system Petri Net.

840

G. ADORNI AND A. POGGI

on-line planning phase and its modification is acquired by the system through the "radio-data-acquirer" which can activate the off-line planner without stopping the on-line planner. This work has been supported by a EUREKA Grant Program (PROMETHEUS Project, PRO-ART Sub-project).

References ADORNI, G., GAGLIO) S., MASSONE, L., MORASSO, P. & ZACCARICA, R. (1987). Representing motor skills. CC-AI, 4(i), 47-71. ADORNI, G., CAMURRI, A., POGGI, A. & ZACCAHIA, R. (1988a). Integrating spatiotemporal knowledge. Proceedings of ECAI-88, pp. 644-649, Munich. ADORNI, G., MASSONE, L. (~ POGGI, A. (1988b). Dedalus: a knowledge based planning system. Proceedhzgs of the 4th International Conference on System Research h~formatics and Cybernetics, Baden Baden. ADORNI, G. & POCGI, A. (1989). A hybrid tool to represent and simulate actions. Proceedings of the International conference on Artificial Intelligence hz hzdustry and Government, pp. 483-492, Hyderabad. AGtIA, G. (1986). Actors, A Model of Concurrent Computation in Distributed Systems. Cambridge, MA: MIT Press. ALLEN, J. F. (1984). Towards a general theory of action and time. Artificial Intelligence, 23, 123-154. CAMURRI, A.) POGOI, A., VERCELLI, G, & ZACCARIA, R. (1988). A-Net: structured representation of time and actions using Petri Nets. Proceedings of the 9th European Workshop on Applications and Theory of Petri Nets, Venice. DIMANzO, M., Ar)ORNI, G. & GIUNCmGL,A, F. (1986). Reasoning about scene descriptions. Proceedings of the 1EEE, 74(7), 1013-1025. FIKES, R. E. & NmSSON, N. J. (1971). A new approach to the application of theorem proving to problem solving. Artificial Intelligence, 2, 189-208. GENRICtt, H. J. & LAVTENBACII,K. (1981). System modelling with high-level Petri Nets. Theoretical Computer Science, 13, 109-136. GEORGEFF, M. P. (1987). Actions, processes and causality. In M. P. GEORGEFF & A. L. LANSKY, Eds. Reasoning about Actions and Plans: Proceedhtgs of the 1986 Workshop, pp. 99-122. Los Altos, CA: Morgan Kaufmann. HEWITr & DE JONG, P. (1983). Analyzing the rules of descriptions and actions in open system. Proceedings of AAAI-83, Washington, pp. 162-167. JACKINS, C. L. (~ TANIMOTO, S. L. (1980). Oct-trees and their use in representing three-dimensional objects. Computer Graphics hnage Processing, 14, 249-270. JENSEN, K. (1981). Coloured Petri Nets and the invariant method. Theoretical Computer Science, 14, 317-336. JENSEN, K. (1987). Coloured Petri Nets. In Lecture Notes in Computer Science, Vol. 254, pp. 248-299., W. BRAUER, W. REISIG t~ZG. ROZENBERG, Eds. Berlin: Springer. KANT, I. (1781). Kritik der reinen Vernunft. McCARTHY,J. (~ HAYES, P. J. (1969). Some philosophical problems from the standpoint of artificial intelligence. Machine Intelligence, 4, 463-502. McDERMO'rr, D. (1982). A temporal logic for reasoning about processes and plans. Cognitive Science, 6, 101-155. MORGENSTERN, L. (1987). Knowledge preconditions for actions and plans. Proceedings of HCAI-IO, pp. 867-874, Milan. PAGNONI, A. (1987). Stochastic nets and performance evaluation. In Lecture Notes in Computer Science, Vol. 254. W. BRAUER,W. REISIG & G. ROZENBERG,Eds. Berlin: Springer. PETERSON,J. L. (1981). Petri Net Theory and the Modeling of Systems. Englewood Cliffs, NJ: Prentice-Hall.

ACTIONS REPRESENTATIONIN A 4-D SPACE

841

PETRI, C. A. (1962). Kommunikation mit Automaten. Institut flit Instrumentelle Mathematik.

Schriften des IIM Nr. 2. POtNCARfZ, H. (1952). Science and Hypothesis. New York: Dorez Publications. REOUICHA, A. G. (1980). Representation of rigid solids: theory, methods and systems. ACM Computer Surveys, 12, 437-464. STEVXK,M. & BonRow, D. G. (1986). Object-oriented programming: themes and variations. AI Magazine, 6(4), 40-62. WOODS, W. A. (1985). What's in a link: foundation for semantic networks. In R.J. BRACKMAN & H. J. LEVESOUE, Eds. Reading in Knowledge Representation, pp. 217-241, Los Altos, CA: Morgan Kaufmann.