Control device, control method, and control program

Abstract

A control device creates a first task representing information pertaining to an action sequence, and a second task representing information pertaining to an action sequence that satisfies a constraint for avoiding conflict when at least some actions of the first task are executed in parallel by a plurality of agents. The control device determines the allocation of each action in the action sequence in the second task to the plurality of agents. The control device controls the plurality of agents so as to execute the actions in the action sequence in the second task according to the determined allocation.

Description

Control device, control method, and control program

[0001] The present invention relates to a control device, a control method, and a control program.

[0002] A system that allows agents, such as humans or robots, to formulate action plans to achieve a goal is called a planning system, or planner. Specifically, when a planning system is given an environment, a set of possible actions, an initial state, and a target state as a task, it outputs a sequence of actions as a plan, starting from the initial state and reaching the target state.

[0003] Planning systems can be divided into totally ordered planners and others based on the format of the action sequence they output. Intuitively speaking, totally ordered planners output a single sequence of actions. Formally, the order in which each action is executed is predetermined. Besides totally ordered planners, there are also partially ordered planners and parallel planners. Partially ordered planners allow sequences of actions where the order is not predetermined for some actions; that is, for certain groups of actions, the order doesn't matter. Parallel planners output sequences of actions that execute multiple actions in parallel. A group of actions executed in parallel is called a coupled action, and the order between coupled actions is totally ordered.

[0004] Since many high-speed planning systems are total-order planners, there also exist methods that use total-order planners to pseudo-configure partial-order planners and parallel planners. Non-Patent Document 1 describes a method for obtaining a partially ordered action sequence by partial-ordering the action sequence output by a total-order planner based on the dependencies between actions. Furthermore, by regarding action groups with undetermined order in a partial-order action sequence as action groups to be executed in parallel, the partial-order action sequence can be easily converted into a parallel action sequence. Therefore, the method of Non-Patent Document 2 can also be used as a parallel planner. In Non-Patent Document 2, by modifying a task given in the PDDL (Planning Domain Definition Language) format, the action sequence output by a total-order planner can be easily parallelized. Both Non-Patent Document 1 and Non-Patent Document 2 disclose methods that do not modify the total-order planner itself, but use it as a parallel planner by adjusting the input and output of the total-order planner. This method has the advantage of requiring lower development costs for utilizing various total-order planners than creating a parallel planner by modifying the total-order planner itself.

[0005] Veloso, M. M.; Perez, M. A.; and Carbonell, J. G. 1990. Nonlinear planning with parallel resource allocation. In Proceedings of the Workshop on Innovative Approaches to Planning, Scheduling and Control, 207-212.Furelos-Blanco, D., Jonsson, A. (2019). Solving Multiagent Planning Problems with Concurrent Conditional Effects. Proceedings of the 33rd AAAI Conference on Artificial Intelligence (AAAI-19), 7594-7601.

[0006] Furthermore, the disclosures in the above-mentioned prior art documents are incorporated into this book by reference. The following analysis was conducted by the inventors.

[0007] However, even using the methods described in Non-Patent Document 1 or Non-Patent Document 2, it is still difficult to obtain a high-quality parallel action sequence at high speed. Here, a high-quality action sequence refers to a shorter action sequence (one that can complete the task faster). In the method described in Non-Patent Document 1, the total sequence planner plans without considering the parallelism of actions at all, so even if the output plan is parallelized, the plan may not become significantly shorter. In the method described in Non-Patent Document 2, the total sequence planner can strictly consider the parallelism of actions during planning and can handle complex parallel constraints (for example, two or more agents must take a certain action in parallel to take that action. However, such complex constraints are not considered in this invention). On the other hand, the computation time required for planning increases because the task becomes more complex, such as by tripling the number of actions included in the task due to modifications. As a solution to these problems, one could modify the total sequence planner itself to construct a parallel planner, but this would incur high development costs.

[0008] In view of the above-mentioned problems, one of the objectives of the present invention is to provide a control device, a control method, and a control program that contribute to outputting a parallel action sequence of higher quality at a higher speed.

[0009] In a first aspect of the present invention, a control device is provided that includes a first task representing information about a sequence of actions, a task modification unit that creates a second task representing information about a sequence of actions that satisfies constraints to avoid conflicts when at least some of the actions in the first task are executed in parallel by multiple agents, an action parallelization unit that determines the assignment of each action in the sequence of actions in the second task to the multiple agents, and a plan output unit that controls the multiple agents to execute each action in the sequence of actions in the second task according to the determined assignment.

[0010] A second aspect of the present invention provides a control method in which a computer creates a first task representing information about a sequence of actions, and a second task representing information about a sequence of actions that satisfies constraints to avoid conflicts when at least some of the actions in the first task are executed in parallel by a plurality of agents, determines the assignment of each action in the sequence of actions in the second task to the plurality of agents, and controls the plurality of agents to execute each action in the sequence of actions in the second task according to the determined assignment.

[0011] A third aspect of the present invention provides a control program that enables a computer to implement the following functions: a first task representing information about a sequence of actions; a second task representing information about a sequence of actions that satisfies the constraint of avoiding conflicts when at least some of the actions in the first task are executed in parallel by multiple agents; a function of determining the assignment of each action in the sequence of actions in the second task to the multiple agents; and a function of controlling the multiple agents to execute each action in the sequence of actions in the second task according to the determined assignment. This program can be recorded on a computer-readable storage medium. The storage medium can be a non-transitory material such as semiconductor memory, hard disk, magnetic recording medium, or optical recording medium. The present invention can also be embodied as a computer program product.

[0012] According to each aspect of the present invention, it is possible to provide a control device, a control method, and a control program that contribute to outputting a faster and higher-quality parallel action sequence.

[0013] Figure 1 shows examples of action sequences output by fully sequential, partially sequential, and parallel planners. Figure 2 is a block diagram of the control device according to Embodiment 1. Figure 3 shows a tree of reachable states from the initial state. Figure 4 is a flowchart of the processing in the control device according to Embodiment 1. Figure 5 shows the flow of the fully sequential plan for an (unmodified) task in Embodiment 1. Figure 6 shows the flow of the fully sequential plan for a modified task in Embodiment 1. Figure 7 shows an example of a multi-agent path planning problem. Figure 8 is a block diagram of a prioritized control device according to Embodiment 2. Figure 9 is a flowchart of the processing in the prioritized control device according to Embodiment 2. Figure 10 shows examples of hardware configurations for the control device and the prioritized control device.

[0014] Embodiments of the present invention will be described below with reference to the drawings. However, the present invention is not limited to the embodiments described below. In each drawing, the same or corresponding elements are appropriately denoted by the same reference numerals. Furthermore, it should be noted that the drawings are schematic, and the dimensional relationships and ratios of each element may differ from those of reality. Even between drawings, there may be parts where the dimensional relationships and ratios differ from each other.

[0015] Figure 1 shows examples of action sequences output by the totally ordered, partially ordered, and parallel planners (hereafter, the action sequences output by each planner will be referred to as totally ordered action sequences, partially ordered action sequences, and parallel action sequences). In the action sequence output by the totally ordered planner, the order is uniquely determined: a1 followed by a2, a2 ​​followed by a3, and a3 followed by a4. On the other hand, in the action sequence output by the partially ordered planner, the order is determined as a1 followed by a2, a2 ​​followed by a4, a1 followed by a3, and a3 followed by a4, but the order between a2 and a3 is not determined. That is, it is possible to execute either a2 or a3 first. In the action sequence output by the parallel planner, it is determined that a1 and a2 are executed in parallel, a3 and a4 in parallel, and a5 and a6 in parallel, and the order between each of the combined actions a1&a2, a3&a4, and a5&a6 is uniquely determined. In particular, in multi-agent systems where multiple agents exist, obtaining a parallel action sequence is important because each agent can act in parallel.

