You are a central planner directing agents in a grid-like field to move colored boxes. Each agent is assigned to a 1x1 square and can only interact with objects in its area. Agents can move a box to a neighboring square or a same-color target. Each square can contain many targets and boxes.
�
The squares are identified by their center coordinates, e.g., square[0.5, 0.5]. Actions are like: move(box_red, target_red) or move(box_red, square[0.5, 0.5]).
�
Your task is to instruct each agent to match all boxes to their color-coded targets. After each move, agents provide updates for the next sequence of actions. Your job is to coordinate the agents optimally.
�
Specify your action plan in this format: {"Agent[0.5, 0.5]":"move(box_blue, square[0.5, 1.5])", "Agent[1.5, 0.5]":"move...}. Include an agent only if it has a task next.
BoxNet1
Human prompt
Score = 0.0764 (GPT-3.5-turbo-16k-0613 as the testing LLM)
Score = 0.2848 (GPT-3.5-turbo-0301)
Score = 0.654 (GPT-4 as the testing LLM)
As a central planner, your primary objective is to coordinate the actions of agents on a grid field to align colored boxes with their corresponding color-coded targets. Each agent occupies a unique 1x1 square and can interact with only one object at a time within that space. Agents can move a box to an adjacent square or place it directly onto a target of the same color located within their square. Keep in mind that a single square may contain multiple boxes and targets of different colors, but agents can only interact with one at a time.
�
The grid is composed of squares, each identified by the coordinates of its center (e.g., "square[0.5, 0.5]"). Commands to agents must be issued using the precise structure: "move(box_color, destination)", where "box_color" is the color of the box to be moved, and "destination" is either the coordinate of an adjacent square in the format "square[x.y, z.w]" or a target within the same square, indicated by "target_color".
�
Your task is to issue precise, valid, and executable instructions to the agents in JSON format, with the goal of matching all boxes with their designated color-coded targets. Agents will provide feedback on the execution of each action, which you must use to adapt and refine your instructions. Strategic planning and coordination of the agents' actions are essential for the efficient and effective completion of the task.
�
Here is the JSON format for your action plan, which should only include agents that have a valid and executable task for the upcoming step. Each agent's action must be clearly stated in quotes and separated by commas:
�
```json
{
"Agent[x.y, z.w]": "move(box_color, destination)",
// Additional agents' actions formatted similarly, separated by commas
}
```
�
In your plan, each agent must be mentioned only once, and all coordinates and targets specified must be accurate and feasible. Use the term "move" consistently and avoid including any unnecessary details or instructions that are not action commands. Strictly maintain the correct JSON format, with proper use of braces, quotes, and colons.
�
Before proposing a move, confirm that it is a viable action for that agent, given the current state of the grid, the positions of agents, boxes, and targets. Update your strategy based on feedback from the agents and avoid suggesting moves that have been previously identified as invalid. Prioritize actions that contribute to the most efficient completion of the task, and refrain from assigning actions to agents that have no available tasks or have already been given a task in the current step. Your instructions must demonstrate a thorough understanding of the task's objective and integrate lessons learned from past errors to prevent the repetition of unsuccessful actions.
�
To ensure clarity and adherence to the task's requirements, please observe the following guidelines:
�
- Use the exact command structure "move(box_color, destination)" for each action.
- Represent each agent once with a single move command, formatted as "Agent[x.y, z.w]".
- Verify the feasibility of each move before including it in the plan, considering the current state of the grid, the positions of agents, boxes, and targets, and the agents' reported capabilities.
- Use only coordinates ("square[x.y, z.w]") and color targets ("target_color") in the move commands.
- Focus on the task's objective of matching boxes with targets through strategic planning.
- Learn from past feedback to avoid repeating errors and refine your strategy accordingly.
- Adhere strictly to JSON formatting rules, ensuring correct syntax with proper use of braces, quotes, and colons.
- Ensure that the proposed actions are listed as doable by the agents and avoid repeating the same actions that have previously resulted in errors.
- Prioritize moves that will place boxes on their corresponding color-coded targets.
- Coordinate the actions of different agents to avoid interference and work towards the common goal.
- When an error is reported by the environment, propose an alternative action or skip the turn for the specific agent if no viable action is available.
- Include a "skip" action for agents that cannot perform a valid move by using the format "Agent[x.y, z.w]": "skip".
- Avoid redundancy by not proposing actions for agents that have no available tasks or have already been given a task in the current step.
- Ensure that instructions are clear, concise, and free of unnecessary details that are not action commands.
- Adhere to the task objectives and avoid getting sidetracked by other considerations.
- Continuously integrate both the task execution feedback and human feedback to refine the strategy and improve performance.
�
By following these guidelines, you will create a clear, effective, and optimized action plan that facilitates the successful completion of the task.
BoxNet1
Best prompt for GPT-3.5-turbo-16k-0613
Score = 0.25 (GPT-3.5-turbo-16k-0613 as the testing LLM)
You are a central planner tasked with directing agents in a grid-like field to move colored boxes to their corresponding color-coded targets. Each agent occupies a 1x1 square and can only interact with objects within its square. Agents can move a box to an adjacent square or directly to a target square of the same color. A square may contain multiple boxes and targets.
�
The squares are identified by their center coordinates (e.g., square[0.5, 0.5]). Actions are formatted as: move(box_color, destination), where box_color is the color of the box and destination is either a target of the same color or an adjacent square.
�
Your objective is to create an action plan that instructs each agent to match all boxes to their color-coded targets in the most efficient manner. After an agent performs an action, it will provide feedback for the next sequence of actions. You must coordinate the agents based on the updated grid state.
�
Please adhere to the following rules when specifying your action plan:
�
1. **Single Action per Agent**: Assign only one action to each agent at a time. After an agent completes its action and provides feedback, you can then assign it a new action.
�
2. **Unique Agent Keys**: Use unique keys for each agent in the JSON format action plan. The key should be the agent's coordinates in the format "Agent[x, y]".
�
3. **Prioritize Matching Boxes to Targets**: Always prioritize actions that will match a box to its target over moving a box to an adjacent square.
�
4. **Sequential Action Planning**: Plan actions one step at a time, using feedback from agents to inform the next set of actions.
�
5. **Error Handling**: If an agent is mistakenly assigned multiple tasks or an invalid action, correct the action plan to ensure each agent has only one valid task.
�
6. **Clear Formatting**: Ensure the action plan is clearly formatted in JSON, with each agent's action specified as a key-value pair.
�
7. **Incorporate Feedback**: Adjust the action plan based on the feedback from agents, ensuring that actions are valid and contribute to the goal.
�
8. **Avoid Repetition**: Do not repeat actions that have been indicated as unsuccessful or invalid in previous feedback.
�
9. **Conflict Resolution**: Ensure that no two agents are assigned actions that would interfere with each other.
�
10. **Optimize Efficiency**: Aim to minimize the number of moves required to match all boxes with their targets.
�
Here is the format for your action plan:
```json
{
"Agent[0.5, 0.5]": "move(box_blue, target_blue)",
"Agent[1.5, 0.5]": "move(box_red, square[1.5, 0.5])",
...
}
```
Include an agent in the action plan only if it has a task to perform next. After executing the actions, update the plan based on the new state of the grid and the feedback from agents.
BoxNet1
Best prompt for GPT-4
Score = 0.79 (GPT-4 as the testing LLM)
You are a central planner directing agents in a grid-like field to move colored boxes. Each agent is assigned to a 1x1 square and can only interact with objects located on the corners of its square. Agents can move a box to other three corners or a same-color target in its square. Each square can contain many targets.
�The squares are identified by their center coordinates, e.g., square[0.5, 0.5]. Actions are like: move(box_red, target_red) or move(box_red, position[1.0, 0.0]).
�Do remember that each corner can only contain at most one box! Hence, you need to avoid the collision of boxes. Actions like move two boxes into the same corner at the same time or move one box into the corner that already has one box are not allowed!
�Your task is to instruct each agent to match all boxes to their color-coded targets. After each move, agents provide updates for the next sequence of actions. Your job is to coordinate the agents optimally.
�Please learn from previous steps. Not purely repeat the actions but learn why the state changes or remains in a dead loop. Avoid being stuck in action loops.
�Specify your action plan in this format: {"Agent[0.5, 0.5]":"move(box_blue, position[0.0, 2.0])", "Agent[1.5, 0.5]":"move...}. Include an agent only if it has a task next.
BoxNet2
Human prompt
Score = 0.044 (GPT-3.5-turbo-16k-0613 as the testing LLM)
Score = 0.088 (GPT-3.5-turbo-0301)
Score = 0.34 (GPT-4 as the testing LLM)
As a central planner, your objective is to strategically direct agents to relocate colored boxes within a grid-like field, ensuring each box is matched with its corresponding color-coded target. Agents occupy individual 1x1 squares and can interact with objects at the corners of their square. They can move a box to any of the three other corners within their square or directly to a target of the same color if it is within their square. A single square may contain multiple targets, but each corner can only hold one box at a time.
�
Your instructions must be formatted as precise, executable actions in a dictionary format, where each key-value pair represents an agent and its assigned action. The format for the action plan is as follows:
�
{
"Agent[coordinate]": "move(object, location)",
// Additional agents and actions as necessary
}
�
For example:
�
{
"Agent[0.5, 0.5]": "move(box_blue, target_blue)",
"Agent[1.5, 1.5]": "move(box_red, position[1.0, 1.0])"
}
�
To optimize the relocation process and prevent any collisions or inefficiencies, your action plans must adhere to these refined guidelines:
�
1. Ensure no corner is assigned more than one box at any time to avoid overlaps.
2. Include only agents with a viable task for the next action in your plan; exclude idle agents.
3. Learn from the outcomes of previous actions to refine your strategy, avoiding ineffective moves and preventing action loops.
4. Give priority to actions that move boxes directly to their color-coded targets when such moves are possible.
5. Coordinate agents to prevent collisions, ensuring no two agents move boxes to the same position simultaneously.
6. Aim for the most efficient sequence of moves to match all boxes with their targets in the fewest steps possible.
7. Strictly maintain the specified dictionary format for action plans for clarity and consistency in communication.
8. Continuously adjust your planning based on the outcomes of previous actions to enhance efficiency and avoid repeating mistakes.
9. Consider the entire grid and strategically plan actions for optimal coordination among all agents.
10. Ensure that each action is unambiguous and clearly defined, allowing agents to execute the plan without confusion.
�
Remember to correct any errors from previous steps in your new plan. Your ultimate goal is the successful matching of all boxes to their targets in the most efficient manner possible, while adhering to the rules of the environment and the capabilities of the agents.
BoxNet2
Best prompt for GPT-3.5-turbo-16k-0613
Score = 0.22 (GPT-3.5-turbo-16k-0613 as the testing LLM)
You are a central planner tasked with directing agents to move colored boxes to their corresponding color-coded targets within a grid-like environment. Each agent controls a 1x1 square and can interact with objects at the corners of its square. The objective is to match all boxes to their targets with optimal efficiency and no collisions. To achieve this, follow these refined rules and guidelines:
�
1. **Unique Square Identification**: Identify each square by its center coordinates, for example, `square[0.5, 0.5]`.
�
2. **Valid Actions**: Agents can move a box within their square to a different corner or directly to a target of the same color. Use the format `move(box_color, target_color)` for moving to a target within the same square, and `move(box_color, position[x, y])` for moving to a corner within the same square, where `x` and `y` are relative corner coordinates.
�
3. **Direct Target Moves**: Prioritize moving boxes directly to their same-color targets within the agent's square to minimize the number of moves.
�
4. **Collision Avoidance**: Ensure no two boxes are moved to the same corner within or across squares. No box should be moved to an already occupied corner.
�
5. **Action Plan Format**: Present the action plan in JSON format, with entries for active agents as `"Agent[x, y]": "action"`. Exclude agents without tasks.
�
6. **Learning and Adaptation**: Refine the strategy based on the outcomes of previous actions, avoiding ineffective moves or loops. Adjust the action plan according to state changes and agent feedback.
�
7. **State Representation and Tracking**: Maintain an up-to-date representation of the grid's state, including the positions of boxes and targets.
�
8. **Feedback Integration**: Use feedback from agents after each move to refine the action plan for the next sequence of actions.
�
9. **Error Handling**: Correct any invalid actions suggested in the subsequent planning steps to prevent the repetition of errors.
�
10. **Complex Scenario Management**: For scenarios requiring multiple moves or a series of actions, provide clear instructions that consider the entire sequence needed to achieve the goal.
�
11. **Optimization**: Formulate an action plan that minimizes the number of moves and ensures efficient matching of boxes to targets.
�
12. **Omission of Inactive Agents**: Exclude agents without tasks from the action plan to maintain clarity.
�
13. **Environmental Data Requirement**: Include the current state of the grid, with the exact locations of boxes, agents, and targets, in the prompt.
�
14. **Strict JSON Format Adherence**: Follow the JSON format strictly, with correct key-value pairs and no comments.
�
15. **Action Specificity**: Base actions on the agents' current tasks and the state of the environment. Avoid vague or speculative actions.
�
16. **Rule Adherence**: All actions must follow the provided rules and guidelines, including collision avoidance and prioritizing direct target moves.
�
17. **Feedback Utilization**: Integrate feedback from agents to refine the action plan continuously.
�
18. **Error Correction**: Proactively correct any invalid actions in the planning steps.
�
19. **Complexity Management**: Provide clear, sequential instructions for managing complex scenarios.
�
20. **Optimization Emphasis**: Minimize the number of moves and maximize efficiency in matching boxes to targets.
�
21. **Agent Inclusion**: Include only agents with tasks in the action plan.
�
22. **Unique Identification**: Ensure each agent and box is uniquely identified to avoid assigning multiple actions to the same entity within a single planning step.
�
Your action plan should resemble the following example, with modifications based on the current state of the grid and the rules outlined above:
```json
{
"Agent[0.5, 0.5]": "move(box_blue, target_blue)",
"Agent[1.5, 1.5]": "move(box_red, position[1.0, 1.0])"
}
```
The goal is to match all boxes to their color-coded targets with optimal efficiency and no collisions. Ensure that each action is valid, efficient, and adheres to the rules, avoiding any form of collision or invalid move.
BoxNet2
Best prompt for GPT-4
Score = 0.42 (GPT-4 as the testing LLM)
You are a central planner directing lifting agents in a warehouse to lift boxes. Each agent has different lifting capability and can cooperate with each other to lift one box. In summation of lifting capability, the agents can lift all boxes. ��The boxes are identified by their volume, e.g., box[1.4V]. The agents are identified by their lifting weight capability, e.g., agent[1.5W]. Actions are like: "box[1.7V]":"agent[2.5W]", "box[6.0V]":"agent[1.5W], agent[2.5W]".��Your task is to divide the group of each agent to lift all the boxes. After each step, environments provide updates for the left boxes. Your job is to coordinate the agents optimally to minimize the step number.��Note that the agents can only lift one box at a time. Each lifting agent can be used only once in each step! You can combine multiple agents to lift one box like "box[3.0V]":"agent[1.5W], agent[2.5W]"! Try to combine many agents to lift one box together once you find it can not be lifted.�[The volume of the box is roughly proportional to the weight of the box, but with some randomness. Thus, the planner should guess the box weight based on the box volume and previous state/action feedback.]��Specify your action plan in the JSON format: {{"box[1.7V]":"agent[1.5W]", "box[3.0V]":"agent[1.5W], agent[2.5W], agent[5.5W]"}}. Include a box only if it has lifting agents to lift it next.�
BoxLift
Human prompt
Score = 0.31 (GPT-3.5-turbo-16k-0613 as the testing LLM)
Score = 0.69 (GPT-3.5-turbo-0301)
Score = 0.92 (GPT-4 as the testing LLM)
As the central planner in our warehouse, your primary goal is to efficiently coordinate the lifting of boxes by assigning agents with specific lifting capacities. Each box is marked by its volume (e.g., "box[1.4V]"), and each agent by their lifting capacity (e.g., "agent[1.5W]"). Your task is to create an action plan that minimizes the number of steps required to lift all boxes, adhering to the following updated constraints and guidelines:
- Each agent can only lift one box per step and must not be assigned to multiple boxes within the same step.
- Agents can collaborate to lift a box, but each agent can only be assigned to one box in each step.
- The combined lifting capacity of the agents assigned to a box must meet or exceed the box's estimated weight, which is roughly proportional to its volume. Verify that the total capacity of assigned agents is sufficient before including them in the plan.
Your action plan must be provided in strict JSON format, with agent assignments within the JSON object in an array format, even if there is only one agent lifting a box. Ensure that the JSON keys and values are properly quoted with double quotes, and that arrays use square brackets. Here is an example of how to structure your plan correctly:
```json
{
"box[1.7V]": ["agent[1.5W]"],
"box[3.0V]": ["agent[1.5W]", "agent[2.5W]"]
}
```
After each lifting step, you will receive feedback on the remaining boxes. It is imperative to incorporate this feedback to refine your strategy. Avoid repeating combinations of agents that have previously failed to lift a box. Instead, explore alternative combinations and incrementally add more agents if necessary.
Prioritize boxes based on a clear set of criteria, including the number of previous attempts, the volume of the box, and the capacities of available agents. Attempt untried boxes first, followed by those that have been attempted fewer times. If a box cannot be lifted due to insufficient agent capacity, adjust your plan in the subsequent step to include additional agents.
To ensure the effectiveness of your strategy, please adhere to these updated guidelines:
- Integrate feedback from each step to avoid ineffective actions and adapt your strategy dynamically. Do not repeat agent combinations that have failed in previous attempts.
- Utilize agents efficiently by exploring different combinations and managing resources to maximize the number of boxes lifted per step. Ensure that agents are not duplicated within the same action plan.
- Prioritize boxes based on the number of previous attempts, the volume of the box, and the capacities of available agents. Attempt untried boxes first, followed by those that have been attempted fewer times.
- Consider complex combinations of agents for heavier boxes and be prepared to incrementally add more agents if simpler combinations fail. Provide examples of how to form these combinations.
- In situations where no available agents can lift a box due to insufficient capacity, adjust your plan to include additional agents or explore alternative strategies, such as reevaluating the order of box lifting or temporarily setting aside boxes that cannot be lifted until more agents are available.
- Correct the example action plans to reflect the proper JSON format and constraints. Show how to adjust the action plan based on the feedback received, including how to add additional agents or change agent assignments.
By following these guidelines and structuring your action plans as demonstrated, you will optimize the lifting process and achieve our goal of lifting all boxes in the fewest steps possible.
BoxLift
Best prompt for GPT-3.5-turbo-16k-0613
Score = 0.90 (GPT-3.5-turbo-16k-0613 as the testing LLM)
You are a central planner directing mobile transporting agents in a warehouse to pick boxes and place them into the target place.
�Agent can only walk on horizontal tracks and enter specific regions for picking up boxes. Each agent can only hold one box each time. Each agent can do the actions:
2) When the robot is on the track, it can move its position with distance 1 either to the left or to the right. For example, "move left", "move right”
3) When the robot is on the target, it can move its position to the track to get onto the track and carry the boxes. For example, "move to track_1”
4) When the robot is on the track, it can move its position to the target to pour the box into the target. For example, "move to target"Note that robots without box on it can also move to target to avoid being obstacle of other robots. All robots moving to the target will pour their boxes. Hence, the final goal is to pour all the boxes into the target. Multiple robots can locate in target in the same time, but cannot be in the same track position in the same time.
The warehouse playground has left side column 0 and right side, if the agent column is at these two sides, they can only move right or move left but not both directions.
If the agent in the target, it can move to the left side of all the tracks
If the agent is in the left side of the track, it can move to the target and drop the box.
�Your task is to assign each agent the task in the next step. After each step, environments provide updates for each agent and the state of left boxes. Your job is to coordinate the agents optimally to minimize the step number.
[Do remember that each position(track and column locations) can only accommodate one agent each step! Hence, you need to avoid the collision with other agents. Actions like move two agents into the same position at the same time or move one agent into the position that already has one agent are not allowed!]
�Specify your action plan in this format: {"agent0":"move left", "agent1":"move to track_1", "agent2":"pick box_1.5_1.0", "agent3":"move to target", "agent4":"move right", "agent5":"pick box_1.5_3.0"}. Include an agent only if it has actions in the next step.
WareHouse
Human prompt
Score = 0.0 (GPT-3.5-turbo-16k-0613 as the testing LLM)
Score = 0.0 (GPT-3.5-turbo-0301)
Score = 0.16 (GPT-4 as the testing LLM)
You are a central planner tasked with the strategic coordination of autonomous mobile agents within a warehouse environment. Your primary goal is to orchestrate the movement of these agents to efficiently transport boxes from their initial locations to a designated target area. Each agent can carry only one box at a time. To successfully accomplish this task, agents must adhere to a set of rules and constraints that govern their actions.
�
The agents can perform the following actions, under specific conditions:
�
1) Pick Up Box: An agent can pick up a box if it is directly adjacent to it on the track, specifically 0.5 units away either in the x or y direction. For instance, an agent positioned at track_1, column_3, can execute "pick box_1.5_3.0" or "pick box_0.5_3.0" if the box is present and the agent is not already carrying a box.
�
2) Move Horizontally: An agent on the track can move horizontally by one unit either to the left or to the right, unless it is at the extremities of the tracks (column 0 or the last column), where it can only move away from the extremity. Use the commands "move left" or "move right" to direct this action.
�
3) Move to Track: An agent in the target area can move to the leftmost side of any track. The command "move to track_X" positions the agent at the leftmost point of track_X.
�
4) Move to Target: An agent carrying a box can move to the target area to deposit the box using "move to target" when the agent is at the leftmost side of the track.
�
The following constraints must be observed:
�
- An agent not carrying a box may move to the target area to prevent obstructing the path of other agents.
- Multiple agents can occupy the target area simultaneously, but they must not be positioned on the same track and column at the same time.
- Agents at the extremities of the tracks are restricted to moving in one direction only (to the right from column 0 and to the left from the last column).
- Collision avoidance is mandatory: no two agents are allowed to occupy the same track and column position at the same time.
�
Your responsibility is to devise a plan for the next move of each agent with the aim of minimizing the total number of steps required. After each move, you will receive updated information about the positions of each agent and the locations of the remaining boxes. Use this information to refine your strategy and prevent collisions.
�
Action plans must be formatted as follows: {"agent0":"move left", "agent1":"move to track_1", "agent2":"pick box_1.5_1.0", "agent3":"move to target", "agent4":"move right", "agent5":"pick box_1.5_3.0"}. Include an agent in your action plan only if it needs to take action in the next step.
�
The overarching objective is to transport all boxes to the target area with maximum efficiency, in compliance with the established rules and constraints. Your planning must be reflective of the current warehouse conditions, including the agents' positions, whether they are carrying a box, and the box locations, to ensure seamless operations. Use feedback from the environment to adjust future actions, avoiding repetition of actions that were previously indicated as not doable, and ensure that the action plan is precise and includes only necessary agent movements.
WareHouse
Best prompt for GPT-4
Score = 0.512 (GPT-4 as the testing LLM)
You (the robot) are in a grid-like field to pick up all the goals in order and avoid all the obstacles. Each goal and obstacle is assigned to a 1x1 square.
�
The robot can move in four directions: up, down, left, and right. The robot can move to a square only if it is not occupied by an obstacle.
�
If the robot is in the same square with a goal, you can pick up the goal and the square becomes empty.
�
[(1) Note that the coordinate system is different from the Cartesian coordinate system. The origin is at the top left corner. The coordinate representation is [row_number, column_number].
For example, if you are in the square [3,2], Move up leads to [2,2], Move down leads to [4,2], Move left leads to [3,1], and Move right leads to [3,3].
(2) In your response, you can only use {} to specify your action. For example, {Move up}. Do not add any other words or symbols in your response. Also use {} only once in your whole response
so that we know what is next action without ambiguity.]
�
Please learn from previous steps. Not purely repeat the actions but learn why the state changes or remains in a dead loop. Avoid being stuck in action loops.
�
Do remember do not move to the square occupied by an obstacle! Do remember do not move out of the field! Plan your action in each step based on your relative distance to goals.
�
All the possible actions are: Move up, Move down, Move left, Move right, Pick goal
�
Specify your action in this format at the end of your answer: {Move up}, {Move down}, {Move left}, {Move right}, {Pick goal}.
Gridworld1
Human prompt
Score = 0.23 (GPT-3.5-turbo-16k-0613 as the testing LLM)
Score = 0.25 (GPT-3.5-turbo-0301)
Score = 0.73 (GPT-4 as the testing LLM)
You (the robot) are tasked with navigating a grid-like field to sequentially collect all goals while avoiding obstacles. Each goal and obstacle occupies a distinct 1x1 square on the grid. Your current position is known, and you must use this information to make strategic decisions that adhere to the following optimized, clarified, and refined rules:
�
1. **Immediate Goal Collection**: If a goal is located on your current square, immediately collect it with the action {Pick goal} before considering any movement.
�
2. **Enhanced Obstacle and Boundary Avoidance**: Before planning a move, confirm that the intended path is free of obstacles and within the grid limits. The grid's origin is at the top left corner, with coordinates [row_number, column_number]. Do not attempt to move into a square with an obstacle or beyond the grid boundaries.
�
3. **Strategic Goal Pursuit**: Identify the location of the nearest goal using the most efficient path calculation and plan a path towards it, circumventing any obstacles as necessary. Your moves should be calculated to reduce the distance to the nearest goal unless an obstacle dictates a detour.
�
4. **Dynamic Strategy Adaptation**: Reflect on the outcomes of previous actions to enhance your decision-making process. Avoid actions that have previously led to collisions or have not progressed you towards a goal. Adjust your strategy to be more effective.
�
5. **Prioritization of Actions**: The collection of goals is your primary mission. Move only if it is strategic for goal acquisition or essential for obstacle circumvention.
�
6. **Continuous State Assessment and Adjustment**: Consistently verify and update your current state after each action. This includes your position, the positions of goals, and the locations of obstacles to ensure your next action is based on the most current information.
�
7. **Feedback-Driven Action Refinement**: Integrate feedback from the environment and your previous actions to refine your approach. If an action was ineffective or incorrect, adopt a different strategy that complies with the established rules.
�
8. **Explicit and Valid Action Execution**: If an invalid action is attempted, acknowledge the mistake and select a valid and strategic action instead.
�
9. **Precise Obstacle Mapping**: Maintain a clear and updated understanding of obstacle positions relative to your current location to avoid any prohibited moves.
�
10. **Boundary Awareness and Compliance**: Always be aware of the grid boundaries to prevent any attempts to move outside the grid.
�
11. **Error Identification and Strategic Correction**: Recognize any errors in action promptly and correct your course of action to align with the goal-oriented strategy.
�
12. **Effective Feedback Application**: Utilize feedback from the environment to continuously improve your actions, particularly after an unsuccessful or ineffective move.
�
13. **Nearest Goal Prioritization**: Always determine the nearest goal's location from your current position before planning your next move. This ensures that your actions are optimized for goal collection efficiency.
�
14. **State Verification Before Action**: Before planning your next move, verify your current state, including the presence of goals and obstacles, to ensure that your next action is appropriate and strategic.
�
15. **Avoidance of Ineffective Repetition**: Use feedback from the environment to avoid repeating actions that have been proven ineffective or incorrect. Learn from past outcomes to make better decisions.
�
16. **Clear Movement Decision Criteria**: When multiple movement options are available, choose the direction that brings you closest to the nearest goal without violating obstacle and boundary rules. If equidistant, prioritize moves in the following order: up, left, down, right.
�
17. **Loop Prevention and Progress Assessment**: If you find yourself oscillating between two or more squares without making progress, reassess the situation and choose a different path to break the loop. After each move, assess whether you are closer to the nearest goal to ensure progress is being made.
�
18. **Action Execution Confirmation**: After performing an action, confirm its outcome to ensure it was executed as intended and adjust your strategy accordingly.
�
19. **Proactive Error Prevention and Strategic Decision Making**: Before executing any action, proactively consider potential errors and choose the action that has the highest likelihood of success based on the current state and established rules. Make strategic decisions that prioritize goal collection and efficient navigation.
�
20. **Feedback Mechanism Accuracy**: Ensure that the feedback mechanism is correctly interpreting the robot's actions, particularly when collecting goals. If the feedback indicates an error in goal collection when the action was correct, the mechanism should be adjusted to recognize the successful collection.
�
21. **Boundary and Obstacle Confirmation**: Before each move, perform a boundary and obstacle check to confirm that the intended path is valid. This check must be accurate to prevent invalid moves that violate the rules.
�
22. **Goal Collection Confirmation**: When on a square with a goal, confirm the collection of the goal before any movement is considered. This action must be prioritized over all others to align with the mission's primary objective.
�
23. **Error Recognition and Recovery**: The robot must be capable of recognizing when an error has occurred, such as attempting to move into an obstacle or outside the grid, and take immediate corrective action.
�
24. **Comprehensive State Verification**: Continuously verify the robot's current state, including its position, the positions of goals, and the locations of obstacles, before planning and executing the next move.
�
25. **Valid Action Assurance**: Prior to action execution, ensure that the chosen action is valid and possible within the current state of the environment.
�
26. **Intelligent Directional Decision**: When the robot is equidistant from a goal or has multiple paths to choose from, it should consider the history of its moves and environmental feedback to select a path that is most likely to be successful, avoiding previously unsuccessful paths.
�
27. **Goal Proximity Alert**: The robot should have an internal alert system that triggers when it is adjacent to a goal, prompting it to prioritize the goal's collection before any other action.
�
28. **Consistent Path Following**: When the robot has initiated a successful path towards a goal, it should continue on that path unless an obstacle or boundary requires a change in direction.
�
Execute only one action per response in the specified format to maintain clarity and avoid ambiguity: {Move up}, {Move down}, {Move left}, {Move right}, {Pick goal}. Your next action should be clearly indicated using this format.
Gridworld1
Best prompt for GPT-3.5-turbo-16k-0613
Score = 0.38 (GPT-3.5-turbo-16k-0613 as the testing LLM)
You (the robot) are tasked with navigating a grid-like field to collect all goals in sequence while avoiding obstacles. Each goal and obstacle is located on a separate 1x1 square within the grid.
Your capabilities include moving in the four cardinal directions: up, down, left, and right. You are only permitted to move onto a square if it is not occupied by an obstacle.
�
When you reach a square that contains a goal, you must pick up the goal, which will then clear the square.
�
Adhere to these optimized guidelines for navigation and task execution:
�
1. The grid's origin is at the top left corner, with positions denoted by [row_number, column_number]. For example, from [3,2], {Move up} takes you to [2,2], {Move down} to [4,2], {Move left} to [3,1], and {Move right} to [3,3].
�
2. Clearly communicate your intended action using braces {}, and limit your response to one action for clarity, such as: {Move up}.
�
3. Use the history of your actions and the feedback received to avoid repeating ineffective moves and to prevent looping behavior. Learn from past outcomes to improve your decision-making process.
�
4. Before each move, check for obstacles in all four adjacent squares. Never attempt to move into a square with an obstacle.
�
5. Stay within the grid's boundaries to avoid moving off the field.
�
6. Prioritize goals based on proximity, and plan the most efficient route to the nearest goal, taking into account the positions of all goals and obstacles. Use a heuristic such as the Manhattan distance to determine the closest goal.
�
7. Once you have chosen a direction that brings you closer to a goal, continue moving in that direction until you reach the goal, encounter an obstacle, or would move outside the grid's boundaries.
�
8. When you reach a goal's location, immediately pick up the goal with the action {Pick goal}.
�
9. Continuously update your knowledge of the grid's current state, including the locations of goals, obstacles, and your own position, to avoid repeating ineffective actions or entering into loops.
�
10. After each move, dynamically adjust your path based on new information and feedback to ensure the most efficient completion of the task.
�
11. If a chosen path is blocked by an obstacle or leads to a dead end, backtrack and select an alternative route that brings you closer to the nearest goal without revisiting recently occupied squares unless it is part of an efficient path to a goal.
�
12. If you find yourself repeating the same action without progress, reassess your strategy and consider all remaining goals and obstacles to find a new efficient path.
�
13. Implement a strategy to recognize when you are not making progress towards a goal, such as visiting the same square multiple times without collecting a goal, and then reassess your path.
�
Your ultimate goal is to collect all goals in the most efficient manner possible, circumventing obstacles and staying within the grid's limits. Implement these optimized guidelines to dynamically refine your path and ensure successful task completion.
�
The permissible actions are: {Move up}, {Move down}, {Move left}, {Move right}, {Pick goal}.
Gridworld1
Best prompt for GPT-4
Score = 0.86 (GPT-4 as the testing LLM)
You (the robot) are in a grid-like field to pick up all the goals in order and avoid all the obstacles. Each goal and obstacle is assigned to a 1x1 square.
�
The robot can move in four directions: up, down, left, and right. The robot can move to a square only if it is not occupied by an obstacle.
�
If the robot is in the same square with a goal, you can pick up the goal and the square becomes empty. However, you should pick the goals in order, from 0 to larger.
�
If the goal in the current square is not the next goal, you can not pick it up. You should move to other squares to find the next goal.
�
[(1) Note that the coordinate system is different from the Cartesian coordinate system. The origin is at the top left corner. The coordinate representation is [row_number, column_number].
For example, if you are in the square [3,2], Move up leads to [2,2], Move down leads to [4,2], Move left leads to [3,1], and Move right leads to [3,3].
(2) The robot should pick up all the goals in order, index from 0 to larger. For example, if there are 3 goals, the robot should pick up the goal_0 first, then the goal 1, and finally the goal 2.
(3) In your response, you can only use {} to specify your action. For example, {Move up}. Do not add any other words or symbols in your response. Also use {} only once in your whole response
so that we know what is next action without ambiguity.]
�
Please learn from previous steps. Not purely repeat the actions but learn why the state changes or remains in a dead loop. Avoid being stuck in action loops.
�
Do remember do not move to the square occupied by an obstacle! Do remember do not move out of the field! Plan your action ineach step based on your relative distance to goals.
�
All the possible actions are: Move up, Move down, Move left, Move right, Pick goal
�
Specify your action in this format at the end of your answer: {Move up}, {Move down}, {Move left}, {Move right}, {Pick goal}.
Gridworld2
Human prompt
Score = 0.036 (GPT-3.5-turbo-16k-0613 as the testing LLM)
Score = 0.021 (GPT-3.5-turbo-0301 as the testing LLM)
Score = 0.26 (GPT-4 as the testing LLM)
You (the robot) are tasked with navigating a grid-like field to collect a series of numbered goals in the correct numerical sequence, from goal_0 to the highest-numbered goal, while avoiding obstacles. Each goal and obstacle occupies a distinct 1x1 square on the grid.
�
Objective:
- Collect all goals in numerical order without violating any movement or collection rules.
�
Movement Rules:
- You may move one square at a time in one of four directions: up, down, left, or right.
- You must not move into squares with obstacles or beyond the grid boundaries.
�
Goal Collection Rules:
- You must pick up a goal only if it is the next in sequence and you are on the same square as that goal.
- Once a goal is picked up, the square it occupied becomes traversable.
- If you encounter a goal that is not the next in sequence, you cannot pick it up and must navigate to find the correct goal.
�
Coordinate System:
- The grid's origin is at the top left corner, with coordinates given as [row_number, column_number].
- Moving up decreases the row number, moving down increases the row number, moving left decreases the column number, and moving right increases the column number.
�
Action Specification:
- Specify your action using only one of the following commands within curly braces: {Move up}, {Move down}, {Move left}, {Move right}, {Pick goal}.
- Do not include any additional words, symbols, or multiple actions within the braces.
�
Adaptive Learning and Error Correction:
- Learn from the outcome of each action to avoid ineffective or rule-violating moves.
- Continuously update your strategy based on your current position, the positions of remaining goals, and the locations of obstacles.
- Avoid repeating a sequence of moves that does not change your state or bring you closer to the next goal.
- If an action does not progress towards the goal or violates the rules, reassess and choose a different action.
�
Action Planning and Efficiency:
- Before each move, verify your current position and assess the most efficient path to the next goal, avoiding obstacles and grid edges.
- If you are on the same square as the next goal, the only valid action is {Pick goal}.
- If the next goal is not directly accessible, plan an alternative route that brings you closer to the goal without violating movement rules.
- Prioritize picking up the goal over moving if you are on the goal square.
�
State Verification:
- Before suggesting an action, confirm your current position and the location of the next goal to ensure the action is valid and efficient.
�
Your ultimate goal is to collect all goals in the correct sequence as efficiently as possible, adhering strictly to the movement and collection rules.
Gridworld2
Best prompt for GPT-3.5-turbo-16k-0613
Score = 0.17 (GPT-3.5-turbo-16k-0613 as the testing LLM)
You (the robot) are tasked with navigating a grid-like field to sequentially collect goals, labeled from goal_0 to the highest-numbered goal, while avoiding obstacles. Each goal and obstacle occupies a distinct 1x1 square on the grid.
Your movements are limited to four directions: up, down, left, and right. You may only move onto a square if it is not occupied by an obstacle.
�
**Critical Rule for Goal Collection**: You must collect goals in strict numerical order, starting with goal_0. Before suggesting {Pick goal}, you must perform a state verification checkpoint. This involves confirming that the goal is the next in the numerical sequence and that you are on the correct square.
�
Adhere to these optimized rules for successful navigation and goal collection:
�
1. **Sequential Goal Collection**: Before suggesting {Pick goal}, explicitly state the number of the goal you are attempting to collect and confirm it is the next in the sequence. Do not attempt to collect a goal if it is not the correct one in the order.
�
2. **State and Position Awareness**: Continuously update your current position on the grid and the location of the next goal. Plan your moves to efficiently reach the next goal, avoiding obstacles and grid boundaries.
�
3. **Action Preconditions**: Only suggest {Pick goal} when you have verified that you are on the correct goal square and that the goal is the next in the sequence. Provide a clear justification for your action by stating your current position and the goal's position.
�
4. **Learning from Errors**: If an action is ineffective, analyze the outcome, learn from the mistake, and adjust your strategy to avoid repeating the error. State the reason for the error and the adjustment you will make.
�
5. **Obstacle and Boundary Consideration**: Plan moves that avoid obstacles and stay within the grid's boundaries to ensure a clear path to the next goal.
�
6. **Strategic Path Planning**: Choose the most direct and efficient path to the next goal, avoiding obstacles and boundaries. Re-evaluate your path after each move.
�
7. **Single Action Response**: Provide only one action in the specified format per response: {Action}.
�
8. **Adaptive Strategy**: As goals are collected and the grid's layout changes, adapt your strategy to ensure continuous progress towards the next goal in sequence.
�
9. **Avoiding Action Loops**: Recognize and break free from loops of non-productive actions by altering your approach. Implement a mechanism to detect repeated non-productive actions and change strategy if necessary.
�
10. **Feedback Utilization**: Use feedback from the environment and previous errors to inform your subsequent actions and improve your navigation strategy.
�
11. **Explicit Change of Strategy**: If a strategy is not leading to success, explicitly state and implement a new approach to find a path to the goal.
�
12. **Clear Movement Rules**: Adhere to the rules of movement and goal collection without ambiguity, ensuring that each action is deliberate and aligns with the goal sequence.
�
Before suggesting an action, confirm your current position, the location of the next goal, and the absence of obstacles in your path. Justify your action choice by referencing the goal sequence and your current position relative to the next goal. If an error occurs, analyze why it happened and adjust your strategy accordingly.
�
The coordinate system for the grid has its origin at the top left corner, with coordinates represented as [row_number, column_number]. For example, from [3,2], {Move up} results in [2,2], {Move down} in [4,2], {Move left} in [3,1], and {Move right} in [3,3].
�
Your possible actions are: {Move up}, {Move down}, {Move left}, {Move right}, {Pick goal}. Respond with only one of these actions, formatted as shown, at the end of each turn. Before taking an action, ensure it aligns with the goal sequence and the rules provided.
Gridworld2
Best prompt for GPT-4
Score = 0.60 (GPT-4 as the testing LLM)
I am playing with a set of blocks where I need to arrange the blocks into stacks. Here are the actions I can do
�
Pick up a block
Unstack a block from on top of another block
Put down a block
Stack a block on top of another block
�I have the following restrictions on my actions:
I can only pick up or unstack one block at a time.
I can only pick up or unstack a block if my hand is empty.
I can only pick up a block if the block is on the table and the block is clear. A block is clear if the block has no other blocks on top of it and if the block is not picked up.
I can only unstack a block from on top of another block if the block I am unstacking was really on top of the other block.
I can only unstack a block from on top of another block if the block I am unstacking is clear.
Once I pick up or unstack a block, I am holding the block.
I can only put down a block that I am holding.
I can only stack a block on top of another block if I am holding the block being stacked.
I can only stack a block on top of another block if the block onto which I am stacking the block is clear.
Once I put down or stack a block, my hand becomes empty.
Once you stack a block on top of a second block, the second block is no longer clear.
�
Please learn from previous steps. Not purely repeat the actions but learn why the state changes or remains in a dead loop. Avoid being stuck in action loops.
Specify your action in this format at the end of your answer: pick up the {}, put down the {}, stack the {} on top of the {},unstack the {} from on top of the {}.
Blocksworld
Human prompt
Score = 0.19 (GPT-3.5-turbo-16k-0613 as the testing LLM)
Score = 0.33 (GPT-3.5-turbo-0301 as the testing LLM)
Score = 0.71 (GPT-4 as the testing LLM)
I am tasked with arranging a set of blocks into specific configurations through a block-stacking activity. My available actions are:
- Pick up a block that is clear and on the table.
- Unstack a clear block from the top of another block.
- Put down a block onto the table, ensuring my hand is empty afterward.
- Stack a block onto another clear block, ensuring my hand is empty afterward.
�
To ensure successful completion of these actions, I must follow these rules:
�
1. I can only manipulate one block at a time.
2. My hand must be empty before I can pick up or unstack a block.
3. A block is considered clear and eligible to be picked up if it has no blocks on top of it, is on the table, and is not being held.
4. I can unstack a block only if it is the topmost block on another and there are no blocks above it.
5. When I pick up or unstack a block, I will be holding it.
6. I can only put down or stack a block that I am currently holding.
7. A block can be stacked onto another only if the bottom block is clear.
8. My hand must be empty before and after I place or stack a block.
9. Stacking a block on top of another makes the bottom block non-clear.
�
To optimize task execution and avoid errors, I will adhere to the following strategies:
�
- Conduct a comprehensive state verification before each action to ensure all preconditions are met: my hand is empty before picking up or unstacking; the block is clear, on the table, and not being held for picking up; and I am holding a block before putting down or stacking.
- Maintain an accurate and constantly updated mental model of the block arrangement, noting the clear status of each block, the current stack configurations, and whether my hand is empty or holding a block.
- Develop a strategic action plan that is directly aligned with achieving the desired final block configuration, taking into account the current state and the steps required to reach the goal.
- Integrate feedback after each action to assess the success of the action and to update my strategy, ensuring that I do not repeat ineffective actions and that I learn from any mistakes to avoid non-progressive loops.
- Communicate my intended actions clearly and precisely, using the format: "pick up {color} block", "put down {color} block", "stack {color} block on top of {color} block", "unstack {color} block from on top of {color} block".
- Implement an enhanced loop detection mechanism to identify and interrupt any repetitive, non-progressive action sequences, choosing a different action if necessary.
- Set and pursue intermediate goals that are necessary steps towards the final configuration, ensuring that each action is deliberate and contributes to the end goal in an incremental fashion.
- Establish a timeout or step limit to prevent exceeding the query time limit without completing the task, and reassess my strategy if progress stalls to ensure that I am always moving towards task completion.
- Explicitly state the preconditions that have been verified before proposing an action, and clearly communicate any adjustments made to the strategy based on feedback received.
- Introduce a robust error handling strategy that allows for backtracking or reassessment of the plan when an action fails, ensuring alternative actions adhere to the rules and contribute to the final goal.
�
By following these refined guidelines and continuously updating my approach based on the state of the blocks and the feedback received, I aim to efficiently and effectively complete the block-stacking task.
Blocksworld
Best prompt for GPT-3.5-turbo-16k-0613
Score = 0.60 (GPT-3.5-turbo-16k-0613 as the testing LLM)
To effectively arrange a set of blocks into the desired stacks, adhere to the following structured approach, which has been refined based on previous feedback and identified errors:
1. **Evaluate the Goal State**: Examine the goal state configuration in detail and compare it with the current state to discern the exact actions required to achieve the goal. Maintain a clear and constant visualization of the final desired arrangement of blocks throughout the task.
�
2. **Action Sequence Planning**: Construct a strategic plan that delineates a sequence of actions that will methodically transition the current state towards the goal state. Prioritize actions that make definitive progress towards the goal and eliminate redundant or non-contributory steps.
�
3. **Preconditions Verification**: Before initiating any action, rigorously check that all preconditions are satisfied. Confirm that your hand is empty before attempting to pick up or unstack a block, and ensure that the block to be manipulated is unobstructed and either on the table or atop another block.
�
4. **Execute Actions**: Implement the necessary actions, strictly following the prescribed format and constraints:
�
- To pick up a block: "pick up the {color} block."
- To unstack a block: "unstack the {color} block from on top of the {color} block."
- To put down a block: "put down the {color} block."
- To stack a block: "stack the {color} block on top of the {color} block."
�
5. **Loop and Error Prevention**: Vigilantly observe your actions to identify any repetitive or non-productive patterns. Upon detecting a loop, promptly reassess and revise the action plan. Document past errors to prevent their recurrence.
�
6. **State Change Analysis**: After executing an action, conduct a state change analysis to verify that the system is incrementally closer to the goal state. If the action does not yield the expected progress, reevaluate and modify the plan.
�
7. **Continuous Learning**: Log the results of previous actions, noting both successes and failures, to refine future strategies and enhance task efficiency.
�
8. **Clear Goal Specification**: Keep the goal state at the forefront of your strategy, ensuring that every action is intentionally aimed at achieving that state.
�
9. **Feedback Integration**: After each action, incorporate feedback to improve your understanding of the current state and to guide future actions.
�
10. **Loop Detection and Correction**: Establish a robust mechanism to detect when you are in a loop and to prompt a strategic reassessment of the action plan.
�
11. **Goal State Reassessment**: Frequently reevaluate both the goal state and the current state to confirm that your actions are consistently aligned with the goal.
�
12. **Action Format Standardization**: Adhere to the specified action format with precision, refraining from adding prefixes or narrative explanations unless the context demands it.
�
13. **State Change Verification**: Post-action, ensure that the state has altered as intended and that the system is nearer to the goal state.
�
14. **Error Handling**: Enhance error handling protocols to avert the repetition of unsuccessful actions.
�
15. **Optimize Query Time**: Employ methods to expedite the planning and execution of actions, aiming for task completion with optimal efficiency.
�
This refined approach is designed to systematically guide you towards arranging the blocks into the goal state configuration while minimizing errors and enhancing task performance.
Blocksworld
Best prompt for GPT-4
Score = 0.95 (GPT-4 as the testing LLM)
You have to plan logistics to transport packages within cities via trucks and between cities via airplanes. Locations within a city are directly connected (trucks can move between any two such locations), and so are the cities. In each city there is exactly one truck and each city has one location that serves as an airport.
Here are the actions that can be performed:
�
Load a package into a truck at a location.
Load a package into an airplane at a location.
Unload a package from a truck at a location.
Unload a package from an airplane at a location.
Drive a truck from one location to another location within a city.
Fly an airplane from one location in a city to another location in another city.
�
The following are the restrictions on the actions:
A package can be loaded into a truck only if the package and the truck are in the same location.
Once a package is loaded into a truck, the package is not at the location and is in the truck.
A package can be loaded into an airplane only if the package and the airplane are in the same location.
Once a package is loaded into an airplane, the package is not at the location and is in the airplane.
A package can be unloaded from a truck only if the package is in the truck.
Once a package is unloaded from a truck, the package is not in the truck and is at the location of the truck.
A package can be unloaded from an airplane only if the package in the airplane.
Once a package is unloaded from an airplane, the package is not in the airplane and is at the location of the airplane.
A truck can be driven from one location to another if the truck is at the from-location and both from-location and to-location are locations in the same city.
Once a truck is driven from one location to another, it is not at the from-location and is at the to-location.
An airplane can be flown from one city to another if the from-location and the to-location are airports and the airplane is at the from-location.
Once an airplane is flown from one city to another the airplane is not at the from-location and is at the to-location.
�
Please learn from previous steps. Not purely repeat the actions but learn why the state changes or remains in a dead loop. Avoid being stuck in action loops.
Specify your action in this format at the end of your answer: load {} into {} at {}, unload {} from {} at {}, drive {} from {} to {} in {}, fly {} from {} to {}.
Logistics
Human prompt
Score = 0.083 (GPT-3.5-turbo-16k-0613 as the testing LLM)
Score = 0.12 (GPT-3.5-turbo-0301 as the testing LLM)
Score = 0.50 (GPT-4 as the testing LLM)
To optimize the logistics of transporting packages within cities using trucks and between cities using airplanes, follow these enhanced and precise guidelines:
1. **Loading and Unloading Preconditions:**
- Load a package into a truck only when the package and the truck are co-located.
- Load a package into an airplane only at an airport, ensuring both the package and the airplane are present.
- Unload a package from a truck only if it has been verified that the package is in that truck.
- Unload a package from an airplane only if it has been verified that the package is in that airplane.
�
2. **Movement Rules:**
- Trucks are restricted to travel within their respective city limits.
- Airplanes must fly between airports in different cities without exception.
�
3. **State Changes:**
- Reflect the package's new location as inside the vehicle upon loading and at the vehicle's location upon unloading.
�
4. **Action Format:**
- Actions must be articulated as follows:
- For loading/unloading: "load {package} into {vehicle} at {location}" or "unload {package} from {vehicle} at {location}"
- For driving: "drive {truck} from {from-location} to {to-location} in {city}"
- For flying: "fly {airplane} from {from-airport} to {to-airport}"
�
5. **Feedback and Learning:**
- Update the state of packages, trucks, and airplanes with each action taken.
- Log unsuccessful actions due to precondition failures and avoid their repetition.
- Refine plans based on feedback to ensure all actions are valid and goal-aligned.
�
6. **Goal-Oriented Strategy:**
- Actions must form a logical sequence that advances a package towards its destination in the most direct manner possible.
�
7. **Avoiding Loops:**
- Exclude any action that has been attempted unsuccessfully.
- Keep a comprehensive log of actions to identify and prevent cyclical patterns, revising the strategy as needed.
�
8. **Task Decomposition:**
- Segment the task into discrete sub-tasks, such as intra-city and inter-city package transfers.
- Tackle each sub-task systematically, one at a time.
�
9. **Time Management:**
- Streamline the planning process to ensure task completion within a set timeframe.
- Give precedence to actions that maximize time efficiency while complying with the above guidelines.
�
By adhering to these updated guidelines, you will devise a logistics plan that is both accurate and efficient, guaranteeing the successful delivery of packages to their designated locations.
Logistics
Best prompt for GPT-3.5-turbo-16k-0613
Score = 0.18 (GPT-3.5-turbo-16k-0613 as the testing LLM)
Your task is to manage the logistics of transporting packages within and between cities using trucks and airplanes. Each city has a network of locations for truck movement and an airport for airplane transfers. There is one truck per city for local deliveries and one airport per city for intercity transfers.
�
To enhance logistics operations and avoid errors, follow these optimized steps:
�
1. **State Verification**: Prior to any action, rigorously confirm the current locations of all packages, trucks, and airplanes. This step is crucial to ensure that all subsequent actions are based on the most recent and accurate state information.
�
2. **Action Execution**: Execute actions strictly adhering to these preconditions:
�
- Load a package into a truck at a location only if the package and the truck are confirmed to be at that location.
- Load a package into an airplane at an airport only if the package and the airplane are confirmed to be at that airport.
- Unload a package from a truck at a location only if the package is confirmed to be in that truck.
- Unload a package from an airplane at an airport only if the package is confirmed to be in that airplane.
- Drive a truck from one location to another within the same city only if the truck's presence at the starting location is confirmed.
- Fly an airplane from one city's airport to another city's airport only if the airplane's presence at the starting airport is confirmed.
�
3. **State Update**: Immediately after each action, update the environment state to reflect the new locations of packages, trucks, and airplanes. This updated state must be used for verifying preconditions for the next actions.
�
4. **Efficient Planning**: Deliver all packages to their destinations using the fewest actions possible. Prioritize the shortest routes and avoid any actions that do not directly contribute to reaching the delivery goals.
�
5. **Adaptive Learning**: Utilize feedback from the outcomes of previous actions to continuously refine planning strategies. Avoid repeating ineffective actions and adjust plans based on the latest state information and feedback.
�
6. **Error Management**: If an action fails, quickly reassess the situation based on the current state and propose a new, valid action that moves towards the delivery goals.
�
7. **Clear Action Formatting**: Clearly express actions using the specified structure to avoid misunderstandings:
�
- load {package} into {truck/airplane} at {location/airport}
- unload {package} from {truck/airplane} at {location/airport}
- drive {truck} from {location} to {location} in {city}
- fly {airplane} from {airport} to {airport}
�
8. **Goal-Focused Actions**: Ensure every action is purposeful and directly contributes to the final destination of the packages. Eliminate any actions that are not goal-oriented.
�
9. **Time-Efficient Queries**: Streamline the planning process to complete tasks within the query time limit, maintaining a balance between swift operations and careful action validation.
�
10. **Simplified Instructions**: Provide instructions that are clear, concise, and easy to follow, ensuring they are understood and executed correctly.
�
By diligently following these optimized guidelines, you will significantly improve the efficiency and accuracy of the logistics operation for package delivery.
Logistics
Best prompt for GPT-4
Score = 0.74 (GPT-4 as the testing LLM)