Publications

@inproceedings{hofmannLTLfSynthesisFirstorder2025,
  title = {{{LTLf}} Synthesis on First-Order Agent Programs in Nondeterministic Environments},
  booktitle = {Proceedings of the 39th {{Annual AAAI Conference}} on {{Artificial Intelligence}} ({{AAAI}})},
  author = {Hofmann, Till and Cla{\ss}en, Jens},
  year = {2025},
  eprint = {2410.00726},
  doi = {10.1609/aaai.v39i14.33642},
  abstract = {We investigate the synthesis of policies for high-level agent programs expressed in Golog, a language based on situation calculus that incorporates nondeterministic programming constructs. Unlike traditional approaches for program realization that assume full agent control or rely on incremental search, we address scenarios where environmental nondeterminism significantly influences program outcomes. Our synthesis problem involves deriving a policy that successfully realizes a given Golog program while ensuring the satisfaction of a temporal specification, expressed in Linear Temporal Logic on finite traces (LTLf), across all possible environmental behaviors. By leveraging an expressive class of first-order action theories, we construct a finite game arena that encapsulates program executions and tracks the satisfaction of the temporal goal. A game-theoretic approach is employed to derive such a policy. Experimental results demonstrate this approach's feasibility in domains with unbounded objects and non-local effects. This work bridges agent programming and temporal logic synthesis, providing a framework for robust agent behavior in nondeterministic environments.},
  keywords = {Computer Science - Artificial Intelligence,Computer Science - Logic in Computer Science},
  url = {https://ml.rwth-aachen.de/~till.hofmann/papers/aaai25-ltlf-golog.pdf},
  url_Poster = {https://ml.rwth-aachen.de/~till.hofmann/papers/aaai25-ltlf-golog_poster.pdf},
  url_Slides = {https://ml.rwth-aachen.de/~till.hofmann/papers/aaai25-ltlf-golog_slides.pdf}
}

We investigate the synthesis of policies for high-level agent programs expressed in Golog, a language based on situation calculus that incorporates nondeterministic programming constructs. Unlike traditional approaches for program realization that assume full agent control or rely on incremental search, we address scenarios where environmental nondeterminism significantly influences program outcomes. Our synthesis problem involves deriving a policy that successfully realizes a given Golog program while ensuring the satisfaction of a temporal specification, expressed in Linear Temporal Logic on finite traces (LTLf), across all possible environmental behaviors. By leveraging an expressive class of first-order action theories, we construct a finite game arena that encapsulates program executions and tracks the satisfaction of the temporal goal. A game-theoretic approach is employed to derive such a policy. Experimental results demonstrate this approach's feasibility in domains with unbounded objects and non-local effects. This work bridges agent programming and temporal logic synthesis, providing a framework for robust agent behavior in nondeterministic environments.

@inproceedings{hofmannLearningGeneralizedPolicies2024,
  title = {Learning Generalized Policies for Fully Observable Non-Deterministic Planning Domains},
  author = {Hofmann, Till and Geffner, Hector},
  year = {2024},
  volume = {7},
  pages = {6733--6742},
  doi = {10.24963/ijcai.2024/744},
  abstract = {Electronic proceedings of IJCAI 2024},
  copyright = {All rights reserved},
  langid = {english},
  booktitle = {Proceedings of the 33rd {{International Joint Conference}} on {{Artificial Intelligence}} ({{IJCAI}})},
  url = {https://ml.rwth-aachen.de/~till.hofmann/papers/ijcai24-genfond.pdf},
  url_Slides = {https://ml.rwth-aachen.de/~till.hofmann/papers/ijcai24-genfond_slides.pdf},
  url_Poster = {https://ml.rwth-aachen.de/~till.hofmann/papers/ijcai24-genfond-poster.pdf}
}

Electronic proceedings of IJCAI 2024

@inproceedings{hofmannStrategySynthesisFirstorder2024,
  entrysubtype = {workshop},
  title = {Strategy Synthesis for First-Order Agent Programs over Finite Traces},
  booktitle = {Proceedings of the 35th {{Nordic Workshop}} on {{Programming Theory}} ({{NWPT}})},
  author = {Hofmann, Till and Cla{\ss}en, Jens},
  year = {2024},
  url = {https://ml.rwth-aachen.de/~till.hofmann/papers/nwpt2025-strategy-synthesis.pdf},
  url_Slides = {https://ml.rwth-aachen.de/~till.hofmann/papers/nwpt2025-strategy-synthesis_slides.pdf}
}

@inproceedings{tschescheUsingOfftheShelfDeep2024,
  title = {Using Off-the-Shelf Deep Neural Networks for Position-Based Visual Servoing},
  booktitle = {{{RoboCup}} 2024: {{Robot World Cup XXVII}}},
  author = {Tschesche, Matteo and Hofmann, Till and Ferrein, Alexander and Lakemeyer, Gerhard},
  year = {2024},
  url_Slides = {https://ml.rwth-aachen.de/~till.hofmann/papers/robocup2024-visual-servoing.pdf}
}

@inproceedings{viehmannWinningRoboCupLogistics2023,
  title = {Winning the~{{RoboCup Logistics League}} with Visual Servoing and Centralized Goal Reasoning},
  booktitle = {{{RoboCup}} 2022: {{Robot World Cup XXV}}},
  author = {Viehmann, Tarik and Limpert, Nicolas and Hofmann, Till and Henning, Mike and Ferrein, Alexander and Lakemeyer, Gerhard},
  year = {2023},
  pages = {300--312},
  publisher = {Springer International Publishing},
  address = {Cham},
  doi = {10.1007/978-3-031-28469-4_25},
  abstract = {The RoboCup Logistics League (RCLL) is a robotics competition in a production logistics scenario in the context of a Smart Factory. In the competition, a team of three robots needs to assemble products to fulfill various orders that are requested online during the game. This year, the Carologistics team was able to win the competition with a new approach to multi-agent coordination as well as significant changes to the robot's perception unit and a pragmatic network setup using the cellular network instead of WiFi. In this paper, we describe the major components of our approach with a focus on the changes compared to the last physical competition in 2019.},
  langid = {english},
  shorthand = {RoboCup22},
  url = {https://ml.rwth-aachen.de/~till.hofmann/papers/carologistics-2022-champions.pdf}
}

The RoboCup Logistics League (RCLL) is a robotics competition in a production logistics scenario in the context of a Smart Factory. In the competition, a team of three robots needs to assemble products to fulfill various orders that are requested online during the game. This year, the Carologistics team was able to win the competition with a new approach to multi-agent coordination as well as significant changes to the robot's perception unit and a pragmatic network setup using the cellular network instead of WiFi. In this paper, we describe the major components of our approach with a focus on the changes compared to the last physical competition in 2019.

@phdthesis{hofmannBridgingGapHighlevel2023,
  title = {Towards Bridging the Gap between High-Level Reasoning and Execution on Robots},
  author = {Hofmann, Till},
  year = {2023},
  address = {{Aachen, Germany}},
  url = {https://doi.org/10.18154/RWTH-2023-10508},
  abstract = {When reasoning about actions, e.g., by means of task planning or agent programming with Golog, the robot's actions are typically modeled on an abstract level, where complex actions such as picking up an object are treated as atomic primitives with deterministic effects and preconditions that only depend on the current state. However, when executing such an action on a robot it can no longer be seen as a primitive. Instead, action execution is a complex task involving multiple steps with additional temporal preconditions and timing constraints. Furthermore, the action may be noisy, e.g., producing erroneous sensing results and not always having the desired effects. While these aspects are typically ignored in reasoning tasks, they need to be dealt with during execution. In this thesis, we propose several approaches towards closing this gap. Based on a logic that combines the situation calculus with metric time and metric temporal logic, we model the robot platform with timed automata and temporal constraints to describe the connection between the high-level actions and the robot platform. We then describe two approaches towards transforming the high-level program. First, we view the transformation as a synthesis problem, where the task is to synthesize a controller that executes the program while satisfying the specification, independent of the environment's choices. We show that the synthesis problem is decidable, describe an algorithm to construct a controller, and evaluate the approach in two robotics scenarios. While this approach supports controlling arbitrary Golog programs against any specification with timing constraints, it does not scale well. For this reason, we describe a second approach based on some simplifying assumptions which allow us to view the transformation problem as a reachability problem on timed automata, which can be solved with state-of-the-art tools. We demonstrate the effectiveness and scalability of the approach in a number of scenarios. Finally, we turn towards noisy sensors and effectors. Based on DS, a probabilistic variant of the situation calculus that allows modeling the agent's degree of belief, we describe an abstraction framework for Golog programs with noisy actions. In this framework, a high-level and non-stochastic program is mapped to a more detailed and stochastic low-level program. As the high-level program is non-stochastic, we may use non-probabilistic reasoning methods such as task planning or classical Golog program execution. At the same time, by mapping the abstract actions to low-level programs, we may still deal with uncertainty during execution. We define a suitable notion of bisimulation that guarantees the equivalence between the high-level and low-level programs and demonstrate the approach with an example.},
  school = {RWTH Aachen University},
  keywords = {artificial intelligence,belief-based programs,cognitive robotics,Golog,knowledge representation,metric temporal logic,situation calculus,stochastic actions,synthesis,timed systems,verification}
}

When reasoning about actions, e.g., by means of task planning or agent programming with Golog, the robot's actions are typically modeled on an abstract level, where complex actions such as picking up an object are treated as atomic primitives with deterministic effects and preconditions that only depend on the current state. However, when executing such an action on a robot it can no longer be seen as a primitive. Instead, action execution is a complex task involving multiple steps with additional temporal preconditions and timing constraints. Furthermore, the action may be noisy, e.g., producing erroneous sensing results and not always having the desired effects. While these aspects are typically ignored in reasoning tasks, they need to be dealt with during execution. In this thesis, we propose several approaches towards closing this gap. Based on a logic that combines the situation calculus with metric time and metric temporal logic, we model the robot platform with timed automata and temporal constraints to describe the connection between the high-level actions and the robot platform. We then describe two approaches towards transforming the high-level program. First, we view the transformation as a synthesis problem, where the task is to synthesize a controller that executes the program while satisfying the specification, independent of the environment's choices. We show that the synthesis problem is decidable, describe an algorithm to construct a controller, and evaluate the approach in two robotics scenarios. While this approach supports controlling arbitrary Golog programs against any specification with timing constraints, it does not scale well. For this reason, we describe a second approach based on some simplifying assumptions which allow us to view the transformation problem as a reachability problem on timed automata, which can be solved with state-of-the-art tools. We demonstrate the effectiveness and scalability of the approach in a number of scenarios. Finally, we turn towards noisy sensors and effectors. Based on DS, a probabilistic variant of the situation calculus that allows modeling the agent's degree of belief, we describe an abstraction framework for Golog programs with noisy actions. In this framework, a high-level and non-stochastic program is mapped to a more detailed and stochastic low-level program. As the high-level program is non-stochastic, we may use non-probabilistic reasoning methods such as task planning or classical Golog program execution. At the same time, by mapping the abstract actions to low-level programs, we may still deal with uncertainty during execution. We define a suitable notion of bisimulation that guarantees the equivalence between the high-level and low-level programs and demonstrate the approach with an example.

@inproceedings{hofmannAbstractingNoisyRobot2023,
  title = {Abstracting Noisy Robot Programs},
  author = {Hofmann, Till and Belle, Vaishak},
  booktitle = {Proceedings of the 22nd International Conference on Autonomous Agents and Multiagent Systems (AAMAS)},
  year = {2023},
  abstract = {
    Abstraction is a commonly used process to represent some low-level
    system by a more coarse specification with the goal to omit unnecessary
    details while preserving important aspects. While recent work on
    abstraction in the situation calculus has focused on non-probabilistic
    domains, we describe an approach to abstraction of probabilistic and
    dynamic systems. Based on a variant of the situation calculus with
    probabilistic belief, we define a notion of bisimulation that allows to
    abstract a detailed probabilistic basic action theory with noisy
    actuators and sensors by a possibly non-stochastic basic action theory.
    By doing so, we obtain abstract Golog programs that omit unnecessary
    details and which can be translated to detailed programs for
    execution. This simplifies the implementation of noisy robot
    programs, opens up the possibility of using non-stochastic reasoning
    methods (e.g., planning) on probabilistic problems, and provides domain
    descriptions that are more easily interpretable.
  },
  url = {https://kbsg.rwth-aachen.de/papers/aamas2023-abstraction.pdf}
}

Abstraction is a commonly used process to represent some low-level system by a more coarse specification with the goal to omit unnecessary details while preserving important aspects. While recent work on abstraction in the situation calculus has focused on non-probabilistic domains, we describe an approach to abstraction of probabilistic and dynamic systems. Based on a variant of the situation calculus with probabilistic belief, we define a notion of bisimulation that allows to abstract a detailed probabilistic basic action theory with noisy actuators and sensors by a possibly non-stochastic basic action theory. By doing so, we obtain abstract Golog programs that omit unnecessary details and which can be translated to detailed programs for execution. This simplifies the implementation of noisy robot programs, opens up the possibility of using non-stochastic reasoning methods (e.g., planning) on probabilistic problems, and provides domain descriptions that are more easily interpretable.

@article{hofmannControllingTimedAutomata2023,
  title = {Controlling Timed Automata against {{MTL}} Specifications with {{TACoS}}},
  author = {Hofmann, Till and Schupp, Stefan},
  year = {2023},
  month = jan,
  journal = {Science of Computer Programming},
  volume = {225},
  pages = {102898},
  issn = {0167-6423},
  url = {https://kbsg.rwth-aachen.de/papers/scico2023-tacos.pdf},
  doi = {https://doi.org/10.1016/j.scico.2022.102898},
  abstract = {TACoS is a tool for synthesizing controllers against specifications of undesired behavior with timing constraints. Given a timed automaton and an MTL specification, the tool synthesizes a controller that guarantees that every possible execution of the system satisfies the given specification. TACoS comes with a C++ library with a simple-to-use API and can read from and write to human-readable text input and output. In this paper, we outline the approach of the tool and present two examples in further detail.},
  langid = {english},
  keywords = {Controller synthesis,Metric temporal logic,Timed automata}
}

TACoS is a tool for synthesizing controllers against specifications of undesired behavior with timing constraints. Given a timed automaton and an MTL specification, the tool synthesizes a controller that guarantees that every possible execution of the system satisfies the given specification. TACoS comes with a C++ library with a simple-to-use API and can read from and write to human-readable text input and output. In this paper, we outline the approach of the tool and present two examples in further detail.

@inproceedings{AbstractionXLoKR22,
  title = {Using Abstraction for Interpretable Robot Programs in Stochastic Domains},
  author = {Till Hofmann and Vaishak Belle},
  booktitle = {Proceedings of the 3rd Workshop on Explainable Logic-Based Knowledge Representation (XLoKR)},
  year = {2022},
  abstract = {
    A robot's actions are inherently stochastic, as its sensors are noisy
    and its actions do not always have the intended effects. For this
    reason, the agent language Golog has been extended to models with
    degrees of belief and stochastic actions. While this allows more precise
    robot models, the resulting programs are much harder to comprehend,
    because they need to deal with the noise, e.g., by looping until some
    desired state has been reached with certainty, and because the resulting
    action traces consist of a large number of actions cluttered with sensor
    noise. To alleviate these issues, we propose to use abstraction. We
    define a high-level and nonstochastic model of the robot and then map
    the high-level model into the lower-level stochastic model. The
    resulting programs are much easier to understand, often do not require
    belief operators or loops, and produce much shorter action traces.
  },
  url = {https://kbsg.rwth-aachen.de/papers/xlokr22-abstraction.pdf},
  url_Slides = {https://kbsg.rwth-aachen.de/papers/xlokr22-abstraction-slides.pdf},
  doi = {10.48550/arXiv.2207.12763}
}

A robot's actions are inherently stochastic, as its sensors are noisy and its actions do not always have the intended effects. For this reason, the agent language Golog has been extended to models with degrees of belief and stochastic actions. While this allows more precise robot models, the resulting programs are much harder to comprehend, because they need to deal with the noise, e.g., by looping until some desired state has been reached with certainty, and because the resulting action traces consist of a large number of actions cluttered with sensor noise. To alleviate these issues, we propose to use abstraction. We define a high-level and nonstochastic model of the robot and then map the high-level model into the lower-level stochastic model. The resulting programs are much easier to understand, often do not require belief operators or loops, and produce much shorter action traces.

@inproceedings{PromisesPlanRob22,
  title = {Towards Using Promises for Multi-Agent Cooperation in Goal Reasoning},
  author = {Daniel Swoboda and Till Hofmann and Tarik Viehmann and Gerhard Lakemeyer},
  booktitle = {Proceedings of the 10th ICAPS Workshop on Planning and Robotics (ICAPS PlanRob)},
  year = {2022},
  abstract = {
    Reasoning and planning for mobile robots is a challenging problem, as the
    world evolves over time and thus the robot's goals may change. One
    technique to tackle this problem is goal reasoning, where the agent not
    only reasons about its actions, but also about which goals to pursue. While
    goal reasoning for single agents has been researched extensively,
    distributed, multi-agent goal reasoning comes with additional challenges,
    especially in a distributed setting.  In such a context, some form of
    coordination is necessary to allow for cooperative behavior. Previous goal
    reasoning approaches share the agent's world model with the other agents,
    which already enables basic cooperation.  However, the agent's goals, and
    thus its intentions, are typically not shared.

    In this paper, we present a method to tackle this limitation. Extending an
    existing goal reasoning framework, we propose enabling cooperative behavior
    between multiple agents through promises, where an agent may promise that
    certain facts will be true at some point in the future. Sharing these
    promises allows other agents to not only consider the current state of the
    world, but also the intentions of other agents when deciding on which goal
    to pursue next.  We describe how promises can be incorporated into the goal
    life cycle, a commonly used goal refinement mechanism. We then show how
    promises can be used when planning for a particular goal by connecting them
    to timed initial literals (TILs) from PDDL planning.  Finally, we evaluate
    our prototypical implementation in a simplified logistics scenario.
  },
  url = {https://kbsg.rwth-aachen.de/papers/planrob22-promises.pdf},
  doi = {10.48550/arXiv.2206.09864},
  url_Code = {https://doi.org/10.5281/zenodo.6610426}
}

Reasoning and planning for mobile robots is a challenging problem, as the world evolves over time and thus the robot's goals may change. One technique to tackle this problem is goal reasoning, where the agent not only reasons about its actions, but also about which goals to pursue. While goal reasoning for single agents has been researched extensively, distributed, multi-agent goal reasoning comes with additional challenges, especially in a distributed setting. In such a context, some form of coordination is necessary to allow for cooperative behavior. Previous goal reasoning approaches share the agent's world model with the other agents, which already enables basic cooperation. However, the agent's goals, and thus its intentions, are typically not shared. In this paper, we present a method to tackle this limitation. Extending an existing goal reasoning framework, we propose enabling cooperative behavior between multiple agents through promises, where an agent may promise that certain facts will be true at some point in the future. Sharing these promises allows other agents to not only consider the current state of the world, but also the intentions of other agents when deciding on which goal to pursue next. We describe how promises can be incorporated into the goal life cycle, a commonly used goal refinement mechanism. We then show how promises can be used when planning for a particular goal by connecting them to timed initial literals (TILs) from PDDL planning. Finally, we evaluate our prototypical implementation in a simplified logistics scenario.

@misc{hofmannControllingGologPrograms2022,
  title = {Controlling Golog Programs against MTL Constraints},
  author = {Hofmann, Till and Schupp, Stefan},
  year = {2022},
  eprint = {2204.03596},
  archivePrefix = {arXiv},
  primaryClass = {cs.AI},
  doi = {10.48550/ARXIV.2204.03596},
  url = {https://arxiv.org/abs/2204.03596},
  abstract = {
    While Golog is an expressive programming language to control the
    high-level behavior of a robot, it is often tedious to use on a real
    robotic system. On an actual robot, the user needs to consider low-level
    details, such as enabling and disabling hardware components, e.g., a
    camera to detect objects for grasping.  In other words, high-level actions
    usually pose implicit temporal constraints on the low-level platform,
    which are typically independent of the concrete program to be executed.
    In this paper, we propose to make these constraints explicit by
    modeling them as MTL formulas, which enforce the execution of certain
    low-level platform operations in addition to the main program.  Based on
    results from timed automata controller synthesis, we describe a method
    to synthesize a controller that executes both the high-level program and
    the low-level platform operations concurrently in order to satisfy the
    MTL specification.  This allows the user to focus on the high-level
    behavior without the need to consider low-level operations. We present
    an extension to Golog by clocks together with the required theoretical
    foundations as well as decidability results.
  }
}

While Golog is an expressive programming language to control the high-level behavior of a robot, it is often tedious to use on a real robotic system. On an actual robot, the user needs to consider low-level details, such as enabling and disabling hardware components, e.g., a camera to detect objects for grasping. In other words, high-level actions usually pose implicit temporal constraints on the low-level platform, which are typically independent of the concrete program to be executed. In this paper, we propose to make these constraints explicit by modeling them as MTL formulas, which enforce the execution of certain low-level platform operations in addition to the main program. Based on results from timed automata controller synthesis, we describe a method to synthesize a controller that executes both the high-level program and the low-level platform operations concurrently in order to satisfy the MTL specification. This allows the user to focus on the high-level behavior without the need to consider low-level operations. We present an extension to Golog by clocks together with the required theoretical foundations as well as decidability results.

@inproceedings{hofmannTACoSToolMTL2021,
  title = {{{TACoS}}: A Tool for {{MTL}} Controller Synthesis},
  booktitle = {Proceedings of the 19th {{International Conference}} on {{Software Engineering}} and {{Formal Methods}}},
  author = {Hofmann, Till and Schupp, Stefan},
  year = {2021},
  abstract = {We introduce TACoS, a tool for synthesizing controllers
              satisfying MTL specifications of undesired behavior with timing
              constraints.  Our contribution extends an existing theoretical
              approach towards practical applications.  The most notable
              features include: Online labeling to terminate early if a
              solution has been found, heuristic search to expand the most
              promising nodes first, search graph pruning to reduce the problem
              size by pruning irrelevant parts of the search graph, and
              re-using previously explored search nodes to further reduce the
              search graph.  Finally, multi-threading support allows to make
              use of modern CPUs with many parallel threads.  TACoS comes with
              a C++ library with minimal external dependencies and
              simple-to-use API.  We evaluate our approach on a number of
              scenarios and investigate how each of the enhancements improves
              the performance. The tool is publicly available at
              https://github.com/morxa/tacos.},
  url = {https://kbsg.rwth-aachen.de/papers/sefm21-tacos.pdf},
  url_slides = {https://kbsg.rwth-aachen.de/papers/sefm21-tacos-slides.pdf},
  doi = {10.1007/978-3-030-92124-8_21},
  note = {Best Tool Paper Award},
  url_Code = {https://github.com/morxa/tacos}
}

We introduce TACoS, a tool for synthesizing controllers satisfying MTL specifications of undesired behavior with timing constraints. Our contribution extends an existing theoretical approach towards practical applications. The most notable features include: Online labeling to terminate early if a solution has been found, heuristic search to expand the most promising nodes first, search graph pruning to reduce the problem size by pruning irrelevant parts of the search graph, and re-using previously explored search nodes to further reduce the search graph. Finally, multi-threading support allows to make use of modern CPUs with many parallel threads. TACoS comes with a C++ library with minimal external dependencies and simple-to-use API. We evaluate our approach on a number of scenarios and investigate how each of the enhancements improves the performance. The tool is publicly available at https://github.com/morxa/tacos.

@inproceedings{viehmannTransformingRoboticPlans2021,
  title = {Transforming Robotic Plans with Timed Automata to Solve Temporal Platform Constraints},
  booktitle = {Proceedings of the 30th {{International Joint Conference}} on {{Artificial Intelligence}} ({{IJCAI}})},
  author = {Viehmann, Tarik and Hofmann, Till and Lakemeyer, Gerhard},
  year = {2021},
  url = {https://kbsg.rwth-aachen.de/papers/ijcai21-ta-transformation.pdf},
  doi = {10.24963/ijcai.2021/287},
  url_Poster = {https://kbsg.rwth-aachen.de/papers/ijcai21-ta-transformation_poster.pdf},
  abstract = {
    Task planning for mobile robots typically uses an abstract planning domain
    that ignores the low-level details of the specific robot platform.
    Therefore, executing a plan on an actual robot often requires
    additional steps to deal with the specifics of the robot platform. Such
    a platform can be modeled with timed automata and a set of temporal
    constraints that need to be satisfied during execution.

    In this paper, we describe how to transform an abstract plan into a
    platform-specific action sequence that satisfies all platform
    constraints. The transformation procedure first transforms the plan into
    a timed automaton, which is then combined with the platform automata
    while removing all transitions that violate any constraint. We then
    apply reachability analysis on the resulting automaton.  From any
    solution trace one can obtain the abstract plan extended by additional
    platform actions such that all platform constraints are satisfied.  We
    describe the transformation procedure in detail and provide an
    evaluation in two real-world robotics scenarios.
  }
}

Task planning for mobile robots typically uses an abstract planning domain that ignores the low-level details of the specific robot platform. Therefore, executing a plan on an actual robot often requires additional steps to deal with the specifics of the robot platform. Such a platform can be modeled with timed automata and a set of temporal constraints that need to be satisfied during execution. In this paper, we describe how to transform an abstract plan into a platform-specific action sequence that satisfies all platform constraints. The transformation procedure first transforms the plan into a timed automaton, which is then combined with the platform automata while removing all transitions that violate any constraint. We then apply reachability analysis on the resulting automaton. From any solution trace one can obtain the abstract plan extended by additional platform actions such that all platform constraints are satisfied. We describe the transformation procedure in detail and provide an evaluation in two real-world robotics scenarios.

@inproceedings{haberingUsingPlatformModels2021,
  title = {Using Platform Models for a Guided Explanatory Diagnosis Generation for Mobile Robots},
  booktitle = {Proceedings of the 30th {{International Joint Conference}} on {{Artificial Intelligence}} ({{IJCAI}})},
  author = {Habering, Daniel and Hofmann, Till and Lakemeyer, Gerhard},
  year = {2021},
  url = {https://kbsg.rwth-aachen.de/papers/ijcai21-diagnosis.pdf},
  doi = {10.24963/ijcai.2021/263},
  url_Slides = {https://kbsg.rwth-aachen.de/papers/ijcai21-diagnosis_slides.pdf},
  url_Poster = {https://kbsg.rwth-aachen.de/papers/ijcai21-diagnosis_poster.pdf},
  abstract = {
    Plan execution on a mobile robot is inherently error-prone, as the robot
    needs to act in a physical world which can never be completely
    controlled by the robot. If an error occurs during execution, the true
    world state is unknown, as a failure may have unobservable consequences.
    One approach to deal with such failures is diagnosis, where the true
    world state is determined by identifying a set of faults based on sensed
    observations. In this paper, we present a novel approach to explanatory
    diagnosis, based on the assumption that most failures occur due to some
    robot hardware failure. We model the robot platform components with
    state machines and formulate action variants for the robots' actions,
    modelling different fault modes. We apply diagnosis as
    planning with a top-k planning approach to determine possible diagnosis
    candidates and then use active diagnosis to find out which of those
    candidates is the true diagnosis.  Finally, based on the platform model,
    we recover from the occurred failure such that the robot can continue to
    operate. We evaluate our approach in a logistics robots scenario by
    comparing it to having no diagnosis and diagnosis without platform
    models, showing a significant improvement to both alternatives.
  }
}

Plan execution on a mobile robot is inherently error-prone, as the robot needs to act in a physical world which can never be completely controlled by the robot. If an error occurs during execution, the true world state is unknown, as a failure may have unobservable consequences. One approach to deal with such failures is diagnosis, where the true world state is determined by identifying a set of faults based on sensed observations. In this paper, we present a novel approach to explanatory diagnosis, based on the assumption that most failures occur due to some robot hardware failure. We model the robot platform components with state machines and formulate action variants for the robots' actions, modelling different fault modes. We apply diagnosis as planning with a top-k planning approach to determine possible diagnosis candidates and then use active diagnosis to find out which of those candidates is the true diagnosis. Finally, based on the platform model, we recover from the occurred failure such that the robot can continue to operate. We evaluate our approach in a logistics robots scenario by comparing it to having no diagnosis and diagnosis without platform models, showing a significant improvement to both alternatives.

@inproceedings{matarePortableHighlevelAgent2021,
  title = {Portable High-Level Agent Programming with Golog++},
  booktitle = {Proceedings of the 13th {{International Conference}} on {{Agents}} and {{Artifical Intelligence}} ({{ICAART}})},
  author = {Matar{\'e}, Victor and Viehmann, Tarik and Hofmann, Till and Lakemeyer, Gerhard and Ferrein, Alexander and Schiffer, Stefan},
  year = {2021},
  url = {https://kbsg.rwth-aachen.de/~hofmann/papers/icaart21-gologpp.pdf},
  doi={10.5220/0010253902180227},
  abstract = {We present golog++, a high-level agent programming and interfacing framework that offers a temporal constraint language to explicitly model layer-penetrating contingencies in low-level platform behavior. It can be used to maintain a clear separation between an agent's domain model and certain quirks of its execution platform that affect problem solving behavior. Our system reasons about the execution of an abstract (i.e. exclusively domain-bound) plan on a particular execution platform. This way, we avoid compounding the complexity of the planning problem while improving the modularity of both golog and the user code. On a run-through example from the well-known blocksworld domain, we demonstrate the entire process from domain modeling and platform modeling to plan transformation and platform-specific plan execution.}
}

We present golog++, a high-level agent programming and interfacing framework that offers a temporal constraint language to explicitly model layer-penetrating contingencies in low-level platform behavior. It can be used to maintain a clear separation between an agent's domain model and certain quirks of its execution platform that affect problem solving behavior. Our system reasons about the execution of an abstract (i.e. exclusively domain-bound) plan on a particular execution platform. This way, we avoid compounding the complexity of the planning problem while improving the modularity of both golog and the user code. On a run-through example from the well-known blocksworld domain, we demonstrate the entire process from domain modeling and platform modeling to plan transformation and platform-specific plan execution.

@inproceedings{hofmannMultiagentGoalReasoning2021,
  title = {Multi-Agent Goal Reasoning with the {{CLIPS Executive}} in the {{Robocup Logistics League}}},
  booktitle = {Proceedings of the 13th {{International Conference}} on {{Agents}} and {{Artifical Intelligence}} ({{ICAART}})},
  author = {Hofmann, Till and Viehmann, Tarik and Gomaa, Mostafa and Habering, Daniel and Niemueller, Tim and Lakemeyer, Gerhard},
  year = {2021},
  url = {https://kbsg.rwth-aachen.de/~hofmann/papers/icaart21-goal-reasoning-rcll.pdf},
  url_Slides = {https://kbsg.rwth-aachen.de/~hofmann/papers/icaart21-goal-reasoning-rcll-slides.pdf},
  doi={10.5220/0010252600800091},
  abstract = {Production processes in smart factories moved away from a process-centered paradigm into a modular production paradigm, facing the variations in demanded product configurations and deadlines with a flexible production.  The RoboCup Logistics League (RCLL) is a robotics competition in the context of in-factory logistics, in which a team of three autonomous mobile robots manufacture dynamically ordered products. The main challenges include task reasoning, multi-agent coordination, and robust execution in a dynamic environment. We present a multi-agent goal reasoning approach where agents continuously reason about which objectives to pursue rather than only planning for a fixed objective.  We describe an incremental, distributed formulation of the RCLL problem implemented in the goal reasoning system CLIPS Executive. We elaborate what kind of goals we use in the RCLL, how we use goal trees to define an effective production strategy and how agents coordinate effectively by means of primitive lock actions as well as goal-level resource allocation.  The system utilizes a PDDL model to describe domain predicates and actions, as well as to determine the executability and effects of actions during execution. Our agent is able to react to unexpected events, such as a broken machine or a failed action, by monitoring the execution of the plan, re-evaluating goals, and taking over goals which were previously pursued by another robot. We present a detailed evaluation of the system used on real robots}
}

Production processes in smart factories moved away from a process-centered paradigm into a modular production paradigm, facing the variations in demanded product configurations and deadlines with a flexible production. The RoboCup Logistics League (RCLL) is a robotics competition in the context of in-factory logistics, in which a team of three autonomous mobile robots manufacture dynamically ordered products. The main challenges include task reasoning, multi-agent coordination, and robust execution in a dynamic environment. We present a multi-agent goal reasoning approach where agents continuously reason about which objectives to pursue rather than only planning for a fixed objective. We describe an incremental, distributed formulation of the RCLL problem implemented in the goal reasoning system CLIPS Executive. We elaborate what kind of goals we use in the RCLL, how we use goal trees to define an effective production strategy and how agents coordinate effectively by means of primitive lock actions as well as goal-level resource allocation. The system utilizes a PDDL model to describe domain predicates and actions, as well as to determine the executability and effects of actions during execution. Our agent is able to react to unexpected events, such as a broken machine or a failed action, by monitoring the execution of the plan, re-evaluating goals, and taking over goals which were previously pursued by another robot. We present a detailed evaluation of the system used on real robots

@misc{hofmannMTLSynthesis2021,
    title={Controller Synthesis for Golog Programs over Finite Domains with Metric Temporal Constraints},
    author={Till Hofmann and Gerhard Lakemeyer},
    year={2021},
    eprint={2102.09837},
    archivePrefix={arXiv},
    primaryClass={cs.AI},
    url = {https://arxiv.org/abs/2102.09837},
    abstract = {
      Executing a Golog program on an actual robot typically requires
      additional steps to account for hardware or software details of the
      robot platform, which can be formulated as constraints on the program.
      Such constraints are often temporal, refer to metric time, and require
      modifications to the abstract Golog program.  We describe how to
      formulate such constraints based on a modal variant of the Situation
      Calculus. These constraints connect the abstract program with the
      platform models, which we describe using timed automata.  We show that
      for programs over finite domains and with fully known initial state, the
      problem of synthesizing a controller that satisfies the constraints
      while preserving the effects of the original program can be reduced to
      MTL synthesis.  We do this by constructing a timed automaton from the
      abstract program and synthesizing an MTL controller from this automaton,
      the platform models, and the constraints. We prove that the synthesized
      controller results in execution traces which are the same as those of
      the original program, possibly interleaved with platform-dependent
      actions, that they satisfy all constraints, and that they have the same
      effects as the traces of the original program. By doing so, we obtain a
      decidable procedure to synthesize a controller that satisfies the
      specification while preserving the original program.
    }
}

Executing a Golog program on an actual robot typically requires additional steps to account for hardware or software details of the robot platform, which can be formulated as constraints on the program. Such constraints are often temporal, refer to metric time, and require modifications to the abstract Golog program. We describe how to formulate such constraints based on a modal variant of the Situation Calculus. These constraints connect the abstract program with the platform models, which we describe using timed automata. We show that for programs over finite domains and with fully known initial state, the problem of synthesizing a controller that satisfies the constraints while preserving the effects of the original program can be reduced to MTL synthesis. We do this by constructing a timed automaton from the abstract program and synthesizing an MTL controller from this automaton, the platform models, and the constraints. We prove that the synthesized controller results in execution traces which are the same as those of the original program, possibly interleaved with platform-dependent actions, that they satisfy all constraints, and that they have the same effects as the traces of the original program. By doing so, we obtain a decidable procedure to synthesize a controller that satisfies the specification while preserving the original program.

@misc{hofmannMTLSynthesis2020,
  title = {Controller Synthesis for {{Golog}} Programs over Finite Domains with Metric Temporal Constraints},
  author = {Till Hofmann and Gerhard Lakemeyer},
  year = {2020},
  month= {September},
  day = {16},
  howpublished = {Poster at the 17th {{International Conference on Principles of Knowledge Representation and Reasoning}}},
  abstract = {
    Executing a Golog program on an actual robot typically requires
    additional steps to account for hardware or software details of the
    robot platform, which can be formulated as constraints on the program.
    Such constraints are often temporal, refer to metric time, and require
    modifications to the abstract Golog program.  We describe how to
    formulate such constraints based on a modal variant of the Situation
    Calculus. These constraints connect the abstract program with the
    platform models, which we describe using timed automata.  We show that
    for programs over finite domains and with fully known initial state, the
    problem of synthesizing a controller that satisfies the constraints
    while preserving the effects of the original program can be reduced to
    MTL synthesis.  We do this by constructing a timed automaton from the
    abstract program and synthesizing an MTL controller from this automaton,
    the platform models, and the constraints. We prove that the synthesized
    controller results in execution traces which are the same as those of
    the original program, possibly interleaved with platform-dependent
    actions, that they satisfy all constraints, and that they have the same
    effects as the traces of the original program. By doing so, we obtain a
    decidable procedure to synthesize a controller that satisfies the
    specification while preserving the original program.
  },
  url = {https://kbsg.rwth-aachen.de/~hofmann/papers/golog-synthesis-poster.pdf},
  url_Teaser = {https://youtu.be/ns4b8L9RlJo}
}

Executing a Golog program on an actual robot typically requires additional steps to account for hardware or software details of the robot platform, which can be formulated as constraints on the program. Such constraints are often temporal, refer to metric time, and require modifications to the abstract Golog program. We describe how to formulate such constraints based on a modal variant of the Situation Calculus. These constraints connect the abstract program with the platform models, which we describe using timed automata. We show that for programs over finite domains and with fully known initial state, the problem of synthesizing a controller that satisfies the constraints while preserving the effects of the original program can be reduced to MTL synthesis. We do this by constructing a timed automaton from the abstract program and synthesizing an MTL controller from this automaton, the platform models, and the constraints. We prove that the synthesized controller results in execution traces which are the same as those of the original program, possibly interleaved with platform-dependent actions, that they satisfy all constraints, and that they have the same effects as the traces of the original program. By doing so, we obtain a decidable procedure to synthesize a controller that satisfies the specification while preserving the original program.

@inproceedings{ Matare:EtAl:IROS2020WS:ConTrAkt,
  author       = {Victor Mataré and Stefan Schiffer and Alexander Ferrein and Tarik Viehmann and Till Hofmann and Gerhard Lakemeyer},
  title        = {Constraint-based Plan Transformation in a Safe and Usable {GOLOG} Language},
  booktitle    = {Proceedings of the Workshop on Bringing Constraint-based Robot Programming to Real-World Applications (IROS CobaRoP)},
  month        = {October},
  day          = {25--29},
  year         = {2020},
  location     = {Las Vegas, NV, USA},
  url          = {https://iros2020-workshop-cobarop.gitlab.io/abstracts/3463_CobaRoP_EA_Matare.pdf},
  url_Presentation    = {https://youtu.be/4t7BOnh8pMI}
}

@inproceedings{hofmannMacroOperatorSynthesis2020,
  title = {Macro Operator Synthesis for {{ADL}} Domains},
  booktitle = {Proceedings of the 24th {{European Conference}} on {{Artificial Intelligence}} ({{ECAI}})},
  author = {Hofmann, Till and Niemueller, Tim and Lakemeyer, Gerhard},
  year = {2020},
  abstract = {A macro operator is a planning operator that is generated from a
    sequence of actions. Macros have mostly been used for macro
    planning, where the planner considers the macro as a single action and
    expands it into the original sequence during execution, but they can
    also be applied to other problems, such as maintaining a plan library.
    There are several approaches to macro operator generation, which differ
    in restrictions on the original actions and in the way they represent
    macros.  However, all existing approaches are either restricted to
    STRIPS domains, only work on grounded actions, or they do not synthesize
    macros but consider the original sequence instead. We study the
    synthesis of macro operators for ADL domains. We describe how to compute
    the parameterized preconditions and effects of a macro operator such that
    they are equivalent to the preconditions and effects of the respective
    action sequence and prove the correctness of the synthesized macro
    operators based on a Situation Calculus semantics for ADL. We use the
    synthesis method for ADL macro planning and evaluate it on a number of domains
    from the IPC. As a second application, we describe how macro operator synthesis
    can be useful for maintaining a plan library by computing the precondition and
    effects of the parameterized library plans.
  },
  url = {http://ecai2020.eu/papers/1491_paper.pdf},
  url_Presentation = {https://www.underline.io/events/24/sessions/194/lecture/2010-macro-operator-synthesis-for-adl-domains}
}

A macro operator is a planning operator that is generated from a sequence of actions. Macros have mostly been used for macro planning, where the planner considers the macro as a single action and expands it into the original sequence during execution, but they can also be applied to other problems, such as maintaining a plan library. There are several approaches to macro operator generation, which differ in restrictions on the original actions and in the way they represent macros. However, all existing approaches are either restricted to STRIPS domains, only work on grounded actions, or they do not synthesize macros but consider the original sequence instead. We study the synthesis of macro operators for ADL domains. We describe how to compute the parameterized preconditions and effects of a macro operator such that they are equivalent to the preconditions and effects of the respective action sequence and prove the correctness of the synthesized macro operators based on a Situation Calculus semantics for ADL. We use the synthesis method for ADL macro planning and evaluate it on a number of domains from the IPC. As a second application, we describe how macro operator synthesis can be useful for maintaining a plan library by computing the precondition and effects of the parameterized library plans.

@techreport{Carologistics2020,
  title =	{The {Carologistics} {RoboCup Logistics} Team 2020},
  author =	{Till Hofmann and Sebastian Eltester and Tarik Viehmann and Nicolas Limpert and Victor Mataré and Alexander Ferrein and Gerhard Lakemeyer},
  institution =	{RWTH Aachen University and Aachen University of Applied Sciences},
  address =	{Aachen, Germany},
  year =	{2020},
  month =	{March},
  url = {https://kbsg.rwth-aachen.de/~hofmann/papers/carologistics-2020-tdp.pdf}
}

@inproceedings{hofmannWinningRoboCupLogistics2019,
  abstract = {The RoboCup Logistics League is a robotics competition in a Smart Factory scenario in which a team of robots has to assemble products for dynamically generated orders. In 2019, the Carologistics was able to win the competition with a redesigned manipulation system, improved navigation, and an incremental and distributed goal reasoning system. In this paper, we describe the major components of our approach that enabled us to win the competition, with a particular focus on this year's changes.},
  author = {Hofmann, Till and Limpert, Nicolas and Matar{\'e}, Victor and Ferrein, Alexander and Lakemeyer, Gerhard},
  booktitle = {{{RoboCup}} 2019: {{Robot World Cup XXIII}}},
  doi = {10.1007/978-3-030-35699-6_41},
  isbn = {978-3-030-35699-6},
  language = {en},
  pages = {504-516},
  publisher = {{Springer International Publishing}},
  title = {Winning the {{RoboCup Logistics League}} with {{Fast Navigation}}, {{Precise Manipulation}}, and {{Robust Goal Reasoning}}},
  year = {2019},
  url = {https://kbsg.rwth-aachen.de/~hofmann/papers/carologistics-2019-champions.pdf}
}

The RoboCup Logistics League is a robotics competition in a Smart Factory scenario in which a team of robots has to assemble products for dynamically generated orders. In 2019, the Carologistics was able to win the competition with a redesigned manipulation system, improved navigation, and an incremental and distributed goal reasoning system. In this paper, we describe the major components of our approach that enabled us to win the competition, with a particular focus on this year's changes.

@inproceedings{niemuellerGoalReasoningCLIPS2019,
  address = {{Berkeley, CA, USA}},
  author = {Niemueller, Tim and Hofmann, Till and Lakemeyer, Gerhard},
  booktitle = {Proceedings of the 29th {{International Conference}} on {{Automated Planning}} and {{Scheduling}} ({{ICAPS}})},
  pages = {754-763},
  title = {Goal Reasoning in the {{CLIPS Executive}} for Integrated Planning and Execution},
  url = {https://kbsg.rwth-aachen.de/~hofmann/papers/clips-exec-icaps19.pdf},
  url_Presentation = {https://youtu.be/HeDFYe5H-gw?t=1835},
  year = {2019}
}

@techreport{Carologistics2019,
  title =	{The {Carologistics} {RoboCup Logistics} Team 2019},
  author =	{Till Hofmann and Nicolas Limpert and Victor Mataré and Alexander Ferrein and Gerhard Lakemeyer},
  institution =	{RWTH Aachen University and Aachen University of Applied Sciences},
  address =	{Aachen, Germany},
  year =	{2019},
  month =	{July},
  url = {https://kbsg.rwth-aachen.de/~hofmann/papers/carologistics-2019-tdp.pdf}
}

@inproceedings{hofmannLogicSpecifyingMetric2018,
  address = {Tempe, AZ, USA},
  author = {Hofmann, Till and Lakemeyer, Gerhard},
  booktitle = {Proceedings of the 11th {{Cognitive Robotics Workshop}} 2018 ({{CogRob}})},
  title = {A Logic for Specifying Metric Temporal Constraints for {{Golog}} Programs},
  url = {https://kbsg.rwth-aachen.de/~hofmann/papers/timed-esg-cogrob18.pdf},
  year = {2018}
}

@inproceedings{CX-PDDL,
  author = {Tim Niemueller and Till Hofmann and Gerhard Lakemeyer},
  title = {CLIPS-based Execution for PDDL Planners},
  booktitle = {Proceedings of the 2nd Workshop on Integrated Planning, Acting,
               and Execution (ICAPS IntEx)},
  url = {https://kbsg.rwth-aachen.de/~hofmann/papers/clips-exec-pddl.pdf},
  address = {Delft, Netherlands},
  abstract = {
  Integrating planning and execution which treats either component as a black
  box may lead to disparate representations of the domain or information
  currently known. Consistency and bidirectional information flow are then hard
  to ensure. However, the separation of these concerns is still useful from an
  integration point of view.

  In this paper, we discuss the integration of planning systems using the
  Planning Domain Definition Language (PDDL) with an executive based on the
  CLIPS rule-based production system. In particular, we describe how we achieved
  one common and unified domain model used by both systems and some additions we
  add for the execution model. We also show how the execution model enables
  effective execution monitoring and selective replanning.
  },
  year = 2018
}

Integrating planning and execution which treats either component as a black box may lead to disparate representations of the domain or information currently known. Consistency and bidirectional information flow are then hard to ensure. However, the separation of these concerns is still useful from an integration point of view. In this paper, we discuss the integration of planning systems using the Planning Domain Definition Language (PDDL) with an executive based on the CLIPS rule-based production system. In particular, we describe how we achieved one common and unified domain model used by both systems and some additions we add for the execution model. We also show how the execution model enables effective execution monitoring and selective replanning.

@techreport{Carologistics2018,
  title =	{The {Carologistics} {RoboCup Logistics} Team 2018},
  author =	{Till Hofmann and Nicolas Limpert and Victor Mataré and Sebastian Schönitz and Tim Niemueller and Alexander Ferrein and Gerhard Lakemeyer},
  institution =	{RWTH Aachen University and Aachen University of Applied Sciences},
  address =	{Aachen, Germany},
  year =	{2018},
  month =	{June},
  url = {https://kbsg.rwth-aachen.de/~hofmann/papers/carologistics-2018-tdp.pdf}
}

@InProceedings{ConTrAkt-SIRLE,
  author = {Till Hofmann and Victor Mataré and Stefan Schiffer and Alexander
            Ferrein and Gerhard Lakemeyer},
  title = {Constraint-Based Online Transformation of Abstract Plans into
           Executable Robot Actions},
  booktitle = {AAAI Spring Symposium 2018 on Integrating Representation,
               Reasoning, Learning, and Execution for Goal Directed Autonomy},
  year = 2018,
  address = {Stanford, CA, USA},
  url = {https://kbsg.rwth-aachen.de/~hofmann/papers/contrakt-sirle.pdf},
  abstract = {
  In this paper, we are concerned with making the execution of abstract action
  plans for robotic agents more robust.  To this end, we propose to model the
  internals of a robot system and its ties to the actions that the robot can
  perform.  Based on these models, we propose an online transformation of an
  abstract plan into executable actions conforming with system specifics.  With
  our framework, we aim to achieve two goals.  First, modeling the system
  internals is beneficial in its own right in order to achieve long term
  autonomy, system transparency, and comprehensibility.  Second, separating the
  system details from determining the course of action on an abstract level
  leverages the use of planning for actual robotic systems.
  }
}

In this paper, we are concerned with making the execution of abstract action plans for robotic agents more robust. To this end, we propose to model the internals of a robot system and its ties to the actions that the robot can perform. Based on these models, we propose an online transformation of an abstract plan into executable actions conforming with system specifics. With our framework, we aim to achieve two goals. First, modeling the system internals is beneficial in its own right in order to achieve long term autonomy, system transparency, and comprehensibility. Second, separating the system details from determining the course of action on an abstract level leverages the use of planning for actual robotic systems.

@inproceedings{CarologisticsCP2017,
  author = {Till Hofmann and Victor Mataré and Tobias Neumann and Sebastian
            Schönitz and Christoph Henke and Nicolas Limpert and Tim Niemueller
            and Alexander Ferrein and Sabina Jeschke and Gerhard Lakemeyer},
  title = {Enhancing Software and Hardware Reliability for a Successful
           Participation in the RoboCup Logistics League 2017},
  booktitle = {RoboCup Symposium -- Champion Teams Track},
  url =   {https://kbsg.rwth-aachen.de/~hofmann/papers/carologistics-2017-champions-tdp.pdf},
  address = {Nagoya, Japan},
  abstract = {
  In 2017, the RoboCup Logistics League has seen major changes to the playing
  field layout, which allows for more configuration variants that are now
  generated randomly and automatically, leading towards a more realistic smart
  factory scenario.  The Carologistics team developed a new strategy for
  exploration and improved existing components with a particular focus on
  navigation and error handling in the behavior engine and high-level reasoning.
  We describe the major concepts of our approach with a focus on the
  improvements in comparison to last year, which enabled us to win the
  competition in 2017.
  },
  year = 2017
}

In 2017, the RoboCup Logistics League has seen major changes to the playing field layout, which allows for more configuration variants that are now generated randomly and automatically, leading towards a more realistic smart factory scenario. The Carologistics team developed a new strategy for exploration and improved existing components with a particular focus on navigation and error handling in the behavior engine and high-level reasoning. We describe the major concepts of our approach with a focus on the improvements in comparison to last year, which enabled us to win the competition in 2017.

@InProceedings {DBMP-STRIPS,
  author = {Till Hofmann and Tim Niemueller and Gerhard Lakemeyer},
  title = {Initial Results on Generating Macro Actions from a Plan Database for
           Planning on Autonomous Mobile Robots},
  booktitle = {Proceedings of the 27th International Conference on Automated
               Planning and Scheduling (ICAPS)},
  url = {https://kbsg.rwth-aachen.de/~hofmann/papers/db-macro-planning-short-proceedings.pdf},
  url_Poster = {https://kbsg.rwth-aachen.de/~hofmann/papers/db-macro-planning-short-poster.pdf},
  url_Presentation = {https://youtu.be/AOQX0vsioqI},
  url_Project = {https://www.fawkesrobotics.org/projects/dbmp-strips/},
  year = 2017,
  address = {Pittsburgh, PA, USA},
  abstract = {Planning in an on-line robotics context has the specific
              requirement of a short planning duration. A property of typical
              contemporary scenarios is that (mobile) robots perform similar or
              even repeating tasks during operation.  With these robot domains
              in mind, we propose database-driven macro planning for STRIPS
              (DBMP/S) that learns macros - action sequences that frequently
              appear in plans - from experience for PDDL-based planners.
              Planning duration is improved over time by off-line processing of
              seed plans using a scalable database. The approach is indifferent
              about the specific planner by representing the resulting macros
              again as actions with preconditions and effects determined based
              on the actions contained in the macro. For some domains we have
              used separate planners for learning and execution exploiting their
              respective strengths. Initial results based on some IPC domains
              and a logistic robot scenario show significantly improved (over
              non-macro planners) or slightly better and comparable (to existing
              macro planners) performance.}
}

Planning in an on-line robotics context has the specific requirement of a short planning duration. A property of typical contemporary scenarios is that (mobile) robots perform similar or even repeating tasks during operation. With these robot domains in mind, we propose database-driven macro planning for STRIPS (DBMP/S) that learns macros - action sequences that frequently appear in plans - from experience for PDDL-based planners. Planning duration is improved over time by off-line processing of seed plans using a scalable database. The approach is indifferent about the specific planner by representing the resulting macros again as actions with preconditions and effects determined based on the actions contained in the macro. For some domains we have used separate planners for learning and execution exploiting their respective strengths. Initial results based on some IPC domains and a logistic robot scenario show significantly improved (over non-macro planners) or slightly better and comparable (to existing macro planners) performance.

@techreport{Carologistics2017,
  title =	{The {Carologistics} {RoboCup Logistics} Team 2017},
  author =	{Tobias Neumann and Till Hofmann and Victor Mataré and Christoph Henke and Sebastian Schönitz and Tim Niemueller and Alexander Ferrein and Sabina Jeschke and Gerhard Lakemeyer},
  institution =	{RWTH Aachen University and Aachen University of Applied Sciences},
  address =	{Aachen, Germany},
  year =	{2017},
  month =	{July},
  url = {https://kbsg.rwth-aachen.de/~hofmann/papers/carologistics-2017-tdp.pdf}
}