chore(ape): clean up solve-finite implementation

Author: arbimo

planning/engine/src/generate.rs

@@ -2,47 +2,41 @@ use std::{collections::BTreeMap, time::Instant};
 
 use aries::{core::state::Evaluable, prelude::*};
 use aries_plan_engine::{
-    encode::{
-        encoding::Encoding,
-        tags::{Tag, format_culprit_set},
+    encode::{encoding::Encoding, tags::Tag},
+    plans::{
+        Operation,
+        lifted_plan::{LiftedPlan, ObjectOrVariable},
     },
-    plans::lifted_plan::{self, LiftedPlan},
 };
-use derive_more::derive::Display;
-use planx::{Model, Res, errors::*};
+use planx::{Model, Res, Sym};
 use timelines::{Sched, explain::ExplainableSolver};
 
-use crate::optimize_plan;
+use crate::optimize_plan::{self, Objective};
 
 pub type RelaxableConstraint = Tag;
 
 #[derive(clap::Args, Debug, Clone)]
 pub struct Options {
+    /// Defines the maximum number of instances per action template.
+    ///
+    /// For instance, if set to 3, the resulting plan may have *at most* three instances
+    /// of a `pick` action and at most 3 instances of a `drop` action.
     #[arg(short, long)]
-    pub max_depth: usize,
+    pub max_instances: usize,
 
-    // #[arg(short, long, num_args(1..))]
-    // pub relaxation: Vec<Relaxation>,
-    #[arg(short, long, default_value("plan-length"))]
+    /// Defines the objective to be minimized
+    #[arg(short, long, default_value("original"))]
     pub objective: Objective,
-}
 
-// #[derive(clap::ValueEnum, Debug, Clone, Copy, Display, PartialEq, PartialOrd, Eq, Ord)]
-// pub enum Relaxation {
-//     ActionPresence,
-//     StartTime,
-// }
-
-#[derive(clap::ValueEnum, Debug, Clone, Copy, Display, PartialEq, Eq, PartialOrd, Ord)]
-pub enum Objective {
-    /// The objective value defined in the domain
-    Original,
-    PlanLength,
-    Makespan,
+    /// If set, the planner will try tro find the optimal solution
+    #[arg(long)]
+    pub optimize: bool,
 }
 
 pub fn solve_finite_planning_problem(model: &Model, options: &Options) -> Res<()> {
-    let plan = &lifted_plan::new_empty_lifted_plan(model, BTreeMap::new(), options.max_depth)?;
+    // create a dummy plan with the appropriate number of actions
+    // this is temporary a workaround to reuse the existing `optimize_plan` facilities
+    let plan = &new_empty_lifted_plan(model, BTreeMap::new(), options.max_instances)?;
 
     let start = Instant::now();
     let (mut solver, encoding, _sched) = encode_finite_planning_problem(model, plan, options)?;
@@ -51,37 +45,31 @@ pub fn solve_finite_planning_problem(model: &Model, options: &Options) -> Res<()
 
     let objective = encoding.objective.unwrap(); //TODO: error message
 
+    // set the objective to a constant if we are not optimizing
+    let solver_objective = if options.optimize { objective } else { 0.into() };
+
     let print = |sol: &Solution| {
-        println!("==== Plan (objective: {}) =====", objective.evaluate(sol).unwrap());
+        println!("\n==== Plan (objective: {}) =====", objective.evaluate(sol).unwrap());
         println!("{}\n", encoding.plan(sol));
     };
 
-    if let Some(solution) = solver.find_optimal(objective, &print) {
-        println!("\n> Found optimal solution:");
+    if let Some(solution) = solver.find_optimal(solver_objective, &print) {
+        println!("\n> Found {}solution:", if options.optimize { "optimal " } else { "" });
         print(&solution);
     } else {
         println!("No solution !!!!");
-        for mus in solver.muses() {
-            let msg = format_culprit_set(Message::error("Invalid in all relaxation"), &mus, model, plan);
-            println!("\n{msg}\n");
-        }
     }
     Ok(())
 }
 
-pub fn encode_finite_planning_problem(
+fn encode_finite_planning_problem(
     model: &Model,
     lifted_plan: &LiftedPlan,
     options: &Options,
 ) -> Res<(ExplainableSolver<RelaxableConstraint>, Encoding, Sched)> {
     // TODO: make specific function.
     // - ability to specify explanations vocabulary via RelaxableConstraint (Tag), including removing (pre)conditions (like in domain repair).
 
-    let objective = match options.objective {
-        Objective::Original => optimize_plan::Objective::Original,
-        Objective::PlanLength => optimize_plan::Objective::PlanLength,
-        Objective::Makespan => optimize_plan::Objective::Makespan,
-    };
     optimize_plan::encode_plan_optimization_problem(
         model,
         lifted_plan,
@@ -90,7 +78,54 @@ pub fn encode_finite_planning_problem(
                 optimize_plan::Relaxation::ActionPresence,
                 optimize_plan::Relaxation::StartTime,
             ],
-            objective,
+            objective: options.objective,
         },
     )
 }
+
+fn new_empty_lifted_plan(
+    model: &Model,
+    a_instances_per_template: BTreeMap<planx::ActionRef, usize>,
+    a_instances_default: usize,
+) -> Res<LiftedPlan> {
+    let top_type = model.env.types.top_user_type();
+    use planx::errors::*;
+
+    let num_instances = |a_name| *a_instances_per_template.get(a_name).unwrap_or(&a_instances_default);
+
+    // all actions in the plan
+    let mut operations = Vec::with_capacity(model.actions.iter().map(|a| num_instances(&a.name)).sum());
+
+    // all variables appearing in the plan
+    let mut variables = BTreeMap::new();
+
+    for a in model.actions.iter() {
+        for aid in 0..num_instances(&a.name) {
+            let mut arguments = Vec::with_capacity(a.parameters.len());
+
+            for param in a.parameters.iter() {
+                let name = Sym::with_source(
+                    format!("{}.{}.{}", a.name.canonical_str(), aid, param.name().canonical_str()),
+                    param.name().span_or_default(),
+                );
+                let tpe = if let planx::Type::User(tpe) = param.tpe() {
+                    tpe.to_single_type().unwrap_or_else(|| top_type.clone())
+                } else {
+                    top_type.clone()
+                };
+
+                variables.insert(name.clone(), tpe);
+
+                arguments.push(ObjectOrVariable::Variable { name });
+            }
+            operations.push(Operation {
+                start: 0,
+                duration: 0,
+                action_ref: a.name.clone(),
+                arguments,
+                span: None,
+            });
+        }
+    }
+    Ok(LiftedPlan { operations, variables })
+}

planning/engine/src/main.rs

@@ -383,7 +383,7 @@ pub struct Problem {
     /// Path to the PDDL problem file.
     problem: PathBuf,
     /// Path to the PDDL domain file.
-    /// If not specified, we will attempt to automatically infer it based on the plan file.
+    /// If not specified, we will attempt to automatically infer it based on the problem file.
     #[arg(short, long)]
     domain: Option<PathBuf>,
 }

planning/engine/src/optimize_plan.rs

@@ -42,7 +42,9 @@ pub enum Relaxation {
 pub enum Objective {
     /// The objective value defined in the domain
     Original,
+    /// Number of actions in the plan
     PlanLength,
+    /// End time of the latest action
     Makespan,
 }
 

planning/engine/src/plans/lifted_plan.rs

@@ -106,50 +106,3 @@ pub fn parse_lifted_plan(plan: &planx::pddl::Plan, model: &Model) -> Res<LiftedP
     }
     Ok(LiftedPlan { operations, variables })
 }
-
-pub fn new_empty_lifted_plan(
-    model: &Model,
-    a_instances_per_template: BTreeMap<planx::ActionRef, usize>,
-    a_instances_default: usize,
-) -> Res<LiftedPlan> {
-    let top_type = model.env.types.top_user_type();
-    use planx::errors::*;
-
-    let num_instances = |a_name| *a_instances_per_template.get(a_name).unwrap_or(&a_instances_default);
-
-    // all actions in the plan
-    let mut operations = Vec::with_capacity(model.actions.iter().map(|a| num_instances(&a.name)).sum());
-
-    // all variables appearing in the plan
-    let mut variables = BTreeMap::new();
-
-    for a in model.actions.iter() {
-        for aid in 0..num_instances(&a.name) {
-            let mut arguments = Vec::with_capacity(a.parameters.len());
-
-            for param in a.parameters.iter() {
-                let name = Sym::with_source(
-                    format!("{}.{}.{}", a.name.canonical_str(), aid, param.name().canonical_str()),
-                    param.name().span_or_default(),
-                );
-                let tpe = if let planx::Type::User(tpe) = param.tpe() {
-                    tpe.to_single_type().unwrap_or_else(|| top_type.clone())
-                } else {
-                    top_type.clone()
-                };
-
-                variables.insert(name.clone(), tpe);
-
-                arguments.push(ObjectOrVariable::Variable { name });
-            }
-            operations.push(Operation {
-                start: 0,
-                duration: 0,
-                action_ref: a.name.clone(),
-                arguments,
-                span: None,
-            });
-        }
-    }
-    Ok(LiftedPlan { operations, variables })
-}