Merge pull request #75 from niklasdewally/issue/68

Translation from Conjure-Oxide Model to Minion Model for XYZ Problem

Cargo.toml

@@ -5,3 +5,9 @@ members = [
     "solvers/minion",
     "solvers/chuffed"
 ]
+
+[workspace.lints.clippy]
+unwrap_used = "warn"
+expect_used = "warn"
+
+

conjure_oxide/Cargo.toml

@@ -5,3 +5,8 @@ edition = "2021"
 
 [dependencies]
 json = "0.12.4"
+minion_rs = {path = "../solvers/minion" }
+
+[lints]
+workspace = true
+

conjure_oxide/src/ast.rs

@@ -39,10 +39,16 @@ pub enum Range<A> {
 }
 
 #[derive(Clone, Debug, PartialEq)]
+#[non_exhaustive]
 pub enum Expression {
     ConstantInt(i32),
     Reference(Name),
     Sum(Vec<Expression>),
     Eq(Box<Expression>, Box<Expression>),
     Geq(Box<Expression>, Box<Expression>),
+
+    // Flattened Constraints
+    SumGeq(Vec<Expression>, Box<Expression>),
+    SumLeq(Vec<Expression>, Box<Expression>),
+    Ineq(Box<Expression>, Box<Expression>, Box<Expression>),
 }

conjure_oxide/src/lib.rs

@@ -1 +1,2 @@
 pub mod ast;
+mod solvers;

conjure_oxide/src/main.rs

@@ -31,7 +31,7 @@ fn main() {
         },
     );
 
