From 46cceb28e6228bedb7d3d92334c7078c3d65db16 Mon Sep 17 00:00:00 2001 From: Jendrik Seipp Date: Sat, 5 Sep 2026 22:31:54 +0200 Subject: [PATCH 1/5] Document research references for search plugins. All references are verified against DBLP. --- src/search/heuristics/additive_heuristic.cc | 8 ++++++++ src/search/heuristics/cea_heuristic.cc | 11 +++++++++++ src/search/heuristics/cg_heuristic.cc | 10 ++++++++++ src/search/heuristics/ff_heuristic.cc | 10 ++++++++++ src/search/heuristics/goal_count_heuristic.cc | 11 +++++++++++ src/search/heuristics/hm_heuristic.cc | 10 ++++++++++ src/search/heuristics/max_heuristic.cc | 8 ++++++++ .../landmarks/landmark_factory_rpg_exhaust.cc | 12 ++++++++++++ .../landmarks/landmark_factory_rpg_sasp.cc | 12 ++++++++++-- .../landmarks/landmark_factory_zhu_givan.cc | 10 ++++++++-- src/search/landmarks/landmark_heuristic.cc | 2 +- .../merge_scoring_function_miasm.cc | 6 +++--- .../merge_strategy_factory_sccs.cc | 6 +++--- .../merge_and_shrink/shrink_bisimulation.cc | 2 +- src/search/merge_and_shrink/shrink_random.cc | 13 ++++++++++++- src/search/open_lists/alternation_open_list.cc | 13 +++++++++++++ src/search/open_lists/pareto_open_list.cc | 13 +++++++++++++ src/search/open_lists/tiebreaking_open_list.cc | 13 ++++++++++++- src/search/open_lists/type_based_open_list.cc | 4 ++-- .../delete_relaxation_rr_constraints.cc | 9 ++++----- src/search/pdbs/canonical_pdbs_heuristic.cc | 14 ++++++++++++++ .../pattern_collection_generator_genetic.cc | 6 +++--- src/search/pdbs/pattern_generator_greedy.cc | 13 +++++++++++++ src/search/pdbs/zero_one_pdbs_heuristic.cc | 13 +++++++++++++ src/search/pruning/limited_pruning.cc | 13 +++++++++++++ .../enforced_hill_climbing_search.cc | 11 ++++++++++- .../search_algorithms/iterated_search.cc | 12 +++++++++++- src/search/search_algorithms/plugin_astar.cc | 11 +++++++++++ src/search/search_algorithms/plugin_eager.cc | 13 ++++++++++++- .../search_algorithms/plugin_eager_greedy.cc | 13 ++++++++++++- .../search_algorithms/plugin_eager_wastar.cc | 9 ++++++++- src/search/search_algorithms/plugin_lazy.cc | 13 ++++++++++++- .../search_algorithms/plugin_lazy_greedy.cc | 13 ++++++++++++- .../search_algorithms/plugin_lazy_wastar.cc | 18 ++++++++++++++++++ 34 files changed, 324 insertions(+), 31 deletions(-) diff --git a/src/search/heuristics/additive_heuristic.cc b/src/search/heuristics/additive_heuristic.cc index 48c0d411e0..d0ca856564 100644 --- a/src/search/heuristics/additive_heuristic.cc +++ b/src/search/heuristics/additive_heuristic.cc @@ -3,6 +3,7 @@ #include "../plugins/plugin.h" #include "../task_utils/task_properties.h" #include "../utils/logging.h" +#include "../utils/markup.h" #include #include @@ -150,6 +151,13 @@ class AdditiveHeuristicFeature public: AdditiveHeuristicFeature() : TypedFeature("add") { document_title("Additive heuristic"); + document_synopsis( + "The additive heuristic is described in the following paper:" + + utils::format_journal_reference( + {"Blai Bonet", "Hector Geffner"}, + "Planning as Heuristic Search", + "https://doi.org/10.1016/S0004-3702%2801%2900108-4", + "Artificial Intelligence", "129(1-2)", "5-33", "2001")); relaxation_heuristic::add_relaxation_heuristic_options_to_feature( *this, "add"); diff --git a/src/search/heuristics/cea_heuristic.cc b/src/search/heuristics/cea_heuristic.cc index 5b1383e396..59f375ed8b 100644 --- a/src/search/heuristics/cea_heuristic.cc +++ b/src/search/heuristics/cea_heuristic.cc @@ -5,6 +5,7 @@ #include "../plugins/plugin.h" #include "../task_utils/task_properties.h" #include "../utils/logging.h" +#include "../utils/markup.h" #include #include @@ -455,6 +456,16 @@ class ContextEnhancedAdditiveHeuristicFeature public: ContextEnhancedAdditiveHeuristicFeature() : TypedFeature("cea") { document_title("Context-enhanced additive heuristic"); + document_synopsis( + "The context-enhanced additive heuristic is described in the " + "following paper:" + + utils::format_conference_reference( + {"Malte Helmert", "Hector Geffner"}, + "Unifying the Causal Graph and Additive Heuristics", + "https://cdn.aaai.org/ICAPS/2008/ICAPS08-018.pdf", + "Proceedings of the 18th International Conference on " + "Automated Planning and Scheduling (ICAPS 2008)", + "140-147", "AAAI Press", "2008")); tasks::add_axioms_option_to_feature(*this); add_heuristic_options_to_feature(*this, "cea"); diff --git a/src/search/heuristics/cg_heuristic.cc b/src/search/heuristics/cg_heuristic.cc index 5a10c7cb64..1e30d3afe2 100644 --- a/src/search/heuristics/cg_heuristic.cc +++ b/src/search/heuristics/cg_heuristic.cc @@ -6,6 +6,7 @@ #include "../plugins/plugin.h" #include "../task_utils/task_properties.h" #include "../utils/logging.h" +#include "../utils/markup.h" #include #include @@ -291,6 +292,15 @@ class CGHeuristicFeature public: CGHeuristicFeature() : TypedFeature("cg") { document_title("Causal graph heuristic"); + document_synopsis( + "The causal graph heuristic is described in the following paper:" + + utils::format_conference_reference( + {"Malte Helmert"}, + "A Planning Heuristic Based on Causal Graph Analysis", + "https://cdn.aaai.org/ICAPS/2004/ICAPS04-021.pdf", + "Proceedings of the 14th International Conference on Automated " + "Planning and Scheduling (ICAPS 2004)", + "161-170", "AAAI Press", "2004")); add_option( "max_cache_size", diff --git a/src/search/heuristics/ff_heuristic.cc b/src/search/heuristics/ff_heuristic.cc index 591ae6035b..ee4a4b8f55 100644 --- a/src/search/heuristics/ff_heuristic.cc +++ b/src/search/heuristics/ff_heuristic.cc @@ -3,6 +3,7 @@ #include "../plugins/plugin.h" #include "../task_utils/task_properties.h" #include "../utils/logging.h" +#include "../utils/markup.h" #include @@ -74,6 +75,15 @@ class FFHeuristicFeature public: FFHeuristicFeature() : TypedFeature("ff") { document_title("FF heuristic"); + document_synopsis( + "The FF heuristic is described in the following paper:" + + utils::format_journal_reference( + {"Jörg Hoffmann", "Bernhard Nebel"}, + "The FF Planning System: Fast Plan Generation Through " + "Heuristic Search", + "https://www.jair.org/index.php/jair/article/download/10276/24496", + "Journal of Artificial Intelligence Research", "14", "253-302", + "2001")); relaxation_heuristic::add_relaxation_heuristic_options_to_feature( *this, "ff"); diff --git a/src/search/heuristics/goal_count_heuristic.cc b/src/search/heuristics/goal_count_heuristic.cc index bc1eee7efc..87b254bf89 100644 --- a/src/search/heuristics/goal_count_heuristic.cc +++ b/src/search/heuristics/goal_count_heuristic.cc @@ -2,6 +2,7 @@ #include "../plugins/plugin.h" #include "../utils/logging.h" +#include "../utils/markup.h" #include using namespace std; @@ -34,6 +35,16 @@ class GoalCountHeuristicFeature public: GoalCountHeuristicFeature() : TypedFeature("goalcount") { document_title("Goal count heuristic"); + document_synopsis( + "Counts the goal facts that are not true in the current state. " + "An early use of the number of remaining goals to guide planning " + "search is described in the following article:" + + utils::format_journal_reference( + {"Richard E. Fikes", "Nils J. Nilsson"}, + "STRIPS: A New Approach to the Application of Theorem Proving " + "to Problem Solving", + "https://doi.org/10.1016/0004-3702%2871%2990010-5", + "Artificial Intelligence", "2(3-4)", "189-208", "1971")); add_heuristic_options_to_feature(*this, "goalcount"); diff --git a/src/search/heuristics/hm_heuristic.cc b/src/search/heuristics/hm_heuristic.cc index 8a39e17375..7233c0bfeb 100644 --- a/src/search/heuristics/hm_heuristic.cc +++ b/src/search/heuristics/hm_heuristic.cc @@ -3,6 +3,7 @@ #include "../plugins/plugin.h" #include "../task_utils/task_properties.h" #include "../utils/logging.h" +#include "../utils/markup.h" #include #include @@ -257,6 +258,15 @@ class HMHeuristicFeature public: HMHeuristicFeature() : TypedFeature("hm") { document_title("h^m heuristic"); + document_synopsis( + "The h^m family of heuristics is described in the following paper:" + + utils::format_conference_reference( + {"Patrik Haslum", "Hector Geffner"}, + "Admissible Heuristics for Optimal Planning", + "https://cdn.aaai.org/AIPS/2000/AIPS00-015.pdf", + "Proceedings of the Fifth International Conference on " + "Artificial Intelligence Planning Systems (AIPS 2000)", + "140-149", "AAAI Press", "2000")); add_option( "m", "subset size", "2", plugins::Bounds("1", "infinity")); diff --git a/src/search/heuristics/max_heuristic.cc b/src/search/heuristics/max_heuristic.cc index 25668945ad..1c7553d8fe 100644 --- a/src/search/heuristics/max_heuristic.cc +++ b/src/search/heuristics/max_heuristic.cc @@ -2,6 +2,7 @@ #include "../plugins/plugin.h" #include "../utils/logging.h" +#include "../utils/markup.h" #include #include @@ -106,6 +107,13 @@ class HSPMaxHeuristicFeature public: HSPMaxHeuristicFeature() : TypedFeature("hmax") { document_title("Max heuristic"); + document_synopsis( + "The h^max heuristic is described in the following paper:" + + utils::format_journal_reference( + {"Blai Bonet", "Hector Geffner"}, + "Planning as Heuristic Search", + "https://doi.org/10.1016/S0004-3702%2801%2900108-4", + "Artificial Intelligence", "129(1-2)", "5-33", "2001")); relaxation_heuristic::add_relaxation_heuristic_options_to_feature( *this, "hmax"); diff --git a/src/search/landmarks/landmark_factory_rpg_exhaust.cc b/src/search/landmarks/landmark_factory_rpg_exhaust.cc index 446885568b..e90eaec21b 100644 --- a/src/search/landmarks/landmark_factory_rpg_exhaust.cc +++ b/src/search/landmarks/landmark_factory_rpg_exhaust.cc @@ -8,6 +8,7 @@ #include "../plugins/plugin.h" #include "../utils/logging.h" +#include "../utils/markup.h" #include @@ -87,6 +88,17 @@ class LandmarkFactoryRpgExhaustFeature public: LandmarkFactoryRpgExhaustFeature() : TypedFeature("lm_exhaust") { document_title("Exhaustive landmarks"); + document_note( + "Reference", + "For background on delete-relaxation landmarks and the causal " + "landmarks computed with use_unary_relaxation=true, see:" + + utils::format_conference_reference( + {"Emil Keyder", "Silvia Richter", "Malte Helmert"}, + "Sound and Complete Landmarks for And/Or Graphs", + "https://ai.dmi.unibas.ch/papers/keyder-et-al-ecai2010.pdf", + "Proceedings of the 19th European Conference on " + "Artificial Intelligence (ECAI 2010)", + "335-340", "IOS Press", "2010")); document_synopsis( "Exhaustively checks for each atom if it is a landmark." "This check is done using relaxed planning."); diff --git a/src/search/landmarks/landmark_factory_rpg_sasp.cc b/src/search/landmarks/landmark_factory_rpg_sasp.cc index e068179718..04a285dd7a 100644 --- a/src/search/landmarks/landmark_factory_rpg_sasp.cc +++ b/src/search/landmarks/landmark_factory_rpg_sasp.cc @@ -11,6 +11,7 @@ #include "../plugins/plugin.h" #include "../utils/collections.h" #include "../utils/logging.h" +#include "../utils/markup.h" #include "../utils/system.h" #include @@ -774,8 +775,15 @@ class LandmarkFactoryRpgSaspFeature public: LandmarkFactoryRpgSaspFeature() : TypedFeature("lm_rhw") { document_title("RHW landmarks"); - document_synopsis("The landmark generation method introduced by " - "Richter, Helmert and Westphal (AAAI 2008)."); + document_synopsis( + "The landmark generation method is described in the following paper:" + + utils::format_conference_reference( + {"Silvia Richter", "Malte Helmert", "Matthias Westphal"}, + "Landmarks Revisited", + "https://cdn.aaai.org/AAAI/2008/AAAI08-155.pdf", + "Proceedings of the 23rd AAAI Conference on Artificial " + "Intelligence (AAAI 2008)", + "975-982", "AAAI Press", "2008")); add_option( "disjunctive_landmarks", "keep disjunctive landmarks", "true"); add_use_orders_option_to_feature(*this); diff --git a/src/search/landmarks/landmark_factory_zhu_givan.cc b/src/search/landmarks/landmark_factory_zhu_givan.cc index 974606bfb1..00b8fabe8c 100644 --- a/src/search/landmarks/landmark_factory_zhu_givan.cc +++ b/src/search/landmarks/landmark_factory_zhu_givan.cc @@ -8,6 +8,7 @@ #include "../plugins/plugin.h" #include "../utils/logging.h" +#include "../utils/markup.h" #include #include @@ -318,8 +319,13 @@ class LandmarkFactoryZhuGivanFeature public: LandmarkFactoryZhuGivanFeature() : TypedFeature("lm_zg") { document_title("Zhu/Givan landmarks"); - document_synopsis("The landmark generation method introduced by " - "Zhu & Givan (ICAPS 2003 Doctoral Consortium)."); + document_synopsis( + "The landmark generation method is described in the following paper:" + + utils::format_conference_reference( + {"Lin Zhu", "Robert Givan"}, + "Landmark Extraction via Planning Graph Propagation", + "https://icaps03.icaps-conference.org/satellite_events/documents/dc/33/Zhu.pdf", + "ICAPS 2003 Doctoral Consortium", "156-160", "", "2003")); add_use_orders_option_to_feature(*this); add_landmark_factory_options_to_feature(*this); diff --git a/src/search/landmarks/landmark_heuristic.cc b/src/search/landmarks/landmark_heuristic.cc index ac0ea99a7e..09a25bfa4a 100644 --- a/src/search/landmarks/landmark_heuristic.cc +++ b/src/search/landmarks/landmark_heuristic.cc @@ -237,7 +237,7 @@ void add_landmark_heuristic_options_to_feature( utils::format_conference_reference( {"Clemens Büchner", "Thomas Keller", "Salomé Eriksson", "Malte Helmert"}, - "Landmarks Progression in Heuristic Search", + "Landmark Progression in Heuristic Search", "https://ai.dmi.unibas.ch/papers/buechner-et-al-icaps2023.pdf", "Proceedings of the Thirty-Third International Conference on " "Automated Planning and Scheduling (ICAPS 2023)", diff --git a/src/search/merge_and_shrink/merge_scoring_function_miasm.cc b/src/search/merge_and_shrink/merge_scoring_function_miasm.cc index 28f248529c..8c1e1b3a59 100644 --- a/src/search/merge_and_shrink/merge_scoring_function_miasm.cc +++ b/src/search/merge_and_shrink/merge_scoring_function_miasm.cc @@ -124,9 +124,9 @@ class MergeScoringFunctionMIASMFeature {"Silvan Sievers", "Martin Wehrle", "Malte Helmert"}, "An Analysis of Merge Strategies for Merge-and-Shrink Heuristics", "https://ai.dmi.unibas.ch/papers/sievers-et-al-icaps2016.pdf", - "Proceedings of the 26th International Conference on Planning and " - "Scheduling (ICAPS 2016)", - "2358-2366", "AAAI Press", "2016")); + "Proceedings of the 26th International Conference on Automated " + "Planning and Scheduling (ICAPS 2016)", + "294-298", "AAAI Press", "2016")); // TODO: use shrink strategy and limit options from // MergeAndShrinkHeuristic instead of having the identical options here diff --git a/src/search/merge_and_shrink/merge_strategy_factory_sccs.cc b/src/search/merge_and_shrink/merge_strategy_factory_sccs.cc index 2b8f3ae13a..ded0ea0576 100644 --- a/src/search/merge_and_shrink/merge_strategy_factory_sccs.cc +++ b/src/search/merge_and_shrink/merge_strategy_factory_sccs.cc @@ -147,9 +147,9 @@ class MergeStrategyFactorySCCsFeature {"Silvan Sievers", "Martin Wehrle", "Malte Helmert"}, "An Analysis of Merge Strategies for Merge-and-Shrink Heuristics", "https://ai.dmi.unibas.ch/papers/sievers-et-al-icaps2016.pdf", - "Proceedings of the 26th International Conference on Planning and " - "Scheduling (ICAPS 2016)", - "2358-2366", "AAAI Press", "2016") + + "Proceedings of the 26th International Conference on Automated " + "Planning and Scheduling (ICAPS 2016)", + "294-298", "AAAI Press", "2016") + "In a nutshell, it computes the maximal strongly connected " "components (SCCs) of the causal graph, " "obtaining a partitioning of the task's variables. Every such " diff --git a/src/search/merge_and_shrink/shrink_bisimulation.cc b/src/search/merge_and_shrink/shrink_bisimulation.cc index 72aec83905..f4d94204f6 100644 --- a/src/search/merge_and_shrink/shrink_bisimulation.cc +++ b/src/search/merge_and_shrink/shrink_bisimulation.cc @@ -382,7 +382,7 @@ class ShrinkBisimulationFeature utils::format_conference_reference( {"Raz Nissim", "Joerg Hoffmann", "Malte Helmert"}, "Computing Perfect Heuristics in Polynomial Time: On Bisimulation" - " and Merge-and-Shrink Abstractions in Optimal Planning.", + " and Merge-and-Shrink Abstraction in Optimal Planning", "https://ai.dmi.unibas.ch/papers/nissim-et-al-ijcai2011.pdf", "Proceedings of the Twenty-Second International Joint Conference" " on Artificial Intelligence (IJCAI 2011)", diff --git a/src/search/merge_and_shrink/shrink_random.cc b/src/search/merge_and_shrink/shrink_random.cc index d7cf526198..0d48230954 100644 --- a/src/search/merge_and_shrink/shrink_random.cc +++ b/src/search/merge_and_shrink/shrink_random.cc @@ -4,6 +4,7 @@ #include "transition_system.h" #include "../plugins/plugin.h" +#include "../utils/markup.h" #include #include @@ -38,7 +39,17 @@ class ShrinkRandomFeature public: ShrinkRandomFeature() : TypedFeature("shrink_random") { document_title("Random"); - document_synopsis(""); + document_synopsis( + "Randomly combining abstract states is discussed as a baseline " + "shrinking strategy in the following paper:" + + utils::format_conference_reference( + {"Malte Helmert", "Patrik Haslum", "Jörg Hoffmann"}, + "Flexible Abstraction Heuristics for Optimal Sequential " + "Planning", + "https://cdn.aaai.org/ICAPS/2007/ICAPS07-023.pdf", + "Proceedings of the 17th International Conference on " + "Automated Planning and Scheduling (ICAPS 2007)", + "176-183", "AAAI Press", "2007")); add_shrink_bucket_options_to_feature(*this); } diff --git a/src/search/open_lists/alternation_open_list.cc b/src/search/open_lists/alternation_open_list.cc index 57ce0760db..ba9b7ca3eb 100644 --- a/src/search/open_lists/alternation_open_list.cc +++ b/src/search/open_lists/alternation_open_list.cc @@ -4,6 +4,7 @@ #include "../plugins/plugin.h" #include "../utils/component_errors.h" +#include "../utils/markup.h" #include "../utils/system.h" #include @@ -159,6 +160,18 @@ class AlternationOpenListFeature public: AlternationOpenListFeature() : TypedFeature("alt") { document_title("Alternation open list"); + document_note( + "Reference", + "Alternating between heuristic queues is discussed in the " + "following paper:" + + utils::format_conference_reference( + {"Gabriele Röger", "Malte Helmert"}, + "The More, the Merrier: Combining Heuristic Estimators " + "for Satisficing Planning", + "https://ojs.aaai.org/index.php/ICAPS/article/download/13435/13284", + "Proceedings of the 20th International Conference on " + "Automated Planning and Scheduling (ICAPS 2010)", + "246-249", "AAAI Press", "2010")); document_synopsis("Alternates between several open lists."); add_list_option>( "sublists", "open lists between which this one alternates"); diff --git a/src/search/open_lists/pareto_open_list.cc b/src/search/open_lists/pareto_open_list.cc index fa41046369..818d08f6f7 100644 --- a/src/search/open_lists/pareto_open_list.cc +++ b/src/search/open_lists/pareto_open_list.cc @@ -5,6 +5,7 @@ #include "../plugins/plugin.h" #include "../utils/hash.h" +#include "../utils/markup.h" #include "../utils/rng.h" #include "../utils/rng_options.h" @@ -258,6 +259,18 @@ class ParetoOpenListFeature public: ParetoOpenListFeature() : TypedFeature("pareto") { document_title("Pareto open list"); + document_note( + "Reference", + "The Pareto approach is described in the following paper. Its " + "sampling scheme corresponds to state_uniform_selection=true:" + + utils::format_conference_reference( + {"Gabriele Röger", "Malte Helmert"}, + "The More, the Merrier: Combining Heuristic Estimators " + "for Satisficing Planning", + "https://ojs.aaai.org/index.php/ICAPS/article/download/13435/13284", + "Proceedings of the 20th International Conference on " + "Automated Planning and Scheduling (ICAPS 2010)", + "246-249", "AAAI Press", "2010")); document_synopsis( "Selects one of the Pareto-optimal (regarding the sub-evaluators) " "entries for removal."); diff --git a/src/search/open_lists/tiebreaking_open_list.cc b/src/search/open_lists/tiebreaking_open_list.cc index 963a0de694..54b4d1fc48 100644 --- a/src/search/open_lists/tiebreaking_open_list.cc +++ b/src/search/open_lists/tiebreaking_open_list.cc @@ -4,6 +4,7 @@ #include "../open_list.h" #include "../plugins/plugin.h" +#include "../utils/markup.h" #include #include @@ -189,7 +190,17 @@ class TieBreakingOpenListFeature public: TieBreakingOpenListFeature() : TypedFeature("tiebreaking") { document_title("Tie-breaking open list"); - document_synopsis(""); + document_synopsis( + "Lexicographic tie-breaking between heuristics is discussed in " + "the following paper:" + + utils::format_conference_reference( + {"Gabriele Röger", "Malte Helmert"}, + "The More, the Merrier: Combining Heuristic Estimators " + "for Satisficing Planning", + "https://ojs.aaai.org/index.php/ICAPS/article/download/13435/13284", + "Proceedings of the 20th International Conference on " + "Automated Planning and Scheduling (ICAPS 2010)", + "246-249", "AAAI Press", "2010")); add_list_option>( "evals", "evaluators"); diff --git a/src/search/open_lists/type_based_open_list.cc b/src/search/open_lists/type_based_open_list.cc index 9676e87466..2c76b30c28 100644 --- a/src/search/open_lists/type_based_open_list.cc +++ b/src/search/open_lists/type_based_open_list.cc @@ -177,9 +177,9 @@ class TypeBasedOpenListFeature "Type-Based Exploration with Multiple Search Queues for" " Satisficing Planning", "http://www.aaai.org/ocs/index.php/AAAI/AAAI14/paper/view/8472/8705", - "Proceedings of the Twenty-Eigth AAAI Conference Conference" + "Proceedings of the Twenty-Eighth AAAI Conference" " on Artificial Intelligence (AAAI 2014)", - "2395-2401", "AAAI Press", "2014")); + "2395-2402", "AAAI Press", "2014")); add_list_option>( "evaluators", diff --git a/src/search/operator_counting/delete_relaxation_rr_constraints.cc b/src/search/operator_counting/delete_relaxation_rr_constraints.cc index aaa42fbeff..609cd4d3e8 100644 --- a/src/search/operator_counting/delete_relaxation_rr_constraints.cc +++ b/src/search/operator_counting/delete_relaxation_rr_constraints.cc @@ -569,15 +569,14 @@ class DeleteRelaxationRRConstraintsFeature "h^+^. With the right settings, these constraints can be used to " "compute the optimal delete-relaxation heuristic h^+^ (see example " "below). For details, see" + - utils::format_journal_reference( + utils::format_conference_reference( {"Masood Feyzbakhsh Rankooh", "Jussi Rintanen"}, "Efficient Computation and Informative Estimation of " - "h+ by Integer and Linear Programming" - "", + "h+ by Integer and Linear Programming", "https://ojs.aaai.org/index.php/ICAPS/article/view/19787/19546", "Proceedings of the Thirty-Second International Conference on " - "Automated Planning and Scheduling (ICAPS2022)", - "32", "71-79", "2022")); + "Automated Planning and Scheduling (ICAPS 2022)", + "71-79", "AAAI Press", "2022")); add_option( "acyclicity_type", diff --git a/src/search/pdbs/canonical_pdbs_heuristic.cc b/src/search/pdbs/canonical_pdbs_heuristic.cc index af19a69bb5..9773932be1 100644 --- a/src/search/pdbs/canonical_pdbs_heuristic.cc +++ b/src/search/pdbs/canonical_pdbs_heuristic.cc @@ -5,6 +5,7 @@ #include "../plugins/plugin.h" #include "../utils/logging.h" +#include "../utils/markup.h" #include "../utils/timer.h" #include @@ -97,6 +98,19 @@ class CanonicalPDBsHeuristicFeature CanonicalPDBsHeuristicFeature() : TypedFeature("cpdbs") { document_subcategory("heuristics_pdb"); document_title("Canonical PDB"); + document_note( + "Reference", + "The canonical pattern database heuristic is described in the " + "following paper:" + + utils::format_conference_reference( + {"Patrik Haslum", "Adi Botea", "Malte Helmert", + "Blai Bonet", "Sven Koenig"}, + "Domain-Independent Construction of Pattern Database " + "Heuristics for Cost-Optimal Planning", + "https://cdn.aaai.org/AAAI/2007/AAAI07-160.pdf", + "Proceedings of the 22nd AAAI Conference on Artificial " + "Intelligence (AAAI 2007)", + "1007-1012", "AAAI Press", "2007")); document_synopsis( "The canonical pattern database heuristic is calculated as follows. " "For a given pattern collection C, the value of the " diff --git a/src/search/pdbs/pattern_collection_generator_genetic.cc b/src/search/pdbs/pattern_collection_generator_genetic.cc index 3340fc8aec..6e9d6e4eb6 100644 --- a/src/search/pdbs/pattern_collection_generator_genetic.cc +++ b/src/search/pdbs/pattern_collection_generator_genetic.cc @@ -320,9 +320,9 @@ class PatternCollectionGeneratorGeneticFeature {"Stefan Edelkamp"}, "Automated Creation of Pattern Database Search Heuristics", "http://www.springerlink.com/content/20613345434608x1/", - "Proceedings of the 4th Workshop on Model Checking and Artificial" - " Intelligence (!MoChArt 2006)", - "35-50", "AAAI Press", "2007")); + "Model Checking and Artificial Intelligence, 4th Workshop " + "(MoChArt 2006), Revised Selected and Invited Papers", + "35-50", "Springer", "2007")); add_option( "pdb_max_size", "maximal number of states per pattern database ", diff --git a/src/search/pdbs/pattern_generator_greedy.cc b/src/search/pdbs/pattern_generator_greedy.cc index f7472e025a..95989003a4 100644 --- a/src/search/pdbs/pattern_generator_greedy.cc +++ b/src/search/pdbs/pattern_generator_greedy.cc @@ -8,6 +8,7 @@ #include "../plugins/plugin.h" #include "../task_utils/variable_order_finder.h" #include "../utils/logging.h" +#include "../utils/markup.h" #include "../utils/math.h" #include "../utils/timer.h" @@ -57,6 +58,18 @@ class PatternGeneratorGreedyFeature public: PatternGeneratorGreedyFeature() : TypedFeature("greedy") { document_title("Greedy"); + document_synopsis( + "This generator adds variables in the GOAL_CG_LEVEL order until " + "the size limit is reached. The variable ordering is described " + "in the following paper:" + + utils::format_conference_reference( + {"Malte Helmert", "Patrik Haslum", "Jörg Hoffmann"}, + "Flexible Abstraction Heuristics for Optimal Sequential " + "Planning", + "https://cdn.aaai.org/ICAPS/2007/ICAPS07-023.pdf", + "Proceedings of the 17th International Conference on " + "Automated Planning and Scheduling (ICAPS 2007)", + "176-183", "AAAI Press", "2007")); add_option( "max_states", "maximal number of abstract states in the pattern database.", diff --git a/src/search/pdbs/zero_one_pdbs_heuristic.cc b/src/search/pdbs/zero_one_pdbs_heuristic.cc index 2f83bc5d3e..280307d601 100644 --- a/src/search/pdbs/zero_one_pdbs_heuristic.cc +++ b/src/search/pdbs/zero_one_pdbs_heuristic.cc @@ -1,6 +1,7 @@ #include "zero_one_pdbs_heuristic.h" #include "../plugins/plugin.h" +#include "../utils/markup.h" #include @@ -40,6 +41,18 @@ class ZeroOnePDBsHeuristicFeature ZeroOnePDBsHeuristicFeature() : TypedFeature("zopdbs") { document_subcategory("heuristics_pdb"); document_title("Zero-One PDB"); + document_note( + "Reference", + "Zero/one cost partitioning for pattern databases is described " + "in the following paper:" + + utils::format_conference_reference( + {"Stefan Edelkamp"}, + "Automated Creation of Pattern Database Search Heuristics", + "https://doi.org/10.1007/978-3-540-74128-2_3", + "Model Checking and Artificial Intelligence, 4th " + "Workshop (MoChArt 2006), Revised Selected and Invited " + "Papers", + "35-50", "Springer", "2007")); document_synopsis( "The zero/one pattern database heuristic is simply the sum of the " "heuristic values of all patterns in the pattern collection. In contrast " diff --git a/src/search/pruning/limited_pruning.cc b/src/search/pruning/limited_pruning.cc index 88d6fddc10..01754fe678 100644 --- a/src/search/pruning/limited_pruning.cc +++ b/src/search/pruning/limited_pruning.cc @@ -2,6 +2,7 @@ #include "../plugins/plugin.h" #include "../utils/logging.h" +#include "../utils/markup.h" using namespace std; @@ -64,6 +65,18 @@ class LimitedPruningFeature public: LimitedPruningFeature() : TypedFeature("limited_pruning") { document_title("Limited pruning"); + document_note( + "Reference", + "Disabling stubborn set pruning based on the observed pruning " + "ratio is evaluated in the following paper:" + + utils::format_conference_reference( + {"Gabriele Röger", "Malte Helmert", "Jendrik Seipp", + "Silvan Sievers"}, + "An Atom-Centric Perspective on Stubborn Sets", + "https://ojs.aaai.org/index.php/SOCS/article/download/18535/18326", + "Proceedings of the 13th Annual Symposium on " + "Combinatorial Search (SoCS 2020)", + "57-65", "AAAI Press", "2020")); document_synopsis( "Limited pruning applies another pruning method and switches it off " "after a fixed number of expansions if the pruning ratio is below a " diff --git a/src/search/search_algorithms/enforced_hill_climbing_search.cc b/src/search/search_algorithms/enforced_hill_climbing_search.cc index dc072e5a0a..d5ae53f0c6 100644 --- a/src/search/search_algorithms/enforced_hill_climbing_search.cc +++ b/src/search/search_algorithms/enforced_hill_climbing_search.cc @@ -8,6 +8,7 @@ #include "../plugins/plugin.h" #include "../task_utils/successor_generator.h" #include "../utils/logging.h" +#include "../utils/markup.h" #include "../utils/system.h" using namespace std; @@ -269,7 +270,15 @@ class EnforcedHillClimbingSearchFeature public: EnforcedHillClimbingSearchFeature() : TypedFeature("ehc") { document_title("Lazy enforced hill-climbing"); - document_synopsis(""); + document_synopsis( + "Enforced hill-climbing search is described in the following paper:" + + utils::format_journal_reference( + {"Jörg Hoffmann", "Bernhard Nebel"}, + "The FF Planning System: Fast Plan Generation Through " + "Heuristic Search", + "https://www.jair.org/index.php/jair/article/download/10276/24496", + "Journal of Artificial Intelligence Research", "14", "253-302", + "2001")); add_option>("h", "heuristic"); add_option( diff --git a/src/search/search_algorithms/iterated_search.cc b/src/search/search_algorithms/iterated_search.cc index a80a7a0611..3ef8a2cb43 100644 --- a/src/search/search_algorithms/iterated_search.cc +++ b/src/search/search_algorithms/iterated_search.cc @@ -6,6 +6,7 @@ #include "../plugins/plugin.h" #include "../utils/component_errors.h" #include "../utils/logging.h" +#include "../utils/markup.h" #include @@ -281,7 +282,16 @@ class IteratedSearchFeature public: IteratedSearchFeature() : TypedFeature("iterated") { document_title("Iterated search"); - document_synopsis(""); + document_synopsis( + "An application of iterated search with decreasing weighted A* " + "weights is described in the following article:" + + utils::format_journal_reference( + {"Silvia Richter", "Matthias Westphal"}, + "The LAMA Planner: Guiding Cost-Based Anytime Planning " + "with Landmarks", + "https://jair.org/index.php/jair/article/download/10667/25496", + "Journal of Artificial Intelligence Research", "39", "127-177", + "2010")); add_list_option>( "algorithm_configs", "list of search algorithms for each phase", diff --git a/src/search/search_algorithms/plugin_astar.cc b/src/search/search_algorithms/plugin_astar.cc index df30728f2d..bda49295aa 100644 --- a/src/search/search_algorithms/plugin_astar.cc +++ b/src/search/search_algorithms/plugin_astar.cc @@ -2,6 +2,7 @@ #include "search_common.h" #include "../plugins/plugin.h" +#include "../utils/markup.h" using namespace std; @@ -11,6 +12,16 @@ class AStarSearchFeature public: AStarSearchFeature() : TypedFeature("astar") { document_title("A* search (eager)"); + document_note( + "Reference", + "The A* algorithm is described in the following paper:" + + utils::format_journal_reference( + {"Peter E. Hart", "Nils J. Nilsson", "Bertram Raphael"}, + "A Formal Basis for the Heuristic Determination of " + "Minimum Cost Paths", + "https://doi.org/10.1109/TSSC.1968.300136", + "IEEE Transactions on Systems Science and Cybernetics", + "4(2)", "100-107", "1968")); document_synopsis( "A* is a special case of eager best first search that uses g+h " "as f-function. " diff --git a/src/search/search_algorithms/plugin_eager.cc b/src/search/search_algorithms/plugin_eager.cc index 57b97e7b63..a74a4578cb 100644 --- a/src/search/search_algorithms/plugin_eager.cc +++ b/src/search/search_algorithms/plugin_eager.cc @@ -2,6 +2,7 @@ #include "search_common.h" #include "../plugins/plugin.h" +#include "../utils/markup.h" using namespace std; @@ -11,7 +12,17 @@ class EagerSearchFeature public: EagerSearchFeature() : TypedFeature("eager") { document_title("Eager best-first search"); - document_synopsis(""); + document_synopsis( + "Eager best-first search and its use of preferred operators are " + "discussed in the following paper:" + + utils::format_conference_reference( + {"Silvia Richter", "Malte Helmert"}, + "Preferred Operators and Deferred Evaluation in " + "Satisficing Planning", + "https://ojs.aaai.org/index.php/ICAPS/article/download/13345/13193", + "Proceedings of the 19th International Conference on " + "Automated Planning and Scheduling (ICAPS 2009)", + "273-280", "AAAI Press", "2009")); add_option>( "open", "open list"); diff --git a/src/search/search_algorithms/plugin_eager_greedy.cc b/src/search/search_algorithms/plugin_eager_greedy.cc index 39d29b2e5b..6f7818b04c 100644 --- a/src/search/search_algorithms/plugin_eager_greedy.cc +++ b/src/search/search_algorithms/plugin_eager_greedy.cc @@ -2,6 +2,7 @@ #include "search_common.h" #include "../plugins/plugin.h" +#include "../utils/markup.h" using namespace std; @@ -11,7 +12,17 @@ class EagerGreedySearchFeature public: EagerGreedySearchFeature() : TypedFeature("eager_greedy") { document_title("Greedy search (eager)"); - document_synopsis(""); + document_synopsis( + "Greedy best-first search and its use of preferred operators are " + "discussed in the following paper:" + + utils::format_conference_reference( + {"Silvia Richter", "Malte Helmert"}, + "Preferred Operators and Deferred Evaluation in " + "Satisficing Planning", + "https://ojs.aaai.org/index.php/ICAPS/article/download/13345/13193", + "Proceedings of the 19th International Conference on " + "Automated Planning and Scheduling (ICAPS 2009)", + "273-280", "AAAI Press", "2009")); add_list_option>( "evals", "evaluators"); diff --git a/src/search/search_algorithms/plugin_eager_wastar.cc b/src/search/search_algorithms/plugin_eager_wastar.cc index 803c01e388..f0a4edbbac 100644 --- a/src/search/search_algorithms/plugin_eager_wastar.cc +++ b/src/search/search_algorithms/plugin_eager_wastar.cc @@ -2,6 +2,7 @@ #include "search_common.h" #include "../plugins/plugin.h" +#include "../utils/markup.h" using namespace std; @@ -11,7 +12,13 @@ class EagerWAstarSearchFeature public: EagerWAstarSearchFeature() : TypedFeature("eager_wastar") { document_title("Eager weighted A* search"); - document_synopsis(""); + document_synopsis( + "Weighted A* is described in the following paper:" + + utils::format_journal_reference( + {"Ira Pohl"}, + "Heuristic Search Viewed as Path Finding in a Graph", + "https://doi.org/10.1016/0004-3702%2870%2990007-X", + "Artificial Intelligence", "1(3-4)", "193-204", "1970")); add_list_option>( "evals", "evaluators"); diff --git a/src/search/search_algorithms/plugin_lazy.cc b/src/search/search_algorithms/plugin_lazy.cc index bb0169b379..82b2a1d8c2 100644 --- a/src/search/search_algorithms/plugin_lazy.cc +++ b/src/search/search_algorithms/plugin_lazy.cc @@ -2,6 +2,7 @@ #include "search_common.h" #include "../plugins/plugin.h" +#include "../utils/markup.h" using namespace std; @@ -11,7 +12,17 @@ class LazySearchFeature public: LazySearchFeature() : TypedFeature("lazy") { document_title("Lazy best-first search"); - document_synopsis(""); + document_synopsis( + "Deferred evaluation and preferred operators are described in " + "the following paper:" + + utils::format_conference_reference( + {"Silvia Richter", "Malte Helmert"}, + "Preferred Operators and Deferred Evaluation in " + "Satisficing Planning", + "https://ojs.aaai.org/index.php/ICAPS/article/download/13345/13193", + "Proceedings of the 19th International Conference on " + "Automated Planning and Scheduling (ICAPS 2009)", + "273-280", "AAAI Press", "2009")); add_option>( "open", "open list"); diff --git a/src/search/search_algorithms/plugin_lazy_greedy.cc b/src/search/search_algorithms/plugin_lazy_greedy.cc index aa4d714ddb..4654098e02 100644 --- a/src/search/search_algorithms/plugin_lazy_greedy.cc +++ b/src/search/search_algorithms/plugin_lazy_greedy.cc @@ -2,6 +2,7 @@ #include "search_common.h" #include "../plugins/plugin.h" +#include "../utils/markup.h" using namespace std; @@ -13,7 +14,17 @@ class LazyGreedySearchFeature public: LazyGreedySearchFeature() : TypedFeature("lazy_greedy") { document_title("Greedy search (lazy)"); - document_synopsis(""); + document_synopsis( + "Deferred evaluation and preferred operators are described in " + "the following paper:" + + utils::format_conference_reference( + {"Silvia Richter", "Malte Helmert"}, + "Preferred Operators and Deferred Evaluation in " + "Satisficing Planning", + "https://ojs.aaai.org/index.php/ICAPS/article/download/13345/13193", + "Proceedings of the 19th International Conference on " + "Automated Planning and Scheduling (ICAPS 2009)", + "273-280", "AAAI Press", "2009")); add_list_option>( "evals", "evaluators"); diff --git a/src/search/search_algorithms/plugin_lazy_wastar.cc b/src/search/search_algorithms/plugin_lazy_wastar.cc index ea3665bc4c..0b56944b79 100644 --- a/src/search/search_algorithms/plugin_lazy_wastar.cc +++ b/src/search/search_algorithms/plugin_lazy_wastar.cc @@ -2,6 +2,7 @@ #include "search_common.h" #include "../plugins/plugin.h" +#include "../utils/markup.h" using namespace std; @@ -13,6 +14,23 @@ class LazyWAstarSearchFeature public: LazyWAstarSearchFeature() : TypedFeature("lazy_wastar") { document_title("(Weighted) A* search (lazy)"); + document_note( + "Reference", + "Weighted A* is described in the following paper:" + + utils::format_journal_reference( + {"Ira Pohl"}, + "Heuristic Search Viewed as Path Finding in a Graph", + "https://doi.org/10.1016/0004-3702%2870%2990007-X", + "Artificial Intelligence", "1(3-4)", "193-204", "1970") + + "Deferred evaluation is described in the following paper:" + + utils::format_conference_reference( + {"Silvia Richter", "Malte Helmert"}, + "Preferred Operators and Deferred Evaluation in Satisficing " + "Planning", + "https://ojs.aaai.org/index.php/ICAPS/article/download/13345/13193", + "Proceedings of the 19th International Conference on " + "Automated Planning and Scheduling (ICAPS 2009)", + "273-280", "AAAI Press", "2009")); document_synopsis( "Weighted A* is a special case of lazy best first search."); From bf1d9e6fbcb11d7264bcb383a3284926e3d4c74d Mon Sep 17 00:00:00 2001 From: Jendrik Seipp Date: Fri, 9 Oct 2026 19:42:03 +0000 Subject: [PATCH 2/5] Address review comments on research references. Add and adjust references following the todo list in issue1200 and the review comments by Simon and Claudia. Use DOI links instead of direct PDF downloads. --- .../subtask_generators.cc | 33 ++++++++++++-- src/search/evaluators/pref_evaluator.cc | 13 +++++- src/search/heuristics/additive_heuristic.cc | 13 +++++- src/search/heuristics/ff_heuristic.cc | 16 +++++-- src/search/heuristics/hm_heuristic.cc | 8 +++- src/search/heuristics/lm_cut_heuristic.cc | 2 +- src/search/heuristics/max_heuristic.cc | 13 +++++- .../landmark_cost_partitioning_heuristic.cc | 22 ++++----- src/search/landmarks/landmark_factory_hm.cc | 2 +- .../landmarks/landmark_factory_rpg_exhaust.cc | 24 +++++----- .../landmarks/landmark_factory_rpg_sasp.cc | 16 +++++-- .../landmarks/landmark_sum_heuristic.cc | 17 +++---- .../merge_and_shrink/label_reduction.cc | 11 ++++- .../merge_and_shrink_heuristic.cc | 28 ++---------- .../merge_scoring_function_dfp.cc | 13 ++++-- .../merge_scoring_function_miasm.cc | 12 ++++- .../merge_scoring_function_single_random.cc | 11 ++++- .../merge_strategy_factory.cc | 12 ++++- .../merge_tree_factory_linear.cc | 26 +++++++++-- .../open_lists/alternation_open_list.cc | 12 +++-- src/search/open_lists/pareto_open_list.cc | 2 +- .../open_lists/tiebreaking_open_list.cc | 2 +- .../operator_counting/lm_cut_constraints.cc | 24 ++++------ src/search/pdbs/canonical_pdbs_heuristic.cc | 23 +++++++++- .../pattern_collection_generator_genetic.cc | 2 +- src/search/pdbs/pattern_generator_random.cc | 2 +- src/search/pdbs/zero_one_pdbs_heuristic.cc | 45 +++++++++++++++---- src/search/pruning/limited_pruning.cc | 20 +++++---- .../enforced_hill_climbing_search.cc | 20 +++++++-- .../search_algorithms/iterated_search.cc | 2 +- src/search/search_algorithms/plugin_eager.cc | 2 +- .../search_algorithms/plugin_eager_greedy.cc | 2 +- src/search/search_algorithms/plugin_lazy.cc | 13 ++++-- .../search_algorithms/plugin_lazy_greedy.cc | 13 ++++-- .../search_algorithms/plugin_lazy_wastar.cc | 25 +++++++---- 35 files changed, 356 insertions(+), 145 deletions(-) diff --git a/src/search/cartesian_abstractions/subtask_generators.cc b/src/search/cartesian_abstractions/subtask_generators.cc index 6344315a01..649b5240ea 100644 --- a/src/search/cartesian_abstractions/subtask_generators.cc +++ b/src/search/cartesian_abstractions/subtask_generators.cc @@ -11,6 +11,7 @@ #include "../tasks/modified_goals_task.h" #include "../utils/hash.h" #include "../utils/logging.h" +#include "../utils/markup.h" #include "../utils/rng.h" #include "../utils/rng_options.h" @@ -189,13 +190,32 @@ static tuple get_fact_order_arguments_from_options( utils::get_rng_arguments_from_options(opts)); } +static string get_references() { + return utils::format_conference_reference( + {"Jendrik Seipp", "Malte Helmert"}, + "Diverse and Additive Cartesian Abstraction Heuristics", + "https://ai.dmi.unibas.ch/papers/seipp-helmert-icaps2014.pdf", + "Proceedings of the 24th International Conference on " + "Automated Planning and Scheduling (ICAPS 2014)", + "289-297", "AAAI Press", "2014") + + utils::format_journal_reference( + {"Jendrik Seipp", "Malte Helmert"}, + "Counterexample-Guided Cartesian Abstraction Refinement for " + "Classical Planning", + "https://ai.dmi.unibas.ch/papers/seipp-helmert-jair2018.pdf", + "Journal of Artificial Intelligence Research", "62", "535-577", + "2018"); +} + class TaskDuplicatorFeature : public plugins::TypedFeature { public: TaskDuplicatorFeature() : TypedFeature("original") { document_title("No abstraction"); document_synopsis( - "Copies of the original task are used as subproblems."); + "Copies of the original task are used as subproblems. For " + "details, see the following papers:" + + get_references()); add_option( "copies", "number of task copies", "1", plugins::Bounds("1", "infinity")); @@ -216,7 +236,10 @@ class GoalDecompositionFeature GoalDecompositionFeature() : TypedFeature("goals") { document_title("Abstraction by goals"); document_synopsis( - "For each goal atom of the original task one subproblem is generated having only the atom as its goal."); + "For each goal atom of the original task one subproblem is " + "generated having only the atom as its goal. For details, see the " + "following papers:" + + get_references()); add_fact_order_option(*this); } @@ -236,7 +259,11 @@ class LandmarkDecompositionFeature LandmarkDecompositionFeature() : TypedFeature("landmarks") { document_title("Abstraction by landmarks"); document_synopsis( - "For each fact landmark of the delete relaxation of the original task one subproblem is generated having only the landmark as goal. This is a generalization of abstractions by goals."); + "For each fact landmark of the delete relaxation of the original " + "task one subproblem is generated having only the landmark as " + "goal. This is a generalization of abstractions by goals. For " + "details, see the following papers:" + + get_references()); add_fact_order_option(*this); add_option( "combine_facts", "combine landmark facts with domain abstraction", diff --git a/src/search/evaluators/pref_evaluator.cc b/src/search/evaluators/pref_evaluator.cc index 429ce930af..7bd7dbed95 100644 --- a/src/search/evaluators/pref_evaluator.cc +++ b/src/search/evaluators/pref_evaluator.cc @@ -4,6 +4,7 @@ #include "../evaluation_result.h" #include "../plugins/plugin.h" +#include "../utils/markup.h" using namespace std; @@ -30,7 +31,17 @@ class PrefEvaluatorFeature PrefEvaluatorFeature() : TypedFeature("pref") { document_subcategory("evaluators_basic"); document_title("Preference evaluator"); - document_synopsis("Returns 0 if preferred is true and 1 otherwise."); + document_synopsis( + "Returns 0 if preferred is true and 1 otherwise. For the use of " + "preferred operators in search, see the following paper:" + + utils::format_conference_reference( + {"Silvia Richter", "Malte Helmert"}, + "Preferred Operators and Deferred Evaluation in " + "Satisficing Planning", + "https://doi.org/10.1609/icaps.v19i1.13345", + "Proceedings of the 19th International Conference on " + "Automated Planning and Scheduling (ICAPS 2009)", + "273-280", "AAAI Press", "2009")); add_evaluator_options_to_feature(*this, "pref"); } diff --git a/src/search/heuristics/additive_heuristic.cc b/src/search/heuristics/additive_heuristic.cc index d0ca856564..fc1be72093 100644 --- a/src/search/heuristics/additive_heuristic.cc +++ b/src/search/heuristics/additive_heuristic.cc @@ -155,9 +155,18 @@ class AdditiveHeuristicFeature "The additive heuristic is described in the following paper:" + utils::format_journal_reference( {"Blai Bonet", "Hector Geffner"}, - "Planning as Heuristic Search", + "Planning as heuristic search", "https://doi.org/10.1016/S0004-3702%2801%2900108-4", - "Artificial Intelligence", "129(1-2)", "5-33", "2001")); + "Artificial Intelligence", "129(1-2)", "5-33", "2001") + + "For a discussion of the heuristic in the context of planning " + "with action costs, see the following paper:" + + utils::format_conference_reference( + {"Emil Keyder", "Hector Geffner"}, + "Heuristics for Planning with Action Costs Revisited", + "https://doi.org/10.3233/978-1-58603-891-5-588", + "Proceedings of the 18th European Conference on " + "Artificial Intelligence (ECAI 2008)", + "588-592", "IOS Press", "2008")); relaxation_heuristic::add_relaxation_heuristic_options_to_feature( *this, "add"); diff --git a/src/search/heuristics/ff_heuristic.cc b/src/search/heuristics/ff_heuristic.cc index ee4a4b8f55..75aa848df3 100644 --- a/src/search/heuristics/ff_heuristic.cc +++ b/src/search/heuristics/ff_heuristic.cc @@ -76,14 +76,24 @@ class FFHeuristicFeature FFHeuristicFeature() : TypedFeature("ff") { document_title("FF heuristic"); document_synopsis( - "The FF heuristic is described in the following paper:" + + "The FF heuristic was introduced in the following paper:" + utils::format_journal_reference( {"Jörg Hoffmann", "Bernhard Nebel"}, "The FF Planning System: Fast Plan Generation Through " "Heuristic Search", - "https://www.jair.org/index.php/jair/article/download/10276/24496", + "https://doi.org/10.1613/jair.855", "Journal of Artificial Intelligence Research", "14", "253-302", - "2001")); + "2001") + + "This implementation extracts the relaxed plan from the best " + "supporters of the additive heuristic, which takes action costs " + "into account. This variant is described in the following paper:" + + utils::format_conference_reference( + {"Emil Keyder", "Hector Geffner"}, + "Heuristics for Planning with Action Costs Revisited", + "https://doi.org/10.3233/978-1-58603-891-5-588", + "Proceedings of the 18th European Conference on " + "Artificial Intelligence (ECAI 2008)", + "588-592", "IOS Press", "2008")); relaxation_heuristic::add_relaxation_heuristic_options_to_feature( *this, "ff"); diff --git a/src/search/heuristics/hm_heuristic.cc b/src/search/heuristics/hm_heuristic.cc index 7233c0bfeb..0b2040aced 100644 --- a/src/search/heuristics/hm_heuristic.cc +++ b/src/search/heuristics/hm_heuristic.cc @@ -263,10 +263,14 @@ class HMHeuristicFeature utils::format_conference_reference( {"Patrik Haslum", "Hector Geffner"}, "Admissible Heuristics for Optimal Planning", - "https://cdn.aaai.org/AIPS/2000/AIPS00-015.pdf", + "https://www.ida.liu.se/divisions/aiics/publications/" + "AIPS-2000-Admissible-Heuristics-Optimal.pdf", "Proceedings of the Fifth International Conference on " "Artificial Intelligence Planning Systems (AIPS 2000)", - "140-149", "AAAI Press", "2000")); + "140-149", "AAAI Press", "2000") + + "Note that the implementation of the h^m heuristic is " + "preliminary and very inefficient. Please do not use it for " + "comparisons."); add_option( "m", "subset size", "2", plugins::Bounds("1", "infinity")); diff --git a/src/search/heuristics/lm_cut_heuristic.cc b/src/search/heuristics/lm_cut_heuristic.cc index 4181be646b..1562abed00 100644 --- a/src/search/heuristics/lm_cut_heuristic.cc +++ b/src/search/heuristics/lm_cut_heuristic.cc @@ -52,7 +52,7 @@ class LandmarkCutHeuristicFeature "https://ai.dmi.unibas.ch/papers/helmert-domshlak-icaps2009.pdf", "Proceedings of the 19th International Conference on Automated " "Planning and Scheduling (ICAPS 2009)", - "162-169", "", "2009") + + "162-169", "AAAI Press", "2009") + "\n" + "The tie-breaking strategies for the precondition choice function " "(options {{{goal_zone_detection}}} and {{{border_detection}}}) " diff --git a/src/search/heuristics/max_heuristic.cc b/src/search/heuristics/max_heuristic.cc index 1c7553d8fe..4fa78665f6 100644 --- a/src/search/heuristics/max_heuristic.cc +++ b/src/search/heuristics/max_heuristic.cc @@ -111,9 +111,18 @@ class HSPMaxHeuristicFeature "The h^max heuristic is described in the following paper:" + utils::format_journal_reference( {"Blai Bonet", "Hector Geffner"}, - "Planning as Heuristic Search", + "Planning as heuristic search", "https://doi.org/10.1016/S0004-3702%2801%2900108-4", - "Artificial Intelligence", "129(1-2)", "5-33", "2001")); + "Artificial Intelligence", "129(1-2)", "5-33", "2001") + + "For a discussion of the heuristic in the context of planning " + "with action costs, see the following paper:" + + utils::format_conference_reference( + {"Emil Keyder", "Hector Geffner"}, + "Heuristics for Planning with Action Costs Revisited", + "https://doi.org/10.3233/978-1-58603-891-5-588", + "Proceedings of the 18th European Conference on " + "Artificial Intelligence (ECAI 2008)", + "588-592", "IOS Press", "2008")); relaxation_heuristic::add_relaxation_heuristic_options_to_feature( *this, "hmax"); diff --git a/src/search/landmarks/landmark_cost_partitioning_heuristic.cc b/src/search/landmarks/landmark_cost_partitioning_heuristic.cc index b944fee66f..05b41580a3 100644 --- a/src/search/landmarks/landmark_cost_partitioning_heuristic.cc +++ b/src/search/landmarks/landmark_cost_partitioning_heuristic.cc @@ -109,22 +109,24 @@ class LandmarkCostPartitioningHeuristicFeature document_note( "History Note", "Formerly known as the admissible landmark heuristic.\n" - "See the papers" + + "The original landmark heuristic is described in the following " + "paper:" + + utils::format_journal_reference( + {"Silvia Richter", "Matthias Westphal"}, + "The LAMA Planner: Guiding Cost-Based Anytime Planning " + "with Landmarks", + "https://doi.org/10.1613/jair.2972", + "Journal of Artificial Intelligence Research", "39", + "127-177", "2010") + + "Admissible landmark heuristics based on cost partitioning are " + "described in the following paper:" + utils::format_conference_reference( {"Erez Karpas", "Carmel Domshlak"}, "Cost-Optimal Planning with Landmarks", "https://www.ijcai.org/Proceedings/09/Papers/288.pdf", "Proceedings of the 21st International Joint Conference on " "Artificial Intelligence (IJCAI 2009)", - "1728-1733", "AAAI Press", "2009") + - "and" + - utils::format_conference_reference( - {"Emil Keyder and Silvia Richter and Malte Helmert"}, - "Sound and Complete Landmarks for And/Or Graphs", - "https://ai.dmi.unibas.ch/papers/keyder-et-al-ecai2010.pdf", - "Proceedings of the 19th European Conference on Artificial " - "Intelligence (ECAI 2010)", - "335-340", "IOS Press", "2010")); + "1728-1733", "AAAI Press", "2009")); document_note( "Usage with A*", "We recommend to add this heuristic as lazy_evaluator when using " diff --git a/src/search/landmarks/landmark_factory_hm.cc b/src/search/landmarks/landmark_factory_hm.cc index 4f91df055c..243141bcfa 100644 --- a/src/search/landmarks/landmark_factory_hm.cc +++ b/src/search/landmarks/landmark_factory_hm.cc @@ -1050,7 +1050,7 @@ class LandmarkFactoryHMFeature document_title("h^m landmarks"); document_synopsis( "The landmark generation method introduced in the " - "following paper" + + "following paper:" + utils::format_conference_reference( {"Emil Keyder", "Silvia Richter", "Malte Helmert"}, "Sound and Complete Landmarks for And/Or Graphs", diff --git a/src/search/landmarks/landmark_factory_rpg_exhaust.cc b/src/search/landmarks/landmark_factory_rpg_exhaust.cc index e90eaec21b..55c9f878c4 100644 --- a/src/search/landmarks/landmark_factory_rpg_exhaust.cc +++ b/src/search/landmarks/landmark_factory_rpg_exhaust.cc @@ -88,20 +88,18 @@ class LandmarkFactoryRpgExhaustFeature public: LandmarkFactoryRpgExhaustFeature() : TypedFeature("lm_exhaust") { document_title("Exhaustive landmarks"); - document_note( - "Reference", - "For background on delete-relaxation landmarks and the causal " - "landmarks computed with use_unary_relaxation=true, see:" + - utils::format_conference_reference( - {"Emil Keyder", "Silvia Richter", "Malte Helmert"}, - "Sound and Complete Landmarks for And/Or Graphs", - "https://ai.dmi.unibas.ch/papers/keyder-et-al-ecai2010.pdf", - "Proceedings of the 19th European Conference on " - "Artificial Intelligence (ECAI 2010)", - "335-340", "IOS Press", "2010")); document_synopsis( - "Exhaustively checks for each atom if it is a landmark." - "This check is done using relaxed planning."); + "Tests for every atom if the relaxed planning task where all " + "achievers of this atom are removed is solvable. If not, the atom " + "is a landmark. For the concept of delete relaxation, see the " + "following paper:" + + utils::format_journal_reference( + {"Jörg Hoffmann", "Bernhard Nebel"}, + "The FF Planning System: Fast Plan Generation Through " + "Heuristic Search", + "https://doi.org/10.1613/jair.855", + "Journal of Artificial Intelligence Research", "14", "253-302", + "2001")); add_option( "use_unary_relaxation", diff --git a/src/search/landmarks/landmark_factory_rpg_sasp.cc b/src/search/landmarks/landmark_factory_rpg_sasp.cc index 04a285dd7a..997ad14490 100644 --- a/src/search/landmarks/landmark_factory_rpg_sasp.cc +++ b/src/search/landmarks/landmark_factory_rpg_sasp.cc @@ -776,14 +776,24 @@ class LandmarkFactoryRpgSaspFeature LandmarkFactoryRpgSaspFeature() : TypedFeature("lm_rhw") { document_title("RHW landmarks"); document_synopsis( - "The landmark generation method is described in the following paper:" + + "The landmark generation method was introduced in the following " + "paper:" + utils::format_conference_reference( {"Silvia Richter", "Malte Helmert", "Matthias Westphal"}, "Landmarks Revisited", - "https://cdn.aaai.org/AAAI/2008/AAAI08-155.pdf", + "https://ai.dmi.unibas.ch/papers/richter-et-al-aaai2008.pdf", "Proceedings of the 23rd AAAI Conference on Artificial " "Intelligence (AAAI 2008)", - "975-982", "AAAI Press", "2008")); + "975-982", "AAAI Press", "2008") + + "The algorithm is described in more detail in the following " + "paper:" + + utils::format_journal_reference( + {"Silvia Richter", "Matthias Westphal"}, + "The LAMA Planner: Guiding Cost-Based Anytime Planning with " + "Landmarks", + "https://doi.org/10.1613/jair.2972", + "Journal of Artificial Intelligence Research", "39", "127-177", + "2010")); add_option( "disjunctive_landmarks", "keep disjunctive landmarks", "true"); add_use_orders_option_to_feature(*this); diff --git a/src/search/landmarks/landmark_sum_heuristic.cc b/src/search/landmarks/landmark_sum_heuristic.cc index cff6b6eddc..cb099468d5 100644 --- a/src/search/landmarks/landmark_sum_heuristic.cc +++ b/src/search/landmarks/landmark_sum_heuristic.cc @@ -129,20 +129,21 @@ class LandmarkSumHeuristicFeature "Formerly known as the landmark heuristic or landmark count " "heuristic.\n" "See the papers" + + utils::format_journal_reference( + {"Silvia Richter", "Matthias Westphal"}, + "The LAMA Planner: Guiding Cost-Based Anytime Planning " + "with Landmarks", + "https://doi.org/10.1613/jair.2972", + "Journal of Artificial Intelligence Research", "39", + "127-177", "2010") + + "and" + utils::format_conference_reference( {"Silvia Richter", "Malte Helmert", "Matthias Westphal"}, "Landmarks Revisited", "https://ai.dmi.unibas.ch/papers/richter-et-al-aaai2008.pdf", "Proceedings of the 23rd AAAI Conference on Artificial " "Intelligence (AAAI 2008)", - "975-982", "AAAI Press", "2008") + - "and" + - utils::format_journal_reference( - {"Silvia Richter", "Matthias Westphal"}, - "The LAMA Planner: Guiding Cost-Based Anytime Planning with Landmarks", - "http://www.aaai.org/Papers/JAIR/Vol39/JAIR-3903.pdf", - "Journal of Artificial Intelligence Research", "39", - "127-177", "2010")); + "975-982", "AAAI Press", "2008")); document_note( "Note on performance for satisficing planning", "The cost of a landmark is based on the cost of the operators that " diff --git a/src/search/merge_and_shrink/label_reduction.cc b/src/search/merge_and_shrink/label_reduction.cc index 1d68218826..77ec6c7852 100644 --- a/src/search/merge_and_shrink/label_reduction.cc +++ b/src/search/merge_and_shrink/label_reduction.cc @@ -309,7 +309,16 @@ class LabelReductionFeature "https://ai.dmi.unibas.ch/papers/sievers-et-al-aaai2014.pdf", "Proceedings of the 28th AAAI Conference on Artificial" " Intelligence (AAAI 2014)", - "2358-2366", "AAAI Press", "2014")); + "2358-2366", "AAAI Press", "2014") + + "For a more general discussion of label reduction, see the " + "following paper:" + + utils::format_journal_reference( + {"Silvan Sievers", "Malte Helmert"}, + "Merge-and-Shrink: A Compositional Theory of Transformations " + "of Factored Transition Systems", + "https://ai.dmi.unibas.ch/papers/sievers-helmert-jair2021.pdf", + "Journal of Artificial Intelligence Research", "71", "781-883", + "2021")); add_option( "before_shrinking", "apply label reduction before shrinking"); diff --git a/src/search/merge_and_shrink/merge_and_shrink_heuristic.cc b/src/search/merge_and_shrink/merge_and_shrink_heuristic.cc index 38b51ea609..a77e174154 100644 --- a/src/search/merge_and_shrink/merge_and_shrink_heuristic.cc +++ b/src/search/merge_and_shrink/merge_and_shrink_heuristic.cc @@ -144,18 +144,9 @@ class MergeAndShrinkHeuristicFeature MergeAndShrinkHeuristicFeature() : TypedFeature("merge_and_shrink") { document_title("Merge-and-shrink heuristic"); document_synopsis( - "This heuristic implements the algorithm described in the following " + "This heuristic implements the merge-and-shrink algorithm. For a " + "comprehensive description of merge-and-shrink, see the following " "paper:" + - utils::format_conference_reference( - {"Silvan Sievers", "Martin Wehrle", "Malte Helmert"}, - "Generalized Label Reduction for Merge-and-Shrink Heuristics", - "https://ai.dmi.unibas.ch/papers/sievers-et-al-aaai2014.pdf", - "Proceedings of the 28th AAAI Conference on Artificial" - " Intelligence (AAAI 2014)", - "2358-2366", "AAAI Press", "2014") + - "\n" + - "For a more exhaustive description of merge-and-shrink, see the journal " - "paper" + utils::format_journal_reference( {"Silvan Sievers", "Malte Helmert"}, "Merge-and-Shrink: A Compositional Theory of Transformations " @@ -164,19 +155,8 @@ class MergeAndShrinkHeuristicFeature "Journal of Artificial Intelligence Research", "71", "781-883", "2021") + "\n" + - "The following paper describes how to improve the DFP merge strategy " - "with tie-breaking, and presents two new merge strategies (dyn-MIASM " - "and SCC-DFP):" + - utils::format_conference_reference( - {"Silvan Sievers", "Martin Wehrle", "Malte Helmert"}, - "An Analysis of Merge Strategies for Merge-and-Shrink Heuristics", - "https://ai.dmi.unibas.ch/papers/sievers-et-al-icaps2016.pdf", - "Proceedings of the 26th International Conference on Automated " - "Planning and Scheduling (ICAPS 2016)", - "294-298", "AAAI Press", "2016") + - "\n" + "Details of the algorithms and the implementation are described in the " - "paper" + + "following paper:" + utils::format_conference_reference( {"Silvan Sievers"}, "Merge-and-Shrink Heuristics for Classical Planning: Efficient " @@ -192,7 +172,7 @@ class MergeAndShrinkHeuristicFeature document_note( "Note", "Conditional effects are supported directly. Note, however, that " - "for tasks that are not factored (in the sense of the JACM 2014 " + "for tasks that are not factored (in the sense of the JAIR 2021 " "merge-and-shrink paper), the atomic transition systems on which " "merge-and-shrink heuristics are based are nondeterministic, " "which can lead to poor heuristics even when only perfect shrinking " diff --git a/src/search/merge_and_shrink/merge_scoring_function_dfp.cc b/src/search/merge_and_shrink/merge_scoring_function_dfp.cc index fecfb9234c..4fac05bb9b 100644 --- a/src/search/merge_and_shrink/merge_scoring_function_dfp.cc +++ b/src/search/merge_and_shrink/merge_scoring_function_dfp.cc @@ -113,9 +113,16 @@ class MergeScoringFunctionDFPFeature document_title("DFP scoring"); document_synopsis( "This scoring function computes the 'DFP' score as described in the " - "paper \"Directed model checking with distance-preserving abstractions\" " - "by Draeger, Finkbeiner and Podelski (SPIN 2006), adapted to planning in " - "the following paper:" + + "following paper:" + + utils::format_journal_reference( + {"Klaus Dräger", "Bernd Finkbeiner", "Andreas Podelski"}, + "Directed model checking with distance-preserving " + "abstractions", + "https://doi.org/10.1007/s10009-008-0092-z", + "International Journal on Software Tools for Technology " + "Transfer", + "11(1)", "27-37", "2009") + + "It was adapted to planning in the following paper:" + utils::format_conference_reference( {"Silvan Sievers", "Martin Wehrle", "Malte Helmert"}, "Generalized Label Reduction for Merge-and-Shrink Heuristics", diff --git a/src/search/merge_and_shrink/merge_scoring_function_miasm.cc b/src/search/merge_and_shrink/merge_scoring_function_miasm.cc index 8c1e1b3a59..a23522497a 100644 --- a/src/search/merge_and_shrink/merge_scoring_function_miasm.cc +++ b/src/search/merge_and_shrink/merge_scoring_function_miasm.cc @@ -117,7 +117,17 @@ class MergeScoringFunctionMIASMFeature "states. To compute this score, this class thus computes the product " "of all pairs of transition systems, potentially copying and shrinking " "the transition systems before if otherwise their product would exceed " - "the specified size limits. A stateless merge strategy using this " + "the specified size limits. The MIASM merge strategy was introduced " + "in the following paper:" + + utils::format_conference_reference( + {"Gaojian Fan", "Martin Müller", "Robert Holte"}, + "Non-Linear Merging Strategies for Merge-and-Shrink Based on " + "Variable Interactions", + "https://doi.org/10.1609/socs.v5i1.18330", + "Proceedings of the Seventh Annual Symposium on Combinatorial " + "Search (SoCS 2014)", + "53-61", "AAAI Press", "2014") + + "A stateless merge strategy using this " "scoring function is called dyn-MIASM (nowadays also called sbMIASM " "for score-based MIASM) and is described in the following paper:" + utils::format_conference_reference( diff --git a/src/search/merge_and_shrink/merge_scoring_function_single_random.cc b/src/search/merge_and_shrink/merge_scoring_function_single_random.cc index 44d9069736..32ec084791 100644 --- a/src/search/merge_and_shrink/merge_scoring_function_single_random.cc +++ b/src/search/merge_and_shrink/merge_scoring_function_single_random.cc @@ -4,6 +4,7 @@ #include "../plugins/plugin.h" #include "../utils/logging.h" +#include "../utils/markup.h" #include "../utils/rng.h" #include "../utils/rng_options.h" @@ -54,7 +55,15 @@ class MergeScoringFunctionSingleRandomFeature document_title("Single random"); document_synopsis( "This scoring function assigns exactly one merge candidate a score of " - "0, chosen randomly, and infinity to all others."); + "0, chosen randomly, and infinity to all others. It is used in the " + "following paper:" + + utils::format_conference_reference( + {"Silvan Sievers", "Martin Wehrle", "Malte Helmert"}, + "An Analysis of Merge Strategies for Merge-and-Shrink Heuristics", + "https://ai.dmi.unibas.ch/papers/sievers-et-al-icaps2016.pdf", + "Proceedings of the 26th International Conference on Automated " + "Planning and Scheduling (ICAPS 2016)", + "294-298", "AAAI Press", "2016")); utils::add_rng_options_to_feature(*this); } diff --git a/src/search/merge_and_shrink/merge_strategy_factory.cc b/src/search/merge_and_shrink/merge_strategy_factory.cc index ac9b880fe8..1cd57168b6 100644 --- a/src/search/merge_and_shrink/merge_strategy_factory.cc +++ b/src/search/merge_and_shrink/merge_strategy_factory.cc @@ -1,6 +1,7 @@ #include "merge_strategy_factory.h" #include "../plugins/plugin.h" +#include "../utils/markup.h" #include @@ -37,7 +38,16 @@ static class MergeStrategyFactoryCategoryPlugin : TypedCategoryPlugin("MergeStrategy") { document_synopsis( "This page describes the various merge strategies supported " - "by the planner."); + "by the planner. The following paper describes how to improve the " + "DFP merge strategy with tie-breaking, and presents two new merge " + "strategies (dyn-MIASM and SCC-DFP):" + + utils::format_conference_reference( + {"Silvan Sievers", "Martin Wehrle", "Malte Helmert"}, + "An Analysis of Merge Strategies for Merge-and-Shrink Heuristics", + "https://ai.dmi.unibas.ch/papers/sievers-et-al-icaps2016.pdf", + "Proceedings of the 26th International Conference on Automated " + "Planning and Scheduling (ICAPS 2016)", + "294-298", "AAAI Press", "2016")); } } _category_plugin; } diff --git a/src/search/merge_and_shrink/merge_tree_factory_linear.cc b/src/search/merge_and_shrink/merge_tree_factory_linear.cc index 21e0891427..853dd0228e 100644 --- a/src/search/merge_and_shrink/merge_tree_factory_linear.cc +++ b/src/search/merge_and_shrink/merge_tree_factory_linear.cc @@ -123,15 +123,35 @@ class MergeTreeFactoryLinearFeature MergeTreeFactoryLinearFeature() : TypedFeature("linear") { document_title("Linear merge trees"); document_synopsis( - "These merge trees implement several linear merge orders, which " - "are described in the paper:" + + "These merge trees implement several linear merge orders. The " + "orders cg_goal_level and goal_cg_level are described in the " + "following paper:" + utils::format_conference_reference( {"Malte Helmert", "Patrik Haslum", "Joerg Hoffmann"}, "Flexible Abstraction Heuristics for Optimal Sequential Planning", "https://ai.dmi.unibas.ch/papers/helmert-et-al-icaps2007.pdf", "Proceedings of the Seventeenth International Conference on" " Automated Planning and Scheduling (ICAPS 2007)", - "176-183", "AAAI Press", "2007")); + "176-183", "AAAI Press", "2007") + + "The order level is described in the following paper:" + + utils::format_conference_reference( + {"Silvan Sievers", "Martin Wehrle", "Malte Helmert"}, + "An Analysis of Merge Strategies for Merge-and-Shrink " + "Heuristics", + "https://ai.dmi.unibas.ch/papers/sievers-et-al-icaps2016.pdf", + "Proceedings of the 26th International Conference on Automated " + "Planning and Scheduling (ICAPS 2016)", + "294-298", "AAAI Press", "2016") + + "The order reverse_level is described in the following paper:" + + utils::format_conference_reference( + {"Raz Nissim", "Jörg Hoffmann", "Malte Helmert"}, + "Computing Perfect Heuristics in Polynomial Time: On " + "Bisimulation and Merge-and-Shrink Abstraction in Optimal " + "Planning", + "https://ai.dmi.unibas.ch/papers/nissim-et-al-ijcai2011.pdf", + "Proceedings of the Twenty-Second International Joint " + "Conference on Artificial Intelligence (IJCAI 2011)", + "1983-1990", "AAAI Press", "2011")); MergeTreeFactoryLinear::add_options_to_feature(*this); } diff --git a/src/search/open_lists/alternation_open_list.cc b/src/search/open_lists/alternation_open_list.cc index ba9b7ca3eb..4a84c46eaa 100644 --- a/src/search/open_lists/alternation_open_list.cc +++ b/src/search/open_lists/alternation_open_list.cc @@ -162,13 +162,19 @@ class AlternationOpenListFeature document_title("Alternation open list"); document_note( "Reference", - "Alternating between heuristic queues is discussed in the " - "following paper:" + + "The idea of alternating between heuristic queues is described in " + "the following paper:" + + utils::format_journal_reference( + {"Malte Helmert"}, "The Fast Downward Planning System", + "https://doi.org/10.1613/jair.1705", + "Journal of Artificial Intelligence Research", "26", + "191-246", "2006") + + "It is discussed in more detail in the following paper:" + utils::format_conference_reference( {"Gabriele Röger", "Malte Helmert"}, "The More, the Merrier: Combining Heuristic Estimators " "for Satisficing Planning", - "https://ojs.aaai.org/index.php/ICAPS/article/download/13435/13284", + "https://doi.org/10.1609/icaps.v20i1.13435", "Proceedings of the 20th International Conference on " "Automated Planning and Scheduling (ICAPS 2010)", "246-249", "AAAI Press", "2010")); diff --git a/src/search/open_lists/pareto_open_list.cc b/src/search/open_lists/pareto_open_list.cc index 818d08f6f7..70b3c41e4f 100644 --- a/src/search/open_lists/pareto_open_list.cc +++ b/src/search/open_lists/pareto_open_list.cc @@ -267,7 +267,7 @@ class ParetoOpenListFeature {"Gabriele Röger", "Malte Helmert"}, "The More, the Merrier: Combining Heuristic Estimators " "for Satisficing Planning", - "https://ojs.aaai.org/index.php/ICAPS/article/download/13435/13284", + "https://doi.org/10.1609/icaps.v20i1.13435", "Proceedings of the 20th International Conference on " "Automated Planning and Scheduling (ICAPS 2010)", "246-249", "AAAI Press", "2010")); diff --git a/src/search/open_lists/tiebreaking_open_list.cc b/src/search/open_lists/tiebreaking_open_list.cc index 54b4d1fc48..c99a51ff79 100644 --- a/src/search/open_lists/tiebreaking_open_list.cc +++ b/src/search/open_lists/tiebreaking_open_list.cc @@ -197,7 +197,7 @@ class TieBreakingOpenListFeature {"Gabriele Röger", "Malte Helmert"}, "The More, the Merrier: Combining Heuristic Estimators " "for Satisficing Planning", - "https://ojs.aaai.org/index.php/ICAPS/article/download/13435/13284", + "https://doi.org/10.1609/icaps.v20i1.13435", "Proceedings of the 20th International Conference on " "Automated Planning and Scheduling (ICAPS 2010)", "246-249", "AAAI Press", "2010")); diff --git a/src/search/operator_counting/lm_cut_constraints.cc b/src/search/operator_counting/lm_cut_constraints.cc index 5b9535be61..c82775eaf9 100644 --- a/src/search/operator_counting/lm_cut_constraints.cc +++ b/src/search/operator_counting/lm_cut_constraints.cc @@ -58,23 +58,15 @@ class LMCutConstraintsFeature "For each landmark L the constraint sum_{o in L} Count_o >= 1 is added " "to the operator-counting LP temporarily. After the heuristic value " "for the state is computed, all temporary constraints are removed " - "again. For details, see" + + "again. The LM-cut method is described in the following paper:" + utils::format_conference_reference( - {"Florian Pommerening", "Gabriele Roeger", "Malte Helmert", - "Blai Bonet"}, - "LP-based Heuristics for Cost-optimal Planning", - "http://www.aaai.org/ocs/index.php/ICAPS/ICAPS14/paper/view/7892/8031", - "Proceedings of the Twenty-Fourth International Conference" - " on Automated Planning and Scheduling (ICAPS 2014)", - "226-234", "AAAI Press", "2014") + - utils::format_conference_reference( - {"Blai Bonet"}, - "An admissible heuristic for SAS+ planning obtained from the" - " state equation", - "http://ijcai.org/papers13/Papers/IJCAI13-335.pdf", - "Proceedings of the Twenty-Third International Joint" - " Conference on Artificial Intelligence (IJCAI 2013)", - "2268-2274", "AAAI Press", "2013")); + {"Malte Helmert", "Carmel Domshlak"}, + "Landmarks, Critical Paths and Abstractions: What's the " + "Difference Anyway?", + "https://ai.dmi.unibas.ch/papers/helmert-domshlak-icaps2009.pdf", + "Proceedings of the 19th International Conference on Automated " + "Planning and Scheduling (ICAPS 2009)", + "162-169", "AAAI Press", "2009")); lm_cut_heuristic::add_landmark_cut_landmarks_options_to_feature(*this); } diff --git a/src/search/pdbs/canonical_pdbs_heuristic.cc b/src/search/pdbs/canonical_pdbs_heuristic.cc index 9773932be1..21d68b10b4 100644 --- a/src/search/pdbs/canonical_pdbs_heuristic.cc +++ b/src/search/pdbs/canonical_pdbs_heuristic.cc @@ -100,7 +100,7 @@ class CanonicalPDBsHeuristicFeature document_title("Canonical PDB"); document_note( "Reference", - "The canonical pattern database heuristic is described in the " + "The canonical pattern database heuristic was introduced in the " "following paper:" + utils::format_conference_reference( {"Patrik Haslum", "Adi Botea", "Malte Helmert", @@ -110,7 +110,26 @@ class CanonicalPDBsHeuristicFeature "https://cdn.aaai.org/AAAI/2007/AAAI07-160.pdf", "Proceedings of the 22nd AAAI Conference on Artificial " "Intelligence (AAAI 2007)", - "1007-1012", "AAAI Press", "2007")); + "1007-1012", "AAAI Press", "2007") + + "It is discussed in the context of other cost partitioning " + "methods in the following paper:" + + utils::format_conference_reference( + {"Jendrik Seipp", "Thomas Keller", "Malte Helmert"}, + "A Comparison of Cost Partitioning Algorithms for Optimal " + "Classical Planning", + "https://ai.dmi.unibas.ch/papers/seipp-et-al-icaps2017.pdf", + "Proceedings of the 27th International Conference on " + "Automated Planning and Scheduling (ICAPS 2017)", + "259-268", "AAAI Press", "2017") + + "For implementation notes, see:" + + utils::format_conference_reference( + {"Silvan Sievers", "Manuela Ortlieb", "Malte Helmert"}, + "Efficient Implementation of Pattern Database Heuristics " + "for Classical Planning", + "https://ai.dmi.unibas.ch/papers/sievers-et-al-socs2012.pdf", + "Proceedings of the Fifth Annual Symposium on " + "Combinatorial Search (SoCS 2012)", + "105-111", "AAAI Press", "2012")); document_synopsis( "The canonical pattern database heuristic is calculated as follows. " "For a given pattern collection C, the value of the " diff --git a/src/search/pdbs/pattern_collection_generator_genetic.cc b/src/search/pdbs/pattern_collection_generator_genetic.cc index 6e9d6e4eb6..2d91edc970 100644 --- a/src/search/pdbs/pattern_collection_generator_genetic.cc +++ b/src/search/pdbs/pattern_collection_generator_genetic.cc @@ -313,7 +313,7 @@ class PatternCollectionGeneratorGeneticFeature "databases with a genetic algorithm. Pattern collections are initially " "created with a bin-packing algorithm. The genetic algorithm is used " "to optimize the pattern collections with an objective function that " - "estimates the mean heuristic value of the the pattern collections. " + "estimates the mean heuristic value of the pattern collections. " "Pattern collections with higher mean heuristic estimates are more " "likely selected for the next generation." + utils::format_conference_reference( diff --git a/src/search/pdbs/pattern_generator_random.cc b/src/search/pdbs/pattern_generator_random.cc index d6c86cc02b..b26b1e9dc2 100644 --- a/src/search/pdbs/pattern_generator_random.cc +++ b/src/search/pdbs/pattern_generator_random.cc @@ -51,7 +51,7 @@ class PatternGeneratorRandomFeature document_title("Random pattern"); document_synopsis( "This pattern generator implements the 'single randomized " - "causal graph' algorithm described in experiments of the the paper" + + "causal graph' algorithm described in experiments of the paper" + get_rovner_et_al_reference() + "See below for a description of the algorithm and some implementation " "notes."); diff --git a/src/search/pdbs/zero_one_pdbs_heuristic.cc b/src/search/pdbs/zero_one_pdbs_heuristic.cc index 280307d601..dea30ba47c 100644 --- a/src/search/pdbs/zero_one_pdbs_heuristic.cc +++ b/src/search/pdbs/zero_one_pdbs_heuristic.cc @@ -43,16 +43,45 @@ class ZeroOnePDBsHeuristicFeature document_title("Zero-One PDB"); document_note( "Reference", - "Zero/one cost partitioning for pattern databases is described " - "in the following paper:" + + "The idea of zero-one cost partitioning is described in the " + "following paper:" + + utils::format_conference_reference( + {"Patrik Haslum", "Blai Bonet", "Hector Geffner"}, + "New Admissible Heuristics for Domain-Independent " + "Planning", + "https://cdn.aaai.org/AAAI/2005/AAAI05-184.pdf", + "Proceedings of the 20th National Conference on " + "Artificial Intelligence (AAAI 2005)", + "1163-1168", "AAAI Press", "2005") + + "Greedy zero-one cost partitioning for pattern databases is " + "described in the following paper:" + utils::format_conference_reference( {"Stefan Edelkamp"}, - "Automated Creation of Pattern Database Search Heuristics", - "https://doi.org/10.1007/978-3-540-74128-2_3", - "Model Checking and Artificial Intelligence, 4th " - "Workshop (MoChArt 2006), Revised Selected and Invited " - "Papers", - "35-50", "Springer", "2007")); + "Symbolic Pattern Databases in Heuristic Search Planning", + "https://cdn.aaai.org/AIPS/2002/AIPS02-028.pdf", + "Proceedings of the Sixth International Conference on " + "Artificial Intelligence Planning Systems " + "(AIPS 2002)", + "274-283", "AAAI Press", "2002") + + "It is discussed in the context of other cost partitioning " + "methods in the following paper:" + + utils::format_conference_reference( + {"Jendrik Seipp", "Thomas Keller", "Malte Helmert"}, + "A Comparison of Cost Partitioning Algorithms for Optimal " + "Classical Planning", + "https://ai.dmi.unibas.ch/papers/seipp-et-al-icaps2017.pdf", + "Proceedings of the 27th International Conference on " + "Automated Planning and Scheduling (ICAPS 2017)", + "259-268", "AAAI Press", "2017") + + "For implementation notes, see:" + + utils::format_conference_reference( + {"Silvan Sievers", "Manuela Ortlieb", "Malte Helmert"}, + "Efficient Implementation of Pattern Database Heuristics " + "for Classical Planning", + "https://ai.dmi.unibas.ch/papers/sievers-et-al-socs2012.pdf", + "Proceedings of the Fifth Annual Symposium on " + "Combinatorial Search (SoCS 2012)", + "105-111", "AAAI Press", "2012")); document_synopsis( "The zero/one pattern database heuristic is simply the sum of the " "heuristic values of all patterns in the pattern collection. In contrast " diff --git a/src/search/pruning/limited_pruning.cc b/src/search/pruning/limited_pruning.cc index 01754fe678..1fd648b0c5 100644 --- a/src/search/pruning/limited_pruning.cc +++ b/src/search/pruning/limited_pruning.cc @@ -67,16 +67,18 @@ class LimitedPruningFeature document_title("Limited pruning"); document_note( "Reference", - "Disabling stubborn set pruning based on the observed pruning " - "ratio is evaluated in the following paper:" + + "Disabling pruning based on the observed pruning ratio is " + "described in the following paper:" + utils::format_conference_reference( - {"Gabriele Röger", "Malte Helmert", "Jendrik Seipp", - "Silvan Sievers"}, - "An Atom-Centric Perspective on Stubborn Sets", - "https://ojs.aaai.org/index.php/SOCS/article/download/18535/18326", - "Proceedings of the 13th Annual Symposium on " - "Combinatorial Search (SoCS 2020)", - "57-65", "AAAI Press", "2020")); + {"Yusra Alkhazraji", "Michael Katz", "Robert Mattmüller", + "Florian Pommerening", "Alexander Shleyfman", + "Martin Wehrle"}, + "Metis: Arming Fast Downward with Pruning and Incremental " + "Computation", + "https://ai.dmi.unibas.ch/papers/alkhazraji-et-al-ipc2014.pdf", + "Eighth International Planning Competition (IPC-8): " + "Planner Abstracts", + "88-92", "", "2014")); document_synopsis( "Limited pruning applies another pruning method and switches it off " "after a fixed number of expansions if the pruning ratio is below a " diff --git a/src/search/search_algorithms/enforced_hill_climbing_search.cc b/src/search/search_algorithms/enforced_hill_climbing_search.cc index d5ae53f0c6..a2498b6718 100644 --- a/src/search/search_algorithms/enforced_hill_climbing_search.cc +++ b/src/search/search_algorithms/enforced_hill_climbing_search.cc @@ -271,14 +271,28 @@ class EnforcedHillClimbingSearchFeature EnforcedHillClimbingSearchFeature() : TypedFeature("ehc") { document_title("Lazy enforced hill-climbing"); document_synopsis( - "Enforced hill-climbing search is described in the following paper:" + + "Enforced hill-climbing search was introduced in the following " + "paper:" + utils::format_journal_reference( {"Jörg Hoffmann", "Bernhard Nebel"}, "The FF Planning System: Fast Plan Generation Through " "Heuristic Search", - "https://www.jair.org/index.php/jair/article/download/10276/24496", + "https://doi.org/10.1613/jair.855", "Journal of Artificial Intelligence Research", "14", "253-302", - "2001")); + "2001") + + "Note that the implementation differs from the algorithm " + "described in the paper in several ways. First, it evaluates " + "states lazily, i.e., it computes the heuristic value of a " + "state only when it is removed from the open list. Second, it " + "uses a global closed list instead of detecting duplicates only " + "within each local breadth-first search. As a result, it can " + "fail to find a solution even on tasks without dead ends. Third, " + "it orders states by their (adjusted) g value, i.e., it performs " + "uniform-cost search instead of breadth-first search in each " + "phase if the task has non-unit action costs. Fourth, instead of " + "the helpful actions of the FF planner, it can use the preferred " + "operators of arbitrary evaluators, either for pruning or for " + "ranking successors."); add_option>("h", "heuristic"); add_option( diff --git a/src/search/search_algorithms/iterated_search.cc b/src/search/search_algorithms/iterated_search.cc index 3ef8a2cb43..8b6752b492 100644 --- a/src/search/search_algorithms/iterated_search.cc +++ b/src/search/search_algorithms/iterated_search.cc @@ -289,7 +289,7 @@ class IteratedSearchFeature {"Silvia Richter", "Matthias Westphal"}, "The LAMA Planner: Guiding Cost-Based Anytime Planning " "with Landmarks", - "https://jair.org/index.php/jair/article/download/10667/25496", + "https://doi.org/10.1613/jair.2972", "Journal of Artificial Intelligence Research", "39", "127-177", "2010")); diff --git a/src/search/search_algorithms/plugin_eager.cc b/src/search/search_algorithms/plugin_eager.cc index a74a4578cb..d886336fc5 100644 --- a/src/search/search_algorithms/plugin_eager.cc +++ b/src/search/search_algorithms/plugin_eager.cc @@ -19,7 +19,7 @@ class EagerSearchFeature {"Silvia Richter", "Malte Helmert"}, "Preferred Operators and Deferred Evaluation in " "Satisficing Planning", - "https://ojs.aaai.org/index.php/ICAPS/article/download/13345/13193", + "https://doi.org/10.1609/icaps.v19i1.13345", "Proceedings of the 19th International Conference on " "Automated Planning and Scheduling (ICAPS 2009)", "273-280", "AAAI Press", "2009")); diff --git a/src/search/search_algorithms/plugin_eager_greedy.cc b/src/search/search_algorithms/plugin_eager_greedy.cc index 6f7818b04c..77ed9d04d4 100644 --- a/src/search/search_algorithms/plugin_eager_greedy.cc +++ b/src/search/search_algorithms/plugin_eager_greedy.cc @@ -19,7 +19,7 @@ class EagerGreedySearchFeature {"Silvia Richter", "Malte Helmert"}, "Preferred Operators and Deferred Evaluation in " "Satisficing Planning", - "https://ojs.aaai.org/index.php/ICAPS/article/download/13345/13193", + "https://doi.org/10.1609/icaps.v19i1.13345", "Proceedings of the 19th International Conference on " "Automated Planning and Scheduling (ICAPS 2009)", "273-280", "AAAI Press", "2009")); diff --git a/src/search/search_algorithms/plugin_lazy.cc b/src/search/search_algorithms/plugin_lazy.cc index 82b2a1d8c2..a5dcfcdc9a 100644 --- a/src/search/search_algorithms/plugin_lazy.cc +++ b/src/search/search_algorithms/plugin_lazy.cc @@ -13,13 +13,20 @@ class LazySearchFeature LazySearchFeature() : TypedFeature("lazy") { document_title("Lazy best-first search"); document_synopsis( - "Deferred evaluation and preferred operators are described in " - "the following paper:" + + "Lazy search (deferred evaluation) is described in the following " + "paper:" + + utils::format_journal_reference( + {"Malte Helmert"}, "The Fast Downward Planning System", + "https://doi.org/10.1613/jair.1705", + "Journal of Artificial Intelligence Research", "26", "191-246", + "2006") + + "Deferred evaluation and preferred operators are discussed in " + "more detail in the following paper:" + utils::format_conference_reference( {"Silvia Richter", "Malte Helmert"}, "Preferred Operators and Deferred Evaluation in " "Satisficing Planning", - "https://ojs.aaai.org/index.php/ICAPS/article/download/13345/13193", + "https://doi.org/10.1609/icaps.v19i1.13345", "Proceedings of the 19th International Conference on " "Automated Planning and Scheduling (ICAPS 2009)", "273-280", "AAAI Press", "2009")); diff --git a/src/search/search_algorithms/plugin_lazy_greedy.cc b/src/search/search_algorithms/plugin_lazy_greedy.cc index 4654098e02..76efd1739f 100644 --- a/src/search/search_algorithms/plugin_lazy_greedy.cc +++ b/src/search/search_algorithms/plugin_lazy_greedy.cc @@ -15,13 +15,20 @@ class LazyGreedySearchFeature LazyGreedySearchFeature() : TypedFeature("lazy_greedy") { document_title("Greedy search (lazy)"); document_synopsis( - "Deferred evaluation and preferred operators are described in " - "the following paper:" + + "Lazy search (deferred evaluation) is described in the following " + "paper:" + + utils::format_journal_reference( + {"Malte Helmert"}, "The Fast Downward Planning System", + "https://doi.org/10.1613/jair.1705", + "Journal of Artificial Intelligence Research", "26", "191-246", + "2006") + + "Deferred evaluation and preferred operators are discussed in " + "more detail in the following paper:" + utils::format_conference_reference( {"Silvia Richter", "Malte Helmert"}, "Preferred Operators and Deferred Evaluation in " "Satisficing Planning", - "https://ojs.aaai.org/index.php/ICAPS/article/download/13345/13193", + "https://doi.org/10.1609/icaps.v19i1.13345", "Proceedings of the 19th International Conference on " "Automated Planning and Scheduling (ICAPS 2009)", "273-280", "AAAI Press", "2009")); diff --git a/src/search/search_algorithms/plugin_lazy_wastar.cc b/src/search/search_algorithms/plugin_lazy_wastar.cc index 0b56944b79..33133d7b19 100644 --- a/src/search/search_algorithms/plugin_lazy_wastar.cc +++ b/src/search/search_algorithms/plugin_lazy_wastar.cc @@ -16,21 +16,30 @@ class LazyWAstarSearchFeature document_title("(Weighted) A* search (lazy)"); document_note( "Reference", - "Weighted A* is described in the following paper:" + + "Lazy search (deferred evaluation) is described in the following " + "papers:" + utils::format_journal_reference( - {"Ira Pohl"}, - "Heuristic Search Viewed as Path Finding in a Graph", - "https://doi.org/10.1016/0004-3702%2870%2990007-X", - "Artificial Intelligence", "1(3-4)", "193-204", "1970") + - "Deferred evaluation is described in the following paper:" + + {"Malte Helmert"}, "The Fast Downward Planning System", + "https://doi.org/10.1613/jair.1705", + "Journal of Artificial Intelligence Research", "26", + "191-246", "2006") + utils::format_conference_reference( {"Silvia Richter", "Malte Helmert"}, "Preferred Operators and Deferred Evaluation in Satisficing " "Planning", - "https://ojs.aaai.org/index.php/ICAPS/article/download/13345/13193", + "https://doi.org/10.1609/icaps.v19i1.13345", "Proceedings of the 19th International Conference on " "Automated Planning and Scheduling (ICAPS 2009)", - "273-280", "AAAI Press", "2009")); + "273-280", "AAAI Press", "2009") + + "Lazy weighted A* is used and described in the following " + "paper:" + + utils::format_journal_reference( + {"Silvia Richter", "Matthias Westphal"}, + "The LAMA Planner: Guiding Cost-Based Anytime Planning " + "with Landmarks", + "https://doi.org/10.1613/jair.2972", + "Journal of Artificial Intelligence Research", "39", + "127-177", "2010")); document_synopsis( "Weighted A* is a special case of lazy best first search."); From c8b7b3eceb9dc37f2c888df4124e66ccd4b3666a Mon Sep 17 00:00:00 2001 From: Jendrik Seipp Date: Fri, 9 Oct 2026 20:20:43 +0000 Subject: [PATCH 3/5] Fix references based on a check against DBLP. Replace dead and direct-download links with DOI links, fix the page numbers of the SoCS 2012 PDB implementation paper, use the original spelling of author names, and use the title capitalization from DBLP. --- .../additive_cartesian_heuristic.cc | 2 +- .../landmark_factory_reasonable_orders_hps.cc | 2 +- .../merge_and_shrink/merge_tree_factory_linear.cc | 2 +- src/search/merge_and_shrink/shrink_bisimulation.cc | 2 +- src/search/merge_and_shrink/shrink_fh.cc | 2 +- src/search/open_lists/epsilon_greedy_open_list.cc | 2 +- src/search/open_lists/type_based_open_list.cc | 4 ++-- .../delete_relaxation_if_constraints.cc | 6 +++--- .../operator_counting/operator_counting_heuristic.cc | 6 +++--- src/search/operator_counting/pho_constraints.cc | 2 +- .../operator_counting/state_equation_constraints.cc | 12 ++++++------ src/search/pdbs/canonical_pdbs_heuristic.cc | 2 +- .../pdbs/pattern_collection_generator_genetic.cc | 2 +- .../pattern_collection_generator_hillclimbing.cc | 2 +- .../pdbs/pattern_collection_generator_systematic.cc | 2 +- src/search/pdbs/pdb_heuristic.cc | 2 +- src/search/pdbs/zero_one_pdbs_heuristic.cc | 2 +- src/search/pruning/stubborn_sets_atom_centric.cc | 2 +- src/search/pruning/stubborn_sets_ec.cc | 4 ++-- src/search/pruning/stubborn_sets_simple.cc | 4 ++-- 20 files changed, 32 insertions(+), 32 deletions(-) diff --git a/src/search/cartesian_abstractions/additive_cartesian_heuristic.cc b/src/search/cartesian_abstractions/additive_cartesian_heuristic.cc index 16543123d5..f5de3fa20f 100644 --- a/src/search/cartesian_abstractions/additive_cartesian_heuristic.cc +++ b/src/search/cartesian_abstractions/additive_cartesian_heuristic.cc @@ -68,7 +68,7 @@ class AdditiveCartesianHeuristicFeature "abstraction refinement (CEGAR) for classical planning:" + utils::format_conference_reference( {"Jendrik Seipp", "Malte Helmert"}, - "Counterexample-guided Cartesian Abstraction Refinement", + "Counterexample-Guided Cartesian Abstraction Refinement", "https://ai.dmi.unibas.ch/papers/seipp-helmert-icaps2013.pdf", "Proceedings of the 23rd International Conference on Automated " "Planning and Scheduling (ICAPS 2013)", diff --git a/src/search/landmarks/landmark_factory_reasonable_orders_hps.cc b/src/search/landmarks/landmark_factory_reasonable_orders_hps.cc index 25da5572ba..ec6797d09e 100644 --- a/src/search/landmarks/landmark_factory_reasonable_orders_hps.cc +++ b/src/search/landmarks/landmark_factory_reasonable_orders_hps.cc @@ -389,7 +389,7 @@ class LandmarkFactoryReasonableOrdersHPSFeature utils::format_journal_reference( {"Jörg Hoffmann", "Julie Porteous", "Laura Sebastia"}, "Ordered Landmarks in Planning", - "https://jair.org/index.php/jair/article/view/10390/24882", + "https://doi.org/10.1613/jair.1492", "Journal of Artificial Intelligence Research", "22", "215-278", "2004")); diff --git a/src/search/merge_and_shrink/merge_tree_factory_linear.cc b/src/search/merge_and_shrink/merge_tree_factory_linear.cc index 853dd0228e..5aeae51e45 100644 --- a/src/search/merge_and_shrink/merge_tree_factory_linear.cc +++ b/src/search/merge_and_shrink/merge_tree_factory_linear.cc @@ -127,7 +127,7 @@ class MergeTreeFactoryLinearFeature "orders cg_goal_level and goal_cg_level are described in the " "following paper:" + utils::format_conference_reference( - {"Malte Helmert", "Patrik Haslum", "Joerg Hoffmann"}, + {"Malte Helmert", "Patrik Haslum", "Jörg Hoffmann"}, "Flexible Abstraction Heuristics for Optimal Sequential Planning", "https://ai.dmi.unibas.ch/papers/helmert-et-al-icaps2007.pdf", "Proceedings of the Seventeenth International Conference on" diff --git a/src/search/merge_and_shrink/shrink_bisimulation.cc b/src/search/merge_and_shrink/shrink_bisimulation.cc index f4d94204f6..7f19c5c718 100644 --- a/src/search/merge_and_shrink/shrink_bisimulation.cc +++ b/src/search/merge_and_shrink/shrink_bisimulation.cc @@ -380,7 +380,7 @@ class ShrinkBisimulationFeature "This shrink strategy implements the algorithm described in" " the paper:" + utils::format_conference_reference( - {"Raz Nissim", "Joerg Hoffmann", "Malte Helmert"}, + {"Raz Nissim", "Jörg Hoffmann", "Malte Helmert"}, "Computing Perfect Heuristics in Polynomial Time: On Bisimulation" " and Merge-and-Shrink Abstraction in Optimal Planning", "https://ai.dmi.unibas.ch/papers/nissim-et-al-ijcai2011.pdf", diff --git a/src/search/merge_and_shrink/shrink_fh.cc b/src/search/merge_and_shrink/shrink_fh.cc index 9a498f8a4e..939122a972 100644 --- a/src/search/merge_and_shrink/shrink_fh.cc +++ b/src/search/merge_and_shrink/shrink_fh.cc @@ -196,7 +196,7 @@ class ShrinkFHFeature "This shrink strategy implements the algorithm described in" " the paper:" + utils::format_conference_reference( - {"Malte Helmert", "Patrik Haslum", "Joerg Hoffmann"}, + {"Malte Helmert", "Patrik Haslum", "Jörg Hoffmann"}, "Flexible Abstraction Heuristics for Optimal Sequential Planning", "https://ai.dmi.unibas.ch/papers/helmert-et-al-icaps2007.pdf", "Proceedings of the Seventeenth International Conference on" diff --git a/src/search/open_lists/epsilon_greedy_open_list.cc b/src/search/open_lists/epsilon_greedy_open_list.cc index cc000e50cb..4fae972f6f 100644 --- a/src/search/open_lists/epsilon_greedy_open_list.cc +++ b/src/search/open_lists/epsilon_greedy_open_list.cc @@ -181,7 +181,7 @@ class EpsilonGreedyOpenListFeature "Jonathan Schaeffer", "Fan Xie"}, "A Comparison of Knowledge-Based GBFS Enhancements and" " Knowledge-Free Exploration", - "http://www.aaai.org/ocs/index.php/ICAPS/ICAPS14/paper/view/7943/8066", + "https://doi.org/10.1609/icaps.v24i1.13681", "Proceedings of the Twenty-Fourth International Conference" " on Automated Planning and Scheduling (ICAPS 2014)", "375-379", "AAAI Press", "2014")); diff --git a/src/search/open_lists/type_based_open_list.cc b/src/search/open_lists/type_based_open_list.cc index 2c76b30c28..dd40e7cb39 100644 --- a/src/search/open_lists/type_based_open_list.cc +++ b/src/search/open_lists/type_based_open_list.cc @@ -173,10 +173,10 @@ class TypeBasedOpenListFeature "uniformly randomly. " "The algorithm is based on" + utils::format_conference_reference( - {"Fan Xie", "Martin Mueller", "Robert Holte", "Tatsuya Imai"}, + {"Fan Xie", "Martin Müller", "Robert Holte", "Tatsuya Imai"}, "Type-Based Exploration with Multiple Search Queues for" " Satisficing Planning", - "http://www.aaai.org/ocs/index.php/AAAI/AAAI14/paper/view/8472/8705", + "https://doi.org/10.1609/aaai.v28i1.9036", "Proceedings of the Twenty-Eighth AAAI Conference" " on Artificial Intelligence (AAAI 2014)", "2395-2402", "AAAI Press", "2014")); diff --git a/src/search/operator_counting/delete_relaxation_if_constraints.cc b/src/search/operator_counting/delete_relaxation_if_constraints.cc index ec533108b5..4772ed72ca 100644 --- a/src/search/operator_counting/delete_relaxation_if_constraints.cc +++ b/src/search/operator_counting/delete_relaxation_if_constraints.cc @@ -259,9 +259,9 @@ class DeleteRelaxationIFConstraintsFeature "For details, see" + utils::format_journal_reference( {"Tatsuya Imai", "Alex Fukunaga"}, - "On a practical, integer-linear programming model for delete-free " - "tasks and its use as a heuristic for cost-optimal planning", - "https://www.jair.org/index.php/jair/article/download/10972/26119/", + "On a Practical, Integer-Linear Programming Model for Delete-Free " + "Tasks and its Use as a Heuristic for Cost-Optimal Planning", + "https://doi.org/10.1613/jair.4936", "Journal of Artificial Intelligence Research", "54", "631-677", "2015")); diff --git a/src/search/operator_counting/operator_counting_heuristic.cc b/src/search/operator_counting/operator_counting_heuristic.cc index b25c1cf263..7fcb23d24b 100644 --- a/src/search/operator_counting/operator_counting_heuristic.cc +++ b/src/search/operator_counting/operator_counting_heuristic.cc @@ -79,10 +79,10 @@ class OperatorCountingHeuristicFeature "some operator-counting constraints is an admissible heuristic. " "For details, see" + utils::format_conference_reference( - {"Florian Pommerening", "Gabriele Roeger", "Malte Helmert", + {"Florian Pommerening", "Gabriele Röger", "Malte Helmert", "Blai Bonet"}, - "LP-based Heuristics for Cost-optimal Planning", - "http://www.aaai.org/ocs/index.php/ICAPS/ICAPS14/paper/view/7892/8031", + "LP-Based Heuristics for Cost-Optimal Planning", + "https://doi.org/10.1609/icaps.v24i1.13621", "Proceedings of the Twenty-Fourth International Conference" " on Automated Planning and Scheduling (ICAPS 2014)", "226-234", "AAAI Press", "2014")); diff --git a/src/search/operator_counting/pho_constraints.cc b/src/search/operator_counting/pho_constraints.cc index ae11335375..da953a5466 100644 --- a/src/search/operator_counting/pho_constraints.cc +++ b/src/search/operator_counting/pho_constraints.cc @@ -74,7 +74,7 @@ class PhOConstraintsFeature " constraint h(s) <= sum_{o in relevant(h)} Count_o. For details," " see" + utils::format_conference_reference( - {"Florian Pommerening", "Gabriele Roeger", "Malte Helmert"}, + {"Florian Pommerening", "Gabriele Röger", "Malte Helmert"}, "Getting the Most Out of Pattern Databases for Classical Planning", "http://ijcai.org/papers13/Papers/IJCAI13-347.pdf", "Proceedings of the Twenty-Third International Joint" diff --git a/src/search/operator_counting/state_equation_constraints.cc b/src/search/operator_counting/state_equation_constraints.cc index 446f2601bb..2cdd4ff732 100644 --- a/src/search/operator_counting/state_equation_constraints.cc +++ b/src/search/operator_counting/state_equation_constraints.cc @@ -136,24 +136,24 @@ class StateEquationConstraintsFeature utils::format_conference_reference( {"Menkes van den Briel", "J. Benton", "Subbarao Kambhampati", "Thomas Vossen"}, - "An LP-based heuristic for optimal planning", + "An LP-Based Heuristic for Optimal Planning", "http://link.springer.com/chapter/10.1007/978-3-540-74970-7_46", "Proceedings of the Thirteenth International Conference on" " Principles and Practice of Constraint Programming (CP 2007)", "651-665", "Springer-Verlag", "2007") + utils::format_conference_reference( {"Blai Bonet"}, - "An admissible heuristic for SAS+ planning obtained from the" - " state equation", + "An Admissible Heuristic for SAS+ Planning Obtained from the" + " State Equation", "http://ijcai.org/papers13/Papers/IJCAI13-335.pdf", "Proceedings of the Twenty-Third International Joint" " Conference on Artificial Intelligence (IJCAI 2013)", "2268-2274", "AAAI Press", "2013") + utils::format_conference_reference( - {"Florian Pommerening", "Gabriele Roeger", "Malte Helmert", + {"Florian Pommerening", "Gabriele Röger", "Malte Helmert", "Blai Bonet"}, - "LP-based Heuristics for Cost-optimal Planning", - "http://www.aaai.org/ocs/index.php/ICAPS/ICAPS14/paper/view/7892/8031", + "LP-Based Heuristics for Cost-Optimal Planning", + "https://doi.org/10.1609/icaps.v24i1.13621", "Proceedings of the Twenty-Fourth International Conference" " on Automated Planning and Scheduling (ICAPS 2014)", "226-234", "AAAI Press", "2014")); diff --git a/src/search/pdbs/canonical_pdbs_heuristic.cc b/src/search/pdbs/canonical_pdbs_heuristic.cc index 21d68b10b4..91f9c6dc0b 100644 --- a/src/search/pdbs/canonical_pdbs_heuristic.cc +++ b/src/search/pdbs/canonical_pdbs_heuristic.cc @@ -129,7 +129,7 @@ class CanonicalPDBsHeuristicFeature "https://ai.dmi.unibas.ch/papers/sievers-et-al-socs2012.pdf", "Proceedings of the Fifth Annual Symposium on " "Combinatorial Search (SoCS 2012)", - "105-111", "AAAI Press", "2012")); + "49-56", "AAAI Press", "2012")); document_synopsis( "The canonical pattern database heuristic is calculated as follows. " "For a given pattern collection C, the value of the " diff --git a/src/search/pdbs/pattern_collection_generator_genetic.cc b/src/search/pdbs/pattern_collection_generator_genetic.cc index 2d91edc970..e9acb8a325 100644 --- a/src/search/pdbs/pattern_collection_generator_genetic.cc +++ b/src/search/pdbs/pattern_collection_generator_genetic.cc @@ -319,7 +319,7 @@ class PatternCollectionGeneratorGeneticFeature utils::format_conference_reference( {"Stefan Edelkamp"}, "Automated Creation of Pattern Database Search Heuristics", - "http://www.springerlink.com/content/20613345434608x1/", + "https://doi.org/10.1007/978-3-540-74128-2_3", "Model Checking and Artificial Intelligence, 4th Workshop " "(MoChArt 2006), Revised Selected and Invited Papers", "35-50", "Springer", "2007")); diff --git a/src/search/pdbs/pattern_collection_generator_hillclimbing.cc b/src/search/pdbs/pattern_collection_generator_hillclimbing.cc index 89c54dba8a..89df619176 100644 --- a/src/search/pdbs/pattern_collection_generator_hillclimbing.cc +++ b/src/search/pdbs/pattern_collection_generator_hillclimbing.cc @@ -578,7 +578,7 @@ static basic_string paper_references() { "https://ai.dmi.unibas.ch/papers/sievers-et-al-socs2012.pdf", "Proceedings of the Fifth Annual Symposium on Combinatorial" " Search (SoCS 2012)", - "105-111", "AAAI Press", "2012"); + "49-56", "AAAI Press", "2012"); } class PatternCollectionGeneratorHillclimbingFeature diff --git a/src/search/pdbs/pattern_collection_generator_systematic.cc b/src/search/pdbs/pattern_collection_generator_systematic.cc index b3d0eee48f..67563d0903 100644 --- a/src/search/pdbs/pattern_collection_generator_systematic.cc +++ b/src/search/pdbs/pattern_collection_generator_systematic.cc @@ -298,7 +298,7 @@ class PatternCollectionGeneratorSystematicFeature "variables. " "For details, see" + utils::format_conference_reference( - {"Florian Pommerening", "Gabriele Roeger", "Malte Helmert"}, + {"Florian Pommerening", "Gabriele Röger", "Malte Helmert"}, "Getting the Most Out of Pattern Databases for Classical Planning", "https://ai.dmi.unibas.ch/papers/pommerening-et-al-ijcai2013.pdf", "Proceedings of the Twenty-Third International Joint" diff --git a/src/search/pdbs/pdb_heuristic.cc b/src/search/pdbs/pdb_heuristic.cc index 1704ba9345..41af55c4f0 100644 --- a/src/search/pdbs/pdb_heuristic.cc +++ b/src/search/pdbs/pdb_heuristic.cc @@ -48,7 +48,7 @@ static basic_string paper_references() { "https://ai.dmi.unibas.ch/papers/sievers-et-al-socs2012.pdf", "Proceedings of the Fifth Annual Symposium on Combinatorial" " Search (SoCS 2012)", - "105-111", "AAAI Press", "2012"); + "49-56", "AAAI Press", "2012"); } class PDBHeuristicFeature : public plugins::TypedFeature { diff --git a/src/search/pdbs/zero_one_pdbs_heuristic.cc b/src/search/pdbs/zero_one_pdbs_heuristic.cc index dea30ba47c..bbd474995f 100644 --- a/src/search/pdbs/zero_one_pdbs_heuristic.cc +++ b/src/search/pdbs/zero_one_pdbs_heuristic.cc @@ -81,7 +81,7 @@ class ZeroOnePDBsHeuristicFeature "https://ai.dmi.unibas.ch/papers/sievers-et-al-socs2012.pdf", "Proceedings of the Fifth Annual Symposium on " "Combinatorial Search (SoCS 2012)", - "105-111", "AAAI Press", "2012")); + "49-56", "AAAI Press", "2012")); document_synopsis( "The zero/one pattern database heuristic is simply the sum of the " "heuristic values of all patterns in the pattern collection. In contrast " diff --git a/src/search/pruning/stubborn_sets_atom_centric.cc b/src/search/pruning/stubborn_sets_atom_centric.cc index 626f615f78..cf1e4368ed 100644 --- a/src/search/pruning/stubborn_sets_atom_centric.cc +++ b/src/search/pruning/stubborn_sets_atom_centric.cc @@ -265,7 +265,7 @@ class StubbornSetsAtomCentricFeature "this implementation focuses on atomic propositions (atoms), which " "often speeds up the computation on IPC benchmarks. For details, see" + utils::format_conference_reference( - {"Gabriele Roeger", "Malte Helmert", "Jendrik Seipp", + {"Gabriele Röger", "Malte Helmert", "Jendrik Seipp", "Silvan Sievers"}, "An Atom-Centric Perspective on Stubborn Sets", "https://ai.dmi.unibas.ch/papers/roeger-et-al-socs2020.pdf", diff --git a/src/search/pruning/stubborn_sets_ec.cc b/src/search/pruning/stubborn_sets_ec.cc index dd2d1c650a..605fdf36dc 100644 --- a/src/search/pruning/stubborn_sets_ec.cc +++ b/src/search/pruning/stubborn_sets_ec.cc @@ -345,9 +345,9 @@ class StubbornSetsECFeature "Expansion Core pruning method. For details, see" + utils::format_conference_reference( {"Martin Wehrle", "Malte Helmert", "Yusra Alkhazraji", - "Robert Mattmueller"}, + "Robert Mattmüller"}, "The Relative Pruning Power of Strong Stubborn Sets and Expansion Core", - "http://www.aaai.org/ocs/index.php/ICAPS/ICAPS13/paper/view/6053/6185", + "https://doi.org/10.1609/icaps.v23i1.13565", "Proceedings of the 23rd International Conference on Automated Planning " "and Scheduling (ICAPS 2013)", "251-259", "AAAI Press", "2013")); diff --git a/src/search/pruning/stubborn_sets_simple.cc b/src/search/pruning/stubborn_sets_simple.cc index 28d9f9780f..95db69e2f5 100644 --- a/src/search/pruning/stubborn_sets_simple.cc +++ b/src/search/pruning/stubborn_sets_simple.cc @@ -88,7 +88,7 @@ class StubbornSetsSimpleFeature "This stubborn set variant resolves the design choices in a " "straight-forward way. For details, see the following papers: " + utils::format_conference_reference( - {"Yusra Alkhazraji", "Martin Wehrle", "Robert Mattmueller", + {"Yusra Alkhazraji", "Martin Wehrle", "Robert Mattmüller", "Malte Helmert"}, "A Stubborn Set Algorithm for Optimal Planning", "https://ai.dmi.unibas.ch/papers/alkhazraji-et-al-ecai2012.pdf", @@ -98,7 +98,7 @@ class StubbornSetsSimpleFeature utils::format_conference_reference( {"Martin Wehrle", "Malte Helmert"}, "Efficient Stubborn Sets: Generalized Algorithms and Selection Strategies", - "http://www.aaai.org/ocs/index.php/ICAPS/ICAPS14/paper/view/7922/8042", + "https://doi.org/10.1609/icaps.v24i1.13638", "Proceedings of the 24th International Conference on Automated Planning " " and Scheduling (ICAPS 2014)", "323-331", "AAAI Press", "2014")); From 1e3ecf62dbae9a3eb19fd4a96c8248bae51ad2fd Mon Sep 17 00:00:00 2001 From: Jendrik Seipp Date: Thu, 15 Oct 2026 18:14:39 +0000 Subject: [PATCH 4/5] Restore last page of xie-et-al-aaai2014. DBLP lists the wrong last page for this paper. --- src/search/open_lists/type_based_open_list.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/search/open_lists/type_based_open_list.cc b/src/search/open_lists/type_based_open_list.cc index dd40e7cb39..130263411a 100644 --- a/src/search/open_lists/type_based_open_list.cc +++ b/src/search/open_lists/type_based_open_list.cc @@ -179,7 +179,7 @@ class TypeBasedOpenListFeature "https://doi.org/10.1609/aaai.v28i1.9036", "Proceedings of the Twenty-Eighth AAAI Conference" " on Artificial Intelligence (AAAI 2014)", - "2395-2402", "AAAI Press", "2014")); + "2395-2401", "AAAI Press", "2014")); add_list_option>( "evaluators", From fc197bf2f6aa6d62abcdfd20bcb7c3e8f5af4ff8 Mon Sep 17 00:00:00 2001 From: Jendrik Seipp Date: Thu, 15 Oct 2026 19:08:51 +0000 Subject: [PATCH 5/5] Refer to journal articles as articles instead of papers. --- .../cartesian_abstractions/additive_cartesian_heuristic.cc | 2 +- src/search/cartesian_abstractions/subtask_generators.cc | 6 +++--- src/search/heuristics/additive_heuristic.cc | 2 +- src/search/heuristics/ff_heuristic.cc | 2 +- src/search/heuristics/max_heuristic.cc | 2 +- .../landmarks/landmark_cost_partitioning_heuristic.cc | 2 +- .../landmarks/landmark_factory_reasonable_orders_hps.cc | 2 +- src/search/landmarks/landmark_factory_rpg_exhaust.cc | 2 +- src/search/landmarks/landmark_factory_rpg_sasp.cc | 2 +- src/search/landmarks/landmark_sum_heuristic.cc | 4 ++-- src/search/merge_and_shrink/label_reduction.cc | 2 +- src/search/merge_and_shrink/merge_and_shrink_heuristic.cc | 4 ++-- src/search/merge_and_shrink/merge_scoring_function_dfp.cc | 2 +- src/search/open_lists/alternation_open_list.cc | 2 +- .../operator_counting/delete_relaxation_if_constraints.cc | 2 +- .../search_algorithms/enforced_hill_climbing_search.cc | 4 ++-- src/search/search_algorithms/plugin_astar.cc | 2 +- src/search/search_algorithms/plugin_eager_wastar.cc | 2 +- src/search/search_algorithms/plugin_lazy.cc | 2 +- src/search/search_algorithms/plugin_lazy_greedy.cc | 2 +- src/search/search_algorithms/plugin_lazy_wastar.cc | 4 ++-- 21 files changed, 27 insertions(+), 27 deletions(-) diff --git a/src/search/cartesian_abstractions/additive_cartesian_heuristic.cc b/src/search/cartesian_abstractions/additive_cartesian_heuristic.cc index f5de3fa20f..52f6ec07e0 100644 --- a/src/search/cartesian_abstractions/additive_cartesian_heuristic.cc +++ b/src/search/cartesian_abstractions/additive_cartesian_heuristic.cc @@ -82,7 +82,7 @@ class AdditiveCartesianHeuristicFeature "Automated Planning and Scheduling (ICAPS 2014)", "289-297", "AAAI Press", "2014") + "For more details on Cartesian CEGAR and saturated cost partitioning, " - "see the journal paper" + + "see the article" + utils::format_journal_reference( {"Jendrik Seipp", "Malte Helmert"}, "Counterexample-Guided Cartesian Abstraction Refinement for " diff --git a/src/search/cartesian_abstractions/subtask_generators.cc b/src/search/cartesian_abstractions/subtask_generators.cc index 649b5240ea..b5da07be2d 100644 --- a/src/search/cartesian_abstractions/subtask_generators.cc +++ b/src/search/cartesian_abstractions/subtask_generators.cc @@ -214,7 +214,7 @@ class TaskDuplicatorFeature document_title("No abstraction"); document_synopsis( "Copies of the original task are used as subproblems. For " - "details, see the following papers:" + + "details, see the following publications:" + get_references()); add_option( "copies", "number of task copies", "1", @@ -238,7 +238,7 @@ class GoalDecompositionFeature document_synopsis( "For each goal atom of the original task one subproblem is " "generated having only the atom as its goal. For details, see the " - "following papers:" + + "following publications:" + get_references()); add_fact_order_option(*this); } @@ -262,7 +262,7 @@ class LandmarkDecompositionFeature "For each fact landmark of the delete relaxation of the original " "task one subproblem is generated having only the landmark as " "goal. This is a generalization of abstractions by goals. For " - "details, see the following papers:" + + "details, see the following publications:" + get_references()); add_fact_order_option(*this); add_option( diff --git a/src/search/heuristics/additive_heuristic.cc b/src/search/heuristics/additive_heuristic.cc index fc1be72093..0ea700850f 100644 --- a/src/search/heuristics/additive_heuristic.cc +++ b/src/search/heuristics/additive_heuristic.cc @@ -152,7 +152,7 @@ class AdditiveHeuristicFeature AdditiveHeuristicFeature() : TypedFeature("add") { document_title("Additive heuristic"); document_synopsis( - "The additive heuristic is described in the following paper:" + + "The additive heuristic is described in the following article:" + utils::format_journal_reference( {"Blai Bonet", "Hector Geffner"}, "Planning as heuristic search", diff --git a/src/search/heuristics/ff_heuristic.cc b/src/search/heuristics/ff_heuristic.cc index 75aa848df3..a292e06824 100644 --- a/src/search/heuristics/ff_heuristic.cc +++ b/src/search/heuristics/ff_heuristic.cc @@ -76,7 +76,7 @@ class FFHeuristicFeature FFHeuristicFeature() : TypedFeature("ff") { document_title("FF heuristic"); document_synopsis( - "The FF heuristic was introduced in the following paper:" + + "The FF heuristic was introduced in the following article:" + utils::format_journal_reference( {"Jörg Hoffmann", "Bernhard Nebel"}, "The FF Planning System: Fast Plan Generation Through " diff --git a/src/search/heuristics/max_heuristic.cc b/src/search/heuristics/max_heuristic.cc index 4fa78665f6..f15ada0470 100644 --- a/src/search/heuristics/max_heuristic.cc +++ b/src/search/heuristics/max_heuristic.cc @@ -108,7 +108,7 @@ class HSPMaxHeuristicFeature HSPMaxHeuristicFeature() : TypedFeature("hmax") { document_title("Max heuristic"); document_synopsis( - "The h^max heuristic is described in the following paper:" + + "The h^max heuristic is described in the following article:" + utils::format_journal_reference( {"Blai Bonet", "Hector Geffner"}, "Planning as heuristic search", diff --git a/src/search/landmarks/landmark_cost_partitioning_heuristic.cc b/src/search/landmarks/landmark_cost_partitioning_heuristic.cc index 05b41580a3..11422b754e 100644 --- a/src/search/landmarks/landmark_cost_partitioning_heuristic.cc +++ b/src/search/landmarks/landmark_cost_partitioning_heuristic.cc @@ -110,7 +110,7 @@ class LandmarkCostPartitioningHeuristicFeature "History Note", "Formerly known as the admissible landmark heuristic.\n" "The original landmark heuristic is described in the following " - "paper:" + + "article:" + utils::format_journal_reference( {"Silvia Richter", "Matthias Westphal"}, "The LAMA Planner: Guiding Cost-Based Anytime Planning " diff --git a/src/search/landmarks/landmark_factory_reasonable_orders_hps.cc b/src/search/landmarks/landmark_factory_reasonable_orders_hps.cc index ec6797d09e..391ea32d0f 100644 --- a/src/search/landmarks/landmark_factory_reasonable_orders_hps.cc +++ b/src/search/landmarks/landmark_factory_reasonable_orders_hps.cc @@ -385,7 +385,7 @@ class LandmarkFactoryReasonableOrdersHPSFeature : TypedFeature("lm_reasonable_orders_hps") { document_title("HPS orders"); document_synopsis( - "Adds reasonable orders described in the following paper" + + "Adds reasonable orders described in the following article:" + utils::format_journal_reference( {"Jörg Hoffmann", "Julie Porteous", "Laura Sebastia"}, "Ordered Landmarks in Planning", diff --git a/src/search/landmarks/landmark_factory_rpg_exhaust.cc b/src/search/landmarks/landmark_factory_rpg_exhaust.cc index 55c9f878c4..baa6b796d5 100644 --- a/src/search/landmarks/landmark_factory_rpg_exhaust.cc +++ b/src/search/landmarks/landmark_factory_rpg_exhaust.cc @@ -92,7 +92,7 @@ class LandmarkFactoryRpgExhaustFeature "Tests for every atom if the relaxed planning task where all " "achievers of this atom are removed is solvable. If not, the atom " "is a landmark. For the concept of delete relaxation, see the " - "following paper:" + + "following article:" + utils::format_journal_reference( {"Jörg Hoffmann", "Bernhard Nebel"}, "The FF Planning System: Fast Plan Generation Through " diff --git a/src/search/landmarks/landmark_factory_rpg_sasp.cc b/src/search/landmarks/landmark_factory_rpg_sasp.cc index 997ad14490..5d8b404d62 100644 --- a/src/search/landmarks/landmark_factory_rpg_sasp.cc +++ b/src/search/landmarks/landmark_factory_rpg_sasp.cc @@ -786,7 +786,7 @@ class LandmarkFactoryRpgSaspFeature "Intelligence (AAAI 2008)", "975-982", "AAAI Press", "2008") + "The algorithm is described in more detail in the following " - "paper:" + + "article:" + utils::format_journal_reference( {"Silvia Richter", "Matthias Westphal"}, "The LAMA Planner: Guiding Cost-Based Anytime Planning with " diff --git a/src/search/landmarks/landmark_sum_heuristic.cc b/src/search/landmarks/landmark_sum_heuristic.cc index cb099468d5..4f0864160e 100644 --- a/src/search/landmarks/landmark_sum_heuristic.cc +++ b/src/search/landmarks/landmark_sum_heuristic.cc @@ -128,7 +128,7 @@ class LandmarkSumHeuristicFeature "History Note", "Formerly known as the landmark heuristic or landmark count " "heuristic.\n" - "See the papers" + + "See the article" + utils::format_journal_reference( {"Silvia Richter", "Matthias Westphal"}, "The LAMA Planner: Guiding Cost-Based Anytime Planning " @@ -136,7 +136,7 @@ class LandmarkSumHeuristicFeature "https://doi.org/10.1613/jair.2972", "Journal of Artificial Intelligence Research", "39", "127-177", "2010") + - "and" + + "and the paper" + utils::format_conference_reference( {"Silvia Richter", "Malte Helmert", "Matthias Westphal"}, "Landmarks Revisited", diff --git a/src/search/merge_and_shrink/label_reduction.cc b/src/search/merge_and_shrink/label_reduction.cc index 77ec6c7852..27c425210f 100644 --- a/src/search/merge_and_shrink/label_reduction.cc +++ b/src/search/merge_and_shrink/label_reduction.cc @@ -311,7 +311,7 @@ class LabelReductionFeature " Intelligence (AAAI 2014)", "2358-2366", "AAAI Press", "2014") + "For a more general discussion of label reduction, see the " - "following paper:" + + "following article:" + utils::format_journal_reference( {"Silvan Sievers", "Malte Helmert"}, "Merge-and-Shrink: A Compositional Theory of Transformations " diff --git a/src/search/merge_and_shrink/merge_and_shrink_heuristic.cc b/src/search/merge_and_shrink/merge_and_shrink_heuristic.cc index a77e174154..2a2a77d395 100644 --- a/src/search/merge_and_shrink/merge_and_shrink_heuristic.cc +++ b/src/search/merge_and_shrink/merge_and_shrink_heuristic.cc @@ -146,7 +146,7 @@ class MergeAndShrinkHeuristicFeature document_synopsis( "This heuristic implements the merge-and-shrink algorithm. For a " "comprehensive description of merge-and-shrink, see the following " - "paper:" + + "article:" + utils::format_journal_reference( {"Silvan Sievers", "Malte Helmert"}, "Merge-and-Shrink: A Compositional Theory of Transformations " @@ -173,7 +173,7 @@ class MergeAndShrinkHeuristicFeature "Note", "Conditional effects are supported directly. Note, however, that " "for tasks that are not factored (in the sense of the JAIR 2021 " - "merge-and-shrink paper), the atomic transition systems on which " + "merge-and-shrink article), the atomic transition systems on which " "merge-and-shrink heuristics are based are nondeterministic, " "which can lead to poor heuristics even when only perfect shrinking " "is performed."); diff --git a/src/search/merge_and_shrink/merge_scoring_function_dfp.cc b/src/search/merge_and_shrink/merge_scoring_function_dfp.cc index 4fac05bb9b..8a66b7b7b6 100644 --- a/src/search/merge_and_shrink/merge_scoring_function_dfp.cc +++ b/src/search/merge_and_shrink/merge_scoring_function_dfp.cc @@ -113,7 +113,7 @@ class MergeScoringFunctionDFPFeature document_title("DFP scoring"); document_synopsis( "This scoring function computes the 'DFP' score as described in the " - "following paper:" + + "following article:" + utils::format_journal_reference( {"Klaus Dräger", "Bernd Finkbeiner", "Andreas Podelski"}, "Directed model checking with distance-preserving " diff --git a/src/search/open_lists/alternation_open_list.cc b/src/search/open_lists/alternation_open_list.cc index 4a84c46eaa..6e4b23720e 100644 --- a/src/search/open_lists/alternation_open_list.cc +++ b/src/search/open_lists/alternation_open_list.cc @@ -163,7 +163,7 @@ class AlternationOpenListFeature document_note( "Reference", "The idea of alternating between heuristic queues is described in " - "the following paper:" + + "the following article:" + utils::format_journal_reference( {"Malte Helmert"}, "The Fast Downward Planning System", "https://doi.org/10.1613/jair.1705", diff --git a/src/search/operator_counting/delete_relaxation_if_constraints.cc b/src/search/operator_counting/delete_relaxation_if_constraints.cc index 4772ed72ca..b6d96c5dc9 100644 --- a/src/search/operator_counting/delete_relaxation_if_constraints.cc +++ b/src/search/operator_counting/delete_relaxation_if_constraints.cc @@ -256,7 +256,7 @@ class DeleteRelaxationIFConstraintsFeature "default the constraints encode an easy-to-compute relaxation of h^+^. " "With the right settings, these constraints can be used to compute the " "optimal delete-relaxation heuristic h^+^ (see example below). " - "For details, see" + + "For details, see the article" + utils::format_journal_reference( {"Tatsuya Imai", "Alex Fukunaga"}, "On a Practical, Integer-Linear Programming Model for Delete-Free " diff --git a/src/search/search_algorithms/enforced_hill_climbing_search.cc b/src/search/search_algorithms/enforced_hill_climbing_search.cc index a2498b6718..00f77d8163 100644 --- a/src/search/search_algorithms/enforced_hill_climbing_search.cc +++ b/src/search/search_algorithms/enforced_hill_climbing_search.cc @@ -272,7 +272,7 @@ class EnforcedHillClimbingSearchFeature document_title("Lazy enforced hill-climbing"); document_synopsis( "Enforced hill-climbing search was introduced in the following " - "paper:" + + "article:" + utils::format_journal_reference( {"Jörg Hoffmann", "Bernhard Nebel"}, "The FF Planning System: Fast Plan Generation Through " @@ -281,7 +281,7 @@ class EnforcedHillClimbingSearchFeature "Journal of Artificial Intelligence Research", "14", "253-302", "2001") + "Note that the implementation differs from the algorithm " - "described in the paper in several ways. First, it evaluates " + "described in the article in several ways. First, it evaluates " "states lazily, i.e., it computes the heuristic value of a " "state only when it is removed from the open list. Second, it " "uses a global closed list instead of detecting duplicates only " diff --git a/src/search/search_algorithms/plugin_astar.cc b/src/search/search_algorithms/plugin_astar.cc index bda49295aa..5a50b30605 100644 --- a/src/search/search_algorithms/plugin_astar.cc +++ b/src/search/search_algorithms/plugin_astar.cc @@ -14,7 +14,7 @@ class AStarSearchFeature document_title("A* search (eager)"); document_note( "Reference", - "The A* algorithm is described in the following paper:" + + "The A* algorithm is described in the following article:" + utils::format_journal_reference( {"Peter E. Hart", "Nils J. Nilsson", "Bertram Raphael"}, "A Formal Basis for the Heuristic Determination of " diff --git a/src/search/search_algorithms/plugin_eager_wastar.cc b/src/search/search_algorithms/plugin_eager_wastar.cc index f0a4edbbac..74f431a0bc 100644 --- a/src/search/search_algorithms/plugin_eager_wastar.cc +++ b/src/search/search_algorithms/plugin_eager_wastar.cc @@ -13,7 +13,7 @@ class EagerWAstarSearchFeature EagerWAstarSearchFeature() : TypedFeature("eager_wastar") { document_title("Eager weighted A* search"); document_synopsis( - "Weighted A* is described in the following paper:" + + "Weighted A* is described in the following article:" + utils::format_journal_reference( {"Ira Pohl"}, "Heuristic Search Viewed as Path Finding in a Graph", diff --git a/src/search/search_algorithms/plugin_lazy.cc b/src/search/search_algorithms/plugin_lazy.cc index a5dcfcdc9a..bd0e0cd8aa 100644 --- a/src/search/search_algorithms/plugin_lazy.cc +++ b/src/search/search_algorithms/plugin_lazy.cc @@ -14,7 +14,7 @@ class LazySearchFeature document_title("Lazy best-first search"); document_synopsis( "Lazy search (deferred evaluation) is described in the following " - "paper:" + + "article:" + utils::format_journal_reference( {"Malte Helmert"}, "The Fast Downward Planning System", "https://doi.org/10.1613/jair.1705", diff --git a/src/search/search_algorithms/plugin_lazy_greedy.cc b/src/search/search_algorithms/plugin_lazy_greedy.cc index 76efd1739f..ef00939b17 100644 --- a/src/search/search_algorithms/plugin_lazy_greedy.cc +++ b/src/search/search_algorithms/plugin_lazy_greedy.cc @@ -16,7 +16,7 @@ class LazyGreedySearchFeature document_title("Greedy search (lazy)"); document_synopsis( "Lazy search (deferred evaluation) is described in the following " - "paper:" + + "article:" + utils::format_journal_reference( {"Malte Helmert"}, "The Fast Downward Planning System", "https://doi.org/10.1613/jair.1705", diff --git a/src/search/search_algorithms/plugin_lazy_wastar.cc b/src/search/search_algorithms/plugin_lazy_wastar.cc index 33133d7b19..14450022d0 100644 --- a/src/search/search_algorithms/plugin_lazy_wastar.cc +++ b/src/search/search_algorithms/plugin_lazy_wastar.cc @@ -17,7 +17,7 @@ class LazyWAstarSearchFeature document_note( "Reference", "Lazy search (deferred evaluation) is described in the following " - "papers:" + + "publications:" + utils::format_journal_reference( {"Malte Helmert"}, "The Fast Downward Planning System", "https://doi.org/10.1613/jair.1705", @@ -32,7 +32,7 @@ class LazyWAstarSearchFeature "Automated Planning and Scheduling (ICAPS 2009)", "273-280", "AAAI Press", "2009") + "Lazy weighted A* is used and described in the following " - "paper:" + + "article:" + utils::format_journal_reference( {"Silvia Richter", "Matthias Westphal"}, "The LAMA Planner: Guiding Cost-Based Anytime Planning "