[0016] <First Embodiment> Figure 2 shows the configuration of the control device according to the first embodiment. The control device 10 includes a task input unit 11, a task modification unit 12, a total sequence planning unit 13, a planning parallelization unit 14, and a planning output unit 15.

[0017] The task input unit 11 accepts tasks for multiple agents whose parallel actions should be planned as input, either as tasks defined in SAS+ format or as tasks in a format that can be converted to SAS+ format. For example, a task defined in PDDL format can be converted to SAS+ format using a format conversion method. If a task defined in a format other than SAS+ format is input, the task input unit converts that task into a task in SAS+ format. Hereafter, the input task will also be referred to as the first task. The first task can also be said to represent information about the sequence of actions that are to be parallelized. Alternatively, the first task can be said to be a sequence of actions that includes multiple actions to achieve a target state from a certain state.

[0018] The task modification unit 12 modifies the task so that multiple agents can act in parallel by adding variables (state elements) to the input task and adding execution conditions and effects corresponding to the added variables to each action defined within the task.

[0019] To explain the correction process in detail, let's first explain the SAS+ format. In the SAS+ format, the state of an agent and its surrounding environment is represented by a combination of multiple variables. For example, there may be a variable that indicates where the agent is, a variable that indicates where the luggage is, or a variable that indicates whether the room is clean or not. If the variable represents the agent's position, it will have corresponding variable values ​​for each possible location where the agent can exist. For example, if the variable var_pos, which represents the agent's position, can exist at four locations a, b, c, and d, then D(var_pos) = {a, b, c, d}. Here, D represents the domain and is a function that shows the set of values ​​that the variable can take.

[0020] Actions in SAS+ format have execution conditions that specify the values ​​of some variables, and effects that specify the values ​​of some variables. Here, the execution condition indicates whether or not the action can be performed, and the effect indicates how the state changes as a result of performing the action. For example, the action of an agent moving from position a to position b has the execution condition that the agent is at position a, i.e., var_pos = a, and the effect is to change the position to b, i.e., var_pos <- b (<- represents the operation of assigning the value on the right to the variable on the left).

[0021] The task modification unit 12 first adds a variable `turn_var` to the input task, which represents the agent's turn. The variable `turn_var` has a variable value corresponding to each agent. For example, if there are agents 1, 2, and 3, then `turn_var` is defined as follows: `D(turn_var)={agent 1, agent 2, agent 3}`

[0022] From now on, to simplify the explanation, we will number each agent and assume that there are N agents in total. That is, we will represent agents as agent 1, agent 2, ..., agent N. The initial value of turn_var will be the first agent, agent 1.

[0023] Secondly, the task modification unit 12 adds the following execution conditions and effects to each action belonging to each agent other than agent N, agent I (I=1,...,N-1): • Execution condition: turn_var = agent I • Effect: turn_var <- agent I+1

[0024] The added execution condition states that each agent can only take action when the variable `turn_var`, which represents the turn, indicates that it is their turn. The added effect states that the variable `turn_var`, which represents the turn, is changed to indicate that it is the next agent's turn. Finally, the last agent, agent N, adds the following execution condition and effect to each action in order to return the turn to the first agent, agent 1: • Execution condition: `turn_var = agent N` • Effect: `turn_var <- agent 1`

[0025] The first and second modifications ensure that in the modified task, each agent takes one action in sequence. That is, the sequence of actions output by the Total Order Planner will always be as follows: • Agent 1's action → Agent 2's action → … → Agent N's action → Agent 1's action → Agent 2's action → … → Agent N's action → Agent 1's action → …

[0026] Thirdly, the task modification unit 12 adds an action to each agent other than agent N, agent I (I=1…N-1), with only the following execution condition and effect: • Execution condition: turn_var = agent I • Effect: turn_var <- agent I+1 And finally, for agent N, it also adds an action with only the following execution condition and effect: • Execution condition: turn_var = agent N • Effect: turn_var <- agent 1

[0027] The added action is for an agent to do nothing and simply pass its turn to the next agent. In a multi-agent system's action plan, there are times when an agent has no need to take any action because they have already achieved their objective or are unable to do what they want to do at the moment. The third modification allows agents to take the action of doing nothing in such situations. This action of doing nothing will be referred to as "noop" from now on.

[0028] The task modification unit 12 may add fourth and fifth modifications in addition to the first to third modifications. For simplicity, the span of one cycle from agent 1 to agent N taking action is called a round. It is expected that the actions of each agent performed in each round will be executed in parallel. However, the first to third modifications alone could not guarantee that each action within a round would be executed in parallel (without conflict). The fourth and fifth modifications are modifications made by the total order planning unit (total order planner) to guarantee that actions executed in parallel will not conflict.

[0029] The task modification unit 12, fourthly, adds a variable v_res, which indicates whether the variable is reserved in this round, and a variable v_aff, which indicates whether the variable has been changed in this round, for each variable v other than turn_var. Both variables are binary variables that represent true or false. Formally, they are expressed as follows: ・D(v_res) = {True, False} ・D(v_aff) = {True, False} The initial values ​​of all v_res and v_aff are set to False.

[0030] The task modification unit 12, fifthly, adds the following execution conditions and effects to each action belonging to each agent I (I=1,...,N-1) other than agent N: - For each variable v other than turn_var included in the execution conditions of that action, add v_aff=False to the execution conditions. Also, for each variable v other than turn_var included in the effects of that action, add v_res=False to the execution conditions. - For each variable v other than turn_var included in the execution conditions of that action, add v_res <- True to the effects. Also, for each variable v other than turn_var included in the effects of that action, add v_aff <- True to the effects. For agent N, who takes action at the end of each round, the following execution conditions and effects are added: - For each variable v other than turn_var included in the execution conditions of that action, add v_aff=False to the execution conditions. Also, for each variable v other than turn_var included in the effects of that action, add v_res <- False and v_aff <- False to the effects.

[0031] Let's explain how these added execution conditions and effects work. In a given round, v_res, which corresponds to a certain variable v, becomes True if an action by any agent (the first agent) in that round has v as an execution condition. If this variable v is changed by the effect of an action by another agent (the second agent) in the same round, the first agent's action may not be able to be executed. In other words, it may not be possible to execute actions in parallel within the same round. However, with the fifth modification, the execution condition of each action has been increased to include the condition that the variable v_res, which corresponds to the variable v that the agent is changing, is False (indicating that the variable v is not an execution condition in this round). In other words, the second agent cannot take an action in the same round that would violate the execution condition of the first agent's action. Thus, conflicts between the actions of the first and second agents can be avoided.

[0032] Furthermore, in a given round, v_aff, which corresponds to a certain variable v, becomes True only if an action taken by any agent (the first agent) during that round modifies this variable v. Suppose, during the same round, another agent (the second agent) attempts to take an action because the value of this variable v satisfies the execution condition (this situation is possible with only the first to third modifications). However, the value of variable v that satisfies the execution condition for the second agent is one that only became satisfied after being changed by the first agent in the same round. In other words, the execution condition is not met at the start of the round, and the first and second agents cannot take actions in parallel during this round. However, with the fifth modification, the execution condition for each action now includes the requirement that v_aff, which corresponds to the variable v that the agent uses as an execution condition, is False (indicating that variable v has not been changed during this round). Therefore, the second agent cannot take such an action in the same round. Thus, conflicts between the actions of the first and second agents can be avoided.