-    let mut m = Model {
+    let m = Model {
         variables,
         constraints: vec![
             Expression::Eq(

conjure_oxide/src/solvers/minion.rs

@@ -0,0 +1,276 @@
+//! Solver interface to minion_rs.
+
+use crate::ast::{
+    DecisionVariable, Domain as ConjureDomain, Expression as ConjureExpression,
+    Model as ConjureModel, Name as ConjureName, Range as ConjureRange,
+};
+use minion_rs::ast::{
+    Constant as MinionConstant, Constraint as MinionConstraint, Model as MinionModel,
+    Var as MinionVar, VarDomain as MinionDomain,
+};
+
+impl TryFrom<ConjureModel> for MinionModel {
+    // TODO (nd60): set this to equal ConjureError once it is merged.
+    type Error = String;
+
+    fn try_from(conjure_model: ConjureModel) -> Result<Self, Self::Error> {
+        let mut minion_model = MinionModel::new();
+
+        // We assume (for now) that the conjure model is fully valid
+        // i.e. type checked and the variables referenced all exist.
+        parse_vars(&conjure_model, &mut minion_model)?;
+        parse_exprs(&conjure_model, &mut minion_model)?;
+
+        Ok(minion_model)
+    }
+}
+
+fn parse_vars(conjure_model: &ConjureModel, minion_model: &mut MinionModel) -> Result<(), String> {
+    // TODO (nd60): remove unused vars?
+    // TODO (nd60): ensure all vars references are used.
+
+    for (name, variable) in conjure_model.variables.iter() {
+        parse_var(name, variable, minion_model)?;
+    }
+    Ok(())
+}
+
+fn parse_var(
+    name: &ConjureName,
+    variable: &DecisionVariable,
+    minion_model: &mut MinionModel,
+) -> Result<(), String> {
+    let str_name = name_to_string(name.to_owned());
+
+    let ranges = match &variable.domain {
+        ConjureDomain::IntDomain(range) => Ok(range),
+        x => Err(format!("Not supported: {:?}", x)),
+    }?;
+
+    // TODO (nd60): Currently, Minion only supports the use of one range in the domain.
+    // If there are multiple ranges, SparseBound should be used here instead.
+    // See: https://github.com/conjure-cp/conjure-oxide/issues/84
+
+    if ranges.len() != 1 {
+        return Err(format!(
+            "Variable {:?} has {:?} ranges. Multiple ranges / SparseBound is not yet supported.",
+            str_name,
+            ranges.len()
+        ));
+    }
+
+    let range = ranges
+        .first()
+        .ok_or(format!("Variable {:?} has no range", str_name))?;
+
+    let (low, high) = match range {
+        ConjureRange::Bounded(x, y) => Ok((x.to_owned(), y.to_owned())),
+        ConjureRange::Single(x) => Ok((x.to_owned(), x.to_owned())),
+        a => Err(format!("Not implemented {:?}", a)),
+    }?;
+
+    minion_model
+        .named_variables
+        .add_var(str_name.to_owned(), MinionDomain::Bound(low, high))
+        .ok_or(format!("Variable {:?} is defined twice", str_name))?;
+
+    Ok(())
+}
+
+fn parse_exprs(conjure_model: &ConjureModel, minion_model: &mut MinionModel) -> Result<(), String> {
+    for expr in conjure_model.constraints.iter() {
+        parse_expr(expr.to_owned(), minion_model)?;
+    }
+    Ok(())
+}
+
+fn parse_expr(expr: ConjureExpression, minion_model: &mut MinionModel) -> Result<(), String> {
+    match expr {
+        ConjureExpression::SumLeq(lhs, rhs) => parse_sumleq(lhs, *rhs, minion_model),
+        ConjureExpression::SumGeq(lhs, rhs) => parse_sumgeq(lhs, *rhs, minion_model),
+        ConjureExpression::Ineq(a, b, c) => parse_ineq(*a, *b, *c, minion_model),
+        x => Err(format!("Not supported: {:?}", x)),
+    }
+}
+
+fn parse_sumleq(
+    sum_vars: Vec<ConjureExpression>,
+    rhs: ConjureExpression,
+    minion_model: &mut MinionModel,
+) -> Result<(), String> {
+    let minion_vars = must_be_vars(sum_vars)?;
+    let minion_rhs = must_be_var(rhs)?;
+    minion_model
+        .constraints
+        .push(MinionConstraint::SumLeq(minion_vars, minion_rhs));
+
+    Ok(())
+}
+
+fn parse_sumgeq(
+    sum_vars: Vec<ConjureExpression>,
+    rhs: ConjureExpression,
+    minion_model: &mut MinionModel,
+) -> Result<(), String> {
+    let minion_vars = must_be_vars(sum_vars)?;
+    let minion_rhs = must_be_var(rhs)?;
+    minion_model
+        .constraints
+        .push(MinionConstraint::SumGeq(minion_vars, minion_rhs));
+
+    Ok(())
+}
+
+fn parse_ineq(
+    a: ConjureExpression,
+    b: ConjureExpression,
+    c: ConjureExpression,
+    minion_model: &mut MinionModel,
+) -> Result<(), String> {
+    let a_minion = must_be_var(a)?;
+    let b_minion = must_be_var(b)?;
+    let c_value = must_be_const(c)?;
+    minion_model.constraints.push(MinionConstraint::Ineq(
+        a_minion,
+        b_minion,
+        MinionConstant::Integer(c_value),
+    ));
+
+    Ok(())
+}
+
+fn must_be_vars(exprs: Vec<ConjureExpression>) -> Result<Vec<MinionVar>, String> {
+    let mut minion_vars: Vec<MinionVar> = vec![];
+    for expr in exprs {
+        let minion_var = must_be_var(expr)?;
+        minion_vars.push(minion_var);
+    }
+    Ok(minion_vars)
+}
+
+fn must_be_var(e: ConjureExpression) -> Result<MinionVar, String> {
+    // a minion var is either a reference or a "var as const"
+    match must_be_ref(e.clone()) {
+        Ok(name) => Ok(MinionVar::NameRef(name)),
+        Err(_) => match must_be_const(e) {
+            Ok(n) => Ok(MinionVar::ConstantAsVar(n)),
+            Err(x) => Err(x),
+        },
+    }
+}
+
+fn must_be_ref(e: ConjureExpression) -> Result<String, String> {
+    let name = match e {
+        ConjureExpression::Reference(n) => Ok(n),
+        _ => Err(""),
+    }?;
+
+    let str_name = name_to_string(name);
+    Ok(str_name)
+}
+
+fn must_be_const(e: ConjureExpression) -> Result<i32, String> {
+    match e {
+        ConjureExpression::ConstantInt(n) => Ok(n),
+        _ => Err("".to_owned()),
+    }
+}
+
+fn name_to_string(name: ConjureName) -> String {
+    match name {
+        ConjureName::UserName(x) => x,
+        ConjureName::MachineName(x) => x.to_string(),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::collections::HashMap;
+
+    use minion_rs::ast::VarName;
+
+    use super::*;
+
+    #[test]
+    fn flat_xyz_model() -> Result<(), String> {
+        // TODO: convert to use public interfaces when these exist.
+        let mut model = ConjureModel {
+            variables: HashMap::new(),
+            constraints: Vec::new(),
+        };
+
+        add_int_with_range(&mut model, "x", 1, 3)?;
+        add_int_with_range(&mut model, "y", 2, 4)?;
+        add_int_with_range(&mut model, "z", 1, 5)?;
+
+        let x = ConjureExpression::Reference(ConjureName::UserName("x".to_owned()));
+        let y = ConjureExpression::Reference(ConjureName::UserName("y".to_owned()));
+        let z = ConjureExpression::Reference(ConjureName::UserName("z".to_owned()));
+        let four = ConjureExpression::ConstantInt(4);
+
+        let geq = ConjureExpression::SumGeq(
+            vec![x.to_owned(), y.to_owned(), z.to_owned()],
+            Box::from(four.to_owned()),
+        );
+        let leq = ConjureExpression::SumLeq(
+            vec![x.to_owned(), y.to_owned(), z.to_owned()],
+            Box::from(four.to_owned()),
+        );
+        let ineq = ConjureExpression::Ineq(Box::from(x), Box::from(y), Box::from(four));
+
+        model.constraints.push(geq);
+        model.constraints.push(leq);
+        model.constraints.push(ineq);
+
+        let minion_model = MinionModel::try_from(model)?;
+        minion_rs::run_minion(minion_model, xyz_callback).map_err(|x| x.to_string())
+    }
+
+    #[allow(clippy::unwrap_used)]
+    fn xyz_callback(solutions: HashMap<VarName, MinionConstant>) -> bool {
+        let x = match solutions.get("x").unwrap() {
+            MinionConstant::Integer(n) => n,
+            _ => panic!("x should be a integer"),
+        };
+
+        let y = match solutions.get("y").unwrap() {
+            MinionConstant::Integer(n) => n,
+            _ => panic!("y should be a integer"),
+        };
+
+        let z = match solutions.get("z").unwrap() {
+            MinionConstant::Integer(n) => n,
+            _ => panic!("z should be a integer"),
+        };
+
+        assert_eq!(*x, 1);
+        assert_eq!(*y, 2);
+        assert_eq!(*z, 1);
+
+        false
+    }
+
+    fn add_int_with_range(
+        model: &mut ConjureModel,
+        name: &str,
+        domain_low: i32,
+        domain_high: i32,
+    ) -> Result<(), String> {
+        // TODO: convert to use public interfaces when these exist.
+        let res = model.variables.insert(
+            ConjureName::UserName(name.to_owned()),
+            DecisionVariable {
+                domain: ConjureDomain::IntDomain(vec![ConjureRange::Bounded(
+                    domain_low,
+                    domain_high,
+                )]),
+            },
+        );
+
+        match res {
+            // variable was not already present
+            None => Ok(()),
+            Some(_) => Err(format!("Variable {:?} was already present", name)),
+        }
+    }
+}

conjure_oxide/src/solvers/mod.rs

@@ -0,0 +1 @@
+pub mod minion;

conjure_oxide/tests/model_tests.rs

@@ -18,9 +18,9 @@ fn modify_domain() {
         constraints: Vec::new(),
     };
 
-    assert!((*m.variables.get(&a).unwrap()).domain == d1);
+    assert!(m.variables.get(&a).unwrap().domain == d1);
 
     m.update_domain(&a, d2.clone());
 
-    assert!((*m.variables.get(&a).unwrap()).domain == d2);
+    assert!(m.variables.get(&a).unwrap().domain == d2);
 }

solvers/minion/Cargo.toml

@@ -13,3 +13,7 @@ cc = { version = "1.0.84", features = ["parallel"] }
 bindgen = "0.69.1"
 glob = "0.3.1"
 
+
+[lints]
+workspace = true
+

solvers/minion/build.rs

@@ -2,7 +2,7 @@
 // - https://github.com/gokberkkocak/rust_glucose/blob/master/build.rs
 // - https://rust-lang.github.io/rust-bindgen/non-system-libraries.html
 // - https://doc.rust-lang.org/cargo/reference/build-scripts.html#rerun-if-changed
-
+//
 use std::env;
 use std::path::PathBuf;
 use std::process::Command;