Algorithm selection in pccompile

bin/pccompile.cpp

@@ -18,6 +18,7 @@
 #include "cnfcompress.h"
 #include "logstream.h"
 #include "normalform.h"
+#include "pc_opt.h"
 #include "pccomp.h"
 #include "pcenc.h"
 #include "pclearncomp.h"
@@ -36,31 +37,16 @@ const std::string prg_help =
     "Implements an incremental algorithm based on adding empowering "
     "implicates and a learning algorithm";
 
-enum class GOAL
-{
-   PC,
-   UC
-};
-
-enum class ALGORITHM
-{
-   INCREMENT,
-   LEARNING,
-   Last = LEARNING
-};
-const std::array<std::string, static_cast<size_t>(ALGORITHM::Last) + 1>
-    algorithm_names{"incremental", "learning"};
-
 struct config_t
 {
    std::string input_file{};
    std::string output_file{};
    bool minimize{false};
    SUBool::MINIMIZE_METHOD minimize_method{SUBool::MINIMIZE_METHOD::FULL};
-   ALGORITHM algorithm{ALGORITHM::INCREMENT};
-   bool level_simplify{true}; // simplification at level increase
-   unsigned verbosity{3};     // 0 means no output
-   bool uc_interleave_pc{false};
+   SUBool::PCCAlgorithmOptions::ALGORITHM algorithm{
+       SUBool::PCCAlgorithmOptions::kDefaultAlgorithm};
+   bool level_simplify{true};                // simplification at level increase
+   unsigned verbosity{3};                    // 0 means no output
    bool use_empty_initial_hypothesis{false}; // For PCLearnComp
    unsigned pccheck_random_rounds{100};
    unsigned pccheck_random_budget{10};
@@ -82,7 +68,6 @@ struct config_t
        SUBool::LIT_IMPL_SYSTEM::NONE,
        SUBool::SOLVER_TYPE::GLUCOSE,
    };
-   GOAL goal{GOAL::PC};
    bool unfinished_write{true};
    SUBool::AmoEncoder::KIND amo_encoding{SUBool::AmoEncoder::KIND::REPR};
    SUBool::ExOneEncoder::KIND exone_encoding{SUBool::ExOneEncoder::KIND::REPR};
@@ -121,10 +106,8 @@ dump_config(const config_t &conf, unsigned level)
        << "\tminimize: " << SUBool::bool_to_string(conf.minimize) << std::endl;
    SUBool::kMinimizeMethodAnnotation.DumpValue(
        "\t", level, "minimize_method", conf.comp_base_config.minimize_method);
-   SUBool::logs.TLog(level)
-       << "\talgorithm: "
-       << algorithm_names.at(static_cast<unsigned>(conf.algorithm))
-       << std::endl;
+   SUBool::PCCAlgorithmOptions::kAlgorithmAnnotation.DumpValue(
+       "\t", level, "algorithm", conf.algorithm);
    SUBool::logs.TLog(level)
        << "\tcomp_base_config.up_empower: "
        << static_cast<unsigned>(conf.comp_base_config.up_empower) << std::endl;
@@ -145,9 +128,6 @@ dump_config(const config_t &conf, unsigned level)
        << static_cast<unsigned>(conf.comp_base_config.preprocess) << std::endl;
    SUBool::logs.DumpValue("\t", level, "comp_base_config.propagate_backbones",
        conf.comp_base_config.propagate_backbones);
-   SUBool::logs.TLog(level)
-       << "\tuc_interleave_pc: "
-       << SUBool::bool_to_string(conf.uc_interleave_pc) << std::endl;
    SUBool::logs.DumpValue("\t", level, "use_empty_initial_hypothesis",
        conf.use_empty_initial_hypothesis);
    SUBool::logs.TLog(level)
@@ -176,8 +156,6 @@ dump_config(const config_t &conf, unsigned level)
        << conf.comp_base_config.timeouts.level_factor << std::endl;
    SUBool::dump_enum_value("\t", level, "cop_base_config.solver_type",
        conf.comp_base_config.solver_type, SUBool::kSolverTypeNames);
-   SUBool::logs.TLog(level)
-       << "\tgoal: " << (conf.goal == GOAL::PC ? "PC" : "UC") << std::endl;
    SUBool::logs.TLog(level) << "\tenc_conf:" << std::endl;
    conf.comp_base_config.enc_conf.Dump("\t\t", level);
    SUBool::AmoEncoder::kKindAnnotation.DumpValue(
@@ -224,10 +202,13 @@ parse_arguments(int argc, char *argv[], config_t &conf)
    SUBool::PrgOptions opts(true);
    opts.SetHelpDesc(prg_help);
    opts.InputOutput(&conf.input_file, &conf.output_file);
+   auto algorithm_opts = std::make_shared<SUBool::PCCAlgorithmOptions>();
+   opts.AddOptionsGroup(algorithm_opts);
    if (!opts.Parse(argc, argv))
    {
       return 1;
    }
+   conf.algorithm = algorithm_opts->Algorithm();
    return 0;
 #if 0
    try
@@ -681,31 +662,32 @@ incremental_compiler(const config_t &conf, SUBool::CNF cnf)
 {
    SUBool::AbsComp::BaseConfig a_conf;
    fill_base_conf(a_conf, conf);
+   bool interleave_pc = false;
 
-   switch (conf.goal)
+   switch (conf.algorithm)
    {
-   case GOAL::PC:
+   case SUBool::PCCAlgorithmOptions::ALGORITHM::INCREMENT_PC:
       return std::make_shared<SUBool::PCComp>(
           std::move(cnf), std::move(a_conf));
-   case GOAL::UC:
+   case SUBool::PCCAlgorithmOptions::ALGORITHM::INCREMENT_URC_PC:
+      interleave_pc = true;
+      [[fallthrough]];
+   case SUBool::PCCAlgorithmOptions::ALGORITHM::INCREMENT_URC:
    {
       SUBool::UCComp::Config uc_conf(a_conf);
-      uc_conf.interleave_pc = conf.uc_interleave_pc;
+      uc_conf.interleave_pc = interleave_pc;
       return std::make_shared<SUBool::UCComp>(
           std::move(cnf), std::move(uc_conf));
    }
+   default:
+      throw SUBool::BadParameterException(
+          "compiler", "Bad algorithm specification");
    }
-   throw SUBool::BadParameterException("compiler", "Bad goal specification");
 }
 
 std::shared_ptr<SUBool::PCLearnComp>
 learning_compiler(const config_t &conf, SUBool::CNF cnf)
 {
-   if (conf.goal != GOAL::PC)
-   {
-      throw SUBool::BadParameterException("learning_compiler",
-          "The learning compiler does not work with goal UC.");
-   }
    SUBool::PCLearnComp::Config l_conf;
    fill_base_conf(l_conf, conf);
    l_conf.use_empty_initial_hypothesis = conf.use_empty_initial_hypothesis;
@@ -720,15 +702,11 @@ learning_compiler(const config_t &conf, SUBool::CNF cnf)
 std::shared_ptr<SUBool::AbsComp>
 compiler(const config_t &conf, SUBool::CNF cnf)
 {
-   switch (conf.algorithm)
+   if (conf.algorithm == SUBool::PCCAlgorithmOptions::ALGORITHM::LEARNING)
    {
-   case ALGORITHM::INCREMENT:
-      return incremental_compiler(conf, std::move(cnf));
-   case ALGORITHM::LEARNING:
       return learning_compiler(conf, std::move(cnf));
    }
-   throw SUBool::BadParameterException(
-       "compiler", "Unknown compilation algorithm specification");
+   return incremental_compiler(conf, std::move(cnf));
 }
 
 int
@@ -779,36 +757,6 @@ const std::string kUCEmpoweringImplicateName = "URC empowering implicate";
 const std::string kPCEmpoweringVarName = "empowering variable";
 const std::string kUCEmpoweringVarName = "extending variable";
 
-const std::string &
-empowering_implicate_name(const config_t &conf)
-{
-   switch (conf.goal)
-   {
-   case GOAL::PC:
-      return kPCEmpoweringImplicateName;
-   case GOAL::UC:
-      return kUCEmpoweringImplicateName;
-   default:
-      throw SUBool::BadParameterException(
-          "empowering_implicate_name", "Bad goal");
-   }
-}
-
-const std::string &
-empowering_variable_name(const config_t &conf)
-{
-   switch (conf.goal)
-   {
-   case GOAL::PC:
-      return kPCEmpoweringVarName;
-   case GOAL::UC:
-      return kUCEmpoweringVarName;
-   default:
-      throw SUBool::BadParameterException(
-          "empowering_variable_name", "Bad goal");
-   }
-}
-
 void
 terminate(int signal)
 {

lib/pc_opt.cpp

@@ -8,9 +8,45 @@
 
 #include "pc_opt.h"
 
+const SUBool::EnumAnnotation<SUBool::PCCAlgorithmOptions::ALGORITHM>
+    SUBool::PCCAlgorithmOptions::kAlgorithmAnnotation("ALGORITHM",
+        {//
+            {ALGORITHM::INCREMENT_PC, "increment_pc",
+                "heuristic algorithm based on incremental adding empowering "
+                "implicates. The goal is an equivalent PC formula and SAT "
+                "solver is used to "
+                "check if the formula is PC."}, //
+            {ALGORITHM::INCREMENT_URC, "increment_urc",
+                "heuristic algorithm based on incremental adding empowering "
+                "implicates. The goal is an equivalent URC formula and SAT "
+                "solver is used to "
+                "check if the formula is URC."}, //
+            {ALGORITHM::INCREMENT_URC_PC, "increment_urc_pc",
+                "heuristic algorithm based on incremental adding empowering "
+                "implicates. The goal is URC formula and SAT solver is used to "
+                "check if the formula is URC or PC in an interleaving wa."}, //
+            {ALGORITHM::LEARNING, "learning",
+                "based on the algorithm for learning a Horn formula through "
+                "equivalence and closure queries (Arias et al. 2015). The goal "
+                "is an equivalent PC formula."}});
+
 auto
 SUBool::minimize_method_opt() -> EnumOption<MINIMIZE_METHOD>
 {
    return make_enum_option(kMinimizeMethodAnnotation, "minimize-method",
        "Minimization method", kDefaultMinimizeMethod);
 }
+
+SUBool::PCCAlgorithmOptions::PCCAlgorithmOptions()
+    : OptionsGroup("Algorithm"),
+      mAlgorithmOption(kAlgorithmAnnotation, "algorithm,a",
+          "Algorithm used for compilation", kDefaultAlgorithm)
+{
+   Add(mAlgorithmOption);
+}
+
+bool
+SUBool::PCCAlgorithmOptions::GetValues()
+{
+   return mAlgorithmOption.GetValue(mAlgorithm);
+}

lib/pc_opt.h

@@ -11,11 +11,46 @@
 
 #include "empower.h"
 #include "enum_opt.h"
+#include "prg_opt_group.h"
 
 namespace SUBool
 {
    // "Minimization method", "minimize-method"
    EnumOption<MINIMIZE_METHOD> minimize_method_opt();
+
+   // Algorithm selection in pccompile
+   class PCCAlgorithmOptions : public OptionsGroup
+   {
+    public:
+      enum class ALGORITHM
+      {
+         INCREMENT_PC,
+         INCREMENT_URC,
+         INCREMENT_URC_PC,
+         LEARNING
+      };
+
+      static const EnumAnnotation<ALGORITHM> kAlgorithmAnnotation;
+      static const ALGORITHM kDefaultAlgorithm = ALGORITHM::LEARNING;
+
+    private:
+      EnumOption<ALGORITHM> mAlgorithmOption;
+      ALGORITHM mAlgorithm{kDefaultAlgorithm};
+
+    public:
+      PCCAlgorithmOptions();
+
+      virtual bool GetValues() override;
+
+      ALGORITHM Algorithm() const;
+   };
+
 } // namespace SUBool
 
+inline auto
+SUBool::PCCAlgorithmOptions::Algorithm() const -> ALGORITHM
+{
+   return mAlgorithm;
+}
+
 #endif

pccompile.help

   pccompile [OPTION...] [input [output]]
 
-Algorithm Selection
+ALGORITHM SELECTION
 
   -a, --algorithm arg           The compilation algorithm. 'incremental' -- a
                                 heuristic algorithm based on incremental
@@ -14,12 +14,15 @@ Algorithm Selection
                                 Other parameters are used appropriately.
                                 (default: incremental)
 
+                                NEW: Includes goal, possible choices:
+                                incremental_pc, incremental_uc, incremental_ucpc, learning
+
 UNIT REFUTATION COMPLETENESS
 
-  -u, --uc                      Aim for unit refutation completeness instead
-                                of propagation completeness.
-      --interleave-pc           In case of compilation to UC, interleave
-                                encodings for UC and PC.
+# -u, --uc                      Aim for unit refutation completeness instead
+#                               of propagation completeness.
+#--interleave-pc           In case of compilation to UC, interleave
+#encodings for UC and PC.
 
 LEARNING ALGORITHM