[0033] The last agent, agent N, ends the round with its action, so it resets all v_res and v_aff to False (changes them) and passes the turn to agent 1, the first agent of the next round.

[0034] The total sequence planning unit 13 takes the tasks modified by the task modification unit 12 as input and outputs a sequence of actions to achieve the input tasks. Any total sequence planner compatible with the SAS+ format can be used in the total sequence planning unit.

[0035] Furthermore, while some fully sequential planners only support PDDL format as input, most high-speed fully sequential planners convert from PDDL format to SAS+ format before planning, and then use the converted tasks for planning. This is because SAS+ format can represent states with less information than PDDL format (there are actually several other reasons, such as the use of algorithms specifically designed for SAS+ format, but these will not be discussed here). Therefore, even if a fully sequential planner only supports PDDL format, in most cases it can be made to support SAS+ format by modifying only the interface.

[0036] Regarding the total sequence planning unit, we will only describe the minimum mechanism necessary to explain the effects of the control device of this embodiment.

[0037] The total sequence programmer 13 enumerates actions that satisfy the execution conditions in the initial state defined by the task, and generates a new state by applying the effect of each enumerated action. Next, for each new state, it enumerates actions that satisfy the execution conditions and generates a new state by applying each enumerated action. By repeating this operation, a tree of states reachable by repeating actions from the initial state can be extended, as shown in Figure 3. If the generated new state satisfies the conditions defined in the task's goal, the (shortest) path from the initial state to that state is output as a sequence of actions. As is clear from this mechanism, the number of states that the total sequence programmer 13 needs to generate increases exponentially with respect to the number of actions that satisfy the execution conditions in each state. For example, when the tree length is 3 (three actions have been applied from the initial state), the number of states generated will be 5 to the power of 3, or 125, if the number of actions that satisfy the execution conditions in each state is 5. Therefore, the computational complexity of the total sequence programmer 13 increases significantly as the number of actions included in the task increases.

[0038] Conventional fully ordered planners have succeeded in quickly generating a sequence of actions by preferentially generating new states that are likely to satisfy the goal conditions. However, the fact that the computational complexity strongly depends on the number of actions included in the task remains unchanged.

[0039] The task modification unit 12 may perform the processing described above for the task modification unit 12 and the processing described above for the total sequence planning unit 13. In this case, the control device does not need to have the total sequence planning unit 13. In this case, it can also be said that the task modification unit 12 creates a second task that represents information about a sequence of actions that satisfies the constraint of avoiding conflict when at least some of the actions in the first task are executed in parallel by multiple agents. For example, the task modification unit 12 can also be said to create a second task that represents information about a sequence of actions that satisfies the constraint of avoiding conflict by adding the information representing the turn as described above to the first task.

[0040] The planning parallelization unit 14 parallelizes the sequence of actions output by the total sequence planning unit 13 (or the sequence of actions represented by the second task output by the task modification unit 12) based on the dependencies between the actions included in that sequence, and outputs a parallel sequence of actions. Alternatively, the planning parallelization unit 14 can be said to assign each action in the sequence of actions in the second task to multiple agents. Alternatively, the planning parallelization unit 14 can be said to decide on the assignment of each action in the sequence of actions in the second task to the multiple agents. For parallelizing the sequence of actions, for example, the method described in Non-Patent Document 1 may be used.

[0041] However, if the task modification unit 12 performs modifications not only from the first to the third, but also from the fourth to the fifth, then a parallelization method like that described in Non-Patent Document 1 is not necessary. Since it is guaranteed that the actions in each round can be executed in parallel, it is simply a matter of parallelizing the actions included in each round as actions that can be executed in parallel (combined actions).

[0042] Techniques for parallelizing totally ordered sequences of actions, such as the method described in Non-Patent Document 1, are not important for implementing the control device of this embodiment. Therefore, only the minimum operating principle will be explained.

[0043] Two actions are said to be dependent on each other when the effect of one action changes whether or not the execution condition of the other action is met. For example, consider the following two actions: • Action 1: Execution condition v1 = True, Effect v2 <- False • Action 2: Execution condition v1 = True, Effect v1 <- False

[0044] In Action 1, its own execution condition v1=True is changed by v1 ← False, which is an effect of Action 2. Therefore, Action 1 and Action 2 have a dependency relationship. As a specific example of parallelization, assume that a total-order action sequence is …→Action 1→Action 2→… . Can Action 1 and Action 2 be parallelized in this case? The answer is that parallelization cannot be performed if there is a dependency between actions, and it can be performed if there is no dependency. In fact, when attempting to execute Action 2 immediately before Action 1, Action 1 does not satisfy the execution condition, resulting in a failure of the plan. On the other hand, two actions that do not have a dependency relationship do not risk changing each other's execution conditions, so they can be parallelized.

[0045] In Non-Patent Document 1, such dependencies are determined for each pair of actions included in an action sequence, and the action sequence is parallelized based on these dependencies.

[0046] Furthermore, when focusing on a single agent, the agent can only perform actions sequentially (it cannot perform multiple actions in parallel), so it is assumed that all actions of the same agent have dependency relationships.

[0047] The plan output unit 15 outputs the parallel action sequence parallelized by the plan parallelization unit 14. The output parallel action sequence is distributed to each agent, and each agent is controlled to act in accordance with the parallel action sequence. Alternatively, the plan output unit 15 may control a plurality of agents to execute each action of the action sequence in the second task in accordance with the allocation determined by the plan parallelization unit 14.

[0048] FIG. 4 shows a flowchart of processing in the control device according to the first embodiment. First, a task input unit 11 receives an input of a task (step S11). Next, a task correction unit 12 corrects the input task (step S12). Then, a total-order planning unit 13 outputs an action sequence for the corrected task (step S13). Thereafter, a plan parallelization unit 14 parallelizes the action sequence output by the total-order planning unit 13 (step S14). Finally, a plan output unit 15 outputs the parallel action sequence (step S15).

[0049] As described above, the processing in the control device shown in Figure 4 can also be implemented as a control method executed in a control device comprising a task input unit 11, a task modification unit 12, a total sequence planning unit 13, a planning parallelization unit 14, and a planning output unit 15.

[0050] According to the control device of this embodiment, by making modifications that minimize the increase in the number of actions included in a task (to the same as the number of agents), agents can be made to act in parallel, and a high-quality parallel action sequence can be output while suppressing the increase in computational complexity in the total sequence planning unit.

[0051] This embodiment demonstrates, using specific examples, that a high-quality parallel action sequence can be obtained with the control device of this embodiment. Embodiment 1 is an example in which only the first to third modifications are made in the task modification unit, and the action sequence is parallelized in the planning parallelization unit using the method described in Non-Patent Document 1. In contrast, Embodiment 2 is an example in which the first to fifth modifications are made in the task modification unit. Furthermore, for the sake of simplicity, it is assumed that the total sequence planning unit always outputs the shortest action sequence (when considered as a total sequence).

[0052] <Example 1> As an example, consider a cleaning task of two rooms, room1 and room2, using two robots, robot1 and robot2, and two vacuum cleaners, vc1 and vc2. The objective of this task is to clean room1 and room2 using the vacuum cleaners. Each robot is assumed to have an action called "pickup" to pick up the vacuum cleaner and an action called "clean" to clean the room (it would be natural for the robot to also have an action to put the vacuum cleaner down, but this is omitted as it is not necessary for the explanation). In SAS+ format, this problem can be defined as follows, for example.

[0053] ・Variable D(v_vc1) = {held_robot1, held_robot2, free} D(v_vc2) = {held_robot1, held_robot2, free} D(v_room1) = {clean, dirty} D(v_room2) = {clean, dirty}

[0054] ・Action (robot1 pickup vc1): Execution condition v_vc1=free, effect v_vc1 <- held_robot1 (robot1 pickup vc2): Execution condition v_vc2=free, effect v_vc2 <- held_robot1 (robot2 pickup vc1): Execution condition v_vc1=free, effect v_vc1 <- held_robot2 (robot2 pickup vc2): Execution condition v_vc2=free, effect v_vc2 <- held_robot2 (robot1 vacuum room1 vc1): Execution condition v_vc1=held_robot1, effect v_room1 <- clean (robot1 vacuum room1 vc2): Execution condition v_vc2=held_robot1, effect v_room1 <- clean (robot1 vacuum room2 vc1): Execution condition v_vc1=held_robot1, effect v_room2 <- clean (robot1 vacuum room2 vc2): Execution condition v_vc2=held_robot1, effect v_room2 <- clean (robot2 vacuum room1 vc1): Execution condition v_vc1=held_robot2, effect v_room1 <- clean (robot2 vacuum room1 vc2): Execution condition v_vc2=held_robot2, effect v_room1 <- clean (robot2 vacuum room2 vc1): Execution condition v_vc1=held_robot2, effect v_room2 <- clean (robot2 vacuum room2 vc2): Execution condition v_vc2=held_robot2, effect v_room2 <- clean

[0055] Initial state: v_vc1 = free, v_vc2 = free, v_room1 = dirty, v_room2 = dirty Goal state: v_room1 = clean, v_room2 = clean

[0056] Here, v_vc1 and v_vc2 are variables that indicate whether vacuum cleaners vc1 and vc2 are being held by one of the robots, or whether they are not being held by anyone (free). Also, v_room1 and v_room2 are variables that indicate whether room1 and room2 are clean or not.

[0057] (robotI pickup vcJ) represents the action of robot I (I=1,2) picking up vacuum cleaner vcJ (J=1,2). Similarly, (robotI vacuum roomJ vcK) represents the action of robot I (I=1,2) vacuuming room J (J=1,2) with vacuum cleaner vcK (K=1,2).

[0058] First, let's consider the plan in the total sequential planning unit when no modifications are made to the tasks. In the initial state, there are four actions that satisfy the execution conditions: pickup ((robotI pickup vcJ) (I=1,2)(J=1,2)). Therefore, four new states are generated. These new states include, for example, the state v_vc=held_robot1, v_vc2=free, v_room1=dirty, v_room2=dirty, which is the result of applying (robot1 pickup vc1). In this new state, there are three actions that satisfy the execution conditions: (robot2 pickup vc2), (robot1 vacuum room1 vc1), and (robot1 vacuum room2 vc1). Therefore, three new states are generated from this state. One of them is the state v_vc=held_robot1, v_vc2=free, v_room1=clean, v_room2=dirty, which is the result of applying (robot1 vacuum room1 vc1). Furthermore, even in this state, the same three actions as before can be taken. Now, considering the state after applying (robot1 vacuum room2 vc1), the state becomes v_vc=held_robot1, v_vc2=free, v_room1=clean, v_room2=clean. Since this state satisfies the goal condition, the total sequential programming unit outputs the following sequence of actions (Figure 5 shows the flow of the plan explained so far (tree of reached states). For clarity of the diagram, the generation of new states from some states has been omitted). ・(robot1 pickup vc1)→(robot1 vacuum room1 vc1)→(robot1 vacuum room2 vc1)

[0059] This plan is the shortest sequence of actions in a totally ordered sequence. However, since all actions are executed by robot1, the plan parallelization unit cannot parallelize it any further. In other words, this sequence of actions remains the parallel sequence of actions.

[0060] Next, the tasks that were modified in the task modification section are shown below. The following are the tasks that underwent the first to third modifications in the task modification section.

[0061] ・Variables D(v_vc1) = {held_robot1, held_robot2, free} D(v_vc2) = {held_robot1, held_robot2, free} D(v_room1) = {clean, dirty} D(v_room2) = {clean, dirty} D(turn_var) = {robot1, robot2}

[0062] • Action (robot1 pickup vc1): Execution condition v_vc1=free, turn_var=robot1, effect v_vc1 <- held_robot1, turn_var <- robot2 (robot1 pickup vc2): Execution condition v_vc2=free, turn_var=robot1, effect v_vc2 <- held_robot1, turn_var <- robot2 (robot2 pickup vc1): Execution condition v_vc1=free, turn_var=robot2, effect v_vc1 <- held_robot2, turn_var <- robot1 (robot2 pickup vc2): Execution condition v_vc2=free, turn_var=robot2, effect v_vc2 <- held_robot2, turn_var <- robot1 (robot1 vacuum room1 vc1): Execution condition v_vc1=held_robot1, turn_var=robot1, effect v_room1 <- clean, turn_var <- robot2 (robot1 vacuum room1 vc2): Execution condition v_vc2=held_robot1, turn_var=robot1, effect v_room1 <- clean, turn_var <- robot2 (robot1 vacuum room2 vc1): Execution condition v_vc1=held_robot1, turn_var=robot1, effect v_room2 <- clean, turn_var <- robot2 (robot1 vacuum room2 vc2): Execution condition v_vc2=held_robot1, turn_var=robot1, effect v_room2 <- clean, turn_var <- robot2 (robot2 vacuum room1 vc1): Execution condition v_vc1=held_robot2, `turn_var=robot2`, effect `v_room1 <- clean`, `turn_var <- robot1 (robot2 vacuum room1 vc2)`: execution condition `v_vc2=held_robot2`.turn_var=robot2, effect v_room1 <- clean, turn_var <- robot1 (robot2 vacuum room2 vc1): Execution condition v_vc1=held_robot2, turn_var=robot2, effect v_room2 <- clean, turn_var <- robot1 (robot2 vacuum room2 vc2): Execution condition v_vc2=held_robot2, turn_var=robot2, effect v_room2 <- clean, turn_var <- robot1 (robot1 noop): Execution condition turn_var=robot1, effect turn_var <- robot2 (robot2 noop): Execution condition turn_var=robot2, effect turn_var <- robot1,

[0063] - Initial state: v_vc1 = free, v_vc2 = free, v_room1=dirty, v_room2=dirty, turn_var=robot1 - Goal state: v_room1=clean, v_room2=clean

[0064] The modified task adds one variable, `turn_var`, and two actions (robot1 noop) and (robot2 noop). Additionally, each action for robot1 has the execution condition `turn_var=robot1` and the effect `turn_var <- robot2`, while each action for robot2 has the execution condition `turn_var=robot2` and the effect `turn_var <- robot1`. Initially, `turn_var` is set to robot1, the first agent.

[0065] Let's consider the plan in the total sequential planning unit when a modification is made to the task. In the initial state, there are three actions that satisfy the execution conditions: two actions by robot1 (pickup) and one noop action (doing nothing). In the initial state, turn_var=robot2 is not satisfied, so robot2 cannot take any action. Applying robot1's actions from the initial state generates three new states. Here, we consider the state where the same action as before the modification (robot1 pickup vc1) is applied: v_vc1=held_robot1, v_vc2=free, v_room1=dirty, v_room2=dirty, turn_var=robot2. In this state, the actions that satisfy the execution conditions are the two actions by robot2 (robot2 pickup vc2) and (robot2 noop). In this state, turn_var=robot1 is not satisfied, so robot1 cannot take any action. In these two new states, the one that corresponds to the original plan is (robot2 noop) (because robot2 took no action in the original action sequence). The new state with (robot2 noop) applied is v_vc1=held_robot1, v_vc2=free, v_room1=dirty, v_room2=dirty, turn_var=robot1, where only the turn is passed to robot 1. In this state, the execution conditions are satisfied by three: (robot1 vacuum room1 vc1), (robot1 vacuum room2 vc1), and (robot1 noop). Therefore, three new states are generated from this state. One of them is the state with (robot1 vacuum room1 vc1) applied, v_vc1=held_robot1, v_vc2=free, v_room1=clean, v_room2=dirty, turn_var=robot2. In this state, the execution conditions are met by the same two actions (robot2 pickup vc2) and (robot2 noop) that met the execution conditions two states prior.Here, we again consider a new state v_vc1=held_robot1, v_vc2=free, v_room1=clean, v_room2=dirty, turn_var=robot1 after applying (robot2 noop). In this state, there are three actions that satisfy the execution conditions: (robot1 vacuum room1 vc1), (robot1 vacuum room2 vc1), and (robot1 noop). Applying (robot1 vacuum room2 vc1) will lead to a state that satisfies the goal conditions. The sequence of actions to reach this state is the following plan of length 5: (robot1 pickup vc1) → (robot2 noop) → (robot1 vacuum room1 vc1) → (robot2 noop) → (robot1 vacuum room2 vc1).

[0066] However, in reality, the total order programmer does not output the above sequence of actions. This is because a shorter plan exists. Consider a new state in which (robot1 pickup vc1) is applied in the initial state, and robot2 takes (robot2 pickup vc2) instead of noop. The new state generated by this action is v_vc1=held_robot1, v_vc2=held_robot2, v_room1=dirty, v_room2=dirty, turn_var=robot1. In this state, the only actions that satisfy the execution conditions are (robot1 vacuum room1 vc1), (robot1 vacuum room2 vc1), and (robot1 noop). Applying (robot1 vacuum room1 vc1) to this state results in a new state of v_vc1=held_robot1, v_vc2=held_robot2, v_room1=clean, v_room2=dirty, turn_var=robot2. In this new state, the execution conditions are met by three actions: (robot2 vacuum room1 vc2), (robot2 vacuum room2 vc2), and (robot2 noop). Applying (robot2 vacuum room2 vc2) results in a newly generated state that satisfies the goal conditions. The sequence of actions to reach this state is shown below: (robot1 pickup vc1) → (robot2 pickup vc2) → (robot1 vacuum room1 vc1) → (robot2 vacuum room2 vc2)

[0067] The length of this action sequence is 4, which is shorter than the previous action sequence of length 5. Since a length of 4 is the shortest action sequence, the total sequence planning unit outputs this action sequence. The planning flow (tree of reached states) in the modified task is shown in Figure 6 (for clarity of the figure, the generation of new states from some states has been omitted).

[0068] The planning parallelization unit parallelizes this sequence of actions. (robot1 pickup vc1) and (robot2 pickup vc2) have no dependency because their effects do not change the execution conditions of the other. Similarly, (robot1 vacuum room1 vc1) and (robot2 vacuum room2 vc2) also have no dependency. Therefore, the parallel sequence of actions becomes: (robot1 pickup vc1)&(robot2 pickup vc2)→(robot1 vacuum room1 vc1)&(robot2 vacuum room2 vc2)

[0069] Here, (robot1 pickup vc1)&(robot2 pickup vc2) and (robot1 vacuum room1 vc1)&(robot2 vacuum room2 vc2) are combined actions, and the length until the plan is completed is 2 (since each action can be executed in parallel within a combined action, the length of the combined action is treated as 1).

[0070] As described above, the length of the parallel action sequence is 3 when no task modification is performed, while the length of the parallel action sequence is 2 when task modification is performed. This shows that the control device of this embodiment can output a higher quality parallel action sequence.

[0071] <Example 2> In Example 2, the effects of the fourth and fifth modifications in the task modification unit will be explained with specific examples. Figure 7 is an example of a multi-agent path planning problem. In this problem, the objective is for each robot to move to its respective destination on the grid map without colliding. This problem can be expressed in SAS+ format as follows, for example.

[0072] ・Digit D(v_robot1) = {p00, p01, p10, p11, p20, p21} D(v_robot2) = {p00, p01, p10, p11, p20, p21} D(v_free_p00) = {True, False} D(v_free_p01) = {True, False} D(v_free_p10) = {True, False} D(v_free_p11) = {True, False} D(v_free_p20) = {True, False} D(v_free_p21) = {True, False}

[0073] • Action (robot1 move p10 p00): Executes conditions v_robot1=p10, v_free_p00=True, Result v_robot1 <- p00, v_free_p00 <- False, v_free_p10 <- True. (robot1 move p10 p11): Executes conditions v_robot1=p10, v_free_p11=True, Result v_robot1 <- p11, v_free_p11 <- False, v_free_p10 <- True. (robot1 move p10 p20): Executes conditions v_robot1=p10, v_free_p20=True, Result v_robot1 <- p20, v_free_p20 <- False, v_free_p10 <- True. (robot2 move p00) p01): Execution condition v_robot2=p00, v_free_p01=True, effect v_robot2 <- p01, v_free_p01 <- False, v_free_p00 <- True (robot2 move p00 p10): Execution condition v_robot2=p00, v_free_p10=True, effect v_robot2 <- p10, v_free_p10 <- False, v_free_p00 <- True (other actions are omitted)

[0074] ・Initial state v_robot1=p10, v_robot2=p00, v_free_p00=False, v_free_p01=True, v_free_p10=False, v_free_p11=True, v_free_p20=True, v_free_p11=True ・Goal v_robot1=p20, v_robot2=p21

[0075] v_robot1 and v_robot2 are variables representing the positions of robot1 and robot2, respectively. Initially, robot1 is at position p10 and is heading towards the target value p20. Initially, robot2 is at position p00 and is heading towards the destination p21. v_free_pij (i=0,1,2, j=0,1) is a variable used to avoid collisions and represents whether each grid is occupied by an agent (True) or not (False). Each robot can take the action move from its current grid to an adjacent grid, but some have been omitted due to the large number of possible actions. Here, we will explain the execution conditions and effects using the action robot1 takes as an example: moving from p10 to p00 (robot1 move p10 p00). The execution condition v_robot1=p10 requires that robot1 is at p10, and v_free_p00=True requires that the destination p00 is not occupied by another agent. The latter is the condition for achieving collision avoidance. In the initial state, p00 is occupied by robot2, and v_free_p00=False, so (robot1 move p10 p00) does not satisfy the execution conditions. The effects v_robot1 <- p00 means that robot1's position is changed to p00, v_free_p00 <- False means that p00 is now occupied by robot1, and v_free_p10 <- True means that p10 is no longer occupied by any robot.

[0076] First, let's assume that if the task modification unit only made the first to third modifications, the total sequence planning unit outputted the following shortest sequence of actions (one of them): (robot1 move p10 p20) → (robot2 move p00 p10) → (robot1 noop) → (robot2 move p10 p11) → (robot1 noop) → (robot2 move p11 p21)

[0077] This sequence of actions is parallelized in the planning parallelization unit as follows. The length of this parallel sequence of actions is 4. (robot1 move p10 p20) → (robot1 noop) & (robot2 move p00 p10) → (robot1 noop) & (robot2 move p10 p11) → (robot2 move p11 p21)

[0078] The reason why (robot1 move p10 p20) and (robot2 move p00 p10) are not coupled actions is that, formally, the execution condition v_free_p10=True for (robot2 move p00 p10) is affected by the effect of (robot1 move p10 p20) v_free_p10 <- True, and these actions have a dependency and cannot be parallelized. In fact, if we consider two robots moving in parallel, when robot2 is about to move to p10, robot1 is still at p10, and there is a risk of collision. If the movements of robot1 and robot2 are perfectly synchronized, there will be no collision, but even a slight delay in synchronization can cause a collision. In fact, in multi-agent path planning problems, there are two types of formulations: one that allows such movements and one that does not (which guarantees that collisions will not occur even if there is a slight delay in synchronization).

[0079] Here, we will not trace the entire planning flow (tree of reachable states) in the total sequential programming unit step by step, but will only explain the first two actions. The new state obtained by applying (robot1 move p10 p20) in the initial state is as follows (turn_var has been added due to the first to third modifications): v_robot1=p20, v_robot2=p00, v_free_p00=False, v_free_p01=True, v_free_p10=True, v_free_p11=True, v_free_p20=False, v_free_p11=True turn_var=robot2

[0080] In this state, (robot2 move p00 p10) satisfies the execution condition (even though it cannot be executed in parallel with (robot1 move p10 p20)) because v_free_p10=True holds. The first to third modifications allow each agent to perform an action once in each round, encouraging parallel actions, but they do not consider whether each action included in the same round can be executed in parallel. As a result, actions that fail to be parallelized may be included in the same round, and in the parallelization of the planning parallelization unit, an action included in one round may be divided into two or more coupled actions. This division of an action in one round into multiple coupled actions is a factor that increases the length of the parallel action sequence. In fact, in the example above, although the totally ordered action sequence consists of three rounds, the length of the parallel action sequence is four.

[0081] Next, the task with the first through fifth modifications is shown below.

[0082] ・Variable D(v_robot1) = {p00, p01, p10, p11, p20, p21}, D(v_robot1_res) = {True, False}, D(v_robot1_aff) = {True, False} D(v_robot2) = {p00, p01, p10, p11, p20, p21} D(v_robot2_res) = {True, False}, D(v_robot2_aff) = {True, False} D(v_free_p00) = {True, False}, D(v_free_p00_res) = {True, False}, D(v_free_p00_aff) = {True, False} D(v_free_p01) = {True, False} D(v_free_p01_res) = {True, False}, D(v_free_p01_aff) = {True, False} D(v_free_p10) = {True, False} D(v_free_p10_res) = {True, False}, D(v_free_p10_aff) = {True, False} D(v_free_p11) = {True, False} D(v_free_p11_res) = {True, False}, D(v_free_p11_aff) = {True, False} D(v_free_p20) = {True, False} D(v_free_p20_res) = {True, False}, D(v_free_p20_aff) = {True, False} D(v_free_p21) = {True, False} D(v_free_p21_res) = {True, False}, D(v_free_p21_aff) = {True, False} D(turn_var) = {robot1, robot2}

[0083] ・Action (robot1 move p10 p20): Execution conditions v_robot1=p10, v_free_p20=True, turn_var=robot1, v_robot1_aff=False, v_free_p20_aff=False, v_robot1_res=False, v_free_p20_res=False, v_free_p10_res=False Effect v_robot1 <- p20, v_free_p20 <- False, v_free_p10 <- True, turn_var <- robot2 v_robot1_res <- True, v_free_p20_res <- True v_robot1_aff <- True, v_free_p20_aff <- True, v_free_p10_aff <- True (robot2 move p00 p10): Execution conditions v_robot2=p00, v_free_p10=True, turn_var=robot2, v_robot2_aff=False, v_free_p10_aff=False, v_robot2_res=False, v_free_p10_res=False, v_free_p00_res=False v_robot2 <- p10, v_free_p10 <- False, v_free_p00 <- True, turn_var <- robot1 All v_res <- False, All v_aff <- False (Other actions are omitted)

[0084] ・Initial state v_robot1=p10, v_robot2=p00, v_free_p00=False, v_free_p01=True, v_free_p10=False, v_free_p11=True, v_free_p20=True, v_free_p11=True turn_var=robot1, All v_res=False, All v_aff=False ・Goal v_robot1=p20, v_robot2=p21

[0085] In the fourth and fifth modifications, for each variable v other than turn_var, a variable v_res is added that indicates whether the variable is reserved in this round, and v_aff indicates whether the variable has been modified in this round. For example, for the variable v_free_p01, which indicates whether grid p01 is occupied by an agent, v_free_p01_res and v_free_p01_aff are added. All var_res and All var_aff are written as all v_res and v_aff. All var_res and var_aff are set to False by default.

[0086] In this modified task, the planning flow up to the second action of the total sequence planner is described. In the initial state, the actions that satisfy the execution conditions are the same as when only the first to third modifications were made. This is because the execution conditions for each action added in the fourth and fifth processes all require that some v_res and v_aff be False. In the initial state, all v_res and v_aff are False, so the execution conditions added in the fourth and fifth processes do not prevent the execution of the actions at this stage.

[0087] Let's consider the new state after applying (robot1 move p10 p20) to the initial state. What's important here is that, due to the effect of (robot1 move p10 p20), the variable v_free_p10, which represents whether grid p10 is occupied by an agent or not, has changed during this round, and v_free_p10_aff has become True. In this state, (robot2 move p00 p10), which cannot be executed in parallel with (robot1 move p10 20), does not satisfy its execution conditions. This is because (robot2 move p00 p10) has v_free_p10_aff=False as an execution condition. On the other hand, (robot2 move p00 p01), which is an action that approaches the destination p21 just like (robot2 move p00 p10), satisfies its execution conditions, so we apply this action to generate the new state. We will omit the explanation of the subsequent planning flow, but as a result, the total sequential planning unit outputs the following plan. (robot1 move p10 p20)→(robot2 move p00 p01)→(robot1 noop)→(robot2 move p01 p11)→(robot1 noop)→(robot2 move p11 p21)

[0088] When the first through fifth modifications are made in the task modification section, the output sequence of actions is guaranteed to always be executable in parallel for each round. Therefore, the actions for each round can simply be combined into a single action. That is, the following sequence of parallel actions will be output: (robot1 move p10 p20)&(robot2 move p00 p01)→(robot1 noop)&(robot2 move p01 p11)→(robot1 noop)&(robot2 move p11 p21)

[0089] The length of this parallel sequence is 3, which is shorter than the length of the parallel sequence of 4 when only the first to third modifications are made.

[0090] Some parallel planners (that do not pseudo-utilize fully sequential planners) determine if there is a conflict with actions to be executed in parallel when applying an action to a state to generate a new state, and then avoid applying the conflicting action. In other words, the method of determining conflicts of parallel actions during planning is not new. However, the novelty of the control device in this embodiment lies in the fact that it is possible to determine conflicts of actions to be executed in parallel only when modifying a task. This mechanism makes it possible to output a sequence of parallel actions without the effort of modifying the planning system itself.

[0091] Furthermore, task modification that ensures parallel execution of actions within the same round can also be achieved using the method described in Non-Patent Document 2. However, while the method described in Non-Patent Document 2 increases the number of actions included in a task by more than three times, the task modification in the control device of this embodiment only adds actions equal to the number of agents (noop for each agent). Therefore, the overall sequence planning unit can calculate the plan more quickly.

[0092] <Second Embodiment> In the second embodiment, a priority-ordering planner, which is particularly fast among parallel planners, is simulated using a fully ordered planner, and a parallel action sequence is output at high speed. Specifically, in the second embodiment, the control device of the first embodiment is used as a submodule to construct a priority-ordering control device.

[0093] Before going into a detailed explanation of the second embodiment, let's first describe the priority-ordered planner. The priority-ordered planner does not plan for all agents at once, but rather plans for each agent sequentially. This is because a task that considers one agent requires fewer actions than a task that considers all agents, so it is faster to complete the plan by repeating the planning for each agent rather than planning for all agents at once.

[0094] Each agent's plan outputs a sequence of actions that does not conflict with any already planned sequences. These pre-planned sequences are called reserved sequences. This procedure can also be described as follows: agents planning first may ignore the actions of agents planning later, but agents planning later are required to consider the actions of agents planning first and avoid interfering with their actions (reserved sequences). In this sense, agents planning first have higher priority, and agents planning later have lower priority, so this type of planning system is called a priority-ordering planner.

[0095] Figure 8 shows the configuration of a priority control device according to the second embodiment. The priority control device 20 includes a task input unit 21, an agent selection unit 22, a task extraction unit 23, a reservation addition unit 24, a parallel planning unit 25, a plan storage unit 26, and a plan output unit 27.

[0096] The task input unit 21 has the same function as the task input unit 11 in the first embodiment. In addition to tasks, the task input unit 21 may also accept agent priority as input.

[0097] The agent selection unit 22 selects one agent whose planning has not yet been completed. If agent priorities have been entered in the task input unit 21, this selection follows those priorities. If no priorities have been entered, the priority is determined by any method. The selected agent will then be the agent that performs the planning.

[0098] Also, for simplicity's sake, we've continued to explain assuming only one agent is selected, but in reality, multiple agents can be selected. In this case, for example, it would be a priority-ordering planner that plans for two agents at a time.

[0099] The task extraction unit 23 removes all actions from the input task except for those of the agent selected by the agent selection unit 22, and also removes the goals of each agent other than the selected agent, and outputs a new task. However, the task extraction unit retains the input task in its original state. For example, it copies the input task, removes actions and goals from the copied task, and outputs the copied task. In the second embodiment, it is necessary to perform iterative planning for each agent and extract a task for each agent being planned, so it is necessary to retain the input task.

[0100] By removing the actions and goals of other agents, the planning agent (the selected agent) can ignore the actions and goals of other agents.

[0101] The reservation addition unit 24 adds the fully connected actions included in the parallel action sequence stored in the plan memory unit 26 (described later), along with the planned goals of each agent, to the tasks output by the task extraction unit 23.

[0102] Each combined action can be added to a task as a single action, even if it involves multiple agents acting in parallel. A single action that combines multiple actions included in a combined action has the following execution conditions and effects: • Execution conditions: All execution conditions of each action included in the combined action • Effects: All effects of each action included in the combined action

[0103] Furthermore, the actions added in the reservation addition unit 24 are set to be performed by a single virtual agent.

[0104] By adding these reserved actions and goals, the task can reflect the already planned sequence of actions (reserved actions) and the goals (for each planned agent).

[0105] The parallel planning unit 25 takes the tasks to which actions have been added by the reservation addition unit as input and outputs parallel actions. The control device of the first embodiment can be used as is for the parallel planning unit 25.

[0106] The planning memory unit 26 stores the parallel action sequences output by the parallel planning unit 25. In a priority-ordered planner, planning is performed for each agent, but the planning memory unit 26 does not store all of them; it may store only the most recent one. That is, it may overwrite already stored parallel action sequences with new parallel action sequences output by the parallel planning unit. The planning memory unit 26 also stores the planned agents and their goals.

[0107] The planning output unit 27 outputs the (latest) parallel action sequence stored in the planning storage unit 26 once the planning for all agents has been completed. Alternatively, the planning output unit 27 may decompose the combined action, which was grouped as a single action in the reservation addition unit 24, back into its original multiple parallel actions before outputting the parallel action sequence. The output parallel action sequence is distributed to each agent, and each agent is controlled to act according to the parallel action sequence.

[0108] Figure 9 shows a flowchart of the processing in the priority control device according to the second embodiment. First, the task input unit 21 accepts task input (step S21). Next, the agent selection unit 22 selects the agent to perform the planning (step S22). The task extraction unit 23 removes elements related to agents other than the selected agent from the task (step S23), and the reservation addition unit 24 adds the combined action included in the already planned (latest stored in the plan storage unit 26) parallel action sequence and the already planned goals of each agent to the task (step S24). Finally, the parallel planning unit 25 outputs a parallel action sequence with the task modified by the task extraction unit 23 and the reservation addition unit 24 as input (step S25), and the plan storage unit 26 stores the output parallel action sequence (and the planned agents and their goals) (step S26).

[0109] Once the planning for one agent is completed using the procedure described above, the agent selection unit 22 selects an agent whose planning is not yet complete and repeats the process up to the parallel action output (step S27). When the planning for all agents is completed, the planning output unit 27 outputs the parallel action sequence for all agents stored in the planning memory unit (step S28).

[0110] As described above, the processing in the priority control device shown in Figure 9 can also be implemented as a priority control method executed in a priority control device comprising a task input unit 21, an agent selection unit 22, a task extraction unit 23, a reservation addition unit 24, a parallel planning unit 25, a plan storage unit 26, and a plan output unit 27.

[0111] This embodiment explains how the prioritized control device provides a high-speed parallel planner. It also explains that, unlike a priority-ordered planner, the goals of pre-planned agents are not made unattainable by the plans of later agents.

[0112] In a priority-ordered planner, calculations are sped up by repeatedly planning for each agent individually. In the priority-ordered control device 20 of the second embodiment, the parallel planning unit 25 repeatedly plans for two agents: the planning agent and the virtual agent corresponding to the reserved action sequence. Furthermore, the number of combined actions included in the reserved action sequence (the number of actions when actions executed in parallel are grouped together) is often much smaller than the number of actions for a single agent. Therefore, the priority-ordered control device 20 of the second embodiment can perform planning faster than planning all agents at once.

[0113] Furthermore, the parallel planning unit performs planning that takes into account both the planning agent and the virtual agent corresponding to the reserved action sequence, and outputs a parallel action sequence that achieves the goals of both. In other words, while a normal priority-ordering planner treats the reserved action sequence as a constraint, in the second embodiment, the goal of each pre-planned agent and the actions included in the reserved action sequence that can achieve that goal are re-included in the task, thereby ensuring that the pre-planned agent achieves its goal on the task side.

[0114] Strictly speaking, in the second embodiment, there is no guarantee that the reserved action sequence will be perfectly preserved. For example, the action sequence output from the parallel planning unit may have a different order of some combined actions than the reserved action sequence, or it may include actions that do nothing (noop). However, what is important in a priority-ordered planner is to guarantee that the planned agent can achieve the goal, and maintaining the reserved action sequence is merely a means to that end. In the second embodiment, as mentioned above, the task definition guarantees that the planned agent will achieve the goal, so changes to the reserved action sequence do not pose a problem.

[0115] According to the priority control device of the second embodiment, a priority-ordered planner can be pseudo-constructed using a full-order planner, and a parallel action sequence can be output at high speed. Furthermore, similar to the control device of the first embodiment, a novel feature of the priority control device of the second embodiment is that the calculation of the parallel action sequence can be accelerated simply by adjusting its input and output, without the need to modify the full-order planner.

[0116] [Hardware Configuration Example] Figure 10 shows an example of the hardware configuration of the control device and the priority control device. That is, the control device 10 and the priority control device 20 can realize each function of the control device 10 and the priority control device 20 by having the parallel action planning direction or the priority parallel action planning direction described above executed as a program on the information processing device (computer) 30 which employs the hardware configuration shown in Figure 10. However, the hardware configuration example shown in Figure 10 is just one example of a hardware configuration that realizes each function of the information processing device 30, and is not intended to limit the hardware configuration of the control device 10 and the priority control device 20. The control device 10 and the priority control device 20 may include hardware not shown in Figure 10.

[0117] As shown in Figure 10, the hardware configuration that the information processing device 30 may employ includes, for example, a CPU (Central Processing Unit) 31, a main memory 32, an auxiliary memory 33, and an IF (Interface) unit 34, all interconnected by an internal bus.

[0118] The CPU 31 executes each instruction included in the program run by the information processing device (computer) 30. The main memory 32 is, for example, RAM (Random Access Memory), and temporarily stores various programs, such as programs that the information processing device (computer) 30 assists in executing, for the CPU 31 to process.

[0119] The auxiliary storage device 33 is, for example, an HDD (Hard Disk Drive) and can store various programs, such as processes executed by the control device 10 and the priority control device 20 of the information processing device (computer) 30, for medium to long term. These programs can be provided as program products recorded on a non-transitory computer-readable storage medium.

[0120] The IF unit 34 provides, for example, an interface for the input and output of the task input unit and the plan output unit.

[0121] The information processing device (computer) 30, which employs the hardware configuration described above, realizes the functions of the control device 10 and the priority control device 20 by executing the aforementioned parallel action planning method or priority control method as a program.

[0122] Furthermore, each disclosure of the above-mentioned non-patent literature cited is incorporated into this document by reference. Within the framework of the full disclosure of the present invention (including the claims), further modifications and adjustments to the embodiments or examples are possible based on the fundamental technical concept. Also, within the framework of the full disclosure of the present invention, various combinations or selections (including partial deletions) of various disclosure elements (including each element of each claim, each element of each embodiment or example, each element of each drawing, etc.) are possible. In other words, the present invention naturally includes the full disclosure, including the claims, and various modifications and alterations that a person skilled in the art could make in accordance with the technical concept. In particular, with respect to the numerical ranges described in this document, any numerical value or sub-range included within that range should be interpreted as being specifically described, even if not otherwise stated. Furthermore, each disclosure item of the above-mentioned cited documents may, if necessary, be used in combination with the items described in this document as part of the disclosure of the present invention, in accordance with the spirit of the present invention, in part or in whole, and this is also considered to be included in the disclosure items of this application.

[0123] 10 Control device 11 Task input unit 12 Task modification unit 13 Total sequence planning unit 14 Parallel planning unit 15 Planning output unit 20 Prioritized control device 21 Task input unit 22 Agent selection unit 23 Task extraction unit 24 Reservation addition unit 25 Parallel planning unit 26 Planning storage unit 27 Planning output unit 30 Information processing device 31 CPU 32 Main memory 33 Auxiliary memory 34 IF unit

Claims

1. A control device comprising: a first task that represents information about a sequence of actions; a task modification unit that creates a second task that represents information about a sequence of actions that satisfies constraints to avoid conflicts when at least some of the actions in the first task are executed in parallel by multiple agents; a planning parallelization unit that determines the assignment of each action in the sequence of actions in the second task to the multiple agents; and a planning output unit that controls the multiple agents to execute each action in the sequence of actions in the second task according to the determined assignment.

2. The control device according to claim 1, characterized in that the task modification unit adds a turn variable to the execution conditions that specifies which of the plurality of agents should take action, and adds a constraint that each agent takes one action in turn.

3. The control device according to claim 2, characterized in that the task modification unit uses the turn variable to add a new action in which the agent does nothing and simply passes the turn to the next agent.

4. The control device according to claim 3, wherein the task modification unit adds, for each variable other than the turn variable, a reserved variable indicating whether or not each variable is reserved at a timing when each agent is scheduled to execute in parallel, and a modified variable indicating whether or not each variable has been modified at a timing when each agent is scheduled to execute in parallel, and adds the condition that the reserved variable and the modified variable are not true to the execution conditions, thereby adding a constraint that each agent does not take an action that cannot be executed in parallel.

5. A control device according to any one of claims 1 to 4, comprising: a task input unit that accepts input of tasks for multiple agents to plan parallel actions; an agent selection unit that selects an agent to perform planning from among the multiple agents; a task extraction unit that removes actions and goals related to agents other than those selected by the agent selection unit from the tasks input to the task input unit; a reservation addition unit that adds actions included in a planned parallel action sequence stored in a plan storage unit and the planned goals of each agent to a task output by the task extraction unit; and a control device according to any one of claims 1 to 4, which outputs a parallel action sequence using the tasks modified by the task extraction unit and the reservation addition unit as input; a plan storage unit that stores a parallel plan output by the control device, a planned agent and its goals; and a plan output unit that outputs a parallel action sequence for all agents to the multiple agents for the control of the multiple agents.

6. The priority control device according to claim 5, characterized in that the reservation addition unit combines each action that is executed in parallel included in the parallel action sequence into a single action before adding it to the task.

7. A control method in which a computer creates a first task representing information about a sequence of actions, and a second task representing information about a sequence of actions that satisfies constraints to avoid conflicts when at least some of the actions in the first task are executed in parallel by multiple agents, determines the assignment of each action in the sequence of actions in the second task to the multiple agents, and controls the multiple agents to execute each action in the sequence of actions in the second task according to the determined assignment.

8. A priority control device comprising a task input unit, an agent selection unit, a task extraction unit, a reservation addition unit, a parallel planning unit, a plan storage unit, and a plan output unit, wherein the control device executes the control method according to claim 7, wherein the task input unit accepts input of tasks for a plurality of agents for which parallel actions should be planned; the agent selection unit selects an agent from the plurality of agents to perform planning; the task extraction unit removes actions and goals relating to agents other than those selected by the agent selection unit from the tasks input to the task input unit; the reservation addition unit adds actions included in the planned parallel action sequence stored in the plan storage unit and the planned goals for each agent to the tasks output by the task extraction unit; the parallel planning unit outputs the parallel action sequence using the tasks modified by the task extraction unit and the reservation addition unit as input; the plan storage unit stores the parallel plan output by the control device and the planned agents and their goals; and the plan output unit outputs the parallel action sequence for all agents to the plurality of agents for the control of the plurality of agents.

9. A control program that causes a computer to implement a task modification function that creates a first task representing information about a sequence of actions, a second task representing information about a sequence of actions that satisfies the constraint of avoiding conflicts when at least some of the actions in the first task are executed in parallel by multiple agents, a plan parallelization function that determines the assignment of each action in the sequence of actions in the second task to the multiple agents, and a plan output function that controls the multiple agents to execute each action in the sequence of actions in the second task according to the determined assignment.

10. A prioritized control program executed in a prioritized control device comprising a task input unit, an agent selection unit, a task extraction unit, a reservation addition unit, a parallel planning unit, a plan storage unit, and a plan output unit, wherein the program causes a computer to execute the following: a process in which the task input unit accepts input of tasks for a plurality of agents for which parallel actions should be planned; a process in which the agent selection unit selects an agent from the plurality of agents to perform planning; a process in which the task extraction unit removes actions and goals relating to agents other than those selected by the agent selection unit from the tasks input to the task input unit; a process in which the reservation addition unit adds actions included in the planned parallel action sequence stored in the plan storage unit and the planned goals for each agent to the tasks output by the task extraction unit; a process in which the parallel planning unit outputs a parallel action sequence using the tasks modified by the task extraction unit and the reservation addition unit as input; a process in which the plan storage unit stores the parallel plan output by the control device, the planned agents and their goals; and a process in which the plan output unit outputs the parallel action sequence for all agents to the plurality of agents for the control of the plurality of agents.

Images