@inproceedings{
 title = {Generalized Planning with Positive and Negative Examples},
 type = {inproceedings},
 year = {2020},
 websites = {www.aaai.org},
 id = {c01096a6-0b75-39a2-a047-aba30ea7027f},
 created = {2019-11-25T08:32:29.469Z},
 file_attached = {true},
 profile_id = {de5765e4-e253-3166-8178-333c824974ba},
 last_modified = {2019-11-25T09:42:07.026Z},
 read = {false},
 starred = {false},
 authored = {true},
 confirmed = {false},
 hidden = {false},
 private_publication = {false},
 abstract = {Generalized planning aims at computing an algorithm-like structure (generalized plan) that solves a set of multiple planning instances. In this paper we define negative examples for generalized planning as planning instances that must not be solved by a generalized plan. With this regard the paper extends the notion of validation of a generalized plan as the problem of verifying that a given generalized plan solves the set of input positives instances while it fails to solve a given input set of negative examples. This notion of plan validation allows us to define quantitative metrics to asses the generalization capacity of generalized plans. The paper also shows how to incorporate this new notion of plan validation into a compilation for plan synthesis that takes both positive and negative instances as input. Experiments show that incorporating negative examples can accelerate plan synthesis in several domains and leverage quantitative metrics to evaluate the generalization capacity of the synthesized plans.},
 bibtype = {inproceedings},
 author = {Segovia-Aguas, Javier and Jiménez, Sergio and Jonsson, Anders},
 booktitle = {Proceedings of the Thirty-Fourth AAAI Conference on Artificial Intelligence}
}

Generalized planning aims at computing an algorithm-like structure (generalized plan) that solves a set of multiple planning instances. In this paper we define negative examples for generalized planning as planning instances that must not be solved by a generalized plan. With this regard the paper extends the notion of validation of a generalized plan as the problem of verifying that a given generalized plan solves the set of input positives instances while it fails to solve a given input set of negative examples. This notion of plan validation allows us to define quantitative metrics to asses the generalization capacity of generalized plans. The paper also shows how to incorporate this new notion of plan validation into a compilation for plan synthesis that takes both positive and negative instances as input. Experiments show that incorporating negative examples can accelerate plan synthesis in several domains and leverage quantitative metrics to evaluate the generalization capacity of the synthesized plans.

