Add option to decide which set of goals to use.

src/search/pdbs/cegar.cc

@@ -84,6 +84,7 @@ class CEGAR {
     const int max_collection_size;
     const double max_time;
     const bool use_wildcard_plans;
+    const bool use_restricted_goal;
     utils::LogProxy &log;
     shared_ptr<utils::RandomNumberGenerator> rng;
     const shared_ptr<AbstractTask> &task;
@@ -151,6 +152,7 @@ class CEGAR {
         int max_collection_size,
         double max_time,
         bool use_wildcard_plans,
+        bool use_restricted_goal,
         utils::LogProxy &log,
         const shared_ptr<utils::RandomNumberGenerator> &rng,
         const shared_ptr<AbstractTask> &task,
@@ -164,6 +166,7 @@ CEGAR::CEGAR(
     int max_collection_size,
     double max_time,
     bool use_wildcard_plans,
+    bool use_restricted_goal,
     utils::LogProxy &log,
     const shared_ptr<utils::RandomNumberGenerator> &rng,
     const shared_ptr<AbstractTask> &task,
@@ -173,6 +176,7 @@ CEGAR::CEGAR(
       max_collection_size(max_collection_size),
       max_time(max_time),
       use_wildcard_plans(use_wildcard_plans),
+      use_restricted_goal(use_restricted_goal),
       log(log),
       rng(rng),
       task(task),
@@ -385,8 +389,7 @@ bool CEGAR::get_flaws_for_pattern(
                 log << "plan did not lead to a goal state: ";
             }
             bool raise_goal_flaw = false;
-            for (const FactProxy &goal_proxy : task_proxy.get_goals()) {
-                const FactPair &goal = goal_proxy.get_pair();
+            for (const FactPair &goal : use_restricted_goal ? goals : task_properties::get_fact_pairs(task_proxy.get_goals())) {
                 int goal_var_id = goal.var;
                 if (final_state[goal_var_id].get_value() != goal.value &&
                     !blacklisted_variables.count(goal_var_id)) {
@@ -565,7 +568,7 @@ PatternCollectionInformation CEGAR::compute_pattern_collection() {
         log << "max time: " << max_time << endl;
         log << "wildcard plans: " << use_wildcard_plans << endl;
         log << "goal variables: ";
-        for (const FactPair &goal : this->goals) {
+        for (const FactPair &goal : use_restricted_goal ? this->goals : task_properties::get_fact_pairs(task_proxy.get_goals())) {
             log << goal.var << ", ";
         }
         log << endl;
@@ -662,6 +665,7 @@ PatternCollectionInformation generate_pattern_collection_with_cegar(
     int max_collection_size,
     double max_time,
     bool use_wildcard_plans,
+    bool use_restricted_goal,
     utils::LogProxy &log,
     const shared_ptr<utils::RandomNumberGenerator> &rng,
     const shared_ptr<AbstractTask> &task,
@@ -672,6 +676,7 @@ PatternCollectionInformation generate_pattern_collection_with_cegar(
         max_collection_size,
         max_time,
         use_wildcard_plans,
+        use_restricted_goal,
         log,
         rng,
         task,
@@ -684,6 +689,7 @@ PatternInformation generate_pattern_with_cegar(
     int max_pdb_size,
     double max_time,
     bool use_wildcard_plans,
+    bool use_restricted_goal,
     utils::LogProxy &log,
     const shared_ptr<utils::RandomNumberGenerator> &rng,
     const shared_ptr<AbstractTask> &task,
@@ -695,6 +701,7 @@ PatternInformation generate_pattern_with_cegar(
         max_pdb_size,
         max_time,
         use_wildcard_plans,
+        use_restricted_goal,
         log,
         rng,
         task,
@@ -779,12 +786,18 @@ void add_cegar_implementation_notes_to_feature(plugins::Feature &feature) {
         true);
 }
 
-void add_cegar_wildcard_option_to_feature(plugins::Feature &feature) {
+void add_cegar_options_to_feature(plugins::Feature &feature) {
     feature.add_option<bool>(
         "use_wildcard_plans",
         "if true, compute wildcard plans which are sequences of sets of "
         "operators that induce the same transition; otherwise compute regular "
         "plans which are sequences of single operators",
         "true");
+
+    feature.add_option<bool>(
+        "use_restricted_goal",
+        "if true, CEGAR considers only those variables for goal flaws that are "
+        "used to initialize the pattern collection; otherwise all goal "
+        "variables can occur in goal flaws");
 }
 }

src/search/pdbs/cegar.h

@@ -40,6 +40,7 @@ extern PatternCollectionInformation generate_pattern_collection_with_cegar(
     int max_collection_size,
     double max_time,
     bool use_wildcard_plans,
+    bool use_restricted_goal,
     utils::LogProxy &log,
     const std::shared_ptr<utils::RandomNumberGenerator> &rng,
     const std::shared_ptr<AbstractTask> &task,
@@ -55,14 +56,15 @@ extern PatternInformation generate_pattern_with_cegar(
     int max_pdb_size,
     double max_time,
     bool use_wildcard_plans,
+    bool use_restricted_goal,
     utils::LogProxy &log,
     const std::shared_ptr<utils::RandomNumberGenerator> &rng,
     const std::shared_ptr<AbstractTask> &task,
     const FactPair &goal,
     std::unordered_set<int> &&blacklisted_variables = std::unordered_set<int>());
 
 extern void add_cegar_implementation_notes_to_feature(plugins::Feature &feature);
-extern void add_cegar_wildcard_option_to_feature(plugins::Feature &feature);
+extern void add_cegar_options_to_feature(plugins::Feature &feature);
 }
 
 #endif

src/search/pdbs/pattern_collection_generator_disjoint_cegar.cc

@@ -17,6 +17,7 @@ PatternCollectionGeneratorDisjointCegar::PatternCollectionGeneratorDisjointCegar
       max_collection_size(opts.get<int>("max_collection_size")),
       max_time(opts.get<double>("max_time")),
       use_wildcard_plans(opts.get<bool>("use_wildcard_plans")),
+      use_restricted_goal(opts.get<bool>("use_restricted_goal")),
       rng(utils::parse_rng_from_options(opts)) {
 }
 
@@ -35,6 +36,7 @@ PatternCollectionInformation PatternCollectionGeneratorDisjointCegar::compute_pa
         max_collection_size,
         max_time,
         use_wildcard_plans,
+        use_restricted_goal,
         log,
         rng,
         task,
@@ -74,7 +76,7 @@ class PatternCollectionGeneratorDisjointCegarFeature : public plugins::TypedFeat
             "singleton pattern for each goal variable)",
             "infinity",
             plugins::Bounds("0.0", "infinity"));
-        add_cegar_wildcard_option_to_feature(*this);
+        add_cegar_options_to_feature(*this);
         add_generator_options_to_feature(*this);
         utils::add_rng_options(*this);
 

src/search/pdbs/pattern_collection_generator_disjoint_cegar.h

@@ -17,6 +17,7 @@ class PatternCollectionGeneratorDisjointCegar : public PatternCollectionGenerato
     const int max_collection_size;
     const double max_time;
     const bool use_wildcard_plans;
+    const bool use_restricted_goal;
     std::shared_ptr<utils::RandomNumberGenerator> rng;
 
     virtual std::string name() const override;

src/search/pdbs/pattern_collection_generator_multiple_cegar.cc

@@ -13,7 +13,8 @@ namespace pdbs {
 PatternCollectionGeneratorMultipleCegar::PatternCollectionGeneratorMultipleCegar(
     const plugins::Options &opts)
     : PatternCollectionGeneratorMultiple(opts),
-      use_wildcard_plans(opts.get<bool>("use_wildcard_plans")) {
+      use_wildcard_plans(opts.get<bool>("use_wildcard_plans")),
+      use_restricted_goal(opts.get<bool>("use_restricted_goal")) {
 }
 
 string PatternCollectionGeneratorMultipleCegar::id() const {
@@ -32,6 +33,7 @@ PatternInformation PatternCollectionGeneratorMultipleCegar::compute_pattern(
         max_pdb_size,
         max_time,
         use_wildcard_plans,
+        use_restricted_goal,
         silent_log,
         rng,
         task,
@@ -52,7 +54,7 @@ class PatternCollectionGeneratorMultipleCegarFeature : public plugins::TypedFeat
             "the algorithms.");
 
         add_multiple_options_to_feature(*this);
-        add_cegar_wildcard_option_to_feature(*this);
+        add_cegar_options_to_feature(*this);
 
         add_cegar_implementation_notes_to_feature(*this);
         add_multiple_algorithm_implementation_notes_to_feature(*this);

src/search/pdbs/pattern_collection_generator_multiple_cegar.h

@@ -6,6 +6,7 @@
 namespace pdbs {
 class PatternCollectionGeneratorMultipleCegar : public PatternCollectionGeneratorMultiple {
     const bool use_wildcard_plans;
+    const bool use_restricted_goal;
 
     virtual std::string id() const override;
     virtual void initialize(const std::shared_ptr<AbstractTask> &) override {}

src/search/pdbs/pattern_generator_cegar.cc

@@ -21,6 +21,7 @@ PatternGeneratorCEGAR::PatternGeneratorCEGAR(const plugins::Options &opts)
       max_pdb_size(opts.get<int>("max_pdb_size")),
       max_time(opts.get<double>("max_time")),
       use_wildcard_plans(opts.get<bool>("use_wildcard_plans")),
+      use_restricted_goal(opts.get<bool>("use_restricted_goal")),
       rng(utils::parse_rng_from_options(opts)) {
 }
 
@@ -36,6 +37,7 @@ PatternInformation PatternGeneratorCEGAR::compute_pattern(
         max_pdb_size,
         max_time,
         use_wildcard_plans,
+        use_restricted_goal,
         log,
         rng,
         task,
@@ -64,7 +66,7 @@ class PatternGeneratorCEGARFeature : public plugins::TypedFeature<PatternGenerat
             "maximum time in seconds for the pattern generation",
             "infinity",
             plugins::Bounds("0.0", "infinity"));
-        add_cegar_wildcard_option_to_feature(*this);
+        add_cegar_options_to_feature(*this);
         add_generator_options_to_feature(*this);
         utils::add_rng_options(*this);
 

src/search/pdbs/pattern_generator_cegar.h

@@ -12,6 +12,7 @@ class PatternGeneratorCEGAR : public PatternGenerator {
     const int max_pdb_size;
     const double max_time;
     const bool use_wildcard_plans;
+    const bool use_restricted_goal;
     std::shared_ptr<utils::RandomNumberGenerator> rng;
 
     virtual std::string name() const override;