@article{
 title = {STRIPS Action Discovery},
 type = {article},
 year = {2020},
 websites = {http://arxiv.org/abs/2001.11457},
 month = {1},
 day = {30},
 id = {18de3dc0-ad2f-3611-a6e7-31e9f28acf9e},
 created = {2020-10-07T10:14:18.184Z},
 file_attached = {true},
 profile_id = {de5765e4-e253-3166-8178-333c824974ba},
 last_modified = {2020-10-07T10:14:18.829Z},
 read = {false},
 starred = {false},
 authored = {true},
 confirmed = {false},
 hidden = {false},
 private_publication = {false},
 abstract = {The problem of specifying high-level knowledge bases for planning becomes a hard task in realistic environments. This knowledge is usually handcrafted and is hard to keep updated, even for system experts. Recent approaches have shown the success of classical planning at synthesizing action models even when all intermediate states are missing. These approaches can synthesize action schemas in Planning Domain Definition Language (PDDL) from a set of execution traces each consisting, at least, of an initial and final state. In this paper, we propose a new algorithm to unsupervisedly synthesize STRIPS action models with a classical planner when action signatures are unknown. In addition, we contribute with a compilation to classical planning that mitigates the problem of learning static predicates in the action model preconditions, exploits the capabilities of SAT planners with parallel encodings to compute action schemas and validate all instances. Our system is flexible in that it supports the inclusion of partial input information that may speed up the search. We show through several experiments how learned action models generalize over unseen planning instances.},
 bibtype = {article},
 author = {Suárez-Hernández, Alejandro and Segovia-Aguas, Javier and Torras, Carme and Alenyà, Guillem}
}

The problem of specifying high-level knowledge bases for planning becomes a hard task in realistic environments. This knowledge is usually handcrafted and is hard to keep updated, even for system experts. Recent approaches have shown the success of classical planning at synthesizing action models even when all intermediate states are missing. These approaches can synthesize action schemas in Planning Domain Definition Language (PDDL) from a set of execution traces each consisting, at least, of an initial and final state. In this paper, we propose a new algorithm to unsupervisedly synthesize STRIPS action models with a classical planner when action signatures are unknown. In addition, we contribute with a compilation to classical planning that mitigates the problem of learning static predicates in the action model preconditions, exploits the capabilities of SAT planners with parallel encodings to compute action schemas and validate all instances. Our system is flexible in that it supports the inclusion of partial input information that may speed up the search. We show through several experiments how learned action models generalize over unseen planning instances.

@article{
 title = {Leveraging Multiple Environments for Learning and Decision Making: a Dismantling Use Case},
 type = {article},
 year = {2020},
 websites = {http://arxiv.org/abs/2009.08837},
 month = {9},
 day = {18},
 id = {3c8975ea-cce6-3472-8ae1-41473001b20a},
 created = {2020-10-07T10:17:47.413Z},
 file_attached = {true},
 profile_id = {de5765e4-e253-3166-8178-333c824974ba},
 last_modified = {2020-10-07T10:17:56.618Z},
 read = {false},
 starred = {false},
 authored = {true},
 confirmed = {false},
 hidden = {false},
 private_publication = {false},
 abstract = {Learning is usually performed by observing real robot executions. Physics-based simulators are a good alternative for providing highly valuable information while avoiding costly and potentially destructive robot executions. We present a novel approach for learning the probabilities of symbolic robot action outcomes. This is done leveraging different environments, such as physics-based simulators, in execution time. To this end, we propose MENID (Multiple Environment Noise Indeterministic Deictic) rules, a novel representation able to cope with the inherent uncertainties present in robotic tasks. MENID rules explicitly represent each possible outcomes of an action, keep memory of the source of the experience, and maintain the probability of success of each outcome. We also introduce an algorithm to distribute actions among environments, based on previous experiences and expected gain. Before using physics-based simulations, we propose a methodology for evaluating different simulation settings and determining the least time-consuming model that could be used while still producing coherent results. We demonstrate the validity of the approach in a dismantling use case, using a simulation with reduced quality as simulated system, and a simulation with full resolution where we add noise to the trajectories and some physical parameters as a representation of the real system.},
 bibtype = {article},
 author = {Suárez-Hernández, Alejandro and Gaugry, Thierry and Segovia-Aguas, Javier and Bernardin, Antonin and Torras, Carme and Marchal, Maud and Alenyà, Guillem}
}

Learning is usually performed by observing real robot executions. Physics-based simulators are a good alternative for providing highly valuable information while avoiding costly and potentially destructive robot executions. We present a novel approach for learning the probabilities of symbolic robot action outcomes. This is done leveraging different environments, such as physics-based simulators, in execution time. To this end, we propose MENID (Multiple Environment Noise Indeterministic Deictic) rules, a novel representation able to cope with the inherent uncertainties present in robotic tasks. MENID rules explicitly represent each possible outcomes of an action, keep memory of the source of the experience, and maintain the probability of success of each outcome. We also introduce an algorithm to distribute actions among environments, based on previous experiences and expected gain. Before using physics-based simulations, we propose a methodology for evaluating different simulation settings and determining the least time-consuming model that could be used while still producing coherent results. We demonstrate the validity of the approach in a dismantling use case, using a simulation with reduced quality as simulated system, and a simulation with full resolution where we add noise to the trajectories and some physical parameters as a representation of the real system.

@misc{
 title = {Online action recognition},
 type = {misc},
 year = {2020},
 source = {arXiv},
 id = {77284886-3fdb-3c25-ba3c-51313675eab5},
 created = {2021-02-11T23:59:00.000Z},
 file_attached = {false},
 profile_id = {de5765e4-e253-3166-8178-333c824974ba},
 last_modified = {2021-02-22T22:09:59.272Z},
 read = {false},
 starred = {false},
 authored = {true},
 confirmed = {false},
 hidden = {false},
 private_publication = {true},
 abstract = {Copyright © 2020, The Authors. All rights reserved. Recognition in planning seeks to find agent intentions, goals or activities given a set of observations and a knowledge library (e.g. goal states, plans or domain theories). In this work we introduce the problem of Online Action Recognition. It consists in recognizing, in an open world, the planning action that best explains a partially observable state transition from a knowledge library of first-order STRIPS actions, which is initially empty. We frame this as an optimization problem, and propose two algorithms to address it: Action Unification (AU) and Online Action Recognition through Unification (OARU). The former builds on logic unification and generalizes two input actions using weighted partial MaxSAT. The latter looks for an action within the library that explains an observed transition. If there is such action, it generalizes it making use of AU, building in this way an AU hierarchy. Otherwise, OARU inserts a Trivial Grounded Action (TGA) in the library that explains just that transition. We report results on benchmarks from the International Planning Competition and PDDLGym, where OARU recognizes actions accurately with respect to expert knowledge, and shows real-time performance.},
 bibtype = {misc},
 author = {Suárez-Hernández, A. and Segovia-Aguas, J. and Torras, C. and Alenyà, G.}
}

Copyright © 2020, The Authors. All rights reserved. Recognition in planning seeks to find agent intentions, goals or activities given a set of observations and a knowledge library (e.g. goal states, plans or domain theories). In this work we introduce the problem of Online Action Recognition. It consists in recognizing, in an open world, the planning action that best explains a partially observable state transition from a knowledge library of first-order STRIPS actions, which is initially empty. We frame this as an optimization problem, and propose two algorithms to address it: Action Unification (AU) and Online Action Recognition through Unification (OARU). The former builds on logic unification and generalizes two input actions using weighted partial MaxSAT. The latter looks for an action within the library that explains an observed transition. If there is such action, it generalizes it making use of AU, building in this way an AU hierarchy. Otherwise, OARU inserts a Trivial Grounded Action (TGA) in the library that explains just that transition. We report results on benchmarks from the International Planning Competition and PDDLGym, where OARU recognizes actions accurately with respect to expert knowledge, and shows real-time performance.

@article{
 title = {Computing programs for generalized planning using a classical planner},
 type = {article},
 year = {2019},
 keywords = {Classical planning,Generalized planning,Planning and learning,Program synthesis},
 id = {198f463a-af3d-389e-831c-1f6ab5975dce},
 created = {2019-02-22T08:15:43.692Z},
 file_attached = {false},
 profile_id = {de5765e4-e253-3166-8178-333c824974ba},
 last_modified = {2019-09-20T12:22:50.272Z},
 read = {true},
 starred = {false},
 authored = {true},
 confirmed = {false},
 hidden = {false},
 private_publication = {false},
 abstract = {Generalized planning is the task of generating a single solution (a generalized plan) that is valid for multiple planning instances. In this paper we introduce a novel formalism for representing generalized plans that borrows two mechanisms from structured programming: control flow and procedure calls. On one hand, control flow structures allow to compactly represent generalized plans. On the other hand, procedure calls allow to represent hierarchical and recursive solutions as well as to reuse existing generalized plans. The paper also presents a compilation from generalized planning into classical planning which allows us to compute generalized plans with off-the-shelf planners. The compilation can incorporate prior knowledge in the form of auxiliary procedures which expands the applicability of the approach to more challenging tasks. Experiments show that a classical planner using our compilation can compute generalized plans that solve a wide range of generalized planning tasks, including sorting lists of variable size or DFS traversing variable-size binary trees. Additionally the paper presents an extension of the compilation for computing generalized plans when generalization requires a high-level state representation that is not provided a priori. This extension brings a new landscape of benchmarks to classical planning since classification tasks can naturally be modeled as generalized planning tasks, and hence, as classical planning tasks. Finally the paper shows that the compilation can be extended to compute control knowledge for off-the-shelf planners and solve planning instances that are difficult to solve without such additional knowledge.},
 bibtype = {article},
 author = {Segovia-Aguas, Javier and Jiménez, Sergio and Jonsson, Anders},
 doi = {10.1016/j.artint.2018.10.006},
 journal = {Artificial Intelligence}
}

Generalized planning is the task of generating a single solution (a generalized plan) that is valid for multiple planning instances. In this paper we introduce a novel formalism for representing generalized plans that borrows two mechanisms from structured programming: control flow and procedure calls. On one hand, control flow structures allow to compactly represent generalized plans. On the other hand, procedure calls allow to represent hierarchical and recursive solutions as well as to reuse existing generalized plans. The paper also presents a compilation from generalized planning into classical planning which allows us to compute generalized plans with off-the-shelf planners. The compilation can incorporate prior knowledge in the form of auxiliary procedures which expands the applicability of the approach to more challenging tasks. Experiments show that a classical planner using our compilation can compute generalized plans that solve a wide range of generalized planning tasks, including sorting lists of variable size or DFS traversing variable-size binary trees. Additionally the paper presents an extension of the compilation for computing generalized plans when generalization requires a high-level state representation that is not provided a priori. This extension brings a new landscape of benchmarks to classical planning since classification tasks can naturally be modeled as generalized planning tasks, and hence, as classical planning tasks. Finally the paper shows that the compilation can be extended to compute control knowledge for off-the-shelf planners and solve planning instances that are difficult to solve without such additional knowledge.

@article{
 title = {A review of generalized planning},
 type = {article},
 year = {2019},
 volume = {34},
 websites = {https://doi.org/10.1017/S0269888918000231},
 id = {41559f3d-3e10-3e17-a92d-be9bec6c7451},
 created = {2019-03-14T08:10:09.791Z},
 file_attached = {true},
 profile_id = {de5765e4-e253-3166-8178-333c824974ba},
 last_modified = {2019-07-24T12:30:29.124Z},
 read = {true},
 starred = {false},
 authored = {true},
 confirmed = {false},
 hidden = {false},
 private_publication = {false},
 abstract = {Generalized planning studies the representation, computation and evaluation of solutions that are valid for multiple planning instances. These are topics studied since the early days of AI. However, in recent years, we are experiencing the appearance of novel formalisms to compactly represent generalized planning tasks, the solutions to these tasks (called generalized plans) and efficient algorithms to compute generalized plans. The paper reviews recent advances in generalized planning and relates them to existing planning formalisms, such as planning with domain control knowledge and approaches for planning under uncertainty, that also aim at generality.},
 bibtype = {article},
 author = {Jiménez, Sergio and Segovia-Aguas, Javier and Jonsson, Anders},
 doi = {10.1017/S0269888918000231},
 journal = {The Knowledge Engineering Review}
}

Generalized planning studies the representation, computation and evaluation of solutions that are valid for multiple planning instances. These are topics studied since the early days of AI. However, in recent years, we are experiencing the appearance of novel formalisms to compactly represent generalized planning tasks, the solutions to these tasks (called generalized plans) and efficient algorithms to compute generalized plans. The paper reviews recent advances in generalized planning and relates them to existing planning formalisms, such as planning with domain control knowledge and approaches for planning under uncertainty, that also aim at generality.

@techreport{
 title = {Natural Teaching of Robot-Assisted Rearranging Exercises for Cognitive Training},
 type = {techreport},
 year = {2019},
 keywords = {Assisted,Exercises ·,Natural,Robotic,SAR ·,Teaching},
 websites = {https://youtu.be/},
 id = {ccff743e-59f0-36b8-a24a-02ca813606cf},
 created = {2019-09-20T07:37:54.457Z},
 file_attached = {true},
 profile_id = {de5765e4-e253-3166-8178-333c824974ba},
 last_modified = {2019-09-20T07:39:40.738Z},
 read = {false},
 starred = {false},
 authored = {true},
 confirmed = {false},
 hidden = {false},
 private_publication = {false},
 abstract = {Social Assistive Robots are a powerful tool to be used in patients' cognitive training. The purpose of this study is to evaluate a new methodology to enable caregivers to teach cognitive exercises to the robot in an easy and natural way. We build upon our existing framework, in which a robot is employed to provide encouragement and hints while a patient is physically playing a cognitive exercise. In this paper, we focus on empowering the caregiver to easily teach new board exercises to the robot by providing positive examples. The proposed learning method has two main advantages i) the teaching procedure is human-friendly ii) the produced exercise rules are human-understandable. The learning algorithm is validated in 6 exercises with different characteristics, correctly identifying and representing the rules from a few examples.},
 bibtype = {techreport},
 author = {Andriella, Antonio and Suárez-Hernández, Alejandro and Segovia-Aguas, Javier and Torras, Carme and Alenyà, Guillem}
}

Social Assistive Robots are a powerful tool to be used in patients' cognitive training. The purpose of this study is to evaluate a new methodology to enable caregivers to teach cognitive exercises to the robot in an easy and natural way. We build upon our existing framework, in which a robot is employed to provide encouragement and hints while a patient is physically playing a cognitive exercise. In this paper, we focus on empowering the caregiver to easily teach new board exercises to the robot by providing positive examples. The proposed learning method has two main advantages i) the teaching procedure is human-friendly ii) the produced exercise rules are human-understandable. The learning algorithm is validated in 6 exercises with different characteristics, correctly identifying and representing the rules from a few examples.

@misc{
 title = {Generalized planning with positive and negative examples},
 type = {misc},
 year = {2019},
 source = {arXiv},
 id = {7a5b0833-2ebd-3b13-a56e-0b860710d882},
 created = {2020-11-01T23:59:00.000Z},
 file_attached = {false},
 profile_id = {de5765e4-e253-3166-8178-333c824974ba},
 last_modified = {2020-11-03T21:11:54.174Z},
 read = {false},
 starred = {false},
 authored = {true},
 confirmed = {false},
 hidden = {false},
 private_publication = {false},
 abstract = {Copyright © 2019, arXiv, All rights reserved. Generalized planning aims at computing an algorithm-like structure (generalized plan) that solves a set of multiple planning instances. In this paper we define negative examples for generalized planning as planning instances that must not be solved by a generalized plan. With this regard the paper extends the notion of validation of a generalized plan as the problem of verifying that a given generalized plan solves the set of input positives instances while it fails to solve a given input set of negative examples. This notion of plan validation allows us to define quantitative metrics to asses the generalization capacity of generalized plans. The paper also shows how to incorporate this new notion of plan validation into a compilation for plan synthesis that takes both positive and negative instances as input. Experiments show that incorporating negative examples can accelerate plan synthesis in several domains and leverage quantitative metrics to evaluate the generalization capacity of the synthesized plans.},
 bibtype = {misc},
 author = {Segovia-Aguas, J. and Jiménez, S. and Jonsson, A.}
}

Copyright © 2019, arXiv, All rights reserved. Generalized planning aims at computing an algorithm-like structure (generalized plan) that solves a set of multiple planning instances. In this paper we define negative examples for generalized planning as planning instances that must not be solved by a generalized plan. With this regard the paper extends the notion of validation of a generalized plan as the problem of verifying that a given generalized plan solves the set of input positives instances while it fails to solve a given input set of negative examples. This notion of plan validation allows us to define quantitative metrics to asses the generalization capacity of generalized plans. The paper also shows how to incorporate this new notion of plan validation into a compilation for plan synthesis that takes both positive and negative instances as input. Experiments show that incorporating negative examples can accelerate plan synthesis in several domains and leverage quantitative metrics to evaluate the generalization capacity of the synthesized plans.

@article{
 title = {Program synthesis for generalized planning},
 type = {article},
 year = {2018},
 keywords = {62,Automated programming,Classical planning,Generalized planning,Program synthesis,info:eu-repo/semantics/publishedVersion},
 websites = {http://www.tdx.cat/handle/10803/663753},
 month = {10},
 publisher = {Universitat Pompeu Fabra},
 day = {5},
 id = {777b5c2c-4184-39b7-8b03-36e7b10b3a3d},
 created = {2019-05-29T08:55:18.727Z},
 accessed = {2019-05-29},
 file_attached = {true},
 profile_id = {de5765e4-e253-3166-8178-333c824974ba},
 last_modified = {2019-07-24T12:34:58.388Z},
 read = {false},
 starred = {false},
 authored = {true},
 confirmed = {false},
 hidden = {false},
 private_publication = {false},
 bibtype = {article},
 author = {Segovia-Aguas, Javier},
 journal = {TDX (Tesis Doctorals en Xarxa)}
}

@techreport{
 title = {Computing Hierarchical Finite State Controllers with Classical Planning},
 type = {techreport},
 year = {2018},
 source = {Journal of Artificial Intelligence Research},
 pages = {755-797},
 volume = {62},
 id = {6a1add0e-c349-3fdf-b27a-53d7face4887},
 created = {2020-10-07T10:16:47.859Z},
 file_attached = {true},
 profile_id = {de5765e4-e253-3166-8178-333c824974ba},
 last_modified = {2020-10-07T10:16:48.483Z},
 read = {false},
 starred = {false},
 authored = {true},
 confirmed = {false},
 hidden = {false},
 private_publication = {false},
 abstract = {Finite State Controllers (FSCs) are an effective way to compactly represent sequential plans. By imposing appropriate conditions on transitions, FSCs can also represent generalized plans (plans that solve a range of planning problems from a given domain). In this paper we introduce the concept of hierarchical FSCs for planning by allowing controllers to call other controllers. This call mechanism allows hierarchical FSCs to represent generalized plans more compactly than individual FSCs, to compute controllers in a modular fashion or even more, to compute recursive controllers. The paper introduces a classical planning compilation for computing hierarchical FSCs that solve challenging generalized planning tasks. The compilation takes as input a finite set of classical planning problems from a given domain. The output of the compilation is a single classical planning problem whose solution induces: (1) a hierarchical FSC and (2), the corresponding validation of that controller on the input classical planning problems.},
 bibtype = {techreport},
 author = {Segovia-Aguas, Javier and Jiménez, Sergio and Jonsson, Anders}
}

Finite State Controllers (FSCs) are an effective way to compactly represent sequential plans. By imposing appropriate conditions on transitions, FSCs can also represent generalized plans (plans that solve a range of planning problems from a given domain). In this paper we introduce the concept of hierarchical FSCs for planning by allowing controllers to call other controllers. This call mechanism allows hierarchical FSCs to represent generalized plans more compactly than individual FSCs, to compute controllers in a modular fashion or even more, to compute recursive controllers. The paper introduces a classical planning compilation for computing hierarchical FSCs that solve challenging generalized planning tasks. The compilation takes as input a finite set of classical planning problems from a given domain. The output of the compilation is a single classical planning problem whose solution induces: (1) a hierarchical FSC and (2), the corresponding validation of that controller on the input classical planning problems.

@inproceedings{
 title = {Generating context-free grammars using classical planning},
 type = {inproceedings},
 year = {2017},
 id = {ab35330f-7730-3d96-a2cb-3dad63a1ed3a},
 created = {2018-07-16T07:35:57.779Z},
 file_attached = {false},
 profile_id = {de5765e4-e253-3166-8178-333c824974ba},
 last_modified = {2018-07-16T07:35:57.779Z},
 read = {false},
 starred = {false},
 authored = {true},
 confirmed = {false},
 hidden = {false},
 private_publication = {false},
 abstract = {This paper presents a novel approach for generating Context-Free Grammars (CFGs) from small sets of input strings (a single input string in some cases). Our approach is to compile this task into a classical planning problem whose solutions are sequences of actions that build and validate a CFG compliant with the input strings. In addition, we show that our compilation is suitable for implementing the two canonical tasks for CFGs, string production and string recognition.},
 bibtype = {inproceedings},
 author = {Segovia-Aguas, J. and Jiménez, S. and Jonsson, A.},
 booktitle = {IJCAI International Joint Conference on Artificial Intelligence}
}

This paper presents a novel approach for generating Context-Free Grammars (CFGs) from small sets of input strings (a single input string in some cases). Our approach is to compile this task into a classical planning problem whose solutions are sequences of actions that build and validate a CFG compliant with the input strings. In addition, we show that our compilation is suitable for implementing the two canonical tasks for CFGs, string production and string recognition.

@inproceedings{
 title = {Hierarchical finite state controllers for generalized planning},
 type = {inproceedings},
 year = {2016},
 volume = {2016-Janua},
 id = {df652bc0-9305-3115-a7c0-12a95c889558},
 created = {2018-07-16T07:35:57.779Z},
 file_attached = {false},
 profile_id = {de5765e4-e253-3166-8178-333c824974ba},
 last_modified = {2018-07-16T07:35:57.779Z},
 read = {false},
 starred = {false},
 authored = {true},
 confirmed = {false},
 hidden = {false},
 private_publication = {false},
 abstract = {Finite State Controllers (FSCs) are an effective way to represent sequential plans compactly. By imposing appropriate conditions on transitions, FSCs can also represent generalized plans that solve a range of planning problems from a given domain. In this paper we introduce the concept of hierarchical FSCs for planning by allowing controllers to call other controllers. We show that hierarchical FSCs can represent generalized plans more compactly than individual FSCs. Moreover, our call mechanism makes it possible to generate hierarchical FSCs in a modular fashion, or even to apply recursion. We also introduce a compilation that enables a classical planner to generate hierarchical FSCs that solve challenging generalized planning problems. The compilation takes as input a set of planning problems from a given domain and outputs a single classical planning problem, whose solution corresponds to a hierarchical FSC.},
 bibtype = {inproceedings},
 author = {Segovia-Aguas, J. and Jimenez, S. and Jonsson, A.},
 booktitle = {IJCAI International Joint Conference on Artificial Intelligence}
}

Finite State Controllers (FSCs) are an effective way to represent sequential plans compactly. By imposing appropriate conditions on transitions, FSCs can also represent generalized plans that solve a range of planning problems from a given domain. In this paper we introduce the concept of hierarchical FSCs for planning by allowing controllers to call other controllers. We show that hierarchical FSCs can represent generalized plans more compactly than individual FSCs. Moreover, our call mechanism makes it possible to generate hierarchical FSCs in a modular fashion, or even to apply recursion. We also introduce a compilation that enables a classical planner to generate hierarchical FSCs that solve challenging generalized planning problems. The compilation takes as input a set of planning problems from a given domain and outputs a single classical planning problem, whose solution corresponds to a hierarchical FSC.

@inproceedings{
 title = {Automatic generation of high-level state features for generalized planning},
 type = {inproceedings},
 year = {2016},
 volume = {2016-Janua},
 id = {e70bfd4e-070e-3a8d-9630-9aa216b687b7},
 created = {2018-07-16T07:35:57.854Z},
 file_attached = {false},
 profile_id = {de5765e4-e253-3166-8178-333c824974ba},
 last_modified = {2018-07-16T08:13:35.876Z},
 read = {false},
 starred = {false},
 authored = {true},
 confirmed = {false},
 hidden = {false},
 private_publication = {false},
 abstract = {In many domains generalized plans can only be computed if certain high-level state features, i.e. features that capture key concepts to accurately distinguish between states and make good decisions, are available. In most applications of generalized planning such features are hand-coded by an expert. This paper presents a novel method to automatically generate high-level state features for solving a generalized planning problem. Our method extends a compilation of generalized planning into classical planning and integrates the computation of generalized plans with the computation of features, in the form of conjunctive queries. Experiments show that we generate features for diverse generalized planning problems and hence, compute generalized plans without providing a prior high-level representation of the states. We also bring a new landscape of challenging benchmarks to classical planning since our compilation naturally models classification tasks as classical planning problems.},
 bibtype = {inproceedings},
 author = {Lotinac, D. and Segovia-Aguas, J. and Jimenez, S. and Jonsson, A.},
 booktitle = {IJCAI International Joint Conference on Artificial Intelligence}
}

In many domains generalized plans can only be computed if certain high-level state features, i.e. features that capture key concepts to accurately distinguish between states and make good decisions, are available. In most applications of generalized planning such features are hand-coded by an expert. This paper presents a novel method to automatically generate high-level state features for solving a generalized planning problem. Our method extends a compilation of generalized planning into classical planning and integrates the computation of generalized plans with the computation of features, in the form of conjunctive queries. Experiments show that we generate features for diverse generalized planning problems and hence, compute generalized plans without providing a prior high-level representation of the states. We also bring a new landscape of challenging benchmarks to classical planning since our compilation naturally models classification tasks as classical planning problems.

@book{
 title = {Planning with partially specified behaviors},
 type = {book},
 year = {2016},
 source = {Frontiers in Artificial Intelligence and Applications},
 keywords = {Agent Programming,Classical Planning,Hierachical Decomposition,Reinforcement Learning},
 volume = {288},
 id = {08216ed4-2fcc-3fab-a0d7-4dc171d88fe2},
 created = {2018-07-16T07:35:57.876Z},
 file_attached = {false},
 profile_id = {de5765e4-e253-3166-8178-333c824974ba},
 last_modified = {2018-07-16T07:35:57.876Z},
 read = {false},
 starred = {false},
 authored = {true},
 confirmed = {false},
 hidden = {false},
 private_publication = {false},
 abstract = {© 2016 The authors and IOS Press. All rights reserved. In this paper we present a framework called Planning with Partially Specified Behaviors, or PPSB, for combining reinforcement learning and planning to solve sequential decision problems. Although not often combined, we show that reinforcement learning and planning complement each other well, in that each can take advantage of the strengths of the other. PPSB uses partial action specifications to decompose sequential decision problems into tasks that serve as an interface between reinforcement learning and planning. On the bottom level, we use reinforcement learning to compute policies for achieving each individual task. On the top level, we use planning to produce a sequence of tasks that achieves an overall goal. We validate PPSB in experiments in which a robot has to perform tasks in a realistic simulated environment.},
 bibtype = {book},
 author = {Segovia-Aguas, J. and Ferrer-Mestres, J. and Jonsson, A.},
 doi = {10.3233/978-1-61499-696-5-263}
}

© 2016 The authors and IOS Press. All rights reserved. In this paper we present a framework called Planning with Partially Specified Behaviors, or PPSB, for combining reinforcement learning and planning to solve sequential decision problems. Although not often combined, we show that reinforcement learning and planning complement each other well, in that each can take advantage of the strengths of the other. PPSB uses partial action specifications to decompose sequential decision problems into tasks that serve as an interface between reinforcement learning and planning. On the bottom level, we use reinforcement learning to compute policies for achieving each individual task. On the top level, we use planning to produce a sequence of tasks that achieves an overall goal. We validate PPSB in experiments in which a robot has to perform tasks in a realistic simulated environment.

@article{
 title = {Generalized planning with procedural domain control knowledge},
 type = {article},
 year = {2016},
 pages = {285--293},
 id = {e0fd0b40-640f-3db0-a043-ae9205e4cdbe},
 created = {2018-07-16T08:10:14.565Z},
 file_attached = {false},
 profile_id = {de5765e4-e253-3166-8178-333c824974ba},
 last_modified = {2018-07-16T08:13:55.819Z},
 read = {false},
 starred = {false},
 authored = {true},
 confirmed = {false},
 hidden = {false},
 private_publication = {false},
 abstract = {Generalized planning is the task of generating a single solution that is valid for a set of planning problems. In this paper we show how to represent and compute generalized plans using procedural Domain Control Knowledge (DCK). We define a divide and conquer approach that first generates the procedural DCK solving a set of planning problems representative of certain subtasks and then compile it as callable procedures of the overall generalized planning problem. Our procedure calling mechanism allows nested and recursive procedure calls and is implemented in PDDL so that classical planners can compute and exploit procedural DCK. Experiments show that an off-the-shelf classical planner, using procedural DCK as callable procedures, can compute generalized plans in a wide range of domains including non-trivial ones, such as sorting variable-size lists or DFS traversal of binary trees with variable size.},
 bibtype = {article},
 author = {Segovia-Aguas, J. and Jiménez, S. and Jonsson, A.},
 journal = {Proceedings of the Twenty-Sixth International Conference on Automated Planning and Scheduling}
}

Generalized planning is the task of generating a single solution that is valid for a set of planning problems. In this paper we show how to represent and compute generalized plans using procedural Domain Control Knowledge (DCK). We define a divide and conquer approach that first generates the procedural DCK solving a set of planning problems representative of certain subtasks and then compile it as callable procedures of the overall generalized planning problem. Our procedure calling mechanism allows nested and recursive procedure calls and is implemented in PDDL so that classical planners can compute and exploit procedural DCK. Experiments show that an off-the-shelf classical planner, using procedural DCK as callable procedures, can compute generalized plans in a wide range of domains including non-trivial ones, such as sorting variable-size lists or DFS traversal of binary trees with variable size.

@techreport{
 title = {Unsupervised Classification of Planning Instances},
 type = {techreport},
 websites = {www.aaai.org},
 id = {8c43704b-8916-330b-a86d-d6eb3c5d9c42},
 created = {2020-10-07T10:15:15.482Z},
 file_attached = {true},
 profile_id = {de5765e4-e253-3166-8178-333c824974ba},
 last_modified = {2020-10-07T10:15:16.205Z},
 read = {false},
 starred = {false},
 authored = {true},
 confirmed = {false},
 hidden = {false},
 private_publication = {false},
 abstract = {In this paper we introduce a novel approach for unsuper-vised classification of planning instances based on the recent formalism of planning programs. Our approach is inspired by structured prediction in machine learning, which aims at predicting structured information about a given input rather than a scalar value. In our case, each input is an unlabelled classical planning instance, and the associated structured information is the planning program that solves the instance. We describe a method that takes as input a set of planning instances and outputs a set of planning programs, classifying each instance according to the program that solves it. Our results show that automated planning can be successfully used to solve structured unsupervised classification tasks, and invites further exploration of the connection between automated planning and structured prediction.},
 bibtype = {techreport},
 author = {Segovia, Javier and Jiménez, Sergio and Jonsson, Anders}
}

In this paper we introduce a novel approach for unsuper-vised classification of planning instances based on the recent formalism of planning programs. Our approach is inspired by structured prediction in machine learning, which aims at predicting structured information about a given input rather than a scalar value. In our case, each input is an unlabelled classical planning instance, and the associated structured information is the planning program that solves the instance. We describe a method that takes as input a set of planning instances and outputs a set of planning programs, classifying each instance according to the program that solves it. Our results show that automated planning can be successfully used to solve structured unsupervised classification tasks, and invites further exploration of the connection between automated planning and structured prediction.