diff --git a/.github/workflows/aries.yml b/.github/workflows/aries.yml
index af9b2595d..b9b151147 100644
--- a/.github/workflows/aries.yml
+++ b/.github/workflows/aries.yml
@@ -50,6 +50,8 @@ jobs:
         run: ./ci/sat.py debug
       - name: Scheduler testing
         run: ./ci/scheduling.py
+      - name: APE validator
+        run: ./ci/ape-val.sh
       - name: GG solving
         run: ./ci/gg.py
       - name: PDDL Solving (PDDL & HDDL)
diff --git a/Cargo.lock b/Cargo.lock
index 64f19e813..84e08d29c 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -173,6 +173,8 @@ dependencies = [
  "itertools",
  "planx",
  "smallvec",
+ "tracing",
+ "tracing-subscriber",
 ]
 
 [[package]]
@@ -183,6 +185,7 @@ dependencies = [
  "env_param",
  "idmap",
  "itertools",
+ "num-rational",
  "smallvec",
  "tracing",
 ]
diff --git a/Cargo.toml b/Cargo.toml
index ca5dc58b8..034d42d16 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -60,7 +60,7 @@ tokio = { default-features = false, version = "1.49.0", features = [
     "macros",
 ] }
 tokio-stream = { default-features = false, version = "0.1" }
-tracing = { version = "0.1", features = ["release_max_level_debug"] }
+tracing = { version = "0.1", features = ["release_max_level_info"] }
 tracing-subscriber = "0.3"
 transitive = "1.2.0"
 vec_map = "0.8"
diff --git a/aries_fzn/src/aries/constraint/abs.rs b/aries_fzn/src/aries/constraint/abs.rs
index 841f9797f..74668535c 100644
--- a/aries_fzn/src/aries/constraint/abs.rs
+++ b/aries_fzn/src/aries/constraint/abs.rs
@@ -1,7 +1,7 @@
 use aries::model::Label;
 use aries::model::Model;
 use aries::model::lang::IVar;
-use aries::model::lang::linear::NFLinearSumItem;
+use aries::model::lang::linear::ScaledVar;
 
 use crate::aries::Post;
 use crate::aries::constraint::LinEq;
@@ -40,11 +40,11 @@ impl<Lbl: Label> Post<Lbl> for Abs {
         let plus_a = self.a;
 
         let sum = vec![
-            NFLinearSumItem {
+            ScaledVar {
                 var: plus_a.into(),
                 factor: 1,
             },
-            NFLinearSumItem {
+            ScaledVar {
                 var: minus_a.into(),
                 factor: 1,
             },
diff --git a/aries_fzn/src/aries/constraint/lin_eq.rs b/aries_fzn/src/aries/constraint/lin_eq.rs
index a5a4f51a0..1591f3299 100644
--- a/aries_fzn/src/aries/constraint/lin_eq.rs
+++ b/aries_fzn/src/aries/constraint/lin_eq.rs
@@ -1,7 +1,7 @@
 use aries::core::IntCst;
 use aries::model::Label;
 use aries::model::Model;
-use aries::model::lang::linear::NFLinearSumItem;
+use aries::model::lang::linear::ScaledVar;
 
 use crate::aries::Post;
 use crate::aries::constraint::LinGe;
@@ -13,16 +13,16 @@ use crate::aries::constraint::LinLe;
 /// where `v[i]` are variables, `b` and `c[i]` constants.
 #[derive(Debug)]
 pub struct LinEq {
-    sum: Vec<NFLinearSumItem>,
+    sum: Vec<ScaledVar>,
     b: IntCst,
 }
 
 impl LinEq {
-    pub fn new(sum: Vec<NFLinearSumItem>, b: IntCst) -> Self {
+    pub fn new(sum: Vec<ScaledVar>, b: IntCst) -> Self {
         Self { sum, b }
     }
 
-    pub fn sum(&self) -> &Vec<NFLinearSumItem> {
+    pub fn sum(&self) -> &Vec<ScaledVar> {
         &self.sum
     }
 
diff --git a/aries_fzn/src/aries/constraint/lin_eq_half.rs b/aries_fzn/src/aries/constraint/lin_eq_half.rs
index 30954b259..de4cb9635 100644
--- a/aries_fzn/src/aries/constraint/lin_eq_half.rs
+++ b/aries_fzn/src/aries/constraint/lin_eq_half.rs
@@ -2,7 +2,7 @@ use aries::core::IntCst;
 use aries::model::Label;
 use aries::model::Model;
 use aries::model::lang::BVar;
-use aries::model::lang::linear::NFLinearSumItem;
+use aries::model::lang::linear::ScaledVar;
 
 use crate::aries::Post;
 use crate::aries::constraint::LinGeHalf;
@@ -16,17 +16,17 @@ use crate::aries::constraint::LinLeHalf;
 /// `b` and `c[i]` constants.
 #[derive(Debug)]
 pub struct LinEqHalf {
-    sum: Vec<NFLinearSumItem>,
+    sum: Vec<ScaledVar>,
     b: IntCst,
     r: BVar,
 }
 
 impl LinEqHalf {
-    pub fn new(sum: Vec<NFLinearSumItem>, b: IntCst, r: BVar) -> Self {
+    pub fn new(sum: Vec<ScaledVar>, b: IntCst, r: BVar) -> Self {
         Self { sum, b, r }
     }
 
-    pub fn sum(&self) -> &Vec<NFLinearSumItem> {
+    pub fn sum(&self) -> &Vec<ScaledVar> {
         &self.sum
     }
 
diff --git a/aries_fzn/src/aries/constraint/lin_eq_reif.rs b/aries_fzn/src/aries/constraint/lin_eq_reif.rs
index 8fe3b0ee7..fbd8f180e 100644
--- a/aries_fzn/src/aries/constraint/lin_eq_reif.rs
+++ b/aries_fzn/src/aries/constraint/lin_eq_reif.rs
@@ -2,7 +2,7 @@ use aries::core::IntCst;
 use aries::model::Label;
 use aries::model::Model;
 use aries::model::lang::BVar;
-use aries::model::lang::linear::NFLinearSumItem;
+use aries::model::lang::linear::ScaledVar;
 
 use crate::aries::Post;
 use crate::aries::constraint::AndReif;
@@ -17,17 +17,17 @@ use crate::aries::constraint::LinLeReif;
 /// `b` and `c[i]` constants.
 #[derive(Debug)]
 pub struct LinEqReif {
-    sum: Vec<NFLinearSumItem>,
+    sum: Vec<ScaledVar>,
     b: IntCst,
     r: BVar,
 }
 
 impl LinEqReif {
-    pub fn new(sum: Vec<NFLinearSumItem>, b: IntCst, r: BVar) -> Self {
+    pub fn new(sum: Vec<ScaledVar>, b: IntCst, r: BVar) -> Self {
         Self { sum, b, r }
     }
 
-    pub fn sum(&self) -> &Vec<NFLinearSumItem> {
+    pub fn sum(&self) -> &Vec<ScaledVar> {
         &self.sum
     }
 
diff --git a/aries_fzn/src/aries/constraint/lin_ge.rs b/aries_fzn/src/aries/constraint/lin_ge.rs
index c6777ce48..d5ac6665a 100644
--- a/aries_fzn/src/aries/constraint/lin_ge.rs
+++ b/aries_fzn/src/aries/constraint/lin_ge.rs
@@ -1,7 +1,7 @@
 use aries::core::IntCst;
 use aries::model::Label;
 use aries::model::Model;
-use aries::model::lang::linear::NFLinearSumItem;
+use aries::model::lang::linear::ScaledVar;
 
 use crate::aries::Post;
 use crate::aries::constraint::LinLe;
@@ -12,16 +12,16 @@ use crate::aries::constraint::LinLe;
 /// where `v[i]` are variables, `b` and `c[i]` constants.
 #[derive(Debug)]
 pub struct LinGe {
-    items: Vec<NFLinearSumItem>,
+    items: Vec<ScaledVar>,
     lb: IntCst,
 }
 
 impl LinGe {
-    pub fn new(items: Vec<NFLinearSumItem>, lb: IntCst) -> Self {
+    pub fn new(items: Vec<ScaledVar>, lb: IntCst) -> Self {
         Self { items, lb }
     }
 
-    pub fn items(&self) -> &Vec<NFLinearSumItem> {
+    pub fn items(&self) -> &Vec<ScaledVar> {
         &self.items
     }
 
@@ -32,7 +32,7 @@ impl LinGe {
 
 impl<Lbl: Label> Post<Lbl> for LinGe {
     fn post(&self, model: &mut Model<Lbl>) {
-        let minus = |i: &NFLinearSumItem| NFLinearSumItem {
+        let minus = |i: &ScaledVar| ScaledVar {
             var: i.var,
             factor: -i.factor,
         };
diff --git a/aries_fzn/src/aries/constraint/lin_ge_half.rs b/aries_fzn/src/aries/constraint/lin_ge_half.rs
index 43fa02ff5..d3f779941 100644
--- a/aries_fzn/src/aries/constraint/lin_ge_half.rs
+++ b/aries_fzn/src/aries/constraint/lin_ge_half.rs
@@ -2,7 +2,7 @@ use aries::core::IntCst;
 use aries::model::Label;
 use aries::model::Model;
 use aries::model::lang::BVar;
-use aries::model::lang::linear::NFLinearSumItem;
+use aries::model::lang::linear::ScaledVar;
 
 use crate::aries::Post;
 use crate::aries::constraint::LinLeHalf;
@@ -15,17 +15,17 @@ use crate::aries::constraint::LinLeHalf;
 /// `lb` and `c[i]` constants.
 #[derive(Debug)]
 pub struct LinGeHalf {
-    sum: Vec<NFLinearSumItem>,
+    sum: Vec<ScaledVar>,
     lb: IntCst,
     r: BVar,
 }
 
 impl LinGeHalf {
-    pub fn new(sum: Vec<NFLinearSumItem>, lb: IntCst, r: BVar) -> Self {
+    pub fn new(sum: Vec<ScaledVar>, lb: IntCst, r: BVar) -> Self {
         Self { sum, lb, r }
     }
 
-    pub fn sum(&self) -> &Vec<NFLinearSumItem> {
+    pub fn sum(&self) -> &Vec<ScaledVar> {
         &self.sum
     }
 
diff --git a/aries_fzn/src/aries/constraint/lin_ge_reif.rs b/aries_fzn/src/aries/constraint/lin_ge_reif.rs
index 2929efdeb..901655726 100644
--- a/aries_fzn/src/aries/constraint/lin_ge_reif.rs
+++ b/aries_fzn/src/aries/constraint/lin_ge_reif.rs
@@ -2,7 +2,7 @@ use aries::core::IntCst;
 use aries::model::Label;
 use aries::model::Model;
 use aries::model::lang::BVar;
-use aries::model::lang::linear::NFLinearSumItem;
+use aries::model::lang::linear::ScaledVar;
 
 use crate::aries::Post;
 use crate::aries::constraint::LinLeReif;
@@ -15,17 +15,17 @@ use crate::aries::constraint::LinLeReif;
 /// `lb` and `c[i]` constants.
 #[derive(Debug)]
 pub struct LinGeReif {
-    sum: Vec<NFLinearSumItem>,
+    sum: Vec<ScaledVar>,
     lb: IntCst,
     r: BVar,
 }
 
 impl LinGeReif {
-    pub fn new(sum: Vec<NFLinearSumItem>, lb: IntCst, r: BVar) -> Self {
+    pub fn new(sum: Vec<ScaledVar>, lb: IntCst, r: BVar) -> Self {
         Self { sum, lb, r }
     }
 
-    pub fn sum(&self) -> &Vec<NFLinearSumItem> {
+    pub fn sum(&self) -> &Vec<ScaledVar> {
         &self.sum
     }
 
diff --git a/aries_fzn/src/aries/constraint/lin_le.rs b/aries_fzn/src/aries/constraint/lin_le.rs
index b8cc48224..107410e86 100644
--- a/aries_fzn/src/aries/constraint/lin_le.rs
+++ b/aries_fzn/src/aries/constraint/lin_le.rs
@@ -2,7 +2,7 @@ use aries::core::IntCst;
 use aries::model::Label;
 use aries::model::Model;
 use aries::model::lang::linear::NFLinearLeq;
-use aries::model::lang::linear::NFLinearSumItem;
+use aries::model::lang::linear::ScaledVar;
 use aries::reif::ReifExpr;
 
 use crate::aries::Post;
@@ -13,16 +13,16 @@ use crate::aries::Post;
 /// where `v[i]` are variables, `b` and `c[i]` constants.
 #[derive(Debug)]
 pub struct LinLe {
-    items: Vec<NFLinearSumItem>,
+    items: Vec<ScaledVar>,
     ub: IntCst,
 }
 
 impl LinLe {
-    pub fn new(items: Vec<NFLinearSumItem>, ub: IntCst) -> Self {
+    pub fn new(items: Vec<ScaledVar>, ub: IntCst) -> Self {
         Self { items, ub }
     }
 
-    pub fn items(&self) -> &Vec<NFLinearSumItem> {
+    pub fn items(&self) -> &Vec<ScaledVar> {
         &self.items
     }
 
diff --git a/aries_fzn/src/aries/constraint/lin_le_half.rs b/aries_fzn/src/aries/constraint/lin_le_half.rs
index a70e67d52..f340146fc 100644
--- a/aries_fzn/src/aries/constraint/lin_le_half.rs
+++ b/aries_fzn/src/aries/constraint/lin_le_half.rs
@@ -5,7 +5,7 @@ use aries::model::lang::BVar;
 use aries::model::lang::IVar;
 use aries::model::lang::linear::LinearSum;
 use aries::model::lang::linear::LinearTerm;
-use aries::model::lang::linear::NFLinearSumItem;
+use aries::model::lang::linear::ScaledVar;
 
 use crate::aries::Post;
 
@@ -17,17 +17,17 @@ use crate::aries::Post;
 /// `ub` and `c[i]` constants.
 #[derive(Debug)]
 pub struct LinLeHalf {
-    sum: Vec<NFLinearSumItem>,
+    sum: Vec<ScaledVar>,
     ub: IntCst,
     r: BVar,
 }
 
 impl LinLeHalf {
-    pub fn new(sum: Vec<NFLinearSumItem>, ub: IntCst, r: BVar) -> Self {
+    pub fn new(sum: Vec<ScaledVar>, ub: IntCst, r: BVar) -> Self {
         Self { sum, ub, r }
     }
 
-    pub fn sum(&self) -> &Vec<NFLinearSumItem> {
+    pub fn sum(&self) -> &Vec<ScaledVar> {
         &self.sum
     }
 
diff --git a/aries_fzn/src/aries/constraint/lin_le_reif.rs b/aries_fzn/src/aries/constraint/lin_le_reif.rs
index fc83d6a57..9777d0824 100644
--- a/aries_fzn/src/aries/constraint/lin_le_reif.rs
+++ b/aries_fzn/src/aries/constraint/lin_le_reif.rs
@@ -2,7 +2,7 @@ use aries::core::IntCst;
 use aries::model::Label;
 use aries::model::Model;
 use aries::model::lang::BVar;
-use aries::model::lang::linear::NFLinearSumItem;
+use aries::model::lang::linear::ScaledVar;
 
 use crate::aries::Post;
 use crate::aries::constraint::LinGeHalf;
@@ -17,17 +17,17 @@ use crate::aries::constraint::Ne;
 /// `ub` and `c[i]` constants.
 #[derive(Debug)]
 pub struct LinLeReif {
-    sum: Vec<NFLinearSumItem>,
+    sum: Vec<ScaledVar>,
     ub: IntCst,
     r: BVar,
 }
 
 impl LinLeReif {
-    pub fn new(sum: Vec<NFLinearSumItem>, ub: IntCst, r: BVar) -> Self {
+    pub fn new(sum: Vec<ScaledVar>, ub: IntCst, r: BVar) -> Self {
         Self { sum, ub, r }
     }
 
-    pub fn sum(&self) -> &Vec<NFLinearSumItem> {
+    pub fn sum(&self) -> &Vec<ScaledVar> {
         &self.sum
     }
 
diff --git a/aries_fzn/src/aries/constraint/lin_ne.rs b/aries_fzn/src/aries/constraint/lin_ne.rs
index f916d460a..4e06e50e5 100644
--- a/aries_fzn/src/aries/constraint/lin_ne.rs
+++ b/aries_fzn/src/aries/constraint/lin_ne.rs
@@ -4,7 +4,7 @@ use aries::model::Model;
 use aries::model::lang::IVar;
 use aries::model::lang::linear::LinearSum;
 use aries::model::lang::linear::LinearTerm;
-use aries::model::lang::linear::NFLinearSumItem;
+use aries::model::lang::linear::ScaledVar;
 
 use crate::aries::Post;
 
@@ -14,16 +14,16 @@ use crate::aries::Post;
 /// where `v[i]` are variables, `b` and `c[i]` constants.
 #[derive(Debug)]
 pub struct LinNe {
-    sum: Vec<NFLinearSumItem>,
+    sum: Vec<ScaledVar>,
     b: IntCst,
 }
 
 impl LinNe {
-    pub fn new(sum: Vec<NFLinearSumItem>, b: IntCst) -> Self {
+    pub fn new(sum: Vec<ScaledVar>, b: IntCst) -> Self {
         Self { sum, b }
     }
 
-    pub fn sum(&self) -> &Vec<NFLinearSumItem> {
+    pub fn sum(&self) -> &Vec<ScaledVar> {
         &self.sum
     }
 
diff --git a/aries_fzn/src/aries/constraint/lin_ne_reif.rs b/aries_fzn/src/aries/constraint/lin_ne_reif.rs
index c1792269f..31c0ebe43 100644
--- a/aries_fzn/src/aries/constraint/lin_ne_reif.rs
+++ b/aries_fzn/src/aries/constraint/lin_ne_reif.rs
@@ -2,7 +2,7 @@ use aries::core::IntCst;
 use aries::model::Label;
 use aries::model::Model;
 use aries::model::lang::BVar;
-use aries::model::lang::linear::NFLinearSumItem;
+use aries::model::lang::linear::ScaledVar;
 
 use crate::aries::Post;
 use crate::aries::constraint::LinGeReif;
@@ -17,17 +17,17 @@ use crate::aries::constraint::OrReif;
 /// `b` and `c[i]` constants.
 #[derive(Debug)]
 pub struct LinNeReif {
-    sum: Vec<NFLinearSumItem>,
+    sum: Vec<ScaledVar>,
     b: IntCst,
     r: BVar,
 }
 
 impl LinNeReif {
-    pub fn new(sum: Vec<NFLinearSumItem>, b: IntCst, r: BVar) -> Self {
+    pub fn new(sum: Vec<ScaledVar>, b: IntCst, r: BVar) -> Self {
         Self { sum, b, r }
     }
 
-    pub fn sum(&self) -> &Vec<NFLinearSumItem> {
+    pub fn sum(&self) -> &Vec<ScaledVar> {
         &self.sum
     }
 
diff --git a/aries_fzn/src/aries/constraint/test.rs b/aries_fzn/src/aries/constraint/test.rs
index ce29a601c..7cbb65895 100644
--- a/aries_fzn/src/aries/constraint/test.rs
+++ b/aries_fzn/src/aries/constraint/test.rs
@@ -9,7 +9,7 @@ use aries::core::VarRef;
 use aries::model::Model;
 use aries::model::lang::BVar;
 use aries::model::lang::IVar;
-use aries::model::lang::linear::NFLinearSumItem;
+use aries::model::lang::linear::ScaledVar;
 use aries::solver::SearchLimit;
 use aries::solver::Solver;
 use itertools::Itertools;
@@ -154,7 +154,7 @@ pub(super) fn basic_int_model_3() -> (Model<String>, IVar, IVar, IVar) {
 /// The linear sum is 3\*x + 2\*y with bound 13.
 pub(super) fn basic_lin_model() -> (
     Model<String>,
-    Vec<NFLinearSumItem>,
+    Vec<ScaledVar>,
     IVar,
     IVar,
     IntCst,
@@ -168,11 +168,11 @@ pub(super) fn basic_lin_model() -> (
     let b = 13;
 
     let sum = vec![
-        NFLinearSumItem {
+        ScaledVar {
             var: x.into(),
             factor: c_x,
         },
-        NFLinearSumItem {
+        ScaledVar {
             var: y.into(),
             factor: c_y,
         },
diff --git a/aries_fzn/src/fzn/constraint/builtins/bool_lin_eq.rs b/aries_fzn/src/fzn/constraint/builtins/bool_lin_eq.rs
index 995a09df8..afaf7bd18 100644
--- a/aries_fzn/src/fzn/constraint/builtins/bool_lin_eq.rs
+++ b/aries_fzn/src/fzn/constraint/builtins/bool_lin_eq.rs
@@ -2,7 +2,7 @@ use std::collections::HashMap;
 use std::rc::Rc;
 
 use aries::core::VarRef;
-use aries::model::lang::linear::NFLinearSumItem;
+use aries::model::lang::linear::ScaledVar;
 use flatzinc::ConstraintItem;
 
 use crate::aries::Post;
@@ -110,16 +110,16 @@ impl Encode for BoolLinEq {
         translation: &HashMap<usize, VarRef>,
     ) -> Box<dyn Post<usize>> {
         let translate = |v: Rc<VarBool>| translation.get(v.id()).unwrap();
-        let mut sum: Vec<NFLinearSumItem> = self
+        let mut sum: Vec<ScaledVar> = self
             .a
             .iter()
             .zip(self.b.clone())
-            .map(|x| NFLinearSumItem {
+            .map(|x| ScaledVar {
                 var: *translate(x.1),
                 factor: *x.0,
             })
             .collect();
-        sum.push(NFLinearSumItem {
+        sum.push(ScaledVar {
             var: *translation.get(self.c.id()).unwrap(),
             factor: -1,
         });
diff --git a/aries_fzn/src/fzn/constraint/builtins/bool_lin_le.rs b/aries_fzn/src/fzn/constraint/builtins/bool_lin_le.rs
index 080fdf41f..20a443272 100644
--- a/aries_fzn/src/fzn/constraint/builtins/bool_lin_le.rs
+++ b/aries_fzn/src/fzn/constraint/builtins/bool_lin_le.rs
@@ -2,7 +2,7 @@ use std::collections::HashMap;
 use std::rc::Rc;
 
 use aries::core::VarRef;
-use aries::model::lang::linear::NFLinearSumItem;
+use aries::model::lang::linear::ScaledVar;
 use flatzinc::ConstraintItem;
 
 use crate::aries::Post;
@@ -113,7 +113,7 @@ impl Encode for BoolLinLe {
             .a
             .iter()
             .zip(self.b.clone())
-            .map(|x| NFLinearSumItem {
+            .map(|x| ScaledVar {
                 var: *translate(x.1),
                 factor: *x.0,
             })
diff --git a/aries_fzn/src/fzn/constraint/builtins/int_lin_eq.rs b/aries_fzn/src/fzn/constraint/builtins/int_lin_eq.rs
index ddcf215f9..864fcf14b 100644
--- a/aries_fzn/src/fzn/constraint/builtins/int_lin_eq.rs
+++ b/aries_fzn/src/fzn/constraint/builtins/int_lin_eq.rs
@@ -2,7 +2,7 @@ use std::collections::HashMap;
 use std::rc::Rc;
 
 use aries::core::VarRef;
-use aries::model::lang::linear::NFLinearSumItem;
+use aries::model::lang::linear::ScaledVar;
 use flatzinc::ConstraintItem;
 
 use crate::aries::Post;
@@ -112,7 +112,7 @@ impl Encode for IntLinEq {
             .a
             .iter()
             .zip(self.b.clone())
-            .map(|x| NFLinearSumItem {
+            .map(|x| ScaledVar {
                 var: *translate(x.1),
                 factor: *x.0,
             })
diff --git a/aries_fzn/src/fzn/constraint/builtins/int_lin_eq_imp.rs b/aries_fzn/src/fzn/constraint/builtins/int_lin_eq_imp.rs
index 14ba1c506..371af5357 100644
--- a/aries_fzn/src/fzn/constraint/builtins/int_lin_eq_imp.rs
+++ b/aries_fzn/src/fzn/constraint/builtins/int_lin_eq_imp.rs
@@ -3,7 +3,7 @@ use std::rc::Rc;
 
 use aries::core::VarRef;
 use aries::model::lang::BVar;
-use aries::model::lang::linear::NFLinearSumItem;
+use aries::model::lang::linear::ScaledVar;
 use flatzinc::ConstraintItem;
 
 use crate::aries::Post;
@@ -127,7 +127,7 @@ impl Encode for IntLinEqImp {
             .a
             .iter()
             .zip(self.b.clone())
-            .map(|x| NFLinearSumItem {
+            .map(|x| ScaledVar {
                 var: *translate(x.1.id()),
                 factor: *x.0,
             })
diff --git a/aries_fzn/src/fzn/constraint/builtins/int_lin_eq_reif.rs b/aries_fzn/src/fzn/constraint/builtins/int_lin_eq_reif.rs
index 1950276fa..5a519138d 100644
--- a/aries_fzn/src/fzn/constraint/builtins/int_lin_eq_reif.rs
+++ b/aries_fzn/src/fzn/constraint/builtins/int_lin_eq_reif.rs
@@ -3,7 +3,7 @@ use std::rc::Rc;
 
 use aries::core::VarRef;
 use aries::model::lang::BVar;
-use aries::model::lang::linear::NFLinearSumItem;
+use aries::model::lang::linear::ScaledVar;
 use flatzinc::ConstraintItem;
 
 use crate::aries::Post;
@@ -127,7 +127,7 @@ impl Encode for IntLinEqReif {
             .a
             .iter()
             .zip(self.b.clone())
-            .map(|x| NFLinearSumItem {
+            .map(|x| ScaledVar {
                 var: *translate(x.1.id()),
                 factor: *x.0,
             })
diff --git a/aries_fzn/src/fzn/constraint/builtins/int_lin_le.rs b/aries_fzn/src/fzn/constraint/builtins/int_lin_le.rs
index a2172f400..b4181dca6 100644
--- a/aries_fzn/src/fzn/constraint/builtins/int_lin_le.rs
+++ b/aries_fzn/src/fzn/constraint/builtins/int_lin_le.rs
@@ -2,7 +2,7 @@ use std::collections::HashMap;
 use std::rc::Rc;
 
 use aries::core::VarRef;
-use aries::model::lang::linear::NFLinearSumItem;
+use aries::model::lang::linear::ScaledVar;
 use flatzinc::ConstraintItem;
 
 use crate::aries::Post;
@@ -112,7 +112,7 @@ impl Encode for IntLinLe {
             .a
             .iter()
             .zip(self.b.clone())
-            .map(|x| NFLinearSumItem {
+            .map(|x| ScaledVar {
                 var: *translate(x.1),
                 factor: *x.0,
             })
diff --git a/aries_fzn/src/fzn/constraint/builtins/int_lin_le_imp.rs b/aries_fzn/src/fzn/constraint/builtins/int_lin_le_imp.rs
index a4cd5be7e..0af3eb3c0 100644
--- a/aries_fzn/src/fzn/constraint/builtins/int_lin_le_imp.rs
+++ b/aries_fzn/src/fzn/constraint/builtins/int_lin_le_imp.rs
@@ -3,7 +3,7 @@ use std::rc::Rc;
 
 use aries::core::VarRef;
 use aries::model::lang::BVar;
-use aries::model::lang::linear::NFLinearSumItem;
+use aries::model::lang::linear::ScaledVar;
 use flatzinc::ConstraintItem;
 
 use crate::aries::Post;
@@ -127,7 +127,7 @@ impl Encode for IntLinLeImp {
             .a
             .iter()
             .zip(self.b.clone())
-            .map(|x| NFLinearSumItem {
+            .map(|x| ScaledVar {
                 var: *translate(x.1.id()),
                 factor: *x.0,
             })
diff --git a/aries_fzn/src/fzn/constraint/builtins/int_lin_le_reif.rs b/aries_fzn/src/fzn/constraint/builtins/int_lin_le_reif.rs
index 819a8a8ae..f26d819ab 100644
--- a/aries_fzn/src/fzn/constraint/builtins/int_lin_le_reif.rs
+++ b/aries_fzn/src/fzn/constraint/builtins/int_lin_le_reif.rs
@@ -3,7 +3,7 @@ use std::rc::Rc;
 
 use aries::core::VarRef;
 use aries::model::lang::BVar;
-use aries::model::lang::linear::NFLinearSumItem;
+use aries::model::lang::linear::ScaledVar;
 use flatzinc::ConstraintItem;
 
 use crate::aries::Post;
@@ -127,7 +127,7 @@ impl Encode for IntLinLeReif {
             .a
             .iter()
             .zip(self.b.clone())
-            .map(|x| NFLinearSumItem {
+            .map(|x| ScaledVar {
                 var: *translate(x.1.id()),
                 factor: *x.0,
             })
diff --git a/aries_fzn/src/fzn/constraint/builtins/int_lin_ne.rs b/aries_fzn/src/fzn/constraint/builtins/int_lin_ne.rs
index a9f9c46f3..db7e93821 100644
--- a/aries_fzn/src/fzn/constraint/builtins/int_lin_ne.rs
+++ b/aries_fzn/src/fzn/constraint/builtins/int_lin_ne.rs
@@ -2,7 +2,7 @@ use std::collections::HashMap;
 use std::rc::Rc;
 
 use aries::core::VarRef;
-use aries::model::lang::linear::NFLinearSumItem;
+use aries::model::lang::linear::ScaledVar;
 use flatzinc::ConstraintItem;
 
 use crate::aries::Post;
@@ -112,7 +112,7 @@ impl Encode for IntLinNe {
             .a
             .iter()
             .zip(self.b.clone())
-            .map(|x| NFLinearSumItem {
+            .map(|x| ScaledVar {
                 var: *translate(x.1),
                 factor: *x.0,
             })
diff --git a/aries_fzn/src/fzn/constraint/builtins/int_lin_ne_reif.rs b/aries_fzn/src/fzn/constraint/builtins/int_lin_ne_reif.rs
index dc682551f..6c02632af 100644
--- a/aries_fzn/src/fzn/constraint/builtins/int_lin_ne_reif.rs
+++ b/aries_fzn/src/fzn/constraint/builtins/int_lin_ne_reif.rs
@@ -3,7 +3,7 @@ use std::rc::Rc;
 
 use aries::core::VarRef;
 use aries::model::lang::BVar;
-use aries::model::lang::linear::NFLinearSumItem;
+use aries::model::lang::linear::ScaledVar;
 use flatzinc::ConstraintItem;
 
 use crate::aries::Post;
@@ -127,7 +127,7 @@ impl Encode for IntLinNeReif {
             .a
             .iter()
             .zip(self.b.clone())
-            .map(|x| NFLinearSumItem {
+            .map(|x| ScaledVar {
                 var: *translate(x.1.id()),
                 factor: *x.0,
             })
diff --git a/ci/ape-val.sh b/ci/ape-val.sh
new file mode 100755
index 000000000..9c0b90630
--- /dev/null
+++ b/ci/ape-val.sh
@@ -0,0 +1,46 @@
+# Runs APE's validator on a all plan files in planning/problem/upf
+#
+#
+# Some pointer for generating plans: (here for tamer)
+#     cd planning/problems/upf
+#     find . -type d -exec sh -c 'cd "{}" && up oneshot-planning --pddl domain.pddl problem.pddl --engine tamer --plan problem.tamer.plan || true' \;
+
+set -e # Exit on first error
+
+# Path to planner and validators (defaults to ci build)
+APE="${PLANNER:-target/ci/ape} "
+HDDL_VAL="${HDDL_VAL:-planning/ext/val-hddl}"
+PDDL_VAL="${PDDL_VAL:-planning/ext/val-pddl}"
+
+# Time allowed for each run (defaults to 90s)
+TIMEOUT="${TIMEOUT:-5s}"
+
+echo "Building..."
+cargo build --profile ci --bin ape
+
+PLAN_FILES=$(find planning/problems/upf -name *.plan | sort)
+
+for PLAN_FILE in $PLAN_FILES
+do
+    echo ""
+    echo "Plan: ${PLAN_FILE}"
+    PROBLEM_FILE=`${APE} find-problem ${PLAN_FILE}`
+    DOMAIN_FILE=`${APE} find-domain ${PROBLEM_FILE}`
+
+    VAL_CMD="${PDDL_VAL} ${DOMAIN_FILE} ${PROBLEM_FILE} ${PLAN_FILE}"
+
+    # Run VAL with some post-processing to
+    #   - exit with error on invalid plan
+    #   - extract only the computed plan quality on the stdout and save in in $PLAN_QUALITY
+    PLAN_QUALITY=`${VAL_CMD} | awk -v cmd="${VAL_CMD}" '/Plan valid/{ok=1} ok && /Final value:/ {print $3; exit} END{if(!ok) {print "INVALID (from val)\n> " cmd >"/dev/stderr"; exit 1}}'`
+    echo "VAL plan quality: ${PLAN_QUALITY}"
+    timeout ${TIMEOUT} ${APE} validate ${PLAN_FILE} --expected-objective ${PLAN_QUALITY}
+
+    # Just check that the plan-optimizer does not crash...
+    # echo "OPT PRESENCE:  " optimize-plan ${PLAN_FILE} -r action-presence
+    # timeout ${TIMEOUT} ${APE} optimize-plan ${PLAN_FILE} -r action-presence > /dev/null
+    # echo "OPT TIME:  " optimize-plan ${PLAN_FILE} -r start-time
+    # timeout ${TIMEOUT} ${APE} optimize-plan ${PLAN_FILE} -r start-time > /dev/null
+    # echo "OPT PRESENCE TIME:  " optimize-plan ${PLAN_FILE} -r action-presence -r start-time
+    timeout ${TIMEOUT} ${APE} optimize-plan ${PLAN_FILE} -r action-presence -r start-time > /dev/null
+done
diff --git a/examples/scheduling/src/search/greedy.rs b/examples/scheduling/src/search/greedy.rs
index d3ba73e74..6a3556c6a 100644
--- a/examples/scheduling/src/search/greedy.rs
+++ b/examples/scheduling/src/search/greedy.rs
@@ -4,7 +4,8 @@ use crate::Var;
 use crate::problem::Encoding;
 use crate::search::Model;
 use aries::backtrack::{Backtrack, DecLvl, DecisionLevelTracker};
-use aries::core::state::{OptDomain, Term};
+use aries::core::state::OptDomain;
+use aries::core::views::Term;
 use aries::core::{IntCst, Lit, VarRef};
 use aries::model::extensions::DomainsExt;
 use aries::solver::search::{Decision, SearchControl};
diff --git a/examples/smt/tests/smt.rs b/examples/smt/tests/smt.rs
index c8a7b88fa..f86efe296 100644
--- a/examples/smt/tests/smt.rs
+++ b/examples/smt/tests/smt.rs
@@ -1,5 +1,6 @@
 use aries::backtrack::Backtrack;
-use aries::core::state::{OptDomain, Term};
+use aries::core::state::OptDomain;
+use aries::core::views::Term;
 use aries::core::Lit;
 use aries::model::extensions::DomainsExt;
 use aries::model::lang::alternative::Alternative;
diff --git a/planning/engine/Cargo.toml b/planning/engine/Cargo.toml
index 7de096290..936c59615 100644
--- a/planning/engine/Cargo.toml
+++ b/planning/engine/Cargo.toml
@@ -13,6 +13,8 @@ derive_more = { workspace = true }
 itertools = { workspace = true }
 im = { workspace = true }
 smallvec = { workspace = true }
+tracing = { workspace = true }
+tracing-subscriber = { workspace = true }
 
 planx = { path = "../planx" }
 timelines = { package = "aries-timelines", path = "../timelines" }
diff --git a/planning/engine/README.md b/planning/engine/README.md
index 3097203e6..e5f193cf4 100644
--- a/planning/engine/README.md
+++ b/planning/engine/README.md
@@ -63,3 +63,137 @@ my-planner --domain `ape find-domain ${PROBLEM_FILE}` --problem ${PROBLEM_FILE}
 It is notably used in the [`zed-pddl`](https://github.com/arbimo/zed-pddl) extension for Zed.
 
 Note that at this point, the discovery is purely based on the filenames, with no attempt to validate that the domain name matches the one declared in the problem.
+
+
+
+## Plan Optimization
+
+The `optimize-plan` command allow specify objectives:
+
+ - `makespan`: minimizes the end time of the last action
+ - `plan-length`: minimizes the number of actions
+
+It also allow to specify the allowed relaxations (what is allowed to change in the plan):
+
+ - `action-presence`: allow removing actions
+ - `start-time`: allow changing the start time of actions
+
+### Example plan
+
+The file [examples/gripper/plan](examples/gripper/plan) contains the following plan:
+
+```
+(pick ball1 rooma left)
+(pick ball2 rooma right)
+(move rooma roomb)
+(move roomb rooma)
+(move rooma roomb)
+(drop ball1 roomb left)
+(drop ball2 roomb right)
+(move roomb rooma)
+(pick ball3 rooma left)
+(pick ball4 rooma right)
+(move rooma roomb)
+(drop ball3 roomb left)
+(drop ball4 roomb right)
+```
+
+### No relaxation -> same plan
+
+Running the `optimize-plan` command with no relaxation will always give the same plan and will succeed if the plan is valid:
+
+```
+> ape optimize-plan examples/gripper/plan -o plan-length
+...
+==== Plan (objective: 13) =====
+   0: (pick left ball1 rooma) [0]
+   1: (pick right ball2 rooma) [0]
+   2: (move rooma roomb) [0]
+   3: (move roomb rooma) [0]
+   4: (move rooma roomb) [0]
+   5: (drop left ball1 roomb) [0]
+   6: (drop right ball2 roomb) [0]
+   7: (move roomb rooma) [0]
+   8: (pick left ball3 rooma) [0]
+   9: (pick right ball4 rooma) [0]
+  10: (move rooma roomb) [0]
+  11: (drop left ball3 roomb) [0]
+  12: (drop right ball4 roomb) [0]
+```
+
+Notice that here, the plan is unchanged. In case of a sequential plan, the start time of each action corresponds to its position in the original plan.
+
+
+### Action presence relaxation
+
+Relaxing action presence (and optimize plan length) will yield a new plan with the third and fourth actions removed:
+
+```
+> ape optimize-plan examples/gripper/plan -o plan-length -r action-presence
+...
+==== Plan (objective: 11) =====
+   0: (pick left ball1 rooma) [0]
+   1: (pick right ball2 rooma) [0]
+   4: (move rooma roomb) [0]
+   5: (drop left ball1 roomb) [0]
+   6: (drop right ball2 roomb) [0]
+   7: (move roomb rooma) [0]
+   8: (pick left ball3 rooma) [0]
+   9: (pick right ball4 rooma) [0]
+  10: (move rooma roomb) [0]
+  11: (drop left ball3 roomb) [0]
+  12: (drop right ball4 roomb) [0]
+```
+
+Note that the timing of actions does not change, and two unoccopied time-stamps remain (2 and 3)
+
+
+### Action timing relaxation
+
+Relaxing action start times (and optimizing makespan) will give a plan where actions are freely allowed to move around and packed so has to minimize the total time:
+
+
+```
+> ape optimize-plan examples/gripper/plan -o makespan -r start-time
+...
+==== Plan (objective: 8) =====
+   0: (pick right ball2 rooma) [0]
+   0: (pick left ball3 rooma) [0]
+   1: (move rooma roomb) [0]
+   2: (drop right ball2 roomb) [0]
+   2: (drop left ball3 roomb) [0]
+   3: (move roomb rooma) [0]
+   4: (pick left ball1 rooma) [0]
+   4: (pick right ball4 rooma) [0]
+   5: (move rooma roomb) [0]
+   6: (drop left ball1 roomb) [0]
+   6: (drop right ball4 roomb) [0]
+   7: (move roomb rooma) [0]
+   8: (move rooma roomb) [0]
+```
+
+Here the pick actions are performed in parallel when possible.
+Note that this goes beyond a partial order extraction: the two useless move actions have been repositioned at the end of the plan (i.e. changing some causal links in the plan).
+However, those actions were not removed: without the `action-presence` relaxation, the solver is not allowed to remove them.
+
+
+### Combining relaxations
+
+Relaxation can of course be combined, e.g., to allow both removing actions and moving them around:
+
+```
+> ape optimize-plan examples/gripper/plan -o makespan -r start-time -r action-presence
+...
+==== Plan (objective: 6) =====
+   0: (pick right ball2 rooma) [0]
+   0: (pick left ball3 rooma) [0]
+   1: (move rooma roomb) [0]
+   2: (drop right ball2 roomb) [0]
+   2: (drop left ball3 roomb) [0]
+   3: (move roomb rooma) [0]
+   4: (pick left ball1 rooma) [0]
+   4: (pick right ball4 rooma) [0]
+   5: (move rooma roomb) [0]
+   6: (drop left ball1 roomb) [0]
+   6: (drop right ball4 roomb) [0]
+```
diff --git a/planning/engine/examples/gripper/domain.pddl b/planning/engine/examples/gripper/domain.pddl
new file mode 100644
index 000000000..c62c8605b
--- /dev/null
+++ b/planning/engine/examples/gripper/domain.pddl
@@ -0,0 +1,17 @@
+(define (domain gripper_x_1-domain)
+ (:requirements :strips :typing)
+ (:types room ball gripper)
+ (:predicates (at_robby ?r - room) (at_ ?b - ball ?r - room) (free ?g - gripper) (carry ?o - ball ?g - gripper))
+ (:action move
+  :parameters ( ?from - room ?to - room)
+  :precondition (and (at_robby ?from))
+  :effect (and (at_robby ?to) (not (at_robby ?from))))
+ (:action pick
+  :parameters ( ?obj - ball ?room - room ?gripper - gripper)
+  :precondition (and (at_ ?obj ?room) (at_robby ?room) (free ?gripper))
+  :effect (and (carry ?obj ?gripper) (not (at_ ?obj ?room)) (not (free ?gripper))))
+ (:action drop
+  :parameters ( ?obj - ball ?room - room ?gripper - gripper)
+  :precondition (and (carry ?obj ?gripper) (at_robby ?room))
+  :effect (and (at_ ?obj ?room) (free ?gripper) (not (carry ?obj ?gripper))))
+)
diff --git a/planning/engine/examples/gripper/plan b/planning/engine/examples/gripper/plan
new file mode 100644
index 000000000..2d037dcb1
--- /dev/null
+++ b/planning/engine/examples/gripper/plan
@@ -0,0 +1,13 @@
+(pick ball1 rooma left)
+(pick ball2 rooma right)
+(move rooma roomb)
+(move roomb rooma)
+(move rooma roomb)
+(drop ball1 roomb left)
+(drop ball2 roomb right)
+(move roomb rooma)
+(pick ball3 rooma left)
+(pick ball4 rooma right)
+(move rooma roomb)
+(drop ball3 roomb left)
+(drop ball4 roomb right)
diff --git a/planning/engine/examples/gripper/problem.pddl b/planning/engine/examples/gripper/problem.pddl
new file mode 100644
index 000000000..19f85e5eb
--- /dev/null
+++ b/planning/engine/examples/gripper/problem.pddl
@@ -0,0 +1,10 @@
+(define (problem gripper_x_1-problem)
+ (:domain gripper_x_1-domain)
+ (:objects
+   rooma roomb - room
+   ball4 ball3 ball2 ball1 - ball
+   left right - gripper
+ )
+ (:init (at_robby rooma) (free left) (free right) (at_ ball4 rooma) (at_ ball3 rooma) (at_ ball2 rooma) (at_ ball1 rooma))
+ (:goal (and (at_ ball4 roomb) (at_ ball3 roomb) (at_ ball2 roomb) (at_ ball1 roomb)))
+)
diff --git a/planning/engine/src/encode.rs b/planning/engine/src/encode.rs
index 40482eaeb..b26fa76e3 100644
--- a/planning/engine/src/encode.rs
+++ b/planning/engine/src/encode.rs
@@ -1,20 +1,25 @@
 //! A number of utility functions for converting from `planx` to `aries-timelines`
 
 pub mod constraints;
+pub mod encoding;
 pub mod required_values;
+pub mod tags;
 
 use aries::{
     core::literals::ConjunctionBuilder,
     model::lang::{
-        FAtom,
-        expr::{and, eq},
+        BoolExpr,
+        expr::{and, eq, lin_eq},
     },
     prelude::*,
     reif::ReifExpr,
 };
 use itertools::Itertools;
-use planx::{ExprId, Model, Res, Sym, TimeRef, Timestamp, errors::Spanned};
-use timelines::{Effect, EffectOp, Sched, StateVar, SymAtom, Time, constraints::HasValueAt, symbols::ObjectEncoding};
+use planx::{ExprId, Fun, Message, Model, Res, Sym, TimeRef, Timestamp, errors::Spanned};
+use timelines::{
+    Effect, EffectOp, IntExp, IntTerm, Sched, StateVar, SymAtom, TaskId, Time, constraints::HasValueAt,
+    symbols::ObjectEncoding,
+};
 
 use crate::encode::{constraints::ConditionConstraint, required_values::RequiredValues};
 
@@ -44,6 +49,7 @@ pub struct Scope<'a> {
     pub end: Time,
     pub presence: Lit,
     pub args: im::OrdMap<&'a Sym, SymAtom>,
+    pub source: Option<TaskId>,
 }
 impl<'a> Scope<'a> {
     pub fn global(sched: &Sched) -> Scope<'a> {
@@ -52,6 +58,7 @@ impl<'a> Scope<'a> {
             end: sched.horizon,
             presence: Lit::TRUE,
             args: im::OrdMap::new(),
+            source: None,
         }
     }
 }
@@ -68,6 +75,7 @@ pub fn condition_to_constraint(
     required_values: Option<&mut RequiredValues>,
 ) -> Res<ConditionConstraint> {
     let expr = model.env.node(expr);
+    let timepoint = reify_timing(tp, model, sched, bindings)?;
     let constraint = match expr.expr() {
         planx::Expr::StateVariable(fluent_id, args) => {
             let fluent = model.env.fluents.get(*fluent_id);
@@ -82,9 +90,10 @@ pub fn condition_to_constraint(
             };
             let c = HasValueAt {
                 state_var,
-                value: Lit::TRUE.into(),
-                timepoint: reify_timing(tp, model, sched, bindings)?,
+                value: IntTerm::TRUE,
+                timepoint,
                 prez: bindings.presence,
+                source: bindings.source,
             };
             ConditionConstraint::HasValue(c)
         }
@@ -93,22 +102,31 @@ pub fn condition_to_constraint(
             let c = condition_to_constraint(tp, exprs[0], model, sched, bindings, None)?;
             match c {
                 ConditionConstraint::HasValue(mut c) => {
-                    let Ok(x) = Lit::try_from(c.value) else {
-                        panic!();
-                    };
-                    c.value = x.not().into();
-                    ConditionConstraint::HasValue(c)
+                    if let Ok(x) = IntCst::try_from(c.value)
+                        && (x == 0 || x == 1)
+                    {
+                        c.value = (1 - x).into(); // negation : 0 -> 1 and 1 -> 0
+                        ConditionConstraint::HasValue(c)
+                    } else {
+                        return expr.todo("unsupported").failed();
+                    }
                 }
-                ConditionConstraint::Eq(a, b) => ConditionConstraint::Neq(a, b),
-                ConditionConstraint::Neq(a, b) => ConditionConstraint::Eq(a, b),
+                ConditionConstraint::EqZero(sum) => ConditionConstraint::NeqZero(sum),
+                ConditionConstraint::NeqZero(sum) => ConditionConstraint::EqZero(sum),
+                ConditionConstraint::LeqZero(_) => todo!(),
             }
         }
         planx::Expr::App(planx::Fun::Eq, exprs) if exprs.len() == 2 => {
-            let e1 = reify_sym(exprs[0], model, sched, bindings)?;
-            let e2 = reify_sym(exprs[1], model, sched, bindings)?;
-            ConditionConstraint::Eq(e1, e2)
+            let e1 = reify_expression(exprs[0], Some(timepoint), model, sched, bindings)?;
+            let e2 = reify_expression(exprs[1], Some(timepoint), model, sched, bindings)?;
+            ConditionConstraint::EqZero(e1 - e2)
+        }
+        planx::Expr::App(planx::Fun::Leq, exprs) if exprs.len() == 2 => {
+            let lhs = reify_expression(exprs[0], Some(timepoint), model, sched, bindings)?;
+            let rhs = reify_expression(exprs[1], Some(timepoint), model, sched, bindings)?;
+            ConditionConstraint::LeqZero(lhs - rhs)
         }
-        e => todo!("{e:?}"),
+        _ => return Err(expr.todo("not supported")),
     };
 
     // update the required values if requested by caller
@@ -117,26 +135,27 @@ pub fn condition_to_constraint(
             ConditionConstraint::HasValue(c) => {
                 // record that someone required such a value
                 let fluent_id = model.env.fluents.get_by_name(&c.state_var.fluent).unwrap();
-                reqs.add(fluent_id, c.value_box(|v| sched.model.int_bounds(v)).as_ref());
+                reqs.add(fluent_id, c.value_box(&sched.model).as_ref());
             }
-            // not on a fluent and thus no need to update the required_values
-            ConditionConstraint::Eq(_, _) => {}
-            ConditionConstraint::Neq(_, _) => {}
+            ConditionConstraint::EqZero(_) => {} // TODO: are those handled in reifications?
+            ConditionConstraint::NeqZero(_) => {}
+            ConditionConstraint::LeqZero(_) => {} //TODO
         }
     }
     Ok(constraint)
 }
 
 pub fn convert_effect(
-    x: &planx::Effect,
+    effect: &planx::Effect,
     transition_time: bool,
     model: &Model,
     sched: &mut Sched,
     bindings: &Scope,
 ) -> Res<timelines::Effect> {
-    assert!(x.universal_quantification.is_empty());
-    let x = &x.effect_expression;
-    assert!(x.condition.is_none());
+    if !effect.universal_quantification.is_empty() || effect.effect_expression.condition.is_some() {
+        return model.env.node(effect).todo("Unsupported").failed();
+    }
+    let x = &effect.effect_expression;
     let t = reify_timing(x.timing, model, sched, bindings)?;
     let args: Vec<SymAtom> = x
         .state_variable
@@ -149,19 +168,18 @@ pub fn convert_effect(
         args,
     };
     let op = match x.operation {
-        planx::EffectOp::Assign(e) => {
-            let val = reify_bool(e, model, sched)?;
-            EffectOp::Assign(val)
-        }
-        _ => todo!(),
+        planx::EffectOp::Assign(v) => EffectOp::Assign(reify_expression_to_term(v, Some(t), model, sched, bindings)?),
+        planx::EffectOp::Increase(v) => EffectOp::Step(reify_expression_to_term(v, Some(t), model, sched, bindings)?),
+        planx::EffectOp::Decrease(v) => EffectOp::Step(-reify_expression_to_term(v, Some(t), model, sched, bindings)?),
     };
     let eff = timelines::Effect {
         transition_start: t,
-        transition_end: if transition_time { t + FAtom::EPSILON } else { t },
+        transition_end: if transition_time { t + sched.epsilon } else { t },
         mutex_end: sched.new_timepoint(),
         state_var: sv,
         operation: op,
         prez: bindings.presence,
+        source: bindings.source,
     };
     Ok(eff)
 }
@@ -171,25 +189,30 @@ pub fn add_closed_world_negative_effects(reqs: &RequiredValues, model: &Model, s
     // time at which to place the negative effects. This is -1 so that it can be overrided by an initial effect (at 0).
     let t = Time::from(-1);
 
-    // all state variables that may require a `false` value
+    // all state variables that may require a `0` value, which encodes `false` for predicates
     // we will only place a negative effect for those state variables.
     let req_state_vars = reqs.state_variables(|v| v == 0);
 
     for sv in req_state_vars {
+        if model.env.fluents.get(sv.fluent).return_type != planx::Type::Bool {
+            continue; // this is not a boolean fluent and thus not eligible for the closed world assumption
+        }
         let args: Vec<SymAtom> = sv.params.0.into_iter().map(SymAtom::from).collect_vec();
         let sv = timelines::StateVar {
             fluent: model.env.fluents.get(sv.fluent).name().to_string(),
             args,
         };
         // we manually create the mutex-end since it may have a negative value if canceledd by an initial positive effect
-        let mutex_end: Time = sched.model.new_fvar(-1, INT_CST_MAX, sched.time_scale, "_").into();
+        let mutex_end: Time = sched.model.new_ivar(-1, INT_CST_MAX, "_").into();
         let eff = timelines::Effect {
             transition_start: t,
             transition_end: t,
             mutex_end,
             state_var: sv,
-            operation: EffectOp::Assign(false),
+            operation: EffectOp::FALSE_ASSIGNMENT,
             prez: Lit::TRUE,
+            // no action source as it is part of the problem definition
+            source: None,
         };
         sched.add_effect(eff);
     }
@@ -213,12 +236,13 @@ pub fn convert_to_pddl_set_semantics(effs: Vec<Effect>, sched: &mut Sched) -> Ve
         let possible_overriden_by = |oid: usize, o: &Effect| -> bool {
             let cancellable = match (&e.operation, &o.operation) {
                 // the delete can be overriden by the add (add-after-delete semantics)
-                (EffectOp::Assign(false), EffectOp::Assign(true)) => true,
+                (&EffectOp::FALSE_ASSIGNMENT, &EffectOp::TRUE_ASSIGNMENT) => true,
                 // the two effects are of the same kind, the currend (eid) can be overriden by one appearing earlier in the effect list
-                (EffectOp::Assign(true), EffectOp::Assign(true)) => eid > oid,
-                (EffectOp::Assign(false), EffectOp::Assign(false)) => eid > oid,
+                (&EffectOp::TRUE_ASSIGNMENT, &EffectOp::TRUE_ASSIGNMENT) => eid > oid,
+                (&EffectOp::FALSE_ASSIGNMENT, &EffectOp::FALSE_ASSIGNMENT) => eid > oid,
                 // an add cannot be overriden by a delete
-                (EffectOp::Assign(true), EffectOp::Assign(false)) => false,
+                (&EffectOp::TRUE_ASSIGNMENT, &EffectOp::FALSE_ASSIGNMENT) => false,
+                (_, _) => todo!("Not a boolean state variable or non-constant assignment"), // TODO: make it truly unreachable
             };
 
             cancellable
@@ -227,8 +251,8 @@ pub fn convert_to_pddl_set_semantics(effs: Vec<Effect>, sched: &mut Sched) -> Ve
                 // they can be placed at the same timepoit
                 && sched
                     .model
-                    .var_domain(e.transition_end.num)
-                    .overlaps(&sched.model.var_domain(o.transition_end.num)) // TODO: we ignore the denominator here, which may not be correct in temporal planning
+                    .var_domain(e.transition_end)
+                    .overlaps(&sched.model.var_domain(o.transition_end))
                 // they arguments are compatible
                 && e.state_var
                     .args
@@ -262,7 +286,7 @@ pub fn convert_to_pddl_set_semantics(effs: Vec<Effect>, sched: &mut Sched) -> Ve
             override_conditions.push(sched.model.reify(eq(e.transition_start, overrider.transition_start)));
             // overrider must have the same state variable arguments
             for (a1, a2) in e.state_var.args.iter().zip_eq(overrider.state_var.args.iter()) {
-                override_conditions.push(sched.model.reify(eq(*a1, *a2)));
+                override_conditions.push(lin_eq(*a1, *a2).reified(&mut sched.model));
             }
             let lits = override_conditions.build();
             let cancelled_by = sched.model.reify(ReifExpr::And(lits.into_lits()));
@@ -282,43 +306,128 @@ pub fn convert_to_pddl_set_semantics(effs: Vec<Effect>, sched: &mut Sched) -> Ve
     with_set_semantics
 }
 
-pub fn reify_timing(t: Timestamp, model: &Model, sched: &mut Sched, binding: &Scope) -> Res<FAtom> {
+pub fn reify_timing(t: Timestamp, model: &Model, sched: &mut Sched, binding: &Scope) -> Res<Time> {
     let tp = reify_timeref(t.reference, model, sched, binding)?;
-    if *t.delay.numer() == 0 { Ok(tp) } else { todo!() }
+    if *t.delay.numer() == 0 {
+        Ok(tp)
+    } else {
+        Message::todo("unsupported non-zero delay").failed()
+    }
 }
-pub fn reify_timeref(t: TimeRef, _model: &Model, sched: &Sched, binding: &Scope) -> Res<FAtom> {
+pub fn reify_timeref(t: TimeRef, _model: &Model, sched: &Sched, binding: &Scope) -> Res<Time> {
     match t {
         TimeRef::Origin => Ok(sched.origin),
         TimeRef::Horizon => Ok(sched.horizon),
         TimeRef::ActionStart => Ok(binding.start),
         TimeRef::ActionEnd => Ok(binding.end),
-        _ => todo!("{t:?}"),
+        _ => Message::todo(format!("unsupported timeref {t:?}")).failed(),
     }
 }
 
-pub fn reify_sym(e: ExprId, model: &Model, sched: &mut Sched, binding: &Scope) -> Res<SymAtom> {
+pub fn reify_sym(eid: ExprId, model: &Model, sched: &mut Sched, binding: &Scope) -> Res<SymAtom> {
+    reify_expression(eid, None, model, sched, binding).and_then(|e| flatten_expression(eid, e, model, sched, binding))
+}
+
+pub fn reify_constant(e: ExprId, model: &Model, sched: &mut Sched, scope: &Scope) -> Res<IntCst> {
+    let reif = reify_expression(e, None, model, sched, scope)?;
+    let reif = flatten_expression(e, reif, model, sched, scope)?;
+    let cst = IntCst::try_from(reif).map_err(|_| model.env.node(e).todo("non constant term unsupported"))?;
+    Ok(cst)
+}
+
+pub fn reify_expression_to_term(
+    e: ExprId,
+    time: Option<Time>,
+    model: &Model,
+    sched: &mut Sched,
+    scope: &Scope,
+) -> Res<IntTerm> {
+    let reif = reify_expression(e, time, model, sched, scope)?;
+    flatten_expression(e, reif, model, sched, scope)
+}
+
+// todo: add required_value!
+pub fn reify_expression(
+    e: ExprId,
+    time: Option<Time>,
+    model: &Model,
+    sched: &mut Sched,
+    binding: &Scope,
+) -> Res<IntExp> {
     let e = model.env.node(e);
+    use planx::Expr::*;
     match e.expr() {
+        Bool(true) => Ok(1.into()),
+        Bool(false) => Ok(0.into()),
+        Real(r) if r.denom() == &1 => {
+            if let Ok(i) = IntCst::try_from(*r.numer()) {
+                Ok(i.into())
+            } else {
+                e.todo(format!("Cannot be converted to an {}", aries::core::INT_TYPE_NAME))
+                    .failed()
+            }
+        }
         planx::Expr::Object(object) => {
             let id = sched
                 .objects
                 .object_id(object.name().canonical_str())
                 .ok_or_else(|| e.invalid("Object has no associated value"))?;
-            Ok(SymAtom::from(id))
+            Ok(id.into())
         }
         planx::Expr::Param(param) => binding
             .args
             .get(param.name().canonical_str())
             .copied()
+            .map(|id| id.into())
             .ok_or_else(|| param.name().invalid("unknown parameter")),
-        _ => todo!(),
+        StateVariable(fluent, args) => {
+            let Some(time) = time else {
+                return e
+                    .invalid("this is a state variable and cannot be interpreted without a temporal context")
+                    .failed();
+            };
+            let fluent = model.env.fluents.get(*fluent);
+            let reified_var = sched
+                .model
+                .new_optional_ivar(INT_CST_MIN, INT_CST_MAX, binding.presence, "");
+            let reified_args = args
+                .iter()
+                .map(|&arg| {
+                    reify_expression(arg, Some(time), model, sched, binding)
+                        .and_then(|arg_expr| flatten_expression(arg, arg_expr, model, sched, binding))
+                })
+                .collect::<Res<Vec<IntTerm>>>()?;
+            let state_var = StateVar {
+                fluent: fluent.name().to_string(),
+                args: reified_args,
+            };
+            let binding = HasValueAt {
+                state_var,
+                value: reified_var.into(),
+                timepoint: time,
+                prez: binding.presence,
+                source: binding.source,
+            };
+            sched.add_constraint(binding);
+            Ok(reified_var.into())
+        }
+        planx::Expr::App(Fun::Plus, args) => {
+            let mut sum = IntExp::zero();
+            for arg in args {
+                sum += reify_expression(*arg, time, model, sched, binding)?;
+            }
+            Ok(sum)
+        }
+        planx::Expr::App(Fun::Minus, args) if args.len() == 2 => {
+            let mut sum = IntExp::zero();
+            sum += reify_expression(args[0], time, model, sched, binding)?;
+            sum -= reify_expression(args[1], time, model, sched, binding)?;
+            Ok(sum)
+        }
+        _ => e.todo(format!("not supported [{e}]")).failed(),
     }
 }
 
-pub fn reify_bool(e: ExprId, model: &Model, _sched: &mut Sched) -> Res<bool> {
-    let e = model.env.node(e);
-    match e.expr() {
-        planx::Expr::Bool(b) => Ok(*b),
-        _ => todo!(),
-    }
+pub fn flatten_expression(eid: ExprId, e: IntExp, model: &Model, _sched: &mut Sched, _binding: &Scope) -> Res<IntTerm> {
+    IntTerm::try_from(e).map_err(|_| model.env.node(eid).todo("cannot be flattened"))
 }
diff --git a/planning/engine/src/encode/constraints.rs b/planning/engine/src/encode/constraints.rs
index 0ad66c89f..e35609819 100644
--- a/planning/engine/src/encode/constraints.rs
+++ b/planning/engine/src/encode/constraints.rs
@@ -1,32 +1,28 @@
-use aries::{
-    model::lang::{
-        expr::{eq, neq},
-        hreif::{BoolExpr, Store},
-    },
-    prelude::*,
-};
-use timelines::{Sched, constraints::HasValueAt};
+use aries::{model::lang::BoolExpr, prelude::*};
+use timelines::{IntExp, constraints::HasValueAt, encoder::SchedEncoder};
 
 /// Constraint representing a condition
 pub enum ConditionConstraint {
     HasValue(HasValueAt),
-    Eq(IAtom, IAtom),
-    Neq(IAtom, IAtom),
+    EqZero(IntExp),
+    NeqZero(IntExp),
+    LeqZero(IntExp),
 }
-impl BoolExpr<Sched> for ConditionConstraint {
-    fn enforce_if(&self, l: Lit, ctx: &Sched, store: &mut dyn Store) {
+impl BoolExpr<SchedEncoder> for ConditionConstraint {
+    fn enforce_if(&self, l: Lit, ctx: &mut SchedEncoder) {
         match self {
-            ConditionConstraint::HasValue(has_value_at) => has_value_at.enforce_if(l, ctx, store),
-            ConditionConstraint::Eq(a, b) => eq(*a, *b).enforce_if(l, ctx, store),
-            ConditionConstraint::Neq(a, b) => neq(*a, *b).enforce_if(l, ctx, store),
+            ConditionConstraint::HasValue(has_value_at) => has_value_at.enforce_if(l, ctx),
+            ConditionConstraint::EqZero(sum) => sum.clone().eq(0).enforce_if(l, ctx),
+            ConditionConstraint::NeqZero(sum) => sum.clone().neq(0).enforce_if(l, ctx),
+            ConditionConstraint::LeqZero(sum) => sum.clone().leq(0).enforce_if(l, ctx),
         }
     }
 
-    fn conj_scope(&self, ctx: &Sched, store: &dyn Store) -> aries::model::lang::hreif::Lits {
+    fn conj_scope(&self, ctx: &SchedEncoder) -> Conjunction {
+        use ConditionConstraint::*;
         match self {
-            ConditionConstraint::HasValue(has_value_at) => has_value_at.conj_scope(ctx, store),
-            ConditionConstraint::Eq(a, b) => eq(*a, *b).conj_scope(ctx, store),
-            ConditionConstraint::Neq(a, b) => neq(*a, *b).conj_scope(ctx, store),
+            HasValue(has_value_at) => has_value_at.conj_scope(ctx),
+            EqZero(sum) | NeqZero(sum) | LeqZero(sum) => sum.conj_scope(ctx),
         }
     }
 }
diff --git a/planning/engine/src/encode/encoding.rs b/planning/engine/src/encode/encoding.rs
new file mode 100644
index 000000000..e0551930f
--- /dev/null
+++ b/planning/engine/src/encode/encoding.rs
@@ -0,0 +1,127 @@
+use std::{collections::BTreeMap, fmt::Display};
+
+use aries::{core::state::Evaluable, prelude::*};
+use itertools::Itertools;
+use planx::ActionRef;
+use timelines::{ConstraintID, IntTerm, Sym, Time, symbols::ObjectDecoder};
+
+use crate::{encode::tags::Tag, plans::Operation};
+
+/// Representation of the encoding that allows reconstructing a solution plan from a valid assignment.
+#[derive(Default)]
+pub struct Encoding {
+    /// All actions instances that may appear in the plan.
+    pub actions: Vec<ActionInstance>,
+    /// Variable encoding the objective value (minimization)
+    pub objective: Option<LinTerm>,
+    /// for each relaxable constraint, stores a constraint tag so that we can later decide if it should be relaxed.
+    pub constraints_tags: BTreeMap<ConstraintID, Tag>,
+}
+
+impl Encoding {
+    pub fn new() -> Self {
+        Encoding {
+            actions: vec![],
+            objective: None,
+            constraints_tags: Default::default(),
+        }
+    }
+
+    pub fn add_action(&mut self, instance: ActionInstance) {
+        self.actions.push(instance);
+    }
+
+    pub fn set_objective(&mut self, objective: impl Into<LinTerm>) {
+        self.objective = Some(objective.into())
+    }
+
+    /// Extracts the plan corresponding to this solution.
+    pub fn plan<'a>(&'a self, solution: &'a Solution) -> Plan<'a> {
+        Plan {
+            encoding: self,
+            solution,
+        }
+    }
+}
+
+/// A plan that can be formatted in the PDDL format.
+pub struct Plan<'a> {
+    encoding: &'a Encoding,
+    solution: &'a Solution,
+}
+
+impl<'a> Display for Plan<'a> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        writeln!(
+            f,
+            "{}",
+            self.encoding
+                .actions
+                .iter()
+                .filter_map(|a| a.evaluate(self.solution))
+                .sorted_by_key(|a| a.start)
+                .format("\n")
+        )
+    }
+}
+
+/// An action instance in the encoding, containing all variables necessary
+/// to determine whether it appears in the solution and its timings and parameters.
+pub struct ActionInstance {
+    pub action_ref: ActionRef,
+    pub prez: Lit,
+    pub start: Time,
+    pub end: Time,
+    pub arguments: Vec<ObjectVar>,
+}
+
+impl Evaluable for ActionInstance {
+    type Value = Operation<Sym>;
+
+    fn evaluate(&self, solution: &Solution) -> Option<Self::Value> {
+        if !solution.entails(self.prez) {
+            return None;
+        }
+        // the presence variable is true, so we can mindlessly evaluate all the sub-expression
+        // that are guaranteed to be present.
+        let start = solution.eval(self.start).unwrap();
+        let duration = solution.eval(self.end).unwrap() - start;
+        Some(Operation {
+            start,
+            duration,
+            action_ref: self.action_ref.clone(),
+            arguments: self
+                .arguments
+                .iter()
+                .map(|arg_var| arg_var.evaluate(solution).unwrap())
+                .collect(),
+            span: None,
+        })
+    }
+}
+
+/// A variable whose domain is a subset of the objects in the problem.
+#[derive(Clone)]
+pub struct ObjectVar {
+    var: IntTerm,
+    decoder: ObjectDecoder,
+}
+
+impl ObjectVar {
+    pub fn new(var: impl Into<IntTerm>, decoder: &ObjectDecoder) -> Self {
+        Self {
+            var: var.into(),
+            decoder: decoder.clone(),
+        }
+    }
+}
+
+impl Evaluable for ObjectVar {
+    type Value = Sym;
+
+    fn evaluate(&self, solution: &Solution) -> Option<Self::Value> {
+        self.var
+            .evaluate(solution)
+            .map(|val| self.decoder.decode(val).unwrap().clone())
+    }
+}
diff --git a/planning/engine/src/encode/required_values.rs b/planning/engine/src/encode/required_values.rs
index e12a3cc28..b9c95fa13 100644
--- a/planning/engine/src/encode/required_values.rs
+++ b/planning/engine/src/encode/required_values.rs
@@ -44,8 +44,7 @@ impl RequiredValues {
             .is_some_and(|b| b.as_ref().overlaps(vbox))
     }
 
-    pub fn may_require_value(&self, fluent: FluentId, value: bool) -> bool {
-        let value = if value { 1 } else { 0 };
+    pub fn may_require_value(&self, fluent: FluentId, value: IntCst) -> bool {
         self.values_by_fluent
             .get(&fluent)
             .is_some_and(|b| b.as_ref().last().unwrap().points().contains(&value))
diff --git a/planning/engine/src/encode/tags.rs b/planning/engine/src/encode/tags.rs
new file mode 100644
index 000000000..906008225
--- /dev/null
+++ b/planning/engine/src/encode/tags.rs
@@ -0,0 +1,55 @@
+use std::collections::BTreeSet;
+
+use planx::{ActionRef, Message, Model, errors::Spanned};
+
+use crate::plans::lifted_plan::LiftedPlan;
+
+/// Tag for a cosntraint imposed in the scheduling model
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone)]
+pub enum Tag {
+    /// Constraint enforcing the i-th goal
+    EnforceGoal(usize),
+    /// Constraint enforcing the given condition of the i-th operator (action in the plan)
+    Support { operator_id: usize, cond: ActionCondition },
+}
+
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone)]
+pub struct ActionCondition {
+    /// Name of the action in which the condition appears
+    pub action: ActionRef,
+    /// Index of the condition in the action.
+    pub condition_id: usize,
+}
+
+/// Extends a base bessage to display all culprits in it.
+pub fn format_culprit_set(mut msg: Message, culprits: &BTreeSet<Tag>, model: &Model, plan: &LiftedPlan) -> Message {
+    for culprit in culprits {
+        match culprit {
+            Tag::EnforceGoal(g) => {
+                let g = &model.goals[*g];
+                let g = model.env.node(g);
+                let annot = g.error("Unsatisfied goal");
+                msg = msg.snippet(annot);
+            }
+            Tag::Support { operator_id, cond } => {
+                let operator = &plan.operations[*operator_id];
+                let annot = operator.error(format!("non applicable (operator #{operator_id})"));
+                msg = msg.snippet(annot);
+                // for all previous operators in the plan, display them if they have span (indicating they were read from a file)
+                for prev in &plan.operations[..*operator_id] {
+                    if let Some(prev_span) = prev.span.as_ref() {
+                        msg = msg.show(prev_span)
+                    }
+                }
+                let action = model.actions.get_action(&cond.action).unwrap();
+                let cond_expr = action.conditions[cond.condition_id].cond;
+                let annot = model
+                    .env
+                    .node(cond_expr)
+                    .info(format!("unsatisfiable condition for operator {operator_id}"));
+                msg = msg.snippet(annot).show(cond.action.span.as_ref().unwrap());
+            }
+        }
+    }
+    msg
+}
diff --git a/planning/engine/src/main.rs b/planning/engine/src/main.rs
index c4ebde1b3..7e1d3a7f9 100644
--- a/planning/engine/src/main.rs
+++ b/planning/engine/src/main.rs
@@ -12,6 +12,7 @@ use planx::{
     errors::*,
     pddl::{self, input::Input},
 };
+use timelines::IntCst;
 
 use crate::repair::RepairOptions;
 
@@ -19,6 +20,9 @@ use crate::repair::RepairOptions;
 #[derive(Parser, Debug)]
 #[command(version, about, long_about = None)]
 struct Args {
+    /// Logging level to use: one of "error", "warn", "info", "debug", "trace"
+    #[structopt(short, long, default_value = "info")]
+    log_level: tracing::Level,
     #[command(subcommand)]
     command: Commands,
 }
@@ -48,6 +52,7 @@ enum Commands {
     /// Domain repair: proposing fixes of a domain based on a valid plan.
     DomRepair(DomRepair),
     FindDomain(FindDomain),
+    FindProblem(FindProblem),
 }
 
 #[derive(Parser, Debug)]
@@ -67,21 +72,42 @@ pub struct ParseDomain {
 }
 
 /// Find the domain of a problem file, from naming conventions.
+///
+/// The file name is printed on the standard output to enable using a command like:
+///
+///     > my-planner `ape find-domain $PROBLEM_FILE` $PROBLEM_FILE
 #[derive(Parser, Debug)]
 pub struct FindDomain {
     /// Path to the problem file
     problem_file: PathBuf,
 }
+/// Find the problem of a plan file, from naming conventions.
+///
+/// The command works similarly to `find-domain` and prints only the file name on the stdout
+/// to enable nesting in other command.
+#[derive(Parser, Debug)]
+pub struct FindProblem {
+    /// Path to the plan file
+    plan_file: PathBuf,
+}
 
 #[derive(Parser, Debug)]
 pub struct Validate {
     /// Expanded to provide command line options to get the plan, problem and domain
     #[command(flatten)]
     plan_pb: PlanAndProblem,
+    /// If set, will print verbose output
+    #[arg(short, long)]
+    verbose: bool,
     /// If set, the plan is expected to be invalid,
     /// The process will exit with error code 1 if the plan is valid.
     #[arg(short, long)]
     invalid: bool,
+    /// If set, the process will exit with error code 1 if the plan's objective value is not the one indicated.
+    ///
+    /// This is primarily intended to enable testing (e.g. that the validator reproduces reference results).
+    #[arg(short, long)]
+    expected_objective: Option<IntCst>,
     #[command(flatten)]
     options: validate::Options,
 }
@@ -111,11 +137,20 @@ pub struct DomRepair {
 
 fn main() -> Res<()> {
     let args = Args::parse();
+    // set up logger
+    let subscriber = tracing_subscriber::fmt()
+        .with_timer(tracing_subscriber::fmt::time::Uptime::from(std::time::Instant::now()))
+        // .without_time() // if activated, no time will be printed on logs (useful for counting events with `counts`)
+        // .with_thread_ids(true)
+        .with_max_level(args.log_level)
+        .finish();
+    tracing::subscriber::set_global_default(subscriber)?;
 
     match &args.command {
         Commands::Parse(command) => parse(command)?,
         Commands::ParseDomain(command) => parse_domain(command)?,
         Commands::FindDomain(command) => find_domain(command)?,
+        Commands::FindProblem(command) => find_problem(command)?,
         Commands::Validate(command) => validate_plan(command)?,
         Commands::OptimizePlan(command) => optimize_plan(command)?,
         Commands::DomRepair(command) => repair(command)?,
@@ -182,25 +217,48 @@ fn find_domain(command: &FindDomain) -> Res<()> {
     }
 }
 
+fn find_problem(command: &FindProblem) -> Res<()> {
+    match pddl::find_problem_of(&command.plan_file) {
+        Ok(path) => {
+            print!("{}", path.display());
+            Ok(())
+        }
+        Err(e) => Err(e),
+    }
+}
+
 fn validate_plan(command: &Validate) -> Res<()> {
     let (dom, pb, plan) = command.plan_pb.parse()?;
 
     // processed model (from planx)
     let model = pddl::build_model(&dom, &pb)?;
     let plan = lifted_plan::parse_lifted_plan(&plan, &model)?;
-    println!("{model}");
-    println!("{plan:?}");
+    if command.verbose {
+        println!("\n===== Model ====\n\n{model}\n");
+        println!("\n===== Plan ====\n\n{plan}\n");
+    }
 
-    let valid = validate::validate(&model, &plan, &command.options)?;
-    if valid {
-        println!("Plan is valid!");
-        if command.invalid {
-            std::process::exit(1);
+    match validate::validate(&model, &plan, &command.options)? {
+        validate::ValidationResult::Valid { objective_value } => {
+            println!("VALID");
+            if command.invalid {
+                std::process::exit(1);
+            }
+            match (command.expected_objective, objective_value) {
+                (Some(_exptected), None) => {
+                    return Message::error("expected an objective value to be computed").failed();
+                }
+                (Some(exptected), Some(computed)) if exptected != computed => {
+                    return Message::error(format!("expected an objective value of {exptected}")).failed();
+                }
+                (_, _) => {}
+            }
         }
-    } else {
-        println!("INVALID plan!");
-        if !command.invalid {
-            std::process::exit(1);
+        validate::ValidationResult::Invalid => {
+            println!("INVALID");
+            if !command.invalid {
+                std::process::exit(1);
+            }
         }
     }
     Ok(())
@@ -213,10 +271,9 @@ fn optimize_plan(command: &OptimizePlan) -> Res<()> {
     let model = pddl::build_model(&dom, &pb)?;
     let plan = lifted_plan::parse_lifted_plan(&plan, &model)?;
     println!("{model}");
-    println!("{plan:?}");
+    println!("\n===== Plan ====\n\n{plan}\n");
 
-    optimize_plan::optimize_plan(&model, &plan, &command.options)?;
-    todo!()
+    optimize_plan::optimize_plan(&model, &plan, &command.options)
 }
 
 fn repair(command: &DomRepair) -> Res<()> {
@@ -283,6 +340,10 @@ impl PlanAndProblem {
             &pddl::find_domain_of(pb)?
         };
 
+        println!("> Domain: {}", dom.display());
+        println!("> Problem: {}", pb.display());
+        println!("> Plan: {}", plan.display());
+
         // raw PDDL model
         let dom = pddl::parse_pddl_domain(Input::from_file(dom)?)?;
         let pb = pddl::parse_pddl_problem(Input::from_file(pb)?)?;
diff --git a/planning/engine/src/optimize_plan.rs b/planning/engine/src/optimize_plan.rs
index 44052d97b..d384b5ec8 100644
--- a/planning/engine/src/optimize_plan.rs
+++ b/planning/engine/src/optimize_plan.rs
@@ -1,58 +1,88 @@
 use std::{collections::BTreeMap, time::Instant};
 
-use aries::prelude::*;
+use aries::{
+    core::state::Evaluable,
+    model::lang::{IntExpr, Store},
+    prelude::*,
+};
 use aries_plan_engine::{
-    encode::{required_values::RequiredValues, *},
+    encode::{
+        encoding::{ActionInstance, Encoding, ObjectVar},
+        required_values::RequiredValues,
+        tags::{ActionCondition, Tag, format_culprit_set},
+        *,
+    },
     plans::lifted_plan::{self, LiftedPlan},
 };
 use derive_more::derive::Display;
 use itertools::Itertools;
 use planx::{ActionRef, Model, Param, Res, Sym, errors::*};
-use timelines::{ConstraintID, SymAtom, Time, boxes::Segment, explain::ExplainableSolver};
+use timelines::{
+    ConstraintID, IntExp, IntTerm, Sched, SymAtom, Task, Time, boxes::Segment, explain::ExplainableSolver,
+};
 
-pub type RelaxableConstraint = ();
+pub type RelaxableConstraint = Tag;
 
 #[derive(clap::Args, Debug, Clone)]
 pub struct Options {
     #[arg(short, long, num_args(1..))]
     pub relaxation: Vec<Relaxation>,
 
-    #[arg(short, long, default_value("plan-length"))]
+    #[arg(short, long, default_value("original"))]
     pub objective: Objective,
 }
 
-#[derive(clap::ValueEnum, Debug, Clone, Copy, Display)]
+#[derive(clap::ValueEnum, Debug, Clone, Copy, Display, PartialEq, PartialOrd, Eq, Ord)]
 pub enum Relaxation {
     ActionPresence,
+    StartTime,
 }
 
-#[derive(clap::ValueEnum, Debug, Clone, Copy, Display)]
+#[derive(clap::ValueEnum, Debug, Clone, Copy, Display, PartialEq, Eq, PartialOrd, Ord)]
 pub enum Objective {
+    /// The objective value defined in the domain
+    Original,
     PlanLength,
+    Makespan,
 }
 
 pub fn optimize_plan(model: &Model, plan: &LiftedPlan, options: &Options) -> Res<()> {
     let start = Instant::now();
-    let mut solver = encode_plan_optimization_problem(model, plan, options)?;
+    let (mut solver, encoding, _sched) = encode_plan_optimization_problem(model, plan, options)?;
 
     let _encoding_time = start.elapsed().as_millis();
 
-    if solver.check_satisfiability() {
-        println!("Plan is valid.");
-        return Ok(());
+    let objective = encoding.objective.unwrap(); //TODO: error message
+
+    let print = |sol: &Solution| {
+        println!("==== 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:");
+        print(&solution);
+        // _sched.print(&solution);
     } else {
-        println!("Invalid plan");
+        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");
+        }
     }
-    todo!()
+    Ok(())
 }
 
 pub fn encode_plan_optimization_problem(
     model: &Model,
     lifted_plan: &LiftedPlan,
-    _options: &Options, // TODO: use those
-) -> Res<ExplainableSolver<RelaxableConstraint>> {
+    options: &Options,
+) -> Res<(ExplainableSolver<RelaxableConstraint>, Encoding, Sched)> {
+    let mut encoding = Encoding::new();
+
     // build encoding of all objects: associates each object to a int value and each type to a range of values
     let objs = types(model);
+    let object_decoder = objs.decoder();
     let mut sched = timelines::Sched::new(1, objs);
 
     let global_scope = Scope::global(&sched);
@@ -88,7 +118,7 @@ pub fn encode_plan_optimization_problem(
     // initial processing of all operations
     // we create its scope (binding of timepoints, params, ...) and process its conditions
     // Effects are defered to a later point
-    for op in lifted_plan.operations.iter() {
+    for (op_id, op) in lifted_plan.operations.iter().enumerate() {
         // corresponding action in the model
         let a = model
             .actions
@@ -100,16 +130,16 @@ pub fn encode_plan_optimization_problem(
         for (param, arg) in a.parameters.iter().zip(op.arguments.iter()) {
             let arg = match arg {
                 // ground parameter, get the corresponding object constant
-                lifted_plan::OperationArg::Ground(object) => sched
+                lifted_plan::ObjectOrVariable::Ground(object) => sched
                     .objects
                     .object_atom(object.name().canonical_str())
                     .ok_or_else(|| object.name().invalid("unknown object"))?,
                 // variable parameter, retrieve the variable we created for it
-                lifted_plan::OperationArg::Variable { name } => plan_variables[name],
+                lifted_plan::ObjectOrVariable::Variable { name } => plan_variables[name],
             };
 
             // incorpare the potential values taken by this operation param into the one of the action
-            let seg = Segment::from(sched.model.int_bounds(arg));
+            let seg = Segment::from(sched.model.bounds(arg));
             actions_instanciations
                 .entry((a.name.clone(), param.clone()))
                 .or_insert(seg)
@@ -118,21 +148,65 @@ pub fn encode_plan_optimization_problem(
             // add argument to the bindings
             args.insert(&param.name, arg);
         }
-
+        let presence = if options.relaxation.contains(&Relaxation::ActionPresence) {
+            sched.model.new_literal(Lit::TRUE)
+        } else {
+            Lit::TRUE
+        };
+        let start = if options.relaxation.contains(&Relaxation::StartTime) {
+            sched.new_opt_timepoint(presence)
+        } else {
+            Time::from(op.start)
+        };
+        assert_eq!(op.duration, 0, "we use the start as end");
+        let end = start;
+
+        // record a task in `Sched` which
+        //  - gives a task id (use by the condition enforcement constraints to enforce mutex conditions)
+        //  - make the scheduler aware of the tasks when computing the makespan.
+        let task_id = sched.add_task(Task {
+            name: format!("op{op_id}"),
+            start,
+            end,
+            presence,
+        });
         let bindings = Scope {
-            start: Time::from(op.start), // start time is the index of the action in the plan
-            end: Time::from(op.start + op.duration),
-            presence: Lit::TRUE, // TODO: action is necessarily present!!
+            start,
+            end,
+            presence,
             args,
+            source: Some(task_id),
         };
+        // add the action to the encoding so we can retrieve it later
+        encoding.add_action(ActionInstance {
+            action_ref: a.name.clone(),
+            prez: bindings.presence,
+            start: bindings.start,
+            end: bindings.end,
+            arguments: a
+                .parameters
+                .iter()
+                .map(|param| ObjectVar::new(bindings.args[&param.name], &object_decoder))
+                .collect(),
+        });
 
         // for each condition, create a constraint stating it should hold. The constraint is tagged so we can later deactivate it
-        for c in a.conditions.iter() {
+        for (cond_id, c) in a.conditions.iter().enumerate() {
             if let Some(tp) = c.interval.as_timestamp() {
                 let constraint =
                     condition_to_constraint(tp, c.cond, model, &mut sched, &bindings, Some(&mut required_values))?;
 
-                sched.add_constraint(constraint);
+                let cid = sched.add_constraint(constraint);
+                encoding.constraints_tags.insert(
+                    cid,
+                    Tag::Support {
+                        operator_id: op_id,
+                        cond: ActionCondition {
+                            action: a.name.clone(),
+                            condition_id: cond_id,
+                        },
+                    },
+                );
             }
         }
 
@@ -140,7 +214,7 @@ pub fn encode_plan_optimization_problem(
         operations_scopes.push((a, bindings));
     }
     // for each goal, add a constraint stating it must hold (the constriant is tagged but not relaxed for domain repair)
-    for x in model.goals.iter() {
+    for (gid, x) in model.goals.iter().enumerate() {
         assert!(x.universal_quantification.is_empty());
         match x.goal_expression {
             planx::SimpleGoal::HoldsDuring(time_interval, expr_id) => {
@@ -154,7 +228,8 @@ pub fn encode_plan_optimization_problem(
                         Some(&mut required_values),
                     )?;
 
-                    sched.add_constraint(constraint);
+                    let cid = sched.add_constraint(constraint);
+                    encoding.constraints_tags.insert(cid, Tag::EnforceGoal(gid));
                 } else {
                     todo!("durative goal")
                 }
@@ -180,25 +255,71 @@ pub fn encode_plan_optimization_problem(
 
         // vec to accumulate all effects of the action.
         // these will then be post-processed to match the set-based semantics of PDDL (add-after-delete, ...)
-        let mut action_effects = Vec::with_capacity(64);
+        let mut action_effects = Vec::with_capacity(16);
+        // store the effects on predicates independently at first because they will need post-processing
+        let mut predicate_action_effects = Vec::with_capacity(16);
 
         // add an effect to the scheduling problem for each effect in the action template
         // the presence of the effect is controlled by the global enabler of the effect in the template
         for x in a.effects.iter() {
             let eff = convert_effect(x, true, model, &mut sched, bindings)?;
-            // replace the effect presence by its enabler
-            assert_eq!(eff.prez, Lit::TRUE);
-            action_effects.push(eff);
+            // store the effect either in hte global pool or in the predicate specific one
+            let is_predicate = model
+                .env
+                .fluents
+                .get(x.effect_expression.state_variable.fluent)
+                .return_type
+                == planx::Type::Bool;
+            if is_predicate {
+                predicate_action_effects.push(eff);
+            } else {
+                action_effects.push(eff);
+            }
         }
 
-        // post process the effect to align them with PDDL semantics
-        let action_effects = convert_to_pddl_set_semantics(action_effects, &mut sched);
+        // post process the effects on predicates to align them with PDDL semantics
+        let predicate_action_effects = convert_to_pddl_set_semantics(predicate_action_effects, &mut sched);
+
+        // merge the post-processed effects on predicate in the global effect set
+        action_effects.extend(predicate_action_effects);
         for eff in action_effects {
             sched.add_effect(eff);
         }
     }
 
-    let constraint_to_repair = |_cid: ConstraintID| None;
+    let objective: LinTerm = match options.objective {
+        Objective::Original if model.metric.is_some() => {
+            // TODO: is if let guard when stabilized
+            let metric = model.metric.unwrap();
+            match metric {
+                planx::Metric::Minimize(expr_id) => {
+                    let lin_obj = reify_expression(expr_id, Some(sched.horizon), model, &mut sched, &global_scope)?;
+                    flatten_expression(expr_id, lin_obj, model, &mut sched, &global_scope)?
+                }
+                planx::Metric::Maximize(_) => {
+                    return Message::error("unsupported maximization metric").failed();
+                }
+            }
+        }
+        // use plan-length as default when no metric is specified
+        Objective::PlanLength | Objective::Original => {
+            let mut sum = IntExp::zero();
+            for (_a, scope) in &operations_scopes {
+                let action_prez = scope.presence;
+                sum += timelines::constraints::bool2int(action_prez, &mut sched.model)
+            }
+            reify_sum(sum, &mut sched)
+        }
+        Objective::Makespan => sched.makespan.into(),
+    };
+    encoding.set_objective(objective);
+
+    let tags = encoding.constraints_tags.clone();
+    let constraint_to_repair = |cid: ConstraintID| tags.get(&cid).cloned();
+
+    Ok((sched.explainable_solver(constraint_to_repair), encoding, sched))
+}
 
-    Ok(sched.explainable_solver(constraint_to_repair))
+fn reify_sum(sum: IntExp, model: &mut Sched) -> IntTerm {
+    sum.reify(sum.conj_scope(&model), &mut model.model)
 }
diff --git a/planning/engine/src/plans.rs b/planning/engine/src/plans.rs
index 29b09e634..1a1f615f6 100644
--- a/planning/engine/src/plans.rs
+++ b/planning/engine/src/plans.rs
@@ -1 +1,4 @@
 pub mod lifted_plan;
+mod operation;
+
+pub use operation::*;
diff --git a/planning/engine/src/plans/lifted_plan.rs b/planning/engine/src/plans/lifted_plan.rs
index 73d1c84f9..fce4ce2a0 100644
--- a/planning/engine/src/plans/lifted_plan.rs
+++ b/planning/engine/src/plans/lifted_plan.rs
@@ -1,32 +1,40 @@
-use std::collections::BTreeMap;
+use std::{collections::BTreeMap, fmt::Display};
 
-use planx::{ActionRef, Model, Res, Sym, errors::Span};
+use itertools::Itertools;
+use planx::{Model, Res, Sym};
 use timelines::IntCst;
 
+use crate::plans::Operation;
+
 #[derive(Debug, Clone)]
 pub struct LiftedPlan {
     /// A set of operations: actions instances with arguments, start times and durations
-    pub operations: Vec<Operation>,
+    pub operations: Vec<Operation<ObjectOrVariable>>,
     /// All variables apprearing in the lifted plan, together with an inferred type (most specific one from all their appearances.)
     pub variables: BTreeMap<Sym, planx::UserType>,
 }
 
-#[derive(Debug, Clone)]
-pub struct Operation {
-    pub start: IntCst,
-    pub duration: IntCst,
-    pub action_ref: ActionRef,
-    pub arguments: Vec<OperationArg>,
-    #[allow(unused)]
-    pub span: Option<Span>,
+impl Display for LiftedPlan {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.operations.iter().format("\n"))
+    }
 }
 
 #[derive(Debug, Clone)]
-pub enum OperationArg {
+pub enum ObjectOrVariable {
     Ground(planx::Object),
     Variable { name: Sym },
 }
 
+impl Display for ObjectOrVariable {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            ObjectOrVariable::Ground(object) => write!(f, "{object}"),
+            ObjectOrVariable::Variable { name } => write!(f, "{name}"),
+        }
+    }
+}
+
 /// Parse a lifted plan into our own representation.
 ///
 /// Note: we take as input a `planx::pddl::Plan` that is essentially a set of SExpr.
@@ -65,7 +73,7 @@ pub fn parse_lifted_plan(plan: &planx::pddl::Plan, model: &Model) -> Res<LiftedP
                         param
                     )));
                 }
-                OperationArg::Ground(obj)
+                ObjectOrVariable::Ground(obj)
             } else if arg.canonical_str().starts_with("?") {
                 // variable: compute its as the most specific between its previous one and the parameter of the action
                 let prev_type = variables.get(arg).unwrap_or(&top_type);
@@ -82,7 +90,7 @@ pub fn parse_lifted_plan(plan: &planx::pddl::Plan, model: &Model) -> Res<LiftedP
                 };
                 // reinsert the variable with the new type
                 variables.insert(arg.clone(), tpe.clone());
-                OperationArg::Variable { name: arg.clone() }
+                ObjectOrVariable::Variable { name: arg.clone() }
             } else {
                 return Err(arg.invalid("cannot interpret argument: not a known object nor a variable"));
             };
diff --git a/planning/engine/src/plans/operation.rs b/planning/engine/src/plans/operation.rs
new file mode 100644
index 000000000..5d4a37b2f
--- /dev/null
+++ b/planning/engine/src/plans/operation.rs
@@ -0,0 +1,50 @@
+use std::fmt::Display;
+
+use itertools::Itertools;
+use planx::{
+    ActionRef,
+    errors::{Span, Spanned},
+};
+use timelines::IntCst;
+
+/// Absolute time, associated to an operation start/end
+pub type Instant = IntCst;
+
+/// Duration (difference between two instants)
+pub type Duration = IntCst;
+
+/// An operation in a plan, typically a grounding of an action.
+///
+/// The type of the action's arguments is generic to allow representing
+/// input plans and output plans.
+///
+/// Can be displayed in the PDDL plan format if `OperationArg: Display`
+#[derive(Debug, Clone)]
+pub struct Operation<OperationArg> {
+    pub start: Instant,
+    pub duration: Duration,
+    pub action_ref: ActionRef,
+    pub arguments: Vec<OperationArg>,
+    #[allow(unused)]
+    pub span: Option<Span>,
+}
+
+impl<Arg: Display> Display for Operation<Arg> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{:>4}: ({}{}{}) [{}]",
+            self.start,
+            self.action_ref,
+            if self.arguments.is_empty() { "" } else { " " },
+            self.arguments.iter().format(" "),
+            self.duration
+        )
+    }
+}
+
+impl<Arg: Display> Spanned for Operation<Arg> {
+    fn span(&self) -> Option<&Span> {
+        self.span.as_ref()
+    }
+}
diff --git a/planning/engine/src/repair.rs b/planning/engine/src/repair.rs
index 143c14bc7..fc0e3441a 100644
--- a/planning/engine/src/repair.rs
+++ b/planning/engine/src/repair.rs
@@ -7,10 +7,7 @@ use std::{
     time::Instant,
 };
 
-use aries::model::{
-    extensions::DomainsExt,
-    lang::{FAtom, hreif::Store},
-};
+use aries::model::{extensions::DomainsExt, lang::Store};
 use aries::prelude::*;
 use aries_plan_engine::{
     encode::*,
@@ -19,7 +16,7 @@ use aries_plan_engine::{
 use derive_more::derive::Display;
 use itertools::Itertools;
 use planx::{ActionRef, FluentId, Message, Model, Param, Res, Sym, errors::Spanned};
-use timelines::{ConstraintID, EffectOp, Sched, SymAtom, Time, boxes::Segment, explain::ExplainableSolver};
+use timelines::{ConstraintID, EffectOp, Sched, SymAtom, Task, Time, boxes::Segment, explain::ExplainableSolver};
 
 use crate::{
     ctags::{ActionCondition, ActionEffect, CTag, PotentialEffect, Repair},
@@ -65,7 +62,7 @@ pub fn domain_repair(model: &Model, plan: &LiftedPlan, options: &RepairOptions)
     let mut solver = encode_dom_repair(model, plan)?;
     let encoding_time = start.elapsed().as_millis();
 
-    if solver.check_satisfiability() {
+    if solver.check_satisfiability().is_some() {
         println!("Plan is valid.");
         return Ok(RepairReport {
             status: RepairStatus::ValidPlan,
@@ -187,16 +184,16 @@ fn encode_dom_repair(model: &Model, plan: &LiftedPlan) -> Res<ExplainableSolver<
         for (param, arg) in a.parameters.iter().zip(op.arguments.iter()) {
             let arg = match arg {
                 // ground parameter, get the corresponding object constant
-                lifted_plan::OperationArg::Ground(object) => sched
+                lifted_plan::ObjectOrVariable::Ground(object) => sched
                     .objects
                     .object_atom(object.name().canonical_str())
                     .ok_or_else(|| object.name().invalid("unknown object"))?,
                 // variable parameter, retrieve the variable we created for it
-                lifted_plan::OperationArg::Variable { name } => plan_variables[name],
+                lifted_plan::ObjectOrVariable::Variable { name } => plan_variables[name],
             };
 
             // incorpare the potential values taken by this operation param into the one of the action
-            let seg = Segment::from(sched.model.int_bounds(arg));
+            let seg = Segment::from(sched.model.bounds(arg));
             actions_instanciations
                 .entry((a.name.clone(), param.clone()))
                 .or_insert(seg)
@@ -205,12 +202,25 @@ fn encode_dom_repair(model: &Model, plan: &LiftedPlan) -> Res<ExplainableSolver<
             // add argument to the bindings
             args.insert(&param.name, arg);
         }
+        // start time is the index of the action in the plan
+        let start = Time::from(op.start);
+        let end = Time::from(op.start + op.duration);
+        // action is necessarily present
+        let presence = Lit::TRUE;
+
+        let task_id = sched.add_task(Task {
+            name: format!("operation{op_id}"),
+            start,
+            end,
+            presence,
+        });
 
         let bindings = Scope {
-            start: Time::from(op.start), // start time is the index of the action in the plan
-            end: Time::from(op.start + op.duration),
-            presence: Lit::TRUE, // action is necessarily present
+            start,
+            end,
+            presence,
             args,
+            source: Some(task_id),
         };
 
         // for each condition, create a constraint stating it should hold. The constraint is tagged so we can later deactivate it
@@ -309,9 +319,9 @@ fn encode_dom_repair(model: &Model, plan: &LiftedPlan) -> Res<ExplainableSolver<
             let enabler = match &eff.effect_expression.operation {
                 planx::EffectOp::Assign(expr_id) => {
                     // hacky way to determine if the effect is positive (will only work for classical planning)
-                    let imposed_value = reify_bool(*expr_id, model, &mut sched)?;
-                    let possibly_detrimental =
-                        required_values.may_require_value(eff.effect_expression.state_variable.fluent, !imposed_value);
+                    let imposed_value = reify_constant(*expr_id, model, &mut sched, &global_scope)?;
+                    let possibly_detrimental = required_values
+                        .may_require_value(eff.effect_expression.state_variable.fluent, 1 - imposed_value);
                     if possibly_detrimental {
                         // effect may delete a precondition, it must be relaxable and we tie its presence to a new literal
                         sched.model.new_literal(Lit::TRUE)
@@ -439,14 +449,16 @@ fn create_potential_effect(
         fluent: model.env.fluents.get(fid).name().to_string(),
         args,
     };
-    let op = EffectOp::Assign(value);
+    let value = if value { 1 } else { 0 };
+    let op = EffectOp::Assign(value.into());
     let eff = timelines::Effect {
         transition_start: t,
-        transition_end: t + FAtom::EPSILON,
+        transition_end: t + sched.epsilon,
         mutex_end: sched.new_timepoint(),
         state_var: sv,
         operation: op,
         prez: enalber,
+        source: bindings.source,
     };
     Ok(eff)
 }
diff --git a/planning/engine/src/validate.rs b/planning/engine/src/validate.rs
index ec46b3258..7f95cce5d 100644
--- a/planning/engine/src/validate.rs
+++ b/planning/engine/src/validate.rs
@@ -1,19 +1,44 @@
-use aries_plan_engine::plans::lifted_plan::LiftedPlan;
-use planx::{Model, Res};
+use aries::core::state::Evaluable;
+use aries_plan_engine::{encode::tags::format_culprit_set, plans::lifted_plan::LiftedPlan};
+use planx::{Message, Model, Res};
 
 use crate::optimize_plan::{self, encode_plan_optimization_problem};
 
 #[derive(clap::Args, Debug, Clone)]
 pub struct Options {}
 
-pub fn validate(model: &Model, plan: &LiftedPlan, _options: &Options) -> Res<bool> {
+pub enum ValidationResult {
+    Valid { objective_value: Option<timelines::IntCst> },
+    Invalid,
+}
+
+pub fn validate(model: &Model, plan: &LiftedPlan, _options: &Options) -> Res<ValidationResult> {
     // we frame the problem as an optimization problem with no relaxation,
     // hence the solver is forced to reproduce the plan
     let opt_options = crate::optimize_plan::Options {
-        relaxation: vec![],                              // no relaxation
-        objective: optimize_plan::Objective::PlanLength, // TODO: change to domain's metric
+        relaxation: vec![],                            // no relaxation
+        objective: optimize_plan::Objective::Original, // TODO: change to domain's metric
     };
-    let mut solver = encode_plan_optimization_problem(model, plan, &opt_options)?;
+    let (mut solver, encoding, _sched) = encode_plan_optimization_problem(model, plan, &opt_options)?;
 
-    Ok(solver.check_satisfiability())
+    if let Some(solution) = solver.check_satisfiability() {
+        println!("> Plan is valid");
+        let objective_value = if let Some(objective) = encoding.objective {
+            let objective_value = objective.evaluate(&solution).unwrap();
+            println!("> Objective: {objective_value}",);
+            Some(objective_value)
+        } else {
+            None
+        };
+        // sched.print(&solution);
+        Ok(ValidationResult::Valid { objective_value })
+    } else {
+        println!("Plan is INVALID!!!!");
+        for mus in solver.muses() {
+            let msg = format_culprit_set(Message::error("INVALID PLAN"), &mus, model, plan);
+            println!("\n{msg}\n");
+        }
+        println!("Plan is INVALID!!!!");
+        Ok(ValidationResult::Invalid)
+    }
 }
diff --git a/planning/planning/src/chronicles/preprocessing/action_rolling.rs b/planning/planning/src/chronicles/preprocessing/action_rolling.rs
index cb9be0443..796d7e8a3 100644
--- a/planning/planning/src/chronicles/preprocessing/action_rolling.rs
+++ b/planning/planning/src/chronicles/preprocessing/action_rolling.rs
@@ -5,7 +5,7 @@ use crate::chronicles::{
     Chronicle, ChronicleLabel, ChronicleTemplate, Condition, Container, Effect, EffectOp, Problem, StateVar, Sub,
     Substitute, Substitution, Time, VarType, TIME_SCALE,
 };
-use aries::core::state::Term;
+use aries::core::views::Term;
 use aries::core::{IntCst, Lit, VarRef, INT_CST_MAX};
 use aries::model::extensions::partial_assignment::{PartialAssignment, PartialAssignmentBuilder};
 use aries::model::lang::linear::LinearSum;
diff --git a/planning/planx/src/effects.rs b/planning/planx/src/effects.rs
index 3116681fb..8b2af8194 100644
--- a/planning/planx/src/effects.rs
+++ b/planning/planx/src/effects.rs
@@ -97,6 +97,7 @@ impl SimpleEffect {
         Effect {
             universal_quantification: vars,
             effect_expression: self,
+            span: None,
         }
     }
 
@@ -104,6 +105,7 @@ impl SimpleEffect {
         Effect {
             universal_quantification: Vec::new(),
             effect_expression: self,
+            span: None,
         }
     }
 }
@@ -130,6 +132,7 @@ pub struct Effect {
     /// Universally quantified variables in the effect expression
     pub universal_quantification: Vec<Param>,
     pub effect_expression: SimpleEffect,
+    pub span: Option<Span>,
 }
 
 impl Effect {
@@ -145,8 +148,15 @@ impl Effect {
         Self {
             universal_quantification: self.universal_quantification,
             effect_expression: self.effect_expression.with_condition(cond),
+            span: self.span,
         }
     }
+
+    /// Set the span of the effect to be the same as `s`
+    pub fn with_span(mut self, s: impl Spanned) -> Self {
+        self.span = s.span().cloned();
+        self
+    }
 }
 
 impl<'a> Display for Env<'a, &Effect> {
@@ -162,3 +172,9 @@ impl<'a> Display for Env<'a, &Effect> {
         Ok(())
     }
 }
+
+impl<'a> Spanned for Env<'a, &Effect> {
+    fn span(&self) -> Option<&Span> {
+        self.elem.span.as_ref()
+    }
+}
diff --git a/planning/planx/src/errors.rs b/planning/planx/src/errors.rs
index 8cdd7e006..4d8cffad6 100644
--- a/planning/planx/src/errors.rs
+++ b/planning/planx/src/errors.rs
@@ -1,6 +1,7 @@
 use std::{
     fmt::{Debug, Display},
     ops::Range,
+    panic::Location,
 };
 
 pub type Res<T> = Result<T, Message>;
@@ -103,6 +104,14 @@ pub trait Spanned: Display {
         }
     }
 
+    /// Creates a debug error message that will also provide the source code location appended to the message.
+    #[track_caller]
+    fn todo(&self, msg: impl ToString) -> Message {
+        let caller = Location::caller();
+        let msg = format!("{} ({}:{})", msg.to_string(), caller.file(), caller.line());
+        self.invalid(msg)
+    }
+
     fn error(&self, message: impl ToString) -> Annot {
         self.annotate(Level::ERROR, message)
     }
@@ -167,6 +176,14 @@ impl Message {
     pub fn error(title: impl ToString) -> Self {
         Self::new(Level::ERROR, title)
     }
+
+    /// Builds an error message with the file:line of the call site
+    #[cold]
+    #[track_caller]
+    pub fn todo(title: impl ToString) -> Self {
+        let caller = Location::caller();
+        Self::error(format!("{} ({}:{}", title.to_string(), caller.file(), caller.line()))
+    }
     #[cold]
     pub fn warning(title: impl ToString) -> Self {
         Self::new(Level::WARNING, title)
diff --git a/planning/planx/src/goals.rs b/planning/planx/src/goals.rs
index 8f8e9c2f5..798a09205 100644
--- a/planning/planx/src/goals.rs
+++ b/planning/planx/src/goals.rs
@@ -2,12 +2,16 @@ use std::fmt::Display;
 
 use itertools::Itertools;
 
-use crate::{Condition, Env, ExprId, Param, RealValue, Sym, TimeInterval, Timestamp};
+use crate::{
+    Condition, Env, ExprId, Param, RealValue, Sym, TimeInterval, Timestamp,
+    errors::{Span, Spanned},
+};
 
 #[derive(Debug, Clone)]
 pub struct Goal {
     pub universal_quantification: Vec<Param>,
     pub goal_expression: SimpleGoal,
+    pub span: Option<Span>,
 }
 
 impl<'a> Display for Env<'a, &Goal> {
@@ -24,6 +28,12 @@ impl<'a> Display for Env<'a, &Goal> {
     }
 }
 
+impl<'a> Spanned for Env<'a, &Goal> {
+    fn span(&self) -> Option<&Span> {
+        self.elem.span.as_ref()
+    }
+}
+
 /// Represents a goal statement (in PDDL goal or constraints).
 ///
 ///  - Regular PDDL goals (expressions that msut hold in the final state) are encoded as
@@ -66,6 +76,7 @@ impl SimpleGoal {
         Goal {
             universal_quantification: vars,
             goal_expression: self,
+            span: None,
         }
     }
 }
diff --git a/planning/planx/src/pddl/convert.rs b/planning/planx/src/pddl/convert.rs
index e7d0aea7c..5f71de9c2 100644
--- a/planning/planx/src/pddl/convert.rs
+++ b/planning/planx/src/pddl/convert.rs
@@ -394,14 +394,14 @@ fn into_effects(
             // stack bindings so that downstream expression know the declared variables
             let bindings = Rc::new(Bindings::stacked(&vars, bindings));
             let effs = into_effects(default_timestamp, quantified_expr, env, &bindings)?;
-            all_effs.extend(effs.into_iter().map(|e| e.with_quantification(&vars)))
+            all_effs.extend(effs.into_iter().map(|e| e.with_quantification(&vars).with_span(expr)))
         } else if let Some([tp, expr]) = expr.as_application("at")
             && let Ok(time) = parse_timestamp(tp)
         {
             // (at end (not (loc r1 l1)))   or   (at 12.3 (loc r1 l2))
             // in the condition we check that we indeed have a valid timepoint because it is common to have also an `at` fluent
             let effs = into_effects(Some(time), expr, env, bindings)?;
-            all_effs.extend(effs);
+            all_effs.extend(effs.into_iter().map(|e| e.with_span(expr)));
         } else if let Some([cond, expr]) = expr.as_application("when") {
             let cond = parse(cond, env, bindings)?;
             let effs = into_effects(default_timestamp, expr, env, bindings)?;
@@ -409,17 +409,16 @@ fn into_effects(
                 if let Some(other_cond) = eff.effect_expression.condition {
                     return Err(env.node(other_cond).invalid("expected second condition"));
                 }
-                all_effs.push(eff.with_condition(cond));
+                all_effs.push(eff.with_condition(cond).with_span(expr));
             }
         } else {
             let Some(time) = default_timestamp else {
                 return Err(expr.invalid("expected temporal qualifier, e.g., (at end ...)"));
             };
             let eff = into_effect(time, expr, env, bindings)?;
-            all_effs.push(eff.not_quantified());
+            all_effs.push(eff.not_quantified().with_span(expr));
         }
     }
-
     Ok(all_effs)
 }
 
@@ -618,16 +617,18 @@ pub fn parse_goal(
     env: &mut Environment,
     bindings: &Rc<Bindings>,
 ) -> Result<Goal, Message> {
-    if let Some([vars, sexpr]) = sexpr.as_application("forall")
+    let mut g = if let Some([vars, sexpr]) = sexpr.as_application("forall")
         && !at_horizon
     {
         // (forall (?x - loc ?y - obj) <constraint>)
         let vars = parse_var_list(vars, env)?;
         let bindings = Rc::new(Bindings::stacked(&vars, bindings));
-        parse_unquantified_goal(sexpr, at_horizon, env, &bindings).map(|g| g.forall(vars))
+        parse_unquantified_goal(sexpr, at_horizon, env, &bindings).map(|g| g.forall(vars))?
     } else {
-        parse_unquantified_goal(sexpr, at_horizon, env, bindings).map(|g| g.forall(vec![]))
-    }
+        parse_unquantified_goal(sexpr, at_horizon, env, bindings).map(|g| g.forall(vec![]))?
+    };
+    g.span = sexpr.span().cloned();
+    Ok(g)
 }
 
 /// Parses a goal (at_horizon=true) of constraint (at_horizon=false), without a forall
diff --git a/planning/planx/src/pddl/parser.rs b/planning/planx/src/pddl/parser.rs
index b9a3551f8..9c962cec8 100644
--- a/planning/planx/src/pddl/parser.rs
+++ b/planning/planx/src/pddl/parser.rs
@@ -48,6 +48,7 @@ pub enum PddlFeature {
     Typing,
     Equality,
     NegativePreconditions,
+    DisjuncivePreconditions,
     UniversalPreconditions,
     ExistentialPreconditions,
     QuantifiedPreconditions,
@@ -75,6 +76,7 @@ impl std::str::FromStr for PddlFeature {
             ":typing" => Ok(PddlFeature::Typing),
             ":equality" => Ok(PddlFeature::Equality),
             ":negative-preconditions" => Ok(PddlFeature::NegativePreconditions),
+            ":disjunctive-preconditions" => Ok(PddlFeature::DisjuncivePreconditions),
             ":universal-preconditions" => Ok(PddlFeature::UniversalPreconditions),
             ":existential-preconditions" => Ok(PddlFeature::ExistentialPreconditions),
             ":quantified-preconditions" => Ok(PddlFeature::QuantifiedPreconditions),
@@ -103,6 +105,7 @@ impl Display for PddlFeature {
             PddlFeature::Typing => ":typing",
             PddlFeature::Equality => ":equality",
             PddlFeature::NegativePreconditions => ":negative-preconditions",
+            PddlFeature::DisjuncivePreconditions => ":disjunctive-preconditions",
             PddlFeature::UniversalPreconditions => ":universal-preconditions",
             PddlFeature::ExistentialPreconditions => ":existential-preconditions",
             PddlFeature::QuantifiedPreconditions => ":quantified-preconditions",
diff --git a/planning/problems/upf/ipc1998-gripper-round1-adl/problem.fd.plan b/planning/problems/upf/ipc1998-gripper-round1-adl/problem.fd.plan
new file mode 100644
index 000000000..fba66a921
--- /dev/null
+++ b/planning/problems/upf/ipc1998-gripper-round1-adl/problem.fd.plan
@@ -0,0 +1,11 @@
+(pick ball1 rooma left)
+(pick ball2 rooma right)
+(move rooma roomb)
+(drop ball1 roomb left)
+(drop ball2 roomb right)
+(move roomb rooma)
+(pick ball3 rooma left)
+(pick ball4 rooma right)
+(move rooma roomb)
+(drop ball3 roomb left)
+(drop ball4 roomb right)
diff --git a/planning/problems/upf/ipc1998-gripper-round1-strips/problem.fd.plan b/planning/problems/upf/ipc1998-gripper-round1-strips/problem.fd.plan
new file mode 100644
index 000000000..fba66a921
--- /dev/null
+++ b/planning/problems/upf/ipc1998-gripper-round1-strips/problem.fd.plan
@@ -0,0 +1,11 @@
+(pick ball1 rooma left)
+(pick ball2 rooma right)
+(move rooma roomb)
+(drop ball1 roomb left)
+(drop ball2 roomb right)
+(move roomb rooma)
+(pick ball3 rooma left)
+(pick ball4 rooma right)
+(move rooma roomb)
+(drop ball3 roomb left)
+(drop ball4 roomb right)
diff --git a/planning/problems/upf/ipc1998-logistics-round2-strips/problem.fd.plan b/planning/problems/upf/ipc1998-logistics-round2-strips/problem.fd.plan
new file mode 100644
index 000000000..6876c747b
--- /dev/null
+++ b/planning/problems/upf/ipc1998-logistics-round2-strips/problem.fd.plan
@@ -0,0 +1,14 @@
+(load_truck package1 truck4 city4_1)
+(drive_truck truck4 city4_1 city4_2 city4)
+(unload_truck package1 truck4 city4_2)
+(load_truck package3 truck1 city1_1)
+(fly_airplane plane1 city2_2 city3_2)
+(drive_truck truck1 city1_1 city1_2 city1)
+(unload_truck package3 truck1 city1_2)
+(load_truck package2 truck1 city1_2)
+(drive_truck truck1 city1_2 city1_1 city1)
+(unload_truck package2 truck1 city1_1)
+(fly_airplane plane1 city3_2 city4_2)
+(load_airplane package1 plane1 city4_2)
+(fly_airplane plane1 city4_2 city3_2)
+(unload_airplane package1 plane1 city3_2)
diff --git a/planning/problems/upf/ipc1998-movie-round1-strips/problem.fd.plan b/planning/problems/upf/ipc1998-movie-round1-strips/problem.fd.plan
new file mode 100644
index 000000000..079181c5b
--- /dev/null
+++ b/planning/problems/upf/ipc1998-movie-round1-strips/problem.fd.plan
@@ -0,0 +1,8 @@
+(get_cheese z1)
+(get_chips c1)
+(get_crackers k1)
+(get_dip d1)
+(get_pop p1)
+(reset_counter)
+(rewind_movie)
+(reset_counter)
diff --git a/planning/problems/upf/ipc1998-mystery-prime-round1-strips/problem.fd.plan b/planning/problems/upf/ipc1998-mystery-prime-round1-strips/problem.fd.plan
new file mode 100644
index 000000000..f617a8108
--- /dev/null
+++ b/planning/problems/upf/ipc1998-mystery-prime-round1-strips/problem.fd.plan
@@ -0,0 +1,5 @@
+(overcome abrasion rest pork uranus venus)
+(feast rest pork lamb alsace quebec)
+(feast rest lamb flounder surrey pennsylvania)
+(feast rest flounder rice pennsylvania alsace)
+(succumb abrasion rest rice uranus venus)
diff --git a/planning/problems/upf/ipc1998-mystery-prime-round2-strips/problem.fd.plan b/planning/problems/upf/ipc1998-mystery-prime-round2-strips/problem.fd.plan
new file mode 100644
index 000000000..ac2c674e4
--- /dev/null
+++ b/planning/problems/upf/ipc1998-mystery-prime-round2-strips/problem.fd.plan
@@ -0,0 +1,5 @@
+(feast love ham cantelope quebec kentucky)
+(overcome prostatitis learning grapefruit earth saturn)
+(feast learning grapefruit ham alsace quebec)
+(feast learning ham cantelope alsace quebec)
+(succumb prostatitis learning cantelope earth saturn)
diff --git a/planning/problems/upf/ipc1998-mystery-round1-strips/problem.fd.plan b/planning/problems/upf/ipc1998-mystery-round1-strips/problem.fd.plan
new file mode 100644
index 000000000..f617a8108
--- /dev/null
+++ b/planning/problems/upf/ipc1998-mystery-round1-strips/problem.fd.plan
@@ -0,0 +1,5 @@
+(overcome abrasion rest pork uranus venus)
+(feast rest pork lamb alsace quebec)
+(feast rest lamb flounder surrey pennsylvania)
+(feast rest flounder rice pennsylvania alsace)
+(succumb abrasion rest rice uranus venus)
diff --git a/planning/problems/upf/ipc2000-blocks-strips-typed/problem.fd.plan b/planning/problems/upf/ipc2000-blocks-strips-typed/problem.fd.plan
new file mode 100644
index 000000000..1846329f0
--- /dev/null
+++ b/planning/problems/upf/ipc2000-blocks-strips-typed/problem.fd.plan
@@ -0,0 +1,6 @@
+(pick_up b)
+(stack b a)
+(pick_up c)
+(stack c b)
+(pick_up d)
+(stack d c)
diff --git a/planning/problems/upf/ipc2000-blocks-strips-untyped/problem.fd.plan b/planning/problems/upf/ipc2000-blocks-strips-untyped/problem.fd.plan
new file mode 100644
index 000000000..1846329f0
--- /dev/null
+++ b/planning/problems/upf/ipc2000-blocks-strips-untyped/problem.fd.plan
@@ -0,0 +1,6 @@
+(pick_up b)
+(stack b a)
+(pick_up c)
+(stack c b)
+(pick_up d)
+(stack d c)
diff --git a/planning/problems/upf/ipc2000-elevator-strips-simple-typed/problem.fd.plan b/planning/problems/upf/ipc2000-elevator-strips-simple-typed/problem.fd.plan
new file mode 100644
index 000000000..03d8ffa50
--- /dev/null
+++ b/planning/problems/upf/ipc2000-elevator-strips-simple-typed/problem.fd.plan
@@ -0,0 +1,4 @@
+(up f0 f1)
+(board f1 p0)
+(down f1 f0)
+(depart f0 p0)
diff --git a/planning/problems/upf/ipc2000-elevator-strips-simple-untyped/problem.fd.plan b/planning/problems/upf/ipc2000-elevator-strips-simple-untyped/problem.fd.plan
new file mode 100644
index 000000000..03d8ffa50
--- /dev/null
+++ b/planning/problems/upf/ipc2000-elevator-strips-simple-untyped/problem.fd.plan
@@ -0,0 +1,4 @@
+(up f0 f1)
+(board f1 p0)
+(down f1 f0)
+(depart f0 p0)
diff --git a/planning/problems/upf/ipc2000-freecell-strips-typed/problem.fd.plan b/planning/problems/upf/ipc2000-freecell-strips-typed/problem.fd.plan
new file mode 100644
index 000000000..7b2abc34e
--- /dev/null
+++ b/planning/problems/upf/ipc2000-freecell-strips-typed/problem.fd.plan
@@ -0,0 +1,9 @@
+(sendtohome_b ha h n1 h0 n0 n2 n3)
+(sendtohome_b da d n1 d0 n0 n3 n4)
+(sendtohome_b d2 d n2 da n1 n4 n5)
+(sendtohome_b h2 h n2 ha n1 n5 n6)
+(sendtofree c2 ca n4 n3)
+(sendtohome ca sa c n1 c0 n0)
+(sendtohome_b sa s n1 s0 n0 n6 n7)
+(sendtohome_b s2 s n2 sa n1 n7 n8)
+(homefromfreecell c2 c n2 ca n1 n3 n4)
diff --git a/planning/problems/upf/ipc2000-freecell-strips-untyped/problem.fd.plan b/planning/problems/upf/ipc2000-freecell-strips-untyped/problem.fd.plan
new file mode 100644
index 000000000..7b2abc34e
--- /dev/null
+++ b/planning/problems/upf/ipc2000-freecell-strips-untyped/problem.fd.plan
@@ -0,0 +1,9 @@
+(sendtohome_b ha h n1 h0 n0 n2 n3)
+(sendtohome_b da d n1 d0 n0 n3 n4)
+(sendtohome_b d2 d n2 da n1 n4 n5)
+(sendtohome_b h2 h n2 ha n1 n5 n6)
+(sendtofree c2 ca n4 n3)
+(sendtohome ca sa c n1 c0 n0)
+(sendtohome_b sa s n1 s0 n0 n6 n7)
+(sendtohome_b s2 s n2 sa n1 n7 n8)
+(homefromfreecell c2 c n2 ca n1 n3 n4)
diff --git a/planning/problems/upf/ipc2002-depots-strips-automatic/problem.fd.plan b/planning/problems/upf/ipc2002-depots-strips-automatic/problem.fd.plan
new file mode 100644
index 000000000..a9867109b
--- /dev/null
+++ b/planning/problems/upf/ipc2002-depots-strips-automatic/problem.fd.plan
@@ -0,0 +1,10 @@
+(lift hoist0 crate1 pallet0 depot0)
+(load hoist0 crate1 truck1 depot0)
+(drive truck1 depot0 distributor0)
+(lift hoist1 crate0 pallet1 distributor0)
+(load hoist1 crate0 truck1 distributor0)
+(unload hoist1 crate1 truck1 distributor0)
+(drive truck1 distributor0 distributor1)
+(unload hoist2 crate0 truck1 distributor1)
+(drop hoist1 crate1 pallet1 distributor0)
+(drop hoist2 crate0 pallet2 distributor1)
diff --git a/planning/problems/upf/ipc2002-driverlog-strips-automatic/problem.fd.plan b/planning/problems/upf/ipc2002-driverlog-strips-automatic/problem.fd.plan
new file mode 100644
index 000000000..9cd76b7e5
--- /dev/null
+++ b/planning/problems/upf/ipc2002-driverlog-strips-automatic/problem.fd.plan
@@ -0,0 +1,7 @@
+(walk driver1 s2 p1_2)
+(walk driver1 p1_2 s1)
+(walk driver1 s1 p1_0)
+(walk driver1 p1_0 s0)
+(board_truck driver1 truck1 s0)
+(drive_truck truck1 s0 s1 driver1)
+(disembark_truck driver1 truck1 s1)
diff --git a/planning/problems/upf/ipc2002-freecell-strips-automatic/problem.fd.plan b/planning/problems/upf/ipc2002-freecell-strips-automatic/problem.fd.plan
new file mode 100644
index 000000000..b2a7c8bd0
--- /dev/null
+++ b/planning/problems/upf/ipc2002-freecell-strips-automatic/problem.fd.plan
@@ -0,0 +1,8 @@
+(sendtohome spadea spade2 spade n1 spade0 n0)
+(sendtohome diamonda hearta diamond n1 diamond0 n0)
+(sendtohome_b hearta heart n1 heart0 n0 n0 n1)
+(sendtohome_b spade2 spade n2 spadea n1 n1 n2)
+(sendtohome heart2 cluba heart n2 hearta n1)
+(sendtohome_b cluba club n1 club0 n0 n2 n3)
+(sendtohome club2 diamond2 club n2 cluba n1)
+(sendtohome_b diamond2 diamond n2 diamonda n1 n3 n4)
diff --git a/planning/problems/upf/ipc2002-rovers-strips-automatic/problem.fd.plan b/planning/problems/upf/ipc2002-rovers-strips-automatic/problem.fd.plan
new file mode 100644
index 000000000..b0d6c5f31
--- /dev/null
+++ b/planning/problems/upf/ipc2002-rovers-strips-automatic/problem.fd.plan
@@ -0,0 +1,10 @@
+(calibrate rover0 camera0 objective1 waypoint3)
+(take_image rover0 waypoint3 objective1 camera0 high_res)
+(communicate_image_data rover0 general objective1 high_res waypoint3 waypoint0)
+(sample_rock rover0 rover0store waypoint3)
+(navigate rover0 waypoint3 waypoint1)
+(navigate rover0 waypoint1 waypoint2)
+(communicate_rock_data rover0 general waypoint3 waypoint2 waypoint0)
+(drop rover0 rover0store)
+(sample_soil rover0 rover0store waypoint2)
+(communicate_soil_data rover0 general waypoint2 waypoint2 waypoint0)
diff --git a/planning/problems/upf/ipc2002-satellite-strips-automatic/problem.fd.plan b/planning/problems/upf/ipc2002-satellite-strips-automatic/problem.fd.plan
new file mode 100644
index 000000000..b31002917
--- /dev/null
+++ b/planning/problems/upf/ipc2002-satellite-strips-automatic/problem.fd.plan
@@ -0,0 +1,9 @@
+(switch_on instrument0 satellite0)
+(turn_to satellite0 groundstation2 phenomenon6)
+(calibrate satellite0 instrument0 groundstation2)
+(turn_to satellite0 phenomenon4 groundstation2)
+(take_image satellite0 phenomenon4 instrument0 thermograph0)
+(turn_to satellite0 phenomenon6 phenomenon4)
+(take_image satellite0 phenomenon6 instrument0 thermograph0)
+(turn_to satellite0 star5 phenomenon6)
+(take_image satellite0 star5 instrument0 thermograph0)
diff --git a/planning/problems/upf/ipc2004-airport-nontemporal-strips/problem.fd.plan b/planning/problems/upf/ipc2004-airport-nontemporal-strips/problem.fd.plan
new file mode 100644
index 000000000..ae05aabe6
--- /dev/null
+++ b/planning/problems/upf/ipc2004-airport-nontemporal-strips/problem.fd.plan
@@ -0,0 +1,8 @@
+(move_seg_rw_0_400_seg_rww_0_50_south_south_medium airplane_cfbeg)
+(move_seg_rww_0_50_seg_tww4_0_50_south_north_medium airplane_cfbeg)
+(move_seg_tww4_0_50_seg_tww3_0_50_north_north_medium airplane_cfbeg)
+(move_seg_tww3_0_50_seg_tww2_0_50_north_north_medium airplane_cfbeg)
+(move_seg_tww2_0_50_seg_tww1_0_200_north_north_medium airplane_cfbeg)
+(move_seg_tww1_0_200_seg_ppdoor_0_40_north_south_medium airplane_cfbeg)
+(move_seg_ppdoor_0_40_seg_pp_0_60_south_south_medium airplane_cfbeg)
+(park_seg_pp_0_60_south airplane_cfbeg)
diff --git a/planning/problems/upf/ipc2004-pipesworld-no-tankage-nontemporal-strips/problem.fd.plan b/planning/problems/upf/ipc2004-pipesworld-no-tankage-nontemporal-strips/problem.fd.plan
new file mode 100644
index 000000000..6e4770278
--- /dev/null
+++ b/planning/problems/upf/ipc2004-pipesworld-no-tankage-nontemporal-strips/problem.fd.plan
@@ -0,0 +1,5 @@
+(pop_unitarypipe s13 b1 a1 a3 b5 lco oca1)
+(push_unitarypipe s12 b5 a1 a2 b4 oca1 lco)
+(push_unitarypipe s13 b2 a1 a3 b1 gasoleo lco)
+(push_unitarypipe s12 b0 a1 a2 b5 oc1b oca1)
+(push_unitarypipe s13 b3 a1 a3 b2 rat_a gasoleo)
diff --git a/planning/problems/upf/ipc2004-pipesworld-tankage-nontemporal-strips/problem.fd.plan b/planning/problems/upf/ipc2004-pipesworld-tankage-nontemporal-strips/problem.fd.plan
new file mode 100644
index 000000000..56b02c3ff
--- /dev/null
+++ b/planning/problems/upf/ipc2004-pipesworld-tankage-nontemporal-strips/problem.fd.plan
@@ -0,0 +1,5 @@
+(pop_unitarypipe s13 b1 a1 a3 b5 lco oca1 ta1_1_oca1 ta3_1_lco)
+(push_unitarypipe s12 b5 a1 a2 b4 oca1 lco ta1_1_oca1 ta2_1_lco)
+(push_unitarypipe s12 b0 a1 a2 b5 oc1b oca1 ta1_1_oc1b ta2_1_oca1)
+(push_unitarypipe s13 b2 a1 a3 b1 gasoleo lco ta1_1_gasoleo ta3_1_lco)
+(push_unitarypipe s13 b3 a1 a3 b2 rat_a gasoleo ta1_1_rat_a ta3_1_gasoleo)
diff --git a/planning/problems/upf/ipc2004-promela-dining-philosophers-strips/problem.fd.plan b/planning/problems/upf/ipc2004-promela-dining-philosophers-strips/problem.fd.plan
new file mode 100644
index 000000000..a069b73c5
--- /dev/null
+++ b/planning/problems/upf/ipc2004-promela-dining-philosophers-strips/problem.fd.plan
@@ -0,0 +1,22 @@
+(activate_trans_philosopher_0_philosopher_forks__pid_wfork_state_1_state_6_0)
+(activate_trans_philosopher_1_philosopher_forks__pid_wfork_state_1_state_6_0)
+(queue_write_philosopher_1_forks__pid_wfork_forks_1__fork_0)
+(advance_empty_queue_tail_forks_1__queue_1_qs_0_qs_0_fork_empty_zero_one_0)
+(perform_trans_philosopher_1_philosopher_forks__pid_wfork_state_1_state_6_0)
+(activate_trans_philosopher_1_philosopher_forks__pid_rfork_state_6_state_3_0)
+(queue_read_philosopher_1_forks__pid_rfork_forks_1__fork_0)
+(advance_queue_head_forks_1__queue_1_qs_0_qs_0_fork_one_zero_0)
+(perform_trans_philosopher_1_philosopher_forks__pid_rfork_state_6_state_3_0)
+(activate_trans_philosopher_1_philosopher_forks____pidp1__2__rfork_state_3_state_4_0)
+(queue_write_philosopher_0_forks__pid_wfork_forks_0__fork_0)
+(advance_empty_queue_tail_forks_0__queue_1_qs_0_qs_0_fork_empty_zero_one_0)
+(perform_trans_philosopher_0_philosopher_forks__pid_wfork_state_1_state_6_0)
+(activate_trans_philosopher_0_philosopher_forks__pid_rfork_state_6_state_3_0)
+(queue_read_philosopher_0_forks__pid_rfork_forks_0__fork_0)
+(advance_queue_head_forks_0__queue_1_qs_0_qs_0_fork_one_zero_0)
+(perform_trans_philosopher_0_philosopher_forks__pid_rfork_state_6_state_3_0)
+(activate_trans_philosopher_0_philosopher_forks____pidp1__2__rfork_state_3_state_4_0)
+(block_read_queue_empty_philosopher_1_forks____pidp1__2__rfork_forks_0__fork_zero_0)
+(block_read_queue_empty_philosopher_0_forks____pidp1__2__rfork_forks_1__fork_zero_0)
+(block_philosopher_0_state_3_philosopher_0)
+(block_philosopher_1_state_3_philosopher_0)
diff --git a/planning/problems/upf/ipc2004-psr-small-strips/problem.fd.plan b/planning/problems/upf/ipc2004-psr-small-strips/problem.fd.plan
new file mode 100644
index 000000000..8c38d512c
--- /dev/null
+++ b/planning/problems/upf/ipc2004-psr-small-strips/problem.fd.plan
@@ -0,0 +1,8 @@
+(wait_cb1)
+(wait_cb1_condeff0_yes)
+(wait_cb1_endof_condeffs)
+(open_sd1)
+(close_cb1)
+(wait_cb1)
+(wait_cb1_condeff0_no_0)
+(wait_cb1_endof_condeffs)
diff --git a/planning/problems/upf/ipc2004-satellite-strips/problem.fd.plan b/planning/problems/upf/ipc2004-satellite-strips/problem.fd.plan
new file mode 100644
index 000000000..b31002917
--- /dev/null
+++ b/planning/problems/upf/ipc2004-satellite-strips/problem.fd.plan
@@ -0,0 +1,9 @@
+(switch_on instrument0 satellite0)
+(turn_to satellite0 groundstation2 phenomenon6)
+(calibrate satellite0 instrument0 groundstation2)
+(turn_to satellite0 phenomenon4 groundstation2)
+(take_image satellite0 phenomenon4 instrument0 thermograph0)
+(turn_to satellite0 phenomenon6 phenomenon4)
+(take_image satellite0 phenomenon6 instrument0 thermograph0)
+(turn_to satellite0 star5 phenomenon6)
+(take_image satellite0 star5 instrument0 thermograph0)
diff --git a/planning/problems/upf/ipc2006-pathways-propositional-strips/problem.fd.plan b/planning/problems/upf/ipc2006-pathways-propositional-strips/problem.fd.plan
new file mode 100644
index 000000000..f91b3b1db
--- /dev/null
+++ b/planning/problems/upf/ipc2006-pathways-propositional-strips/problem.fd.plan
@@ -0,0 +1,6 @@
+(choose_p300_l1_l0)
+(initialize_p300)
+(choose_pcaf_l2_l1)
+(initialize_pcaf)
+(associate_pcaf_p300_pcaf_p300)
+(dummy_action_1_2)
diff --git a/planning/problems/upf/ipc2006-pipesworld-propositional-strips/problem.fd.plan b/planning/problems/upf/ipc2006-pipesworld-propositional-strips/problem.fd.plan
new file mode 100644
index 000000000..1f601ab52
--- /dev/null
+++ b/planning/problems/upf/ipc2006-pipesworld-propositional-strips/problem.fd.plan
@@ -0,0 +1,5 @@
+(pop_unitarypipe_s13_b1_a1_a3_b5_lco_oca1_ta1_1_oca1_ta3_1_lco)
+(push_unitarypipe_s12_b5_a1_a2_b4_oca1_lco_ta1_1_oca1_ta2_1_lco)
+(push_unitarypipe_s13_b2_a1_a3_b1_gasoleo_lco_ta1_1_gasoleo_ta3_1_lco)
+(push_unitarypipe_s12_b0_a1_a2_b5_oc1b_oca1_ta1_1_oc1b_ta2_1_oca1)
+(push_unitarypipe_s13_b3_a1_a3_b2_rat_a_gasoleo_ta1_1_rat_a_ta3_1_gasoleo)
diff --git a/planning/problems/upf/ipc2006-pipesworld-propositional/problem.fd.plan b/planning/problems/upf/ipc2006-pipesworld-propositional/problem.fd.plan
new file mode 100644
index 000000000..56b02c3ff
--- /dev/null
+++ b/planning/problems/upf/ipc2006-pipesworld-propositional/problem.fd.plan
@@ -0,0 +1,5 @@
+(pop_unitarypipe s13 b1 a1 a3 b5 lco oca1 ta1_1_oca1 ta3_1_lco)
+(push_unitarypipe s12 b5 a1 a2 b4 oca1 lco ta1_1_oca1 ta2_1_lco)
+(push_unitarypipe s12 b0 a1 a2 b5 oc1b oca1 ta1_1_oc1b ta2_1_oca1)
+(push_unitarypipe s13 b2 a1 a3 b1 gasoleo lco ta1_1_gasoleo ta3_1_lco)
+(push_unitarypipe s13 b3 a1 a3 b2 rat_a gasoleo ta1_1_rat_a ta3_1_gasoleo)
diff --git a/planning/problems/upf/ipc2006-rovers-propositional-strips/problem.fd.plan b/planning/problems/upf/ipc2006-rovers-propositional-strips/problem.fd.plan
new file mode 100644
index 000000000..a7fed0afe
--- /dev/null
+++ b/planning/problems/upf/ipc2006-rovers-propositional-strips/problem.fd.plan
@@ -0,0 +1,10 @@
+(calibrate_rover0_camera0_objective1_waypoint3)
+(take_image_rover0_waypoint3_objective1_camera0_high_res)
+(communicate_image_data_rover0_general_objective1_high_res_waypoint3_waypoint0)
+(sample_rock_rover0_rover0store_waypoint3)
+(navigate_rover0_waypoint3_waypoint1)
+(navigate_rover0_waypoint1_waypoint2)
+(communicate_rock_data_rover0_general_waypoint3_waypoint2_waypoint0)
+(drop_rover0_rover0store)
+(sample_soil_rover0_rover0store_waypoint2)
+(communicate_soil_data_rover0_general_waypoint2_waypoint2_waypoint0)
diff --git a/planning/problems/upf/ipc2006-rovers-propositional/problem.fd.plan b/planning/problems/upf/ipc2006-rovers-propositional/problem.fd.plan
new file mode 100644
index 000000000..b0d6c5f31
--- /dev/null
+++ b/planning/problems/upf/ipc2006-rovers-propositional/problem.fd.plan
@@ -0,0 +1,10 @@
+(calibrate rover0 camera0 objective1 waypoint3)
+(take_image rover0 waypoint3 objective1 camera0 high_res)
+(communicate_image_data rover0 general objective1 high_res waypoint3 waypoint0)
+(sample_rock rover0 rover0store waypoint3)
+(navigate rover0 waypoint3 waypoint1)
+(navigate rover0 waypoint1 waypoint2)
+(communicate_rock_data rover0 general waypoint3 waypoint2 waypoint0)
+(drop rover0 rover0store)
+(sample_soil rover0 rover0store waypoint2)
+(communicate_soil_data rover0 general waypoint2 waypoint2 waypoint0)
diff --git a/planning/problems/upf/ipc2006-tpp-propositional-strips/problem.fd.plan b/planning/problems/upf/ipc2006-tpp-propositional-strips/problem.fd.plan
new file mode 100644
index 000000000..835310fdc
--- /dev/null
+++ b/planning/problems/upf/ipc2006-tpp-propositional-strips/problem.fd.plan
@@ -0,0 +1,5 @@
+(drive_truck1_depot1_market1)
+(buy_truck1_goods1_market1_level0_level1_level0_level1)
+(load_goods1_truck1_market1_level0_level1_level0_level1)
+(drive_truck1_market1_depot1)
+(unload_goods1_truck1_depot1_level0_level1_level0_level1)
diff --git a/planning/problems/upf/ipc2006-tpp-propositional/problem.fd.plan b/planning/problems/upf/ipc2006-tpp-propositional/problem.fd.plan
new file mode 100644
index 000000000..07bf3dc08
--- /dev/null
+++ b/planning/problems/upf/ipc2006-tpp-propositional/problem.fd.plan
@@ -0,0 +1,5 @@
+(drive truck1 depot1 market1)
+(buy truck1 goods1 market1 level0 level1 level0 level1)
+(load goods1 truck1 market1 level0 level1 level0 level1)
+(drive truck1 market1 depot1)
+(unload goods1 truck1 depot1 level0 level1 level0 level1)
diff --git a/planning/problems/upf/ipc2006-trucks-propositional-strips/problem.fd.plan b/planning/problems/upf/ipc2006-trucks-propositional-strips/problem.fd.plan
new file mode 100644
index 000000000..d9483f751
--- /dev/null
+++ b/planning/problems/upf/ipc2006-trucks-propositional-strips/problem.fd.plan
@@ -0,0 +1,15 @@
+(drive_truck1_l3_l2_t0_t1)
+(load_package1_truck1_a2_l2)
+(drive_truck1_l2_l3_t1_t2)
+(unload_package1_truck1_a2_l3)
+(deliver_package1_l3_t2_t3)
+(drive_truck1_l3_l2_t2_t3)
+(load_package2_truck1_a1_l2)
+(drive_truck1_l2_l1_t3_t4)
+(unload_package2_truck1_a1_l1)
+(deliver_package2_l1_t4_t4)
+(drive_truck1_l1_l2_t4_t5)
+(load_package3_truck1_a1_l2)
+(drive_truck1_l2_l1_t5_t6)
+(unload_package3_truck1_a1_l1)
+(deliver_package3_l1_t6_t6)
diff --git a/planning/problems/upf/ipc2008-openstacks-sequential-optimal-strips/problem.fd.plan b/planning/problems/upf/ipc2008-openstacks-sequential-optimal-strips/problem.fd.plan
new file mode 100644
index 000000000..7f016771d
--- /dev/null
+++ b/planning/problems/upf/ipc2008-openstacks-sequential-optimal-strips/problem.fd.plan
@@ -0,0 +1,18 @@
+(open_new_stack n0 n1)
+(start_order o1 n1 n0)
+(open_new_stack n0 n1)
+(start_order o3 n1 n0)
+(open_new_stack n0 n1)
+(start_order o5 n1 n0)
+(make_product_p5)
+(ship_order_o5 n0 n1)
+(start_order o2 n1 n0)
+(make_product_p1)
+(make_product_p2)
+(ship_order_o2 n0 n1)
+(ship_order_o1 n1 n2)
+(start_order o4 n2 n1)
+(make_product_p4)
+(make_product_p3)
+(ship_order_o4 n1 n2)
+(ship_order_o3 n2 n3)
diff --git a/planning/problems/upf/ipc2008-openstacks-sequential-satisficing-strips/problem.fd.plan b/planning/problems/upf/ipc2008-openstacks-sequential-satisficing-strips/problem.fd.plan
new file mode 100644
index 000000000..7f016771d
--- /dev/null
+++ b/planning/problems/upf/ipc2008-openstacks-sequential-satisficing-strips/problem.fd.plan
@@ -0,0 +1,18 @@
+(open_new_stack n0 n1)
+(start_order o1 n1 n0)
+(open_new_stack n0 n1)
+(start_order o3 n1 n0)
+(open_new_stack n0 n1)
+(start_order o5 n1 n0)
+(make_product_p5)
+(ship_order_o5 n0 n1)
+(start_order o2 n1 n0)
+(make_product_p1)
+(make_product_p2)
+(ship_order_o2 n0 n1)
+(ship_order_o1 n1 n2)
+(start_order o4 n2 n1)
+(make_product_p4)
+(make_product_p3)
+(ship_order_o4 n1 n2)
+(ship_order_o3 n2 n3)
diff --git a/planning/problems/upf/ipc2011-scanalyzer3-d-sequential-optimal/problem.fd.plan b/planning/problems/upf/ipc2011-scanalyzer3-d-sequential-optimal/problem.fd.plan
new file mode 100644
index 000000000..b0bf95ae2
--- /dev/null
+++ b/planning/problems/upf/ipc2011-scanalyzer3-d-sequential-optimal/problem.fd.plan
@@ -0,0 +1,5 @@
+(analyze_4 seg_in_1a seg_in_1b seg_out_1a seg_out_1b car_in_1a car_in_1b car_out_1a car_out_1b)
+(analyze_4 seg_in_1a seg_in_1b seg_out_1a seg_out_1b car_in_1b car_out_1a car_out_1b car_in_1a)
+(analyze_4 seg_in_1a seg_in_1b seg_out_1a seg_out_1b car_out_1a car_out_1b car_in_1a car_in_1b)
+(analyze_4 seg_in_1a seg_in_1b seg_out_1a seg_out_1b car_out_1b car_in_1a car_in_1b car_out_1a)
+(analyze_4 seg_in_1a seg_in_1b seg_out_1a seg_out_1b car_in_1a car_in_1b car_out_1a car_out_1b)
diff --git a/planning/problems/upf/ipc2018-organic-synthesis-sequential-optimal/problem.fd.plan b/planning/problems/upf/ipc2018-organic-synthesis-sequential-optimal/problem.fd.plan
new file mode 100644
index 000000000..88ac0dd79
--- /dev/null
+++ b/planning/problems/upf/ipc2018-organic-synthesis-sequential-optimal/problem.fd.plan
@@ -0,0 +1 @@
+(additionofrohacrossgemdisubstitutedalkene c033 c032 h061 o066 c034 h133 c034 h134 c016)
diff --git a/planning/timelines/Cargo.toml b/planning/timelines/Cargo.toml
index 1b2d1aa2b..b83497a6f 100644
--- a/planning/timelines/Cargo.toml
+++ b/planning/timelines/Cargo.toml
@@ -13,3 +13,4 @@ aries = { path = "../../solver" }
 env_param = { path = "../../env_param" }
 idmap = { workspace = true }
 smallvec = { workspace = true }
+num-rational = { workspace = true }
diff --git a/planning/timelines/src/assignment.rs b/planning/timelines/src/assignment.rs
deleted file mode 100644
index 77b4ad96d..000000000
--- a/planning/timelines/src/assignment.rs
+++ /dev/null
@@ -1,81 +0,0 @@
-use aries::{core::state::Term, prelude::*};
-
-/// Trait representing the capability to be evaluated (to a givn type) when provided a total assignment.
-///
-/// TODO: move to `aries` crate and make superseed the provided methods for all atoms.
-pub trait Evaluable {
-    type Value;
-
-    fn evaluate(&self, value_of_var: impl Fn(VarRef) -> Option<IntCst>) -> Option<Self::Value>;
-}
-
-impl Evaluable for VarRef {
-    type Value = IntCst;
-
-    fn evaluate(&self, value_of_var: impl Fn(VarRef) -> Option<IntCst>) -> Option<Self::Value> {
-        value_of_var(*self)
-    }
-}
-impl Evaluable for SignedVar {
-    type Value = IntCst;
-
-    fn evaluate(&self, value_of_var: impl Fn(VarRef) -> Option<IntCst>) -> Option<Self::Value> {
-        value_of_var(self.variable()).map(|val| val * self.sign())
-    }
-}
-impl Evaluable for Lit {
-    type Value = bool;
-
-    fn evaluate(&self, value_of_var: impl Fn(VarRef) -> Option<IntCst>) -> Option<Self::Value> {
-        self.svar().evaluate(value_of_var).map(|val| val <= self.ub_value())
-    }
-}
-
-impl Evaluable for IVar {
-    type Value = IntCst;
-
-    fn evaluate(&self, value_of_var: impl Fn(VarRef) -> Option<IntCst>) -> Option<Self::Value> {
-        value_of_var(self.variable())
-    }
-}
-impl Evaluable for IAtom {
-    type Value = IntCst;
-
-    fn evaluate(&self, value_of_var: impl Fn(VarRef) -> Option<IntCst>) -> Option<Self::Value> {
-        self.var.evaluate(value_of_var).map(|val| val + self.shift)
-    }
-}
-
-/// Represents a total assignment, i.e., constructing this type is only valid if all variables are bound or absent in the model
-///
-/// TODO: this type should be removed
-pub struct Assignment {
-    sol: Solution,
-}
-
-impl Assignment {
-    pub fn new(doms: &Domains) -> Self {
-        Self {
-            sol: doms.extract_solution(),
-        }
-    }
-    pub fn shared(sol: Solution) -> Self {
-        Self { sol }
-    }
-
-    fn value_of_var(&self, var: VarRef) -> Option<IntCst> {
-        let doms = &self.sol;
-        match doms.present(var) {
-            Some(true) => Some(doms.lb(var)),
-            Some(false) => None,
-            None => panic!("The assignment is not total"),
-        }
-    }
-
-    pub fn eval<V, E>(&self, expr: E) -> Option<V>
-    where
-        E: Evaluable<Value = V>,
-    {
-        expr.evaluate(|v| self.value_of_var(v))
-    }
-}
diff --git a/planning/timelines/src/boxes.rs b/planning/timelines/src/boxes.rs
index 6855f5aad..512ea1cdc 100644
--- a/planning/timelines/src/boxes.rs
+++ b/planning/timelines/src/boxes.rs
@@ -21,6 +21,7 @@ impl Segment {
         Segment { first, last }
     }
 
+    /// A segment that spans all possible values
     pub fn all() -> Self {
         Self {
             first: IntCst::MIN,
@@ -28,10 +29,12 @@ impl Segment {
         }
     }
 
+    /// A segment that contains conly a specific value
     pub fn point(val: IntCst) -> Self {
         Self { first: val, last: val }
     }
 
+    /// A segment with no values.
     pub fn empty() -> Self {
         Self {
             first: IntCst::MAX,
@@ -61,7 +64,7 @@ impl From<(IntCst, IntCst)> for Segment {
     }
 }
 
-type Segments = SmallVec<[Segment; 5]>;
+pub(crate) type Segments = SmallVec<[Segment; 5]>;
 
 #[derive(Clone, Debug)]
 pub struct BBox {
@@ -84,6 +87,10 @@ impl BBox {
     pub fn as_ref<'a>(&'a self) -> BoxRef<'a> {
         BoxRef::new(&self.dimensions)
     }
+
+    pub fn segments(&self) -> &[Segment] {
+        &self.dimensions
+    }
 }
 /// An axis-aligned box, defined by its projection on all dimensions.
 #[derive(Copy, Clone)]
@@ -218,6 +225,10 @@ impl<World: Ord + Clone, Tag> BoxUniverse<World, Tag> {
             .into_iter()
             .flat_map(move |w| w.find_overlapping_with(bx))
     }
+
+    pub fn has_world(&self, world: &World) -> bool {
+        self.worlds.contains_key(world)
+    }
 }
 
 impl<World: Ord + Clone, Tag> Default for BoxUniverse<World, Tag> {
diff --git a/planning/timelines/src/constraints.rs b/planning/timelines/src/constraints.rs
index 79f4c424e..8d3103cdc 100644
--- a/planning/timelines/src/constraints.rs
+++ b/planning/timelines/src/constraints.rs
@@ -1,17 +1,39 @@
+use aries::core::literals::ConjunctionBuilder;
+use aries::model::lang::element::Element;
+use aries::model::lang::exclusive_choice::exclu_choice;
+use aries::model::lang::expr::{And, geq, leq, lin_eq, lin_neq, lt};
+use aries::prelude::*;
 use aries::{
-    core::literals::DisjunctionBuilder,
-    lits,
+    core::{literals::DisjunctionBuilder, views::Dom},
     model::lang::{
-        expr::{and, eq, f_geq, f_leq, neq, or},
-        hreif::{BoolExpr, Store, exclu_choice},
+        expr::{and, eq, or},
+        max::EqMax,
     },
 };
 
-use crate::{
-    boxes::Segment,
-    effects::{Effect, EffectOp},
-    *,
-};
+use crate::{boxes::Segment, effects::EffectOp, *};
+
+/// Constraint that enforces the [`Sched::makespan`] variable to be equal to the
+/// maximum end time of tasks, or zero in the absence of tasks.
+///
+/// It is encorced by default in [`Sched`].
+pub(crate) struct MakespanIsMaxTaskEnd;
+
+impl BoolExpr<SchedEncoder> for MakespanIsMaxTaskEnd {
+    fn enforce_if(&self, l: Lit, ctx: &mut SchedEncoder) {
+        let mut ends = ctx.sched.tasks.iter().map(|t| t.end).collect_vec();
+        ends.push(IAtom::ZERO); // default value when no task is present
+        EqMax::new(ctx.sched.makespan, ends).enforce_if(l, ctx);
+
+        // enforce the horizon to be after the end of all actions
+        leq(ctx.sched.makespan, ctx.sched.horizon).enforce_if(l, ctx);
+    }
+
+    fn conj_scope(&self, _ctx: &SchedEncoder) -> Conjunction {
+        // constraints is always valid (scope of makespan variable)
+        Conjunction::tautology()
+    }
+}
 
 pub struct NoOverlap(Vec<TaskId>);
 impl NoOverlap {
@@ -20,151 +42,378 @@ impl NoOverlap {
     }
 }
 
-impl BoolExpr<Sched> for NoOverlap {
-    fn enforce_if(&self, l: Lit, ctx: &Sched, store: &mut dyn Store) {
+impl BoolExpr<SchedEncoder> for NoOverlap {
+    fn enforce_if(&self, l: Lit, ctx: &mut SchedEncoder) {
         for (i, t1) in self.0.iter().copied().enumerate() {
             for &t2 in &self.0[(i + 1)..] {
-                Mutex(t1, t2).opt_enforce_if(l, ctx, store);
+                Mutex(t1, t2).opt_enforce_if(l, ctx);
             }
         }
     }
 
-    fn conj_scope(&self, _ctx: &Sched, _store: &dyn Store) -> hreif::Lits {
-        lits![]
+    fn conj_scope(&self, _ctx: &SchedEncoder) -> Conjunction {
+        Conjunction::tautology()
     }
 }
 
 pub struct Mutex(TaskId, TaskId);
 
-impl BoolExpr<Sched> for Mutex {
-    fn enforce_if(&self, l: Lit, ctx: &Sched, store: &mut dyn Store) {
-        let t1 = &ctx.tasks[self.0];
-        let t2 = &ctx.tasks[self.1];
-        let exclu = exclu_choice(f_leq(t1.end, t2.start), f_leq(t2.end, t1.start));
-        exclu.opt_enforce_if(l, ctx, store);
+impl BoolExpr<SchedEncoder> for Mutex {
+    fn enforce_if(&self, l: Lit, ctx: &mut SchedEncoder) {
+        let t1 = &ctx.sched.tasks[self.0];
+        let t2 = &ctx.sched.tasks[self.1];
+        let exclu = exclu_choice(leq(t1.end, t2.start), leq(t2.end, t1.start));
+        exclu.opt_enforce_if(l, ctx);
     }
 
-    fn conj_scope(&self, ctx: &Sched, _store: &dyn Store) -> hreif::Lits {
-        aries::lits![ctx.tasks[self.0].presence, ctx.tasks[self.1].presence]
+    fn conj_scope(&self, ctx: &SchedEncoder) -> Conjunction {
+        [ctx.sched.tasks[self.0].presence, ctx.sched.tasks[self.1].presence].into()
     }
 }
 
+/// Ensures all effects are coherent (enforced by default in [`Sched`]).
+///
+/// This requires to conditions
+///  - that no two assignments have overlapping exclusitivity periods
+///  - that every step is within an assignment validity period
 pub(crate) struct EffectCoherence;
 
-impl EffectCoherence {
-    /// Adds the constraint that if `l` is true, then the two effects should be non-overlapping.
-    fn enforce_non_overlapping_if(l: Lit, e: &Effect, e2: &Effect, ctx: &Sched, store: &mut dyn Store) {
-        debug_assert_eq!(e.state_var.fluent, e2.state_var.fluent);
-        let mut disjuncts = DisjunctionBuilder::new();
-        for (x1, x2) in e.state_var.args.iter().zip_eq(e2.state_var.args.iter()) {
-            for opt in neq(*x1, *x2).as_elementary_disjuncts(store) {
-                disjuncts.push(opt.implicant(ctx, store));
-                if disjuncts.tautological() {
-                    return;
-                }
-            }
-        }
-        // put last as we are more likely to be able to short circuit on the parameters
-        disjuncts.push(f_leq(e.mutex_end, e2.transition_start).implicant(ctx, store));
-        disjuncts.push(f_leq(e2.mutex_end, e.transition_start).implicant(ctx, store));
-        disjuncts.push(!e.prez);
-        disjuncts.push(!e2.prez);
-        if !disjuncts.tautological() {
-            or(disjuncts).opt_enforce_if(l, ctx, store);
-        }
-    }
-}
-
-impl BoolExpr<Sched> for EffectCoherence {
-    fn enforce_if(&self, l: Lit, ctx: &Sched, store: &mut dyn Store) {
-        for e in ctx.effects.iter() {
+impl BoolExpr<SchedEncoder> for EffectCoherence {
+    fn enforce_if(&self, l: Lit, ctx: &mut SchedEncoder) {
+        let sched = ctx.sched.clone();
+        for e in sched.effects.iter() {
             // WARN: this is not guarded by the effect presence (assumption is that this is always true in an effect)
-            f_leq(e.transition_start, e.transition_end).opt_enforce_if(l, ctx, store);
+            leq(e.transition_start, e.transition_end).opt_enforce_if(l, ctx);
             // WARN: this is not guarded by the effect presence (assumption is that that the mutex end has the same scope as the effect)
-            f_leq(e.transition_end, e.mutex_end).opt_enforce_if(l, ctx, store);
+            leq(e.transition_end, e.mutex_end).opt_enforce_if(l, ctx);
+
+            // enforce that the horizon is after all effects
+            leq(e.mutex_end, ctx.sched.horizon).opt_enforce_if(l, ctx);
         }
 
-        // two phases coherence enforcement:
+        // two phases coherence enforcement (between assignments only):
         //  - broad phase: computing a bounding box of the space potentially affected by the effect and gather all overlapping boxes
         //  - for any pair of effects with overlapping bounding boxes, add coherence constraints
-        for (eff_id1, eff_id2) in ctx.effects.potentially_interacting_effects() {
-            Self::enforce_non_overlapping_if(l, &ctx.effects[eff_id1], &ctx.effects[eff_id2], ctx, store);
+        for (eff_id1, eff_id2) in sched.effects.potentially_interacting_effects() {
+            // ensure that the interval `(transition_start, mutex_end]` do not overlap
+            let eff1 = &sched.effects[eff_id1];
+            let eff2 = &sched.effects[eff_id2];
+
+            // this phase only concerns assignments
+            let EffectOp::Assign(_) = eff1.operation else {
+                continue;
+            };
+            let EffectOp::Assign(_) = eff2.operation else {
+                continue;
+            };
+            let itv1 = IntervalOnStateVariable {
+                state_var: &eff1.state_var,
+                start: eff1.transition_start + ctx.sched.epsilon,
+                end: eff1.mutex_end,
+                presence: eff1.prez,
+            };
+            let itv2 = IntervalOnStateVariable {
+                state_var: &eff2.state_var,
+                start: eff2.transition_start + ctx.sched.epsilon,
+                end: eff2.mutex_end,
+                presence: eff2.prez,
+            };
+            let exclu = Exclusive { a: &itv1, b: &itv2 };
+            exclu.opt_enforce_if(l, ctx);
+        }
+
+        // for any 'step', ensures that:
+        //  1) it appears in an assignments exclusivity interval
+        //  2) its mutex_end matches this assignments' mutex end
+        // Condition 2) is necessary to make sure that any time at which the step contributes to the state variable value is included in its interval
+        for step in sched.effects.iter() {
+            let EffectOp::Step(_) = step.operation else {
+                continue;
+            };
+            let compatible_assignemnts = ctx
+                .sched
+                .effects
+                .potentially_overlapping_effects(&step.state_var.fluent, step.affected_box(&ctx).as_ref())
+                .filter_map(|eid| {
+                    let eff = &sched.effects[eid];
+                    match eff.operation {
+                        EffectOp::Assign(_) => Some(eff),
+                        EffectOp::Step(_) => None,
+                    }
+                })
+                .collect_vec();
+
+            let mut support_options = DisjunctionBuilder::new();
+
+            for ass in compatible_assignemnts {
+                let mut conjuncts = ConjunctionBuilder::new();
+                conjuncts.push(ass.prez);
+                conjuncts.push(leq(ass.transition_end, step.transition_start).implicant(ctx));
+                // note: this forces the `step` interval to exactly match the end of the assignment
+                conjuncts.push(leq(ass.mutex_end, step.mutex_end).implicant(ctx));
+                conjuncts.push(geq(ass.mutex_end, step.mutex_end).implicant(ctx));
+                for (arg1, arg2) in ass.state_var.args.iter().zip_eq(step.state_var.args.iter()) {
+                    conjuncts.push(lin_eq(*arg1, *arg2).implicant(ctx))
+                }
+                let supports = and(conjuncts.build().into_lits().into_boxed_slice()).implicant(ctx);
+                support_options.push(supports);
+            }
+            // if the step it present, then at least one of the assignment must "support it"
+            support_options.push(!step.prez);
+            support_options.build().enforce_if(l, ctx);
         }
     }
 
-    fn conj_scope(&self, _ctx: &Sched, _store: &dyn Store) -> hreif::Lits {
-        lits![]
+    fn conj_scope(&self, _ctx: &SchedEncoder) -> Conjunction {
+        Conjunction::tautology()
     }
 }
 
 #[derive(Debug)]
 pub struct HasValueAt {
     pub state_var: StateVar,
-    pub value: Atom,
+    pub value: IntTerm,
     pub timepoint: Time,
     /// Presence of the condition. Must imply the presence of all variables appearing in it.
     pub prez: Lit,
+    /// Specifies if this condition originates from a particular task.
+    /// This is used to enforce the PDDL-mutex constraint that specifies
+    /// that an aciton must not rely on a value that is immediately delete by *another* action.
+    /// (mutex conditions).
+    pub source: Option<TaskId>,
 }
 
 impl HasValueAt {
     /// Returns a box capturing when and what may be the value required by this condition.
-    pub fn value_box(&self, dom: impl Fn(IAtom) -> (IntCst, IntCst)) -> crate::boxes::BBox {
+    pub fn value_box(&self, dom: impl Dom) -> crate::boxes::BBox {
         let mut buff = Vec::with_capacity(self.state_var.args.len() + 2);
-        let (earliest, latest) = dom(self.timepoint.num); // TODO: careful with denom
-        buff.push(Segment::new(earliest, latest));
+        buff.push(Segment::from(dom.bounds(self.timepoint)));
         for arg in &self.state_var.args {
-            let (lb, ub) = dom(*arg);
-            buff.push(Segment::new(lb, ub));
+            buff.push(Segment::from(dom.bounds(*arg)));
         }
-        let value_segment = match self.value {
-            Atom::Bool(lit) if lit.tautological() => Segment::new(1, 1),
-            Atom::Bool(lit) if lit.absurd() => Segment::new(0, 0),
-            Atom::Bool(_) => Segment::new(0, 1),
-            _ => todo!(),
-        };
-        buff.push(value_segment);
+        buff.push(Segment::from(dom.bounds(self.value)));
         crate::boxes::BBox::new(buff)
     }
 }
 
-impl BoolExpr<Sched> for HasValueAt {
-    fn enforce_if(&self, l: Lit, ctx: &Sched, store: &mut dyn Store) {
-        let mut options = Vec::with_capacity(4);
+#[derive(Debug)]
+struct StepContributor {
+    contributes: Lit,
+    contribution: IntTerm,
+}
 
-        let value_box = self.value_box(|v| ctx.model.int_bounds(v));
+impl BoolExpr<SchedEncoder> for HasValueAt {
+    fn enforce_if(&self, l: Lit, ctx: &mut SchedEncoder) {
+        let _span = tracing::debug_span!("HasValueAt");
+        let _span = _span.enter();
+        tracing::debug!("{l:?} => {self:?}");
+        // cheap clone to please the borrow checker
+        let sched: std::sync::Arc<Sched> = ctx.sched.clone();
 
-        for eff_id in ctx
+        let value_box = self.value_box(&*ctx);
+
+        // all effects (assign or steps) that may contribute to the value
+        let relevant_effects = sched
             .effects
             .potentially_supporting_effects(&self.state_var.fluent, value_box.as_ref())
-        {
-            let eff = &ctx.effects[eff_id];
-            let EffectOp::Assign(value) = eff.operation;
+            .map(|eff_id| &sched.effects[eff_id])
+            .collect_vec();
+
+        // gather all step effects that may contribute and
+        // create a literal that it is true iff it does contribute
+        //   - effect is present, and
+        //   - condition within activity period, and
+        //   - same state variable
+        let mut step_contributors = Vec::new();
+        for &eff in &relevant_effects {
+            let _span = tracing::debug_span!("Step");
+            let _span = _span.enter();
+            debug_assert_eq!(self.state_var.fluent, eff.state_var.fluent);
+            let EffectOp::Step(step) = eff.operation else {
+                continue;
+            };
+            if step == IntTerm::ZERO {
+                continue;
+            }
+
+            let mut conjuncts = ConjunctionBuilder::new();
+            conjuncts.push(eff.prez);
+            conjuncts.push(geq(self.timepoint, eff.effective_start()).reified(ctx));
+            conjuncts.push(leq(self.timepoint, eff.mutex_end).reified(ctx));
+            for (arg1, arg2) in self.state_var.args.iter().zip_eq(eff.state_var.args.iter()) {
+                conjuncts.push(lin_eq(*arg1, *arg2).reified(ctx))
+            }
+            if !conjuncts.absurd() {
+                let conjuncts: And = and(conjuncts.build().into_lits().into_boxed_slice()); // TODO: make And = Conjunction
+                let contributes = conjuncts.reified(ctx); // presence should be the same as self.presence?
+                step_contributors.push(StepContributor {
+                    contributes,
+                    contribution: step,
+                });
+            }
+        }
+
+        // compute assign establisehrs. Those are exclusive (by effect coherence) so half reification is sufficient
+        let mut establishers = Element::new();
+        for &eff in &relevant_effects {
+            let _span = tracing::debug_span!("Establisher");
+            let _span = _span.enter();
+            debug_assert_eq!(self.state_var.fluent, eff.state_var.fluent);
+            let EffectOp::Assign(assignment) = eff.operation else {
+                continue;
+            };
             if self.state_var.fluent != eff.state_var.fluent {
                 continue;
             }
-            assert_eq!(self.state_var.args.len(), eff.state_var.args.len());
-            let mut conjuncts = vec![
-                eff.prez,
-                f_geq(self.timepoint, eff.effective_start()).implicant(ctx, store),
-                f_leq(self.timepoint, eff.mutex_end).implicant(ctx, store),
-            ];
-            conjuncts.extend(
-                self.state_var
-                    .args
-                    .iter()
-                    .zip(eff.state_var.args.iter())
-                    .map(|(x, y)| eq(*x, *y).implicant(ctx, store)),
-            );
-            conjuncts.push(eq(self.value, Atom::from(value)).implicant(ctx, store));
-
-            if conjuncts.iter().all(|c| *c != Lit::FALSE) {
-                options.push(and(conjuncts.as_slice()).implicant(ctx, store));
+            let mut conjuncts = ConjunctionBuilder::new();
+            conjuncts.push(eff.prez);
+            conjuncts.push(geq(self.timepoint, eff.effective_start()).implicant(ctx));
+            conjuncts.push(leq(self.timepoint, eff.mutex_end).implicant(ctx));
+            for (arg1, arg2) in self.state_var.args.iter().zip_eq(eff.state_var.args.iter()) {
+                conjuncts.push(lin_eq(*arg1, *arg2).implicant(ctx))
+            }
+            if !conjuncts.absurd() {
+                let conjuncts: And = and(conjuncts.build().into_lits().into_boxed_slice()); // TODO: make And = Conjunction
+                let establishes = conjuncts.implicant(ctx); // presence should be the same as self.presence?
+                establishers.add_option(establishes, assignment);
+            }
+        }
+
+        {
+            let _span = tracing::debug_span!("main");
+            let _span = _span.enter();
+            if step_contributors.is_empty() {
+                // there are no steps, we can use self.value as the base_variable (which is equivalent to the previous encoding?)
+                establishers.enforce_eq_if(l, self.value, ctx);
+            } else {
+                // Create a `base_variable` that will take the value of the selected establisher
+                // has a base_variable = alternative { e in assign_establishers }
+                let base_var = establishers.reify([self.prez], ctx);
+
+                // and self.value = base_variable + Sum { step contirbutions }
+                let lhs = IntExp::from(self.value);
+                let mut rhs = IntExp::from(base_var);
+                for step in step_contributors {
+                    if let Ok(contribution) = IntCst::try_from(step.contribution) {
+                        rhs += bool2int(step.contributes, ctx) * contribution;
+                    } else {
+                        let value =
+                            Element::build(&[(step.contributes, step.contribution), (!step.contributes, 0.into())]);
+                        rhs += value.reify([self.prez], ctx)
+                    }
+                }
+                lhs.clone().leq(rhs.clone()).enforce(ctx);
+                lhs.geq(rhs).enforce(ctx);
+            }
+        }
+
+        {
+            let _span = tracing::debug_span!("PDDL Mutex");
+            let _span = _span.enter();
+            // PDDL mutex: a condition of an action cannot rely on a fact that is about to be modified by another action
+            // given the interval `[cond.start, cond.end]`, we ensure it does not meet the interval `[eff.transition_start, eff.transition_end)`
+            // for any effect `eff` with a different source
+            let itv_cond = IntervalOnStateVariable {
+                state_var: &self.state_var,
+                start: self.timepoint,
+                end: self.timepoint,
+                presence: self.prez,
+            };
+            for eff_id in sched
+                .effects
+                .potentially_overlapping_transitions(&self.state_var.fluent, value_box.as_ref())
+            {
+                // TODO: mutex when considering steps?
+                let eff = &sched.effects[eff_id];
+                if eff.source != self.source {
+                    let itv_eff = IntervalOnStateVariable {
+                        state_var: &eff.state_var,
+                        start: eff.transition_start,
+                        end: eff.transition_end - sched.epsilon,
+                        presence: eff.prez,
+                    };
+                    let exclu = Exclusive {
+                        a: &itv_cond,
+                        b: &itv_eff,
+                    };
+                    exclu.opt_enforce_if(l, ctx);
+                }
+            }
+        }
+    }
+
+    fn conj_scope(&self, _ctx: &SchedEncoder) -> Conjunction {
+        [self.prez].into()
+    }
+}
+
+/// A closed interval `[start, end]` associated to a state variable
+#[derive(Debug)]
+struct IntervalOnStateVariable<'a> {
+    state_var: &'a StateVar,
+    start: Time,
+    end: Time,
+    presence: Lit,
+}
+
+/// Enforces that if both intervals are present and on the same state variable,
+/// then their should be an epsilon separation between them:
+///
+/// `!prez1 | !prez2 | sv1 != sv2 | end1 < start2 | end2 < start1`
+///
+/// Note: it assumed that the two state variable share the same fluent (which is only checked in debug mode to avoid costly stirng comparisons)
+struct Exclusive<'a> {
+    a: &'a IntervalOnStateVariable<'a>,
+    b: &'a IntervalOnStateVariable<'a>,
+}
+impl<'a, Ctx: Store + Dom> BoolExpr<Ctx> for Exclusive<'a> {
+    fn enforce_if(&self, l: Lit, ctx: &mut Ctx) {
+        let a = &self.a;
+        let b = &self.b;
+        debug_assert_eq!(
+            a.state_var.fluent, b.state_var.fluent,
+            "To expensive to check here, must be filtered earlier"
+        );
+        let mut disjuncts = DisjunctionBuilder::new();
+        for (x1, x2) in a.state_var.args.iter().zip_eq(b.state_var.args.iter()) {
+            // TODO: this reifies the value even though it could be decomposed into the two disjuncts
+            let opt = lin_neq(*x1, *x2).implicant(ctx);
+            disjuncts.push(opt.implicant(ctx));
+            if disjuncts.tautological() {
+                return;
             }
         }
-        or(options).opt_enforce_if(l, ctx, store);
+        // put last as we are more likely to be able to short circuit on the parameters
+        disjuncts.push(lt(a.end, b.start).implicant(ctx));
+        disjuncts.push(lt(b.end, a.start).implicant(ctx));
+        disjuncts.push(!a.presence);
+        disjuncts.push(!b.presence);
+        if !disjuncts.tautological() {
+            or(disjuncts).opt_enforce_if(l, ctx);
+        }
+    }
+
+    fn conj_scope(&self, _ctx: &Ctx) -> Conjunction {
+        Conjunction::tautology()
     }
+}
 
-    fn conj_scope(&self, _ctx: &Sched, _store: &dyn Store) -> hreif::Lits {
-        lits![self.prez]
+/// Transforms a boolean into an integer expression
+/// NOte: the implementation is currently incomplete
+#[doc(hidden)]
+pub fn bool2int<Ctx: Store + Dom>(b: Lit, model: &mut Ctx) -> IntExp {
+    let is_zero_one = model.bounds(b.variable()) == (0, 1);
+    if model.entails(b) {
+        1.into()
+    } else if model.entails(!b) {
+        0.into()
+    } else if is_zero_one && b == b.variable().geq(1) {
+        b.variable().into()
+    } else if is_zero_one && b == b.variable().leq(0) {
+        IntExp::cst(1) - b.variable()
+    } else {
+        let bvar = model.new_optional_var(0, 1, model.presence_literal(b));
+        eq(bvar.geq(1), b).enforce(model);
+        IntExp::from(bvar)
     }
 }
diff --git a/planning/timelines/src/effects.rs b/planning/timelines/src/effects.rs
index a579dfbf0..90da40ed7 100644
--- a/planning/timelines/src/effects.rs
+++ b/planning/timelines/src/effects.rs
@@ -1,16 +1,12 @@
-use aries::{
-    core::{IntCst, Lit},
-    model::lang::IAtom,
-};
-use smallvec::SmallVec;
+use aries::{core::views::Dom, prelude::*};
 use std::{
     fmt::{Debug, Formatter},
     ops::Index,
 };
 
 use crate::{
-    StateVar, Time,
-    boxes::{BoxRef, BoxUniverse, Segment},
+    IntTerm, StateVar, TaskId, Time,
+    boxes::{BBox, BoxRef, BoxUniverse, Segment},
 };
 
 /// Represents an effect on a state variable.
@@ -33,14 +29,22 @@ pub struct Effect {
     pub operation: EffectOp,
     /// Presence literal indicating whether the effect is present
     pub prez: Lit,
+    /// Specifies if this effect originates from a particular task.
+    /// This is used to enforce the PDDL-mutex constraint that specifies
+    /// that an aciton must not rely on a value that is immediately delete by *another* action.
+    /// (mutex conditions).
+    pub source: Option<TaskId>,
 }
 #[derive(Clone, Eq, PartialEq)]
 pub enum EffectOp {
-    Assign(bool),
+    /// Sets the state variable to an absolute value
+    Assign(IntTerm),
+    /// Increase the state variable by a given value (positive or negative)
+    Step(IntTerm),
 }
 impl EffectOp {
-    // pub const TRUE_ASSIGNMENT: EffectOp = EffectOp::Assign(Atom::TRUE);
-    // pub const FALSE_ASSIGNMENT: EffectOp = EffectOp::Assign(Atom::FALSE);
+    pub const TRUE_ASSIGNMENT: EffectOp = EffectOp::Assign(IntTerm::TRUE);
+    pub const FALSE_ASSIGNMENT: EffectOp = EffectOp::Assign(IntTerm::FALSE);
 }
 impl Debug for EffectOp {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
@@ -48,6 +52,7 @@ impl Debug for EffectOp {
             EffectOp::Assign(val) => {
                 write!(f, ":= {val:?}")
             }
+            EffectOp::Step(v) => write!(f, "+= {v:?}"), // TODO: nicer print of negative constants
         }
     }
 }
@@ -72,6 +77,55 @@ impl Effect {
     pub fn variable(&self) -> &StateVar {
         &self.state_var
     }
+
+    /// Bounding box capturing the space affected by this effect
+    ///
+    /// - `[lb(trans-start), ub(mutex_end)]`
+    /// - `[lb(a), ub(a)]` for a in args
+    pub(crate) fn affected_box(&self, dom: impl Dom) -> crate::boxes::BBox {
+        let mut buff = crate::boxes::Segments::new();
+        buff.push(Segment::new(dom.lb(self.transition_start), dom.ub(self.mutex_end)));
+        buff.extend(self.args_segments(&dom));
+        BBox::new(buff)
+    }
+    /// Returns a box capturing when and what may be the value the effect may help achieve
+    ///
+    /// - `[lb(trans-start), ub(mutex_end)]`
+    /// - `[lb(a), ub(a)]` for a in args
+    /// - `[v, v]` where v is the value in the assignment or step operation
+    pub(crate) fn value_box(&self, dom: impl Dom) -> crate::boxes::BBox {
+        let mut buff = crate::boxes::Segments::new();
+        let start = dom.lb(self.transition_end);
+        let end = dom.ub(self.mutex_end);
+        buff.push(Segment::new(start, end));
+        buff.extend(self.args_segments(&dom));
+        let value_segment = match self.operation {
+            EffectOp::Assign(v) | EffectOp::Step(v) => Segment::from(dom.bounds(v)),
+        };
+        buff.push(value_segment);
+        crate::boxes::BBox::new(buff)
+    }
+
+    /// Returns a box capturing when the effect induces a transition
+    ///
+    /// - `[lb(trans-start), ub(trans-end)[`  (note that the transition is excluded from the segment)
+    /// - `[lb(a), ub(a)]` for a in args
+    pub(crate) fn transition_box(&self, dom: &impl Dom) -> crate::boxes::BBox {
+        let mut buff = crate::boxes::Segments::new();
+        buff.push(Segment::new(
+            dom.lb(self.transition_start),
+            dom.ub(self.transition_end) - 1,
+        ));
+        buff.extend(self.args_segments(&dom));
+        BBox::new(buff)
+    }
+
+    fn args_segments(&self, dom: impl Dom) -> impl Iterator<Item = Segment> {
+        self.state_var
+            .args
+            .iter()
+            .map(move |arg| Segment::from(dom.bounds(arg)))
+    }
 }
 
 pub type EffectId = usize;
@@ -105,17 +159,31 @@ pub struct Effects {
     ///  - value: `[lb(value), ub(value)]`
     ///
     /// If the boxes of two effects to not overlap, they can be safely determined to never overlap (and thus do not require coherence enforcement constraints).
-    achieved_bounding_boxes: BoxUniverse<String, usize>,
+    assignment_bounding_boxes: BoxUniverse<String, usize>,
+    steps_bounding_boxes: BoxUniverse<String, usize>,
+    /// Associates every effect to a `Box` in a universe.
+    /// This box denotes a the set of values that the effect may support.
+    /// The intuition if that
+    ///
+    /// Boxes are partitioned based on their state variables (one world per state variable).
+    /// The box of each effect captures the space-time region it affects with dimesions:
+    ///
+    ///  - time: `[lb(transition_start), ub(transition_end))`
+    ///  - for each parameter p:
+    ///    - `[lb(p), ub(p)]`
+    ///
+    /// If the boxes of two effects to not overlap, they can be safely determined to never overlap (and thus do not require coherence enforcement constraints).
+    transition_bounding_boxes: BoxUniverse<String, usize>,
 }
 
-type Segments = SmallVec<[Segment; 16]>;
-
 impl Effects {
     pub fn new() -> Self {
         Self {
             effects: Default::default(),
             affected_bb: BoxUniverse::new(),
-            achieved_bounding_boxes: BoxUniverse::new(),
+            assignment_bounding_boxes: BoxUniverse::new(),
+            steps_bounding_boxes: BoxUniverse::new(),
+            transition_bounding_boxes: BoxUniverse::new(),
         }
     }
 
@@ -127,52 +195,88 @@ impl Effects {
         &self.effects[eff_id]
     }
 
-    pub fn add_effect(&mut self, eff: Effect, dom: impl Fn(IAtom) -> (IntCst, IntCst)) -> EffectId {
+    pub fn add_effect(&mut self, eff: Effect, dom: impl Dom) -> EffectId {
         // ID of the effect will be the index of the next free slot
         let eff_id = self.effects.len();
 
-        let mut buff = Segments::new();
+        let fluent = &eff.state_var.fluent;
 
         // compute and store affected bounding_box
-        buff.push(Segment::new(dom(eff.transition_start.num).0, dom(eff.mutex_end.num).1)); // TODO: careful with denom
-        for arg in &eff.state_var.args {
-            let (lb, ub) = dom(*arg);
-            buff.push(Segment::new(lb, ub));
-        }
-        self.affected_bb.add_box(&eff.state_var.fluent, &buff, eff_id);
+        let bbox = eff.affected_box(&dom);
+        self.affected_bb.add_box(fluent, bbox.segments(), eff_id);
 
         // compute and store the achievable bounding boxes
-        buff.clear();
-        buff.push(Segment::new(dom(eff.transition_end.num).0, dom(eff.mutex_end.num).1)); // TODO: careful with denom
-        for arg in &eff.state_var.args {
-            let (lb, ub) = dom(*arg);
-            buff.push(Segment::new(lb, ub));
+        let bbox = eff.value_box(&dom);
+        match eff.operation {
+            EffectOp::Assign(_) => self.assignment_bounding_boxes.add_box(fluent, bbox.segments(), eff_id),
+            EffectOp::Step(_) => self.steps_bounding_boxes.add_box(fluent, bbox.segments(), eff_id),
         }
-        let value_segment = match &eff.operation {
-            EffectOp::Assign(true) => Segment::new(1, 1),
-            EffectOp::Assign(false) => Segment::new(0, 0),
-        };
-        buff.push(value_segment);
-        self.achieved_bounding_boxes
-            .add_box(&eff.state_var.fluent, &buff, eff_id);
+
+        // compute and store the achievable bounding boxes
+        let bbox = eff.transition_box(&dom);
+        self.transition_bounding_boxes.add_box(fluent, bbox.segments(), eff_id);
 
         self.effects.push(eff);
         eff_id
     }
 
-    pub fn potentially_interacting_effects(&self) -> impl Iterator<Item = (EffectId, EffectId)> + '_ {
+    /// Returns a list of effects that may overlap on the state variable and overall activity period `[transition_start, mutex_end]`
+    pub(crate) fn potentially_interacting_effects(&self) -> impl Iterator<Item = (EffectId, EffectId)> + '_ {
         self.affected_bb.overlapping_boxes().map(|(e1, e2)| (*e1, *e2))
     }
 
-    pub fn potentially_supporting_effects<'a>(
+    /// Returns a list of effects that may overlap the given box (time + arguments)
+    pub(crate) fn potentially_overlapping_effects<'a>(
+        &'a self,
+        fluent: &'a String,
+        affected_box: BoxRef<'a>,
+    ) -> impl Iterator<Item = EffectId> + 'a {
+        self.affected_bb.find_overlapping_with(fluent, affected_box).copied()
+    }
+
+    /// Returns a list of potentially supporting effect (assign or step) for a condition, represented as a bounding box with
+    /// the given fluents and the following segments:
+    ///
+    ///  - time: `[lb(condition_start), ub(condition_end)]`
+    ///  - for each parameter p:
+    ///    - `[lb(p), ub(p)]`
+    ///  - value: `[lb(value), ub(value)]`
+    pub(crate) fn potentially_supporting_effects<'a>(
+        &'a self,
+        fluent: &'a String,
+        value_box: BoxRef<'a>,
+    ) -> impl Iterator<Item = EffectId> + 'a {
+        if self.steps_bounding_boxes.has_world(fluent) {
+            // there exists step effects for this fluent
+            // This means we cannot immediately rely on the value because the values achievable for an assignment should consider the contribution of any step
+            //
+            // For now, we workaround this by ignoring the value and juste looking for boxes that overlap the box on time and arguments.
+            // A potential improvement would be to consider the min/max for all steps and then look for the assignment that achieve the value expaned by this min/max
+            // Note that that the step effects must be included in the return as well
+            let affected_box = value_box.drop_tail(1);
+            self.affected_bb.find_overlapping_with(fluent, affected_box).copied()
+        } else {
+            // no steps, we simply return
+            self.assignment_bounding_boxes
+                .find_overlapping_with(fluent, value_box)
+                .copied()
+        }
+    }
+
+    /// Returns a list of effects whose transition period `[transition_start, transition_end)` may overlap a condition with the
+    /// the given fluents and a given value_box (same bounding box as [`Self::potentially_supporting_effects`]).
+    ///
+    /// Note that the last segment of the box (representing the value) is ignored in the lookup.
+    pub(crate) fn potentially_overlapping_transitions<'a>(
         &'a self,
         fluent: &'a String,
         value_box: BoxRef<'a>,
     ) -> impl Iterator<Item = EffectId> + 'a {
-        // compute the value bounding box
+        // the same box but without the value
+        let box_without_value = value_box.drop_tail(1);
 
-        self.achieved_bounding_boxes
-            .find_overlapping_with(fluent, value_box)
+        self.transition_bounding_boxes
+            .find_overlapping_with(fluent, box_without_value)
             .copied()
     }
 }
diff --git a/planning/timelines/src/encoder.rs b/planning/timelines/src/encoder.rs
new file mode 100644
index 000000000..7cc1475cc
--- /dev/null
+++ b/planning/timelines/src/encoder.rs
@@ -0,0 +1,35 @@
+use std::sync::Arc;
+
+use aries::model::lang::ModelWrapper;
+
+use crate::*;
+
+/// Structure that provide all the context for encoding the scheduling problem
+/// into a CSP.
+pub struct SchedEncoder {
+    /// Scheduling problem that is being encoded
+    pub sched: Arc<Sched>,
+    /// solver's model that will be populated with all constraints and variables
+    pub(crate) store: crate::Model,
+}
+
+impl Dom for SchedEncoder {
+    fn upper_bound(&self, svar: SignedVar) -> IntCst {
+        self.store.upper_bound(svar)
+    }
+
+    fn presence(&self, var: VarRef) -> Lit {
+        self.store.presence(var)
+    }
+}
+impl ModelWrapper for SchedEncoder {
+    type Lbl = String;
+
+    fn get_model(&self) -> &crate::Model {
+        &self.store
+    }
+
+    fn get_model_mut(&mut self) -> &mut crate::Model {
+        &mut self.store
+    }
+}
diff --git a/planning/timelines/src/explain.rs b/planning/timelines/src/explain.rs
index 825052f1e..21018d927 100644
--- a/planning/timelines/src/explain.rs
+++ b/planning/timelines/src/explain.rs
@@ -3,12 +3,12 @@ use std::collections::{BTreeMap, BTreeSet};
 use aries::prelude::*;
 use aries::{
     backtrack::Backtrack,
-    model::lang::{IVar, hreif::Store, linear::LinearSum},
+    model::lang::*,
     solver::{Solver, musmcs::MusMcs},
 };
 use itertools::Itertools;
 
-use crate::{ConstraintID, Sched};
+use crate::{ConstraintID, IntExp, IntTerm, Sched};
 
 pub struct ExplainableSolver<T> {
     solver: Solver<crate::Sym>,
@@ -22,7 +22,7 @@ impl<T: Ord + Clone> ExplainableSolver<T> {
     ///  - foreground constraints (soft), enabled by assumptions. Two foregrounds constriants with the
     ///    same projection will be enabled together by the same assumption.
     pub fn new(sched: &Sched, project: impl Fn(ConstraintID) -> Option<T>) -> Self {
-        let mut encoding = sched.model.clone();
+        let mut encoding = sched.clone().encoder();
 
         let mut assumptions_map = BTreeMap::new();
         let mut trigger = BTreeMap::new();
@@ -32,35 +32,47 @@ impl<T: Ord + Clone> ExplainableSolver<T> {
                 let l = if let Some(l) = trigger.get(&tag) {
                     *l
                 } else {
-                    let l = encoding.new_literal(Lit::TRUE);
+                    let l = encoding.new_literal(Lit::TRUE); // could we use the conjunctive scope directly?
                     assumptions_map.insert(l, tag.clone());
                     trigger.insert(tag, l);
                     l
                 };
-                c.enforce_if(l, sched, &mut encoding);
+                c.opt_enforce_if(l, &mut encoding);
             } else {
-                c.enforce(sched, &mut encoding);
+                c.enforce(&mut encoding);
             }
         }
-        let solver = Solver::new(encoding);
+        let solver = Solver::new(encoding.store);
         Self {
             solver,
             enablers: assumptions_map,
         }
     }
 
-    /// Returns true if the model is satisfiable with all assumptions
-    pub fn check_satisfiability(&mut self) -> bool {
+    /// Check if the model is satifiable with all assumptions, and returns a solution if it is.
+    pub fn check_satisfiability(&mut self) -> Option<Solution> {
         let assumptions = self.enablers.keys().copied().collect_vec();
         let res = self
             .solver
             .solve_with_assumptions(&assumptions, aries::solver::SearchLimit::None)
             .unwrap()
-            .is_ok();
-        self.solver.print_stats();
+            .ok();
+        // self.solver.print_stats();
         self.solver.reset(); // TODO: this should not be needed
         res
     }
+    ///
+    /// Check if the model is satifiable with all assumptions, and returns a solution if it is.
+    pub fn find_optimal(&mut self, obj: IntTerm, on_new_solution: impl FnMut(&Solution)) -> Option<Solution> {
+        let assumptions = self.enablers.keys().copied().collect_vec();
+        let res = self
+            .solver
+            .minimize_with_assumptions(obj, &assumptions, aries::solver::SearchLimit::None, on_new_solution)
+            .unwrap();
+        // self.solver.print_stats();
+        self.solver.reset(); // TODO: this should not be needed
+        res.ok()
+    }
 
     /// Returns an iterator over all MUS and MCS in the model.
     pub fn explain_unsat<'x>(&'x mut self) -> impl Iterator<Item = MusMcs<T>> + 'x {
@@ -71,6 +83,14 @@ impl<T: Ord + Clone> ExplainableSolver<T> {
             .map(move |mm| mm.project(projection))
     }
 
+    /// Returns an iterator over all MUS (Minimal Unsatifiable Subsets) in the model.
+    pub fn muses(&mut self) -> impl Iterator<Item = BTreeSet<T>> + '_ {
+        self.explain_unsat().filter_map(|mus_mcs| match mus_mcs {
+            MusMcs::Mus(mus) => Some(mus),
+            MusMcs::Mcs(_) => None,
+        })
+    }
+
     /// Returns the smallest MCS over all assumptions
     pub fn find_smallest_mcs(&mut self) -> Option<BTreeSet<T>> {
         let assumptions = self.enablers.keys().copied().collect_vec();
@@ -81,9 +101,7 @@ impl<T: Ord + Clone> ExplainableSolver<T> {
         let max_relaxed_assumptions = self.solver.model.new_ivar(0, assumptions.len() as IntCst, "objective");
         let num_relaxed_assumptions = assumptions
             .iter()
-            .fold(LinearSum::constant_int(num_assumptions), |sum, l| {
-                sum - IVar::new(l.variable())
-            });
+            .fold(IntExp::cst(num_assumptions), |sum, l| sum - l.variable());
         self.solver
             .enforce(num_relaxed_assumptions.leq(max_relaxed_assumptions), []);
 
diff --git a/planning/timelines/src/lib.rs b/planning/timelines/src/lib.rs
index 25ed29e11..24c230888 100644
--- a/planning/timelines/src/lib.rs
+++ b/planning/timelines/src/lib.rs
@@ -1,20 +1,21 @@
-pub mod assignment;
 pub mod boxes;
 pub mod constraints;
 mod effects;
+pub mod encoder;
 pub mod explain;
+pub mod rational;
 pub mod symbols;
 pub mod tasks;
 
-use aries::model::extensions::DomainsExt;
+use aries::core::state::Evaluable;
+use aries::core::views::Dom;
 use constraints::*;
 use core::fmt::Debug;
 use core::hash::{Hash, Hasher};
-use std::collections::HashMap;
+use std::sync::Arc;
 
 use aries::core::INT_CST_MAX;
 pub use aries::core::IntCst;
-use aries::model::lang::hreif::BoolExpr;
 use aries::model::lang::*;
 use aries::prelude::*;
 use aries::solver::Solver;
@@ -22,14 +23,24 @@ use idmap::DirectIdMap;
 use itertools::Itertools;
 
 pub type Model = aries::model::Model<Sym>;
-use crate::assignment::Assignment;
 pub use crate::effects::*;
+use crate::encoder::SchedEncoder;
 use crate::explain::ExplainableSolver;
 use crate::symbols::ObjectEncoding;
 pub use crate::tasks::*;
 
 pub type Sym = String;
-pub type Time = FAtom;
+
+/// Type of timepoints
+pub type Time = IAtom;
+
+/// Type of simple int expressions (composed of at most one variable)
+pub type IntTerm = aries::prelude::LinTerm;
+
+/// Type of compound integer expressions.
+pub type IntExp = aries::prelude::LinSum;
+
+pub type SymAtom = IntTerm;
 
 /// A fluent is a state function defined as a symbol and a set of parameter and return types.
 ///
@@ -67,96 +78,105 @@ impl Hash for Fluent {
     }
 }
 
-pub type SymAtom = IAtom;
-
-#[derive(Clone, Eq, PartialEq, Debug)]
+#[derive(Clone, Eq, PartialEq)]
 pub struct StateVar {
     pub fluent: Sym,
     pub args: Vec<SymAtom>,
 }
 
+impl Debug for StateVar {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}{:?}", self.fluent, self.args)
+    }
+}
+
 #[derive(Debug, Clone, Hash, PartialEq, PartialOrd, Eq, Ord)]
 pub enum Tag {
     TaskStart(TaskId),
     TaskEnd(TaskId),
 }
 
-type Constraint = Box<dyn BoolExpr<Sched>>;
+type Constraint = std::sync::Arc<dyn BoolExpr<SchedEncoder> + Send + Sync>;
 pub type ConstraintID = usize;
 
+#[derive(Clone)]
 pub struct Sched {
     pub model: Model,
     pub objects: ObjectEncoding,
     pub time_scale: IntCst,
+    /// temporal separation between events `(1/time_scale)`
+    pub epsilon: IntCst,
     pub origin: Time,
     pub horizon: Time,
     pub makespan: Time,
     pub tasks: Tasks,
     pub effects: Effects,
-    tags: HashMap<Atom, Vec<Tag>>,
     constraints: Vec<Constraint>,
 }
 
 impl Sched {
     pub fn new(time_scale: IntCst, objects: ObjectEncoding) -> Self {
+        assert_eq!(time_scale, 1, "Non-integer time is not supported yet");
         let mut model = Model::new();
-        let origin = Time::new(0.into(), time_scale);
-        let horizon = model.new_fvar(0, INT_CST_MAX, time_scale, "horizon").into();
-        let makespan = model.new_fvar(0, INT_CST_MAX, time_scale, "makespan").into();
+        let origin = Time::ZERO;
+        let horizon = model.new_ivar(0, INT_CST_MAX, "horizon").into();
+        let makespan = model.new_ivar(0, INT_CST_MAX, "makespan").into();
         Sched {
             model,
             objects,
             time_scale,
+            epsilon: 1,
             origin,
             horizon,
             makespan,
             tasks: Default::default(),
             effects: Default::default(),
-            tags: Default::default(),
-            constraints: vec![Box::new(EffectCoherence)], // TODO: add default constraints (consitency, makespan), ...
+            constraints: vec![Arc::new(MakespanIsMaxTaskEnd), Arc::new(EffectCoherence)],
         }
     }
 
-    pub fn tag(&mut self, atom: impl Into<Atom>, tag: Tag) {
-        let atom = atom.into();
-        self.tags.entry(atom).or_default().push(tag);
-    }
-
     pub fn add_task(&mut self, task: Task) -> TaskId {
         self.tasks.insert(task)
     }
 
     pub fn add_effect(&mut self, eff: Effect) -> EffectId {
-        self.effects.add_effect(eff, |var| self.model.int_bounds(var))
+        self.effects.add_effect(eff, &self.model)
     }
 
     pub fn new_timepoint(&mut self) -> Time {
-        self.model.new_fvar(0, INT_CST_MAX, self.time_scale, "_").into()
+        self.model.new_ivar(0, INT_CST_MAX, "_").into()
     }
     pub fn new_opt_timepoint(&mut self, scope: Lit) -> Time {
-        self.model
-            .new_optional_fvar(0, INT_CST_MAX, self.time_scale, scope, "_")
-            .into()
+        self.model.new_optional_ivar(0, INT_CST_MAX, scope, "_").into()
     }
-    pub fn add_constraint<C: BoolExpr<Sched> + 'static>(&mut self, c: C) -> ConstraintID {
-        self.add_boxed_constraint(Box::new(c))
+    pub fn add_constraint<C: BoolExpr<SchedEncoder> + 'static + Send + Sync>(&mut self, c: C) -> ConstraintID {
+        self.add_boxed_constraint(Arc::new(c))
     }
-    pub fn add_boxed_constraint(&mut self, c: Box<dyn BoolExpr<Sched> + 'static>) -> ConstraintID {
+    pub fn add_boxed_constraint(&mut self, c: Arc<dyn BoolExpr<SchedEncoder> + 'static + Send + Sync>) -> ConstraintID {
         self.constraints.push(c);
         self.constraints.len() - 1
     }
+
+    fn encoder(self) -> SchedEncoder {
+        let store = self.model.clone();
+        SchedEncoder {
+            sched: Arc::new(self),
+            store,
+        }
+    }
+
     pub fn encode(&self) -> Model {
-        let mut encoding = self.model.clone();
+        let mut encoder = self.clone().encoder();
         for c in &self.constraints {
-            c.enforce(self, &mut encoding);
+            c.enforce(&mut encoder);
         }
-        encoding
+        encoder.store
     }
 
-    pub fn solve(&self) -> Option<Assignment> {
+    pub fn solve(&self) -> Option<Solution> {
         let encoding = self.encode();
         let mut solver = Solver::new(encoding);
-        solver.solve(SearchLimit::None).unwrap().map(Assignment::shared)
+        solver.solve(SearchLimit::None).unwrap()
     }
 
     pub fn explainable_solver<T: Ord + Clone>(
@@ -166,14 +186,44 @@ impl Sched {
         ExplainableSolver::new(self, project)
     }
 
-    pub fn print(&self, sol: &Assignment) {
+    pub fn print(&self, sol: &Solution) {
+        println!("==== tasks ====");
         let sorted_tasks = self
             .tasks
             .iter()
             .filter(|t| sol.eval(t.presence) == Some(true))
-            .sorted_by_cached_key(|t| sol.eval(t.start.num).unwrap());
+            .sorted_by_cached_key(|t| sol.eval(t.start).unwrap());
         for t in sorted_tasks {
-            println!("{}: {}", t.name, sol.eval(t.start.num).unwrap())
+            println!("{}: {}", t.name, sol.eval(t.start).unwrap())
+        }
+        println!("==== Effects ====");
+        for e in self.effects.iter().sorted_by_key(|e| &e.state_var.fluent) {
+            if !sol.entails(e.prez) {
+                println!("{:?}", e);
+                continue;
+            }
+            println!(
+                "{}: [{},{}] {} ...[{}]",
+                e.state_var.fluent,
+                e.transition_start.evaluate(sol).unwrap(),
+                e.transition_end.evaluate(sol).unwrap(),
+                match e.operation {
+                    EffectOp::Assign(v) => format!(":= {}", v.evaluate(sol).unwrap()),
+                    EffectOp::Step(v) => format!("+= {}", v.evaluate(sol).unwrap()),
+                },
+                e.mutex_end.evaluate(sol).unwrap(),
+            );
         }
+        println!("Horizon: {}", self.horizon.evaluate(sol).unwrap())
+    }
+}
+
+impl Dom for Sched {
+    fn upper_bound(&self, svar: SignedVar) -> IntCst {
+        self.model.upper_bound(svar)
+    }
+
+    fn presence(&self, var: VarRef) -> Lit {
+        self.model.presence(var)
     }
 }
diff --git a/planning/timelines/src/rational.rs b/planning/timelines/src/rational.rs
new file mode 100644
index 000000000..efb7103bf
--- /dev/null
+++ b/planning/timelines/src/rational.rs
@@ -0,0 +1,7 @@
+use aries::model::lang::FAtom;
+
+/// A rational constant
+pub type QCst = aries::core::QCst;
+
+/// A rational atom
+pub type QAtom = FAtom;
diff --git a/planning/timelines/src/symbols.rs b/planning/timelines/src/symbols.rs
index d0d3f6331..b148faee3 100644
--- a/planning/timelines/src/symbols.rs
+++ b/planning/timelines/src/symbols.rs
@@ -1,4 +1,4 @@
-use std::{borrow::Borrow, collections::BTreeMap, fmt::Debug};
+use std::{borrow::Borrow, collections::BTreeMap, fmt::Debug, sync::Arc};
 
 use aries::core::IntCst;
 
@@ -75,4 +75,28 @@ impl ObjectEncoding {
     fn next_object_id(&self) -> IntCst {
         self.objects.len() as IntCst
     }
+
+    /// Builds a decoder that allows retrieving the object from its ID.
+    ///
+    /// Note: the decoder is heavy to compute but cheap to clone. Best if constructed only once.
+    pub fn decoder(&self) -> ObjectDecoder {
+        let id_to_object: BTreeMap<IntCst, Sym> = self.objects.iter().map(|(obj, id)| (*id, obj.clone())).collect();
+        ObjectDecoder {
+            decoder: Arc::new(id_to_object),
+        }
+    }
+}
+
+/// Mapping from object ID to object names.
+///
+/// Note: This datastructure is cheaply clonable.
+#[derive(Clone)]
+pub struct ObjectDecoder {
+    decoder: Arc<BTreeMap<IntCst, Sym>>,
+}
+
+impl ObjectDecoder {
+    pub fn decode(&self, id: IntCst) -> Option<&Sym> {
+        self.decoder.get(&id)
+    }
 }
diff --git a/planning/timelines/src/tasks.rs b/planning/timelines/src/tasks.rs
index 32e7684cd..49c638d05 100644
--- a/planning/timelines/src/tasks.rs
+++ b/planning/timelines/src/tasks.rs
@@ -20,14 +20,12 @@ pub struct Task {
     pub start: Time,
     /// Time reference at which the task must end
     pub end: Time,
-    /// Arguments of the task
-    pub args: Vec<Atom>,
     /// Presence of the task, true iff it appears in the solution
     pub presence: Lit,
 }
 impl Debug for Task {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "[{:?},{:?}] {:?}{:?}", self.start, self.end, self.name, self.args)?;
+        write!(f, "[{:?},{:?}] {:?}", self.start, self.end, self.name)?;
         Ok(())
     }
 }
diff --git a/solver/src/core/cst.rs b/solver/src/core/cst.rs
index 33f4c7394..3df1d7062 100644
--- a/solver/src/core/cst.rs
+++ b/solver/src/core/cst.rs
@@ -11,6 +11,9 @@ mod types {
 
     /// Name of the `IntCst` underlying type
     pub const INT_TYPE_NAME: &str = "i32";
+
+    /// Type representing a rational constant.
+    pub type QCst = num_rational::Rational32;
 }
 
 #[cfg(all(feature = "i64", not(feature = "i128")))]
@@ -23,6 +26,9 @@ mod types {
 
     /// Name of the `IntCst` underlying type
     pub const INT_TYPE_NAME: &str = "i64";
+
+    /// Type representing a rational constant.
+    pub type QCst = num_rational::Rational64;
 }
 
 #[cfg(feature = "i128")]
@@ -35,6 +41,9 @@ mod types {
 
     /// Name of the `IntCst` underlying type
     pub const INT_TYPE_NAME: &str = "i128";
+
+    /// Type representing a rational constant.
+    pub type QCst = num_rational::Ratio<i128>;
 }
 
 /// Convert IntCst to LongCst
diff --git a/solver/src/core/literals.rs b/solver/src/core/literals.rs
index 8c1a35de7..075bc274a 100644
--- a/solver/src/core/literals.rs
+++ b/solver/src/core/literals.rs
@@ -3,6 +3,7 @@
 use std::{
     borrow::Borrow,
     cmp::Reverse,
+    fmt::Debug,
     ops::{Deref, DerefMut},
 };
 
@@ -26,7 +27,7 @@ const INLINE_SIZE: usize = 3;
 /// A sequence of literals, optimized to represent at least 3 elements inline.
 ///
 /// In the base case (when [`IntCst`] is 32 bits), it should only occupy 4 machine words (one more that a `Vec<Lit>`).
-#[derive(PartialEq, PartialOrd, Ord, Eq, Clone, Debug, Hash)]
+#[derive(PartialEq, PartialOrd, Ord, Eq, Clone, Hash)]
 pub struct Lits {
     elems: SmallVec<[Lit; INLINE_SIZE]>,
 }
@@ -98,7 +99,13 @@ impl Lits {
     /// TODO: we are missing an opportunity to detect and simplify the clause in the presence of mutually exclusive literals.
     /// This step could be fused in the deduplication phase to keep a single traversal.
     pub(crate) fn simplify_disjunctive(&mut self) {
-        if self.len() <= 1 {
+        if self.is_empty() {
+            return;
+        }
+        if self.len() == 1 {
+            if self.elems[0].absurd() {
+                self.elems.pop();
+            }
             return;
         }
         // sort literals, so that they are grouped by (1) variable and (2) affected bound
@@ -149,6 +156,12 @@ impl Lits {
     }
 }
 
+impl Debug for Lits {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{:?}", self.elems)
+    }
+}
+
 impl Default for Lits {
     fn default() -> Self {
         Self::new()
diff --git a/solver/src/core/literals/conjunction.rs b/solver/src/core/literals/conjunction.rs
index 6873e753a..2ec1537e3 100644
--- a/solver/src/core/literals/conjunction.rs
+++ b/solver/src/core/literals/conjunction.rs
@@ -72,6 +72,7 @@ impl Conjunction {
         self.literals.contains(&lit)
     }
 }
+
 impl<'a> IntoIterator for &'a Conjunction {
     type Item = Lit;
     type IntoIter = <&'a Lits as IntoIterator>::IntoIter;
diff --git a/solver/src/core/state/domains.rs b/solver/src/core/state/domains.rs
index 9ba20758d..e4234a984 100644
--- a/solver/src/core/state/domains.rs
+++ b/solver/src/core/state/domains.rs
@@ -7,9 +7,8 @@ use crate::core::state::int_domains::IntDomains;
 use crate::core::state::{
     Cause, DomainsSnapshot, Explainer, Explanation, ExplanationQueue, InvalidUpdate, OptDomain, RangeDomain, Solution,
 };
-use crate::core::views::{Boundable, VarView};
+use crate::core::views::{Boundable, Term, VarView};
 use crate::core::*;
-use crate::model::lang::{Atom, IAtom};
 use crate::prelude::*;
 use itertools::Itertools;
 use std::fmt::{Debug, Formatter};
@@ -866,37 +865,6 @@ impl Debug for Conflict {
     }
 }
 
-/// A term that can be converted into a variable.
-/// Notably implemented for `VarRef`, `Lit`, `IVar`, `SVar`, `BVar`
-pub trait Term {
-    fn variable(self) -> VarRef;
-}
-impl Term for Lit {
-    fn variable(self) -> VarRef {
-        self.variable()
-    }
-}
-impl Term for SignedVar {
-    fn variable(self) -> VarRef {
-        self.variable()
-    }
-}
-impl<T: Into<VarRef>> Term for T {
-    fn variable(self) -> VarRef {
-        self.into()
-    }
-}
-impl Term for IAtom {
-    fn variable(self) -> VarRef {
-        self.var.variable()
-    }
-}
-impl Term for Atom {
-    fn variable(self) -> VarRef {
-        self.variable()
-    }
-}
-
 impl crate::core::views::Dom for Domains {
     fn upper_bound(&self, svar: SignedVar) -> IntCst {
         Domains::upper_bound(self, svar)
@@ -1316,9 +1284,9 @@ mod tests {
 
         model.save_state();
         assert!(model.assume(x.leq(3)).unwrap());
-        assert_eq!(model.bounds(x.variable()), (0, 3));
+        assert_eq!(model.bounds(x), (0, 3));
         propagate(&mut model).unwrap();
-        assert_eq!(model.bounds(y.variable()), (6, 10));
+        assert_eq!(model.bounds(y), (6, 10));
 
         model.save_state();
         let err = model.assume(y.leq(4)).unwrap_err();
diff --git a/solver/src/core/state/solution.rs b/solver/src/core/state/solution.rs
index 2d79be2bc..8c105469e 100644
--- a/solver/src/core/state/solution.rs
+++ b/solver/src/core/state/solution.rs
@@ -2,7 +2,10 @@ use std::sync::Arc;
 
 use crate::{
     collections::ref_store::RefVec,
-    core::{state::ValueCause, views::Dom},
+    core::{
+        state::ValueCause,
+        views::{Dom, Optional, VarView},
+    },
     prelude::*,
 };
 
@@ -25,6 +28,11 @@ impl Solution {
         }
     }
 
+    /// Returns the value that the expression has in the solution, or None if the value is absent.
+    pub fn eval<T: Evaluable>(&self, expr: T) -> Option<T::Value> {
+        expr.evaluate(self)
+    }
+
     /// Returns the number of variables declared.
     pub fn num_variables(&self) -> usize {
         debug_assert!(self.data.values.len().is_multiple_of(2));
@@ -60,3 +68,33 @@ impl Dom for Solution {
         self.data.presences[var]
     }
 }
+
+/// Denotes expressions that can be evaluated in a solution.
+pub trait Evaluable {
+    /// Type of the value of this expression.
+    ///
+    /// For instance it would be [`IntCst`] for [`VarRef`] and `bool` for [`Lit`].
+    type Value;
+
+    /// Determines the value that the expression has in a solution.
+    ///
+    /// Returns `None`  the value is absent and the value wrapped in `Some(...)` otherwise.
+    fn evaluate(&self, solution: &Solution) -> Option<Self::Value>;
+}
+
+impl<T> Evaluable for T
+where
+    T: VarView + Optional,
+{
+    type Value = <T as VarView>::Value;
+
+    fn evaluate(&self, solution: &Solution) -> Option<Self::Value> {
+        if self.present(solution) {
+            // in a solution it is guaranteed that the domain of any present variable is a singleton,
+            // so we only take the lower bound
+            Some(solution.lb(self))
+        } else {
+            None
+        }
+    }
+}
diff --git a/solver/src/core/views.rs b/solver/src/core/views.rs
index 2098dcf88..2602d2e08 100644
--- a/solver/src/core/views.rs
+++ b/solver/src/core/views.rs
@@ -1,4 +1,4 @@
-use crate::core::{IntCst, Lit, SignedVar, VarRef};
+use crate::{model::lang::Atom, prelude::*};
 
 pub trait Dom {
     fn upper_bound(&self, svar: SignedVar) -> IntCst;
@@ -10,7 +10,7 @@ pub trait Dom {
     }
 }
 
-impl<X> Dom for &X
+impl<X: ?Sized> Dom for &X
 where
     X: Dom,
 {
@@ -22,7 +22,7 @@ where
         Dom::presence(*self, var)
     }
 }
-impl<X> Dom for &mut X
+impl<X: ?Sized> Dom for &mut X
 where
     X: Dom,
 {
@@ -42,6 +42,18 @@ pub trait VarView {
     fn lower_bound(&self, dom: impl Dom) -> Self::Value;
 }
 
+impl<T: VarView> VarView for &T {
+    type Value = <T as VarView>::Value;
+
+    fn upper_bound(&self, dom: impl Dom) -> Self::Value {
+        VarView::upper_bound(*self, dom)
+    }
+
+    fn lower_bound(&self, dom: impl Dom) -> Self::Value {
+        VarView::lower_bound(*self, dom)
+    }
+}
+
 impl VarView for SignedVar {
     type Value = IntCst;
 
@@ -93,3 +105,51 @@ impl Boundable for SignedVar {
         Lit::geq(*self, lb)
     }
 }
+
+/// Determine whether an expression is already determined to be present in the given domain..
+///
+/// If an expression is always defined (its presence literal is [`Lit::TRUE`]), it should return `true` regardless of the domain.
+pub trait Optional {
+    fn present(&self, domains: impl Dom) -> bool;
+}
+
+impl<T: Term + Copy> Optional for T {
+    fn present(&self, domains: impl Dom) -> bool {
+        domains.present(self.variable()) == Some(true)
+    }
+}
+
+/// An expression that is a view of exactly one variable (which may be the [`VarRef::ZERO`] variable).
+///
+/// Notably implemented for `VarRef`, `Lit`, `IVar`, `SVar`, `BVar`
+pub trait Term {
+    /// Extracts the underlying variable in the expression.
+    ///
+    /// Note that the resulting in [`VarRef`] cannot in general be considered as equivalent to the expression.
+    fn variable(self) -> VarRef;
+}
+impl Term for Lit {
+    fn variable(self) -> VarRef {
+        self.variable()
+    }
+}
+impl Term for SignedVar {
+    fn variable(self) -> VarRef {
+        self.variable()
+    }
+}
+impl<T: Into<VarRef>> Term for T {
+    fn variable(self) -> VarRef {
+        self.into()
+    }
+}
+impl Term for IAtom {
+    fn variable(self) -> VarRef {
+        self.var.variable()
+    }
+}
+impl Term for Atom {
+    fn variable(self) -> VarRef {
+        self.variable()
+    }
+}
diff --git a/solver/src/model/extensions/domains_ext.rs b/solver/src/model/extensions/domains_ext.rs
index c8607cecd..30c63f03a 100644
--- a/solver/src/model/extensions/domains_ext.rs
+++ b/solver/src/model/extensions/domains_ext.rs
@@ -1,14 +1,13 @@
 use crate::core::state::{FixedDomain, IntDomain, OptDomain, RangeDomain};
-use crate::core::views::{Dom, VarView};
+use crate::core::views::{Dom, Term, VarView};
 use crate::core::*;
 use crate::model::lang::linear::LinearSum;
 use crate::model::lang::{Atom, Cst, IAtom, Rational, SAtom};
 use crate::model::symbols::SymId;
 use crate::model::symbols::TypedSym;
-use state::Term;
 
 /// Extension methods for an object containing a partial or total assignment to a problem.
-pub trait DomainsExt: Dom + Sized {
+pub trait DomainsExt: Dom {
     fn entails(&self, literal: Lit) -> bool {
         Dom::upper_bound(self, literal.svar()) <= literal.ub_value()
     }
@@ -112,7 +111,7 @@ pub trait DomainsExt: Dom + Sized {
     }
 }
 
-impl<D> DomainsExt for D where D: Dom + Sized {}
+impl<D: ?Sized> DomainsExt for D where D: Dom {}
 
 #[cfg(test)]
 mod test {
diff --git a/solver/src/model/extensions/partial_assignment.rs b/solver/src/model/extensions/partial_assignment.rs
index cea9b6cf8..0b1c19c9e 100644
--- a/solver/src/model/extensions/partial_assignment.rs
+++ b/solver/src/model/extensions/partial_assignment.rs
@@ -1,4 +1,4 @@
-use crate::core::state::Term;
+use crate::core::views::Term;
 use crate::core::{IntCst, Lit, SignedVar, VarRef};
 use crate::model::lang::{Atom, Cst, FAtom, IAtom, Rational, SAtom};
 use crate::model::symbols::{SymId, TypedSym};
diff --git a/solver/src/model/lang.rs b/solver/src/model/lang.rs
index 3315b4386..99fb9b925 100644
--- a/solver/src/model/lang.rs
+++ b/solver/src/model/lang.rs
@@ -1,31 +1,39 @@
 pub mod alternative;
 mod atom;
+mod bool_expr;
 mod boolean;
 mod cst;
+pub mod element;
+pub mod exclusive_choice;
 pub mod expr;
 mod fixed;
-pub mod hreif;
 mod int;
-pub mod linear;
+mod int_expr;
+pub mod linear; // TODO: make pub(crate)
 pub mod max;
 pub mod mul;
 pub mod reification;
+mod store;
 mod sym;
 mod validity_scope;
 mod variables;
 
 pub use crate::core::Lit;
 pub use atom::Atom;
+pub use bool_expr::BoolExpr;
 pub use boolean::BVar;
 pub use cst::Cst;
 pub use fixed::{FAtom, FVar, Rational};
 pub use int::{IAtom, IVar};
+pub use int_expr::IntExpr;
+pub use linear::{LinearLeq, LinearSum, LinearTerm};
+pub use store::{ModelWrapper, Store};
+pub use sym::{SAtom, SVar};
 pub use validity_scope::*;
+pub use variables::Variable;
 
 use crate::core::{INT_CST_MAX, INT_CST_MIN, IntCst};
 use crate::model::types::TypeId;
-pub use sym::{SAtom, SVar};
-pub use variables::Variable;
 
 #[derive(Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Debug, Hash)]
 pub enum Type {
diff --git a/solver/src/model/lang/alternative.rs b/solver/src/model/lang/alternative.rs
index 00350829b..40fa4b7e8 100644
--- a/solver/src/model/lang/alternative.rs
+++ b/solver/src/model/lang/alternative.rs
@@ -1,4 +1,4 @@
-use crate::core::state::Term;
+use crate::core::views::Term;
 use crate::core::{IntCst, VarRef};
 use crate::model::lang::{Atom, ConversionError, IAtom};
 use crate::reif::ReifExpr;
diff --git a/solver/src/model/lang/bool_expr.rs b/solver/src/model/lang/bool_expr.rs
new file mode 100644
index 000000000..b85ae59c9
--- /dev/null
+++ b/solver/src/model/lang/bool_expr.rs
@@ -0,0 +1,299 @@
+use crate::{
+    model::lang::{
+        expr::{And, Leq, Or, or},
+        max::{EqMax, EqMin},
+        *,
+    },
+    prelude::*,
+    reif::ReifExpr,
+};
+
+/// Representation of a boolean expression, that can be reified, made conditional or enforced
+/// in a [`Model`].
+pub trait BoolExpr<Ctx: Store> {
+    /// Enforce the expression to be true when `implicant` is true and defined.
+    ///
+    /// IMPORTANT: it must be the case that expression is defined whenever `implicant` is.
+    fn enforce_if(&self, implicant: Lit, ctx: &mut Ctx);
+
+    /// Returns a set of literals that must all be true for the expression to be valid.
+    /// The list is interpreted as a set: order and redundant elements are ignored.
+    ///
+    /// Examples:
+    ///   - (a < b) would have a conjunctive scope `[prez(a), prez(b)]` as it is only valid when both
+    ///     a and b are present. The conjunctive scope is thus the list their presence variable.
+    fn conj_scope(&self, ctx: &Ctx) -> Conjunction; // TODO: should be Conjunction
+
+    /// Return a single literal that is true iff all leterals of the conjunctive scope are true.
+    fn scope(&self, ctx: &mut Ctx) -> Lit {
+        let conj_scope = self.conj_scope(ctx);
+        ctx.conjunctive_scope(&conj_scope)
+    }
+    fn opt_enforce_if(&self, l: Lit, ctx: &mut Ctx) {
+        let scope = self.scope(ctx);
+        let implicant = if scope == ctx.presence(l.variable()) {
+            l // TODO: here we should instead test that scope => prez(l)
+        } else if ctx.entails(l) {
+            ctx.tautology_of_scope(scope)
+        } else {
+            let imp = ctx.new_literal(scope);
+            or([imp, !scope]).enforce_if(l, ctx);
+            imp
+        };
+        self.enforce_if(implicant, ctx);
+    }
+
+    /// Half-reifies the expression, posting a constraint that is
+    /// enforces the expression to be true whenever the return literal is.
+    fn implicant(&self, ctx: &mut Ctx) -> Lit {
+        let scope = self.scope(ctx);
+        let implicant = ctx.new_literal(scope);
+        self.enforce_if(implicant, ctx);
+        implicant
+    }
+
+    /// Fully reifies the expression into a literal.
+    ///
+    /// Note that for this to be possible, it must be possible to build the logical negation of the expression.
+    fn reified<'a, NotSelf>(&'a self, ctx: &mut Ctx) -> Lit
+    where
+        Self: Sized,
+        &'a Self: std::ops::Not<Output = NotSelf>,
+        NotSelf: BoolExpr<Ctx>,
+    {
+        let implicant = self.implicant(ctx);
+        let negated = !self;
+        negated.enforce_if(!implicant, ctx);
+        implicant
+    }
+
+    /// Enforces that the expression is true whenever it is defined.
+    fn enforce(&self, ctx: &mut Ctx) {
+        self.opt_enforce_if(Lit::TRUE, ctx);
+    }
+}
+
+impl<Ctx: Store, T: BoolExpr<Ctx>> BoolExpr<Ctx> for &T {
+    fn enforce_if(&self, l: Lit, ctx: &mut Ctx) {
+        (*self).enforce_if(l, ctx);
+    }
+
+    fn conj_scope(&self, ctx: &Ctx) -> Conjunction {
+        (*self).conj_scope(ctx)
+    }
+    fn implicant(&self, ctx: &mut Ctx) -> Lit {
+        (*self).implicant(ctx)
+    }
+
+    //TODO: implement all other methods to make sure we use the most specific implementation
+}
+
+impl<Ctx: Store> BoolExpr<Ctx> for ReifExpr {
+    fn enforce_if(&self, l: Lit, ctx: &mut Ctx) {
+        ctx.add_implies(l, self.clone());
+    }
+
+    fn conj_scope(&self, ctx: &Ctx) -> Conjunction {
+        let vs = self.scope(|v| ctx.presence_literal(v));
+        // TODO: give flattening context
+        let conj_scope = vs.to_conjunction(|_| Option::<[Lit; 0]>::None, |l| l == Lit::TRUE);
+        Conjunction::from_iter(conj_scope.literals())
+    }
+    fn implicant(&self, ctx: &mut Ctx) -> Lit {
+        if let ReifExpr::Lit(l) = self {
+            *l // short circuit happy case
+        } else {
+            ctx.get_implicant(self.clone())
+        }
+    }
+}
+
+// Derive `impl BoolExpr<_>` for Expression convertible to `ReifExpr`
+crate::impl_reif!(Lit);
+crate::impl_reif!(Or);
+crate::impl_reif!(And);
+crate::impl_reif!(Leq);
+crate::impl_reif!(LinearLeq);
+crate::impl_reif!(EqMax);
+crate::impl_reif!(EqMin);
+
+#[macro_export]
+macro_rules! impl_reif {
+    ($A: ty) => {
+        impl<Ctx: Store> BoolExpr<Ctx> for $A
+        where
+            $A: Clone,
+            ReifExpr: From<$A>,
+        {
+            fn enforce_if(&self, l: Lit, ctx: &mut Ctx) {
+                ReifExpr::from(self.clone()).enforce_if(l, ctx);
+            }
+            fn conj_scope(&self, ctx: &Ctx) -> Conjunction {
+                ReifExpr::from(self.clone()).conj_scope(ctx)
+            }
+            fn implicant(&self, ctx: &mut Ctx) -> Lit {
+                ctx.get_implicant(ReifExpr::from(self.clone()))
+            }
+            // TODO: add reification impl
+        }
+    };
+}
+
+#[cfg(test)]
+mod test {
+    use crate::{
+        core::views::{Dom, Term},
+        model::{
+            Label,
+            extensions::DomainsExt,
+            lang::{
+                Atom, IAtom,
+                expr::{lt, neq},
+            },
+        },
+        solver::{SearchLimit, Solver},
+    };
+
+    use super::*;
+
+    /// All different with potentially optional variables
+    struct AllDifferent(Vec<IAtom>);
+
+    /// True if the the two atoms are different, and undefined if at least one is absent
+    struct Different(IAtom, IAtom);
+
+    impl<Ctx: Store> BoolExpr<Ctx> for AllDifferent {
+        fn enforce_if(&self, l: Lit, ctx: &mut Ctx) {
+            for (i, t1) in self.0.iter().copied().enumerate() {
+                for t2 in self.0[i + 1..].iter().copied() {
+                    Different(t1, t2).opt_enforce_if(l, ctx);
+                }
+            }
+        }
+
+        fn conj_scope(&self, _ctx: &Ctx) -> Conjunction {
+            Conjunction::tautology()
+        }
+    }
+
+    impl<Ctx: Store> BoolExpr<Ctx> for Different {
+        fn enforce_if(&self, l: Lit, ctx: &mut Ctx) {
+            neq(self.0, self.1).opt_enforce_if(l, ctx);
+        }
+
+        fn conj_scope(&self, ctx: &Ctx) -> Conjunction {
+            [ctx.presence_literal(self.0), ctx.presence_literal(self.1)].into()
+        }
+    }
+
+    #[test]
+    fn test_alldiff_exp() {
+        let n = 2;
+        let mut m: Model<String> = Model::new();
+        let mut tasks = Vec::with_capacity(n);
+        for i in 1..=n {
+            let pi = m.new_presence_variable(Lit::TRUE, format!("p{i}")).true_lit();
+            let ti = m.new_optional_ivar(0, 1, pi, format!("t{i}"));
+            tasks.push(IAtom::from(ti));
+        }
+
+        let _activator = m.new_bvar("activator").true_lit();
+        let no = AllDifferent(tasks.clone());
+        no.opt_enforce_if(Lit::TRUE, &mut m);
+        //no.opt_enforce_if(_activator, &mut m);
+        m.print_state();
+
+        let s = Solver::new(m);
+        let count = enumerate(s, &tasks);
+        assert_eq!(count, 7);
+    }
+    fn enumerate<L: Label>(mut s: Solver<L>, ints: &[IAtom]) -> i32 {
+        let mut vars = Vec::with_capacity(ints.len() * 2);
+        for &i in ints {
+            vars.push(i.variable());
+            vars.push(s.model.presence(i.variable()).variable());
+        }
+        vars.sort();
+        vars.dedup();
+        let mut counter = 0;
+        s.enumerate_with(
+            &vars,
+            |sol| {
+                counter += 1;
+                println!("Sol {}", &counter);
+                for i in ints {
+                    print!("  {i:?}: ");
+                    if sol.present(*i) == Some(true) {
+                        println!("{:?}", sol.evaluate(Atom::from(*i)).unwrap());
+                    } else {
+                        println!("-");
+                    }
+                }
+            },
+            SearchLimit::None,
+        )
+        .expect("error returned by enumerate");
+        counter
+    }
+
+    type TaskId = usize;
+
+    struct Ordered(TaskId, TaskId);
+
+    struct ModelWithMetadata {
+        starts: Vec<IAtom>,
+        model: Model<String>,
+    }
+    impl ModelWrapper for ModelWithMetadata {
+        type Lbl = String;
+
+        fn get_model(&self) -> &Model<Self::Lbl> {
+            &self.model
+        }
+
+        fn get_model_mut(&mut self) -> &mut Model<Self::Lbl> {
+            &mut self.model
+        }
+    }
+
+    impl Dom for ModelWithMetadata {
+        fn upper_bound(&self, svar: SignedVar) -> IntCst {
+            self.model.upper_bound(svar)
+        }
+
+        fn presence(&self, var: VarRef) -> Lit {
+            self.model.presence(var)
+        }
+    }
+
+    impl BoolExpr<ModelWithMetadata> for Ordered {
+        fn enforce_if(&self, l: Lit, ctx: &mut ModelWithMetadata) {
+            let c = lt(ctx.starts[self.0], ctx.starts[self.1]);
+            c.opt_enforce_if(l, ctx);
+        }
+
+        fn conj_scope(&self, ctx: &ModelWithMetadata) -> Conjunction {
+            let c = lt(ctx.starts[self.0], ctx.starts[self.1]);
+            c.conj_scope(ctx)
+        }
+    }
+
+    #[test]
+    fn test_ctx2() {
+        let mut store: Model<String> = Model::new();
+        let s1 = store.new_ivar(0, 1000, "start1");
+        let s2 = store.new_ivar(0, 1000, "start2");
+        let s3 = store.new_ivar(0, 1000, "start3");
+        let mut model = ModelWithMetadata {
+            starts: vec![s1.into(), s2.into(), s3.into()],
+            model: store,
+        };
+        let x = Ordered(1, 2);
+        let y: &dyn BoolExpr<_> = &x;
+
+        y.opt_enforce_if(Lit::FALSE, &mut model);
+
+        let e = ReifExpr::And(crate::core::literals::Lits::new());
+        e.opt_enforce_if(Lit::TRUE, &mut model);
+    }
+}
diff --git a/solver/src/model/lang/boolean.rs b/solver/src/model/lang/boolean.rs
index 1d1770123..443fc1537 100644
--- a/solver/src/model/lang/boolean.rs
+++ b/solver/src/model/lang/boolean.rs
@@ -1,4 +1,4 @@
-use crate::core::state::Term;
+use crate::core::views::Term;
 use crate::core::*;
 use crate::model::lang::IVar;
 
diff --git a/solver/src/model/lang/element.rs b/solver/src/model/lang/element.rs
new file mode 100644
index 000000000..c17fbce65
--- /dev/null
+++ b/solver/src/model/lang/element.rs
@@ -0,0 +1,114 @@
+use crate::{
+    model::lang::{
+        expr::{implies, lin_eq},
+        *,
+    },
+    prelude::*,
+};
+
+/// Represent a single option in an element constraint.
+#[derive(Copy, Clone, Debug)]
+struct ElementOption {
+    /// True if the value is selected (provides the value of the expression)
+    selector: Lit,
+    /// Value given to the expression when this option is selected.
+    value: LinTerm,
+}
+
+/// An integer expression that mimicks the `element` constraint.
+///
+/// It is composed of a number of options, each of the form `(selector_i, value_i)`
+/// If, for any `i`, `selector_i` is true then the expression is equal to `value_i`.
+///
+/// Note that the options are not necessarily exclusive: there might more that one selector
+/// that are true (which only implies that they have the same value).
+#[derive(Default, Clone)]
+pub struct Element {
+    options: Vec<ElementOption>,
+}
+
+impl Element {
+    /// Creates a new element expression with no options.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub fn build(options: &[(Lit, LinTerm)]) -> Self {
+        Self {
+            options: options
+                .iter()
+                .copied()
+                .map(|(selector, value)| ElementOption { selector, value })
+                .collect(),
+        }
+    }
+
+    /// Adds a value option and its selector to the element expresion.
+    pub fn add_option(&mut self, selector: Lit, value: impl Into<LinTerm>) {
+        self.options.push(ElementOption {
+            selector,
+            value: value.into(),
+        });
+    }
+}
+
+impl<Ctx: Store> IntExpr<Ctx> for Element {
+    fn enforce_eq_if(&self, implicant: Lit, value: LinTerm, ctx: &mut Ctx) {
+        let constraint = EqElement {
+            variable: value,
+            element: self.clone(),
+        };
+        constraint.opt_enforce_if(implicant, ctx);
+    }
+
+    fn bounds(&self, ctx: &Ctx) -> (IntCst, IntCst) {
+        let lb = self
+            .options
+            .iter()
+            .map(|e| ctx.lb(e.value))
+            .min()
+            .unwrap_or(INT_CST_MAX);
+        let ub = self
+            .options
+            .iter()
+            .map(|e| ctx.ub(e.value))
+            .max()
+            .unwrap_or(INT_CST_MIN);
+        (lb, ub)
+    }
+}
+
+/// Element constraint stating that the `variable` must be equal to at least one element for which the selector is true.
+///
+/// If `variable` is present, then:
+///
+///   - exists `(sel_i, val_i) in elements` such that `sel_i` is true
+///   - forall `(sel_i, val_i) in elements`, `sel_i => (variable == val_i)`
+pub struct EqElement {
+    variable: LinTerm,
+    element: Element,
+}
+
+impl<Ctx: Store> BoolExpr<Ctx> for EqElement {
+    fn enforce_if(&self, l: Lit, ctx: &mut Ctx) {
+        let _span = tracing::debug_span!("EqElement");
+        let _span = _span.enter();
+        // make sure that the implicant's scope is large enough
+        ctx.add_assertion(implies(ctx.presence_literal(l), ctx.presence_literal(self.variable)));
+
+        // at least one esatablisher must hold
+        Disjunction::from_iter(self.element.options.iter().map(|a| a.selector)).enforce_if(l, ctx);
+
+        for o in &self.element.options {
+            // if `a` is the establishers the the variable must have its value
+            implies(o.selector, lin_eq(o.value, self.variable).implicant(ctx)).enforce_if(l, ctx);
+            // TODO: we could do a stronger propagation by ensuring that at least each value in the lhs domain is supported by value in the rhs domains
+
+            ctx.add_assertion(implies(o.selector, ctx.presence_literal(o.value)));
+        }
+    }
+
+    fn conj_scope(&self, ctx: &Ctx) -> Conjunction {
+        [ctx.presence_literal(self.variable)].into()
+    }
+}
diff --git a/solver/src/model/lang/exclusive_choice.rs b/solver/src/model/lang/exclusive_choice.rs
new file mode 100644
index 000000000..7e3941219
--- /dev/null
+++ b/solver/src/model/lang/exclusive_choice.rs
@@ -0,0 +1,49 @@
+use crate::{
+    model::lang::{BoolExpr, Store, expr::or},
+    prelude::*,
+};
+
+/// Builds an exclusive choice between two alternatives.
+///
+/// Excluvise choices are useful in that they sometime allow to avoid creating intermediate
+/// variable (see [`ExclusiveChoice`]).
+pub fn exclu_choice<T>(alt1: T, alt2: T) -> ExclusiveChoice<T> {
+    ExclusiveChoice { alt1, alt2 }
+}
+
+/// Represent a choice between two incompatible choices.
+/// `ExclusiveChoice(a, b) <=> a or b` however it is in addition known
+/// that  `(a -> !b) and (b -> !a)` (i.e. the two choices are mutually exclusive).
+///
+/// When enforced (half-reified to an always true literal),
+/// we can thus create a single variable `l` and impose:
+///   - `l -> a`
+///   - `!l -> b`
+pub struct ExclusiveChoice<T> {
+    /// First alternative (exclusive to the second one)
+    alt1: T,
+    /// Second alternative (exclusive to the first one)
+    alt2: T,
+}
+
+impl<Ctx: Store, T: BoolExpr<Ctx>> BoolExpr<Ctx> for ExclusiveChoice<T> {
+    fn enforce_if(&self, l: Lit, ctx: &mut Ctx) {
+        if ctx.entails(l) {
+            // a tautolgy, create a single variable representing both options
+            let choice_var = ctx.new_literal(ctx.presence_literal(l));
+            self.alt1.opt_enforce_if(choice_var, ctx);
+            self.alt2.opt_enforce_if(!choice_var, ctx);
+        } else {
+            // no optimisation possible, resort to general formulation
+            let a = self.alt1.implicant(ctx);
+            let b = self.alt2.implicant(ctx);
+            or([a, b]).opt_enforce_if(l, ctx);
+        }
+    }
+    fn conj_scope(&self, ctx: &Ctx) -> Conjunction {
+        let mut sa = self.alt1.conj_scope(ctx).into_lits();
+        let sb = self.alt2.conj_scope(ctx);
+        sa.extend_from_slice(&sb);
+        sa.into()
+    }
+}
diff --git a/solver/src/model/lang/expr.rs b/solver/src/model/lang/expr.rs
index 0559f91e2..1678d3d86 100644
--- a/solver/src/model/lang/expr.rs
+++ b/solver/src/model/lang/expr.rs
@@ -1,9 +1,10 @@
 use crate::core::literals::{Disjunction, Lits};
-use crate::core::*;
+use crate::core::state::Evaluable;
 use crate::model::lang::alternative::Alternative;
-use crate::model::lang::hreif::{BoolExpr, Store};
-use crate::model::lang::{Atom, FAtom, IAtom, SAtom};
+use crate::model::lang::linear::{LinEq, LinNeq};
+use crate::model::lang::*;
 use crate::model::{Label, Model};
+use crate::prelude::*;
 use crate::reif::{DifferenceExpression, ReifExpr, Reifiable};
 use env_param::EnvParam;
 use itertools::Itertools;
@@ -50,6 +51,13 @@ pub fn f_geq(lhs: impl Into<FAtom>, rhs: impl Into<FAtom>) -> Leq {
     geq(lhs.num, rhs.num)
 }
 
+pub fn lin_eq(lhs: impl Into<LinSum>, rhs: impl Into<LinSum>) -> LinEq {
+    lhs.into().eq(rhs)
+}
+pub fn lin_neq(lhs: impl Into<LinSum>, rhs: impl Into<LinSum>) -> LinNeq {
+    lhs.into().neq(rhs)
+}
+
 pub fn eq(lhs: impl Into<Atom>, rhs: impl Into<Atom>) -> Eq {
     let lhs = lhs.into();
     let rhs = rhs.into();
@@ -95,6 +103,20 @@ impl Not for Or {
     }
 }
 
+impl Evaluable for Disjunction {
+    type Value = bool;
+
+    fn evaluate(&self, solution: &Solution) -> Option<Self::Value> {
+        if self.iter().any(|l| l.evaluate(solution) == Some(true)) {
+            Some(true)
+        } else if self.iter().any(|l| l.evaluate(solution).is_none()) {
+            None
+        } else {
+            Some(false)
+        }
+    }
+}
+
 #[derive(Clone)]
 pub struct And(Box<[Lit]>);
 
@@ -107,6 +129,13 @@ impl Not for And {
         Disjunction::from_vec(lits.to_vec())
     }
 }
+impl Not for &And {
+    type Output = Or;
+
+    fn not(self) -> Self::Output {
+        Disjunction::from_iter(self.0.iter().map(|&l| !l))
+    }
+}
 
 impl From<And> for ReifExpr {
     fn from(value: And) -> Self {
@@ -127,6 +156,13 @@ impl Not for Leq {
         gt(self.0, self.1)
     }
 }
+impl Not for &Leq {
+    type Output = Leq;
+
+    fn not(self) -> Self::Output {
+        !*self
+    }
+}
 
 impl From<Leq> for ReifExpr {
     fn from(value: Leq) -> Self {
@@ -160,6 +196,21 @@ impl From<Leq> for ReifExpr {
 #[derive(Copy, Clone, Debug)]
 pub struct Eq(Atom, Atom);
 
+impl Not for Eq {
+    type Output = Neq;
+
+    fn not(self) -> Self::Output {
+        Neq(self.0, self.1)
+    }
+}
+impl Not for &Eq {
+    type Output = Neq;
+
+    fn not(self) -> Self::Output {
+        !*self
+    }
+}
+
 impl<Lbl: Label> Reifiable<Lbl> for Eq {
     fn decompose(self, model: &mut Model<Lbl>) -> ReifExpr {
         let a = self.0;
@@ -215,7 +266,7 @@ impl<Lbl: Label> Reifiable<Lbl> for Eq {
 
 impl Eq {
     /// Returns an equivalent *conjunction* of `ReifExpr`
-    fn as_elementary_constraints(&self, store: &dyn Store) -> SmallVec<[ReifExpr; 2]> {
+    fn as_elementary_constraints<Ctx: Store>(&self, store: &mut Ctx) -> SmallVec<[ReifExpr; 2]> {
         let a = self.0;
         let b = self.1;
         let subs: SmallVec<[ReifExpr; 2]> = if a == b {
@@ -270,27 +321,24 @@ impl Eq {
     }
 }
 
-impl<Ctx> BoolExpr<Ctx> for Eq {
-    fn enforce_if(&self, l: Lit, ctx: &Ctx, store: &mut dyn Store) {
-        let elems = self.as_elementary_constraints(store);
+impl<Ctx: Store> BoolExpr<Ctx> for Eq {
+    fn enforce_if(&self, l: Lit, ctx: &mut Ctx) {
+        let elems = self.as_elementary_constraints(ctx);
         for elem in elems {
-            elem.enforce_if(l, ctx, store);
+            elem.enforce_if(l, ctx);
         }
     }
-    fn implicant(&self, _ctx: &Ctx, store: &mut dyn Store) -> Lit {
-        let elems = self.as_elementary_constraints(store);
+    fn implicant(&self, ctx: &mut Ctx) -> Lit {
+        let elems = self.as_elementary_constraints(ctx);
         if elems.contains(&ReifExpr::Lit(Lit::FALSE)) {
             return Lit::FALSE;
         }
-        let conjuncts = elems.into_iter().map(|e| store.get_implicant(e)).collect_vec();
-        store.get_implicant(and(conjuncts).into())
+        let conjuncts = elems.into_iter().map(|e| ctx.get_implicant(e)).collect_vec();
+        ctx.get_implicant(and(conjuncts).into())
     }
 
-    fn conj_scope(&self, _ctx: &Ctx, store: &dyn Store) -> super::hreif::Lits {
-        smallvec::smallvec![
-            store.presence_of_var(self.0.variable()),
-            store.presence_of_var(self.1.variable())
-        ]
+    fn conj_scope(&self, ctx: &Ctx) -> Conjunction {
+        [ctx.presence_literal(self.0), ctx.presence_literal(self.1)].into()
     }
 }
 
@@ -310,7 +358,7 @@ impl<Lbl: Label> Reifiable<Lbl> for Neq {
 
 impl Neq {
     /// Returns an equivalent *disjunction* of `ReifExpr`
-    pub fn as_elementary_disjuncts(&self, store: &dyn Store) -> SmallVec<[ReifExpr; 2]> {
+    pub fn as_elementary_disjuncts<Ctx: Store>(&self, store: &Ctx) -> SmallVec<[ReifExpr; 2]> {
         let a = self.0;
         let b = self.1;
         let subs: SmallVec<[ReifExpr; 2]> = if a == b {
@@ -368,24 +416,21 @@ impl Neq {
     }
 }
 
-impl<Ctx> BoolExpr<Ctx> for Neq {
-    fn enforce_if(&self, l: Lit, ctx: &Ctx, store: &mut dyn Store) {
-        let elems = self.as_elementary_disjuncts(store);
-        let disjuncts = elems.into_iter().map(|e| store.get_implicant(e)).collect_vec();
-        or(disjuncts).enforce_if(l, ctx, store);
+impl<Ctx: Store> BoolExpr<Ctx> for Neq {
+    fn enforce_if(&self, l: Lit, ctx: &mut Ctx) {
+        let elems = self.as_elementary_disjuncts(ctx);
+        let disjuncts = elems.into_iter().map(|e| ctx.get_implicant(e)).collect_vec();
+        or(disjuncts).enforce_if(l, ctx);
     }
-    fn implicant(&self, _ctx: &Ctx, store: &mut dyn Store) -> Lit {
-        let elems = self.as_elementary_disjuncts(store);
+    fn implicant(&self, ctx: &mut Ctx) -> Lit {
+        let elems = self.as_elementary_disjuncts(ctx);
         if elems.contains(&ReifExpr::Lit(Lit::TRUE)) {
             return Lit::TRUE;
         }
-        let disjuncts = elems.into_iter().map(|e| store.get_implicant(e)).collect_vec();
-        store.get_implicant(or(disjuncts).into())
+        let disjuncts = elems.into_iter().map(|e| ctx.get_implicant(e)).collect_vec();
+        ctx.get_implicant(or(disjuncts).into())
     }
-    fn conj_scope(&self, _ctx: &Ctx, store: &dyn Store) -> super::hreif::Lits {
-        smallvec::smallvec![
-            store.presence_of_var(self.0.variable()),
-            store.presence_of_var(self.1.variable())
-        ]
+    fn conj_scope(&self, ctx: &Ctx) -> Conjunction {
+        [ctx.presence_literal(self.0), ctx.presence_literal(self.1)].into()
     }
 }
diff --git a/solver/src/model/lang/fixed.rs b/solver/src/model/lang/fixed.rs
index e3b5b959f..a8b97e862 100644
--- a/solver/src/model/lang/fixed.rs
+++ b/solver/src/model/lang/fixed.rs
@@ -1,4 +1,5 @@
-use crate::core::{IntCst, VarRef};
+use crate::core::views::{Dom, Term, VarView};
+use crate::core::{IntCst, QCst, VarRef};
 use crate::model::lang::{ConversionError, IAtom, IVar};
 use num_rational::Ratio;
 use std::cmp::Ordering;
@@ -59,6 +60,24 @@ pub struct FAtom {
     pub num: IAtom,
     pub denom: IntCst,
 }
+impl VarView for FAtom {
+    type Value = QCst;
+
+    fn upper_bound(&self, dom: impl Dom) -> Self::Value {
+        debug_assert!(self.denom > 0);
+        QCst::new(self.num.upper_bound(dom), self.denom)
+    }
+
+    fn lower_bound(&self, dom: impl Dom) -> Self::Value {
+        debug_assert!(self.denom > 0);
+        QCst::new(self.num.lower_bound(dom), self.denom)
+    }
+}
+impl Term for FAtom {
+    fn variable(self) -> VarRef {
+        self.num.variable()
+    }
+}
 
 //Implement Debug for FAtom
 // `?` represents a variable
diff --git a/solver/src/model/lang/hreif.rs b/solver/src/model/lang/hreif.rs
deleted file mode 100644
index 28ed3aadc..000000000
--- a/solver/src/model/lang/hreif.rs
+++ /dev/null
@@ -1,373 +0,0 @@
-use smallvec::SmallVec;
-
-use crate::{
-    core::{IntCst, Lit, VarRef, state::Term},
-    model::{
-        Label, Model,
-        lang::expr::{And, Leq, Or, or},
-    },
-    prelude::DomainsExt,
-    reif::ReifExpr,
-};
-
-pub trait Store {
-    fn new_literal(&mut self, presence: Lit) -> Lit;
-    fn new_optional_var(&mut self, lb: IntCst, ub: IntCst, presence: Lit) -> VarRef;
-    fn get_implicant(&mut self, e: ReifExpr) -> Lit;
-    fn add_implies(&mut self, l: Lit, e: ReifExpr);
-    fn bounds(&self, var: VarRef) -> (IntCst, IntCst);
-    fn entails(&self, l: Lit) -> bool;
-
-    /// Returns the literal indicating whether the variable is present.
-    ///
-    /// See [`presence`] for a more general version.
-    fn presence_of_var(&self, var: VarRef) -> Lit;
-    fn conjunctive_scope(&mut self, lits: &[Lit]) -> Lit;
-    fn tautology_of_scope(&mut self, scope: Lit) -> Lit;
-
-    /// Returns the literal indicate the whether the term is present.
-    ///
-    /// Note: this method is not dyn-compatible.
-    /// [`presence_of_var`] may be used as a more verbose fall-back.
-    fn presence(&self, var: impl Term) -> Lit
-    where
-        Self: Sized,
-    {
-        self.presence_of_var(var.variable())
-    }
-}
-
-pub trait ModelWrapper {
-    type Lbl: Label;
-    fn get_model(&self) -> &Model<Self::Lbl>;
-    fn get_model_mut(&mut self) -> &mut Model<Self::Lbl>;
-}
-impl<L: Label> ModelWrapper for Model<L> {
-    type Lbl = L;
-
-    fn get_model(&self) -> &Model<Self::Lbl> {
-        self
-    }
-
-    fn get_model_mut(&mut self) -> &mut Model<Self::Lbl> {
-        self
-    }
-}
-
-impl<T> Store for T
-where
-    T: ModelWrapper,
-{
-    fn new_literal(&mut self, presence: Lit) -> Lit {
-        self.get_model_mut().state.new_optional_var(0, 1, presence).geq(1)
-    }
-    fn new_optional_var(&mut self, lb: IntCst, ub: IntCst, presence: Lit) -> VarRef {
-        self.get_model_mut().state.new_optional_var(lb, ub, presence)
-    }
-    fn get_implicant(&mut self, e: ReifExpr) -> Lit {
-        self.get_model_mut().half_reify(e.clone())
-    }
-
-    fn add_implies(&mut self, l: Lit, e: ReifExpr) {
-        //println!("[{:?}] {l:?} -> {e:?}", self.presence(l)); // TODO: remove
-        self.get_model_mut().enforce_if(l, e);
-    }
-    fn bounds(&self, var: VarRef) -> (IntCst, IntCst) {
-        self.get_model().state.bounds(var)
-    }
-    fn entails(&self, l: Lit) -> bool {
-        self.get_model().state.entails(l)
-    }
-
-    fn presence_of_var(&self, var: VarRef) -> Lit {
-        self.get_model().state.presence_literal(var)
-    }
-    fn conjunctive_scope(&mut self, presence_variables: &[Lit]) -> Lit {
-        self.get_model_mut().get_conjunctive_scope(presence_variables)
-    }
-    fn tautology_of_scope(&mut self, scope: Lit) -> Lit {
-        self.get_model_mut().get_tautology_of_scope(scope)
-    }
-}
-
-pub trait BoolExpr<Ctx> {
-    fn enforce_if(&self, l: Lit, ctx: &Ctx, store: &mut dyn Store);
-
-    /// Returns a set of literals that must all be true for the expression to be valid.
-    /// The list is interpreted as a set: order and redundant elements are ignored.
-    ///
-    /// Examples:
-    ///   - (a < b) would have a conjunctive scope `[prez(a), prez(b)]` as it is only valid when both
-    ///     a and b are present. The conjunctive scope is thus the list their presence variable.
-    fn conj_scope(&self, ctx: &Ctx, store: &dyn Store) -> Lits;
-    fn scope(&self, ctx: &Ctx, store: &mut dyn Store) -> Lit {
-        let conj_scope = self.conj_scope(ctx, store);
-        store.conjunctive_scope(&conj_scope)
-    }
-    fn opt_enforce_if(&self, l: Lit, ctx: &Ctx, store: &mut dyn Store) {
-        let scope = self.scope(ctx, store);
-        let implicant = if scope == store.presence_of_var(l.variable()) {
-            l // TODO: here we should instead test that scope => prez(l)
-        } else if store.entails(l) {
-            store.tautology_of_scope(scope)
-        } else {
-            let imp = store.new_literal(scope);
-            or([imp, !scope]).enforce_if(l, ctx, store);
-            imp
-        };
-        self.enforce_if(implicant, ctx, store);
-    }
-    fn implicant(&self, ctx: &Ctx, store: &mut dyn Store) -> Lit {
-        let scope = self.scope(ctx, store);
-        let implicant = store.new_literal(scope);
-        self.enforce_if(implicant, ctx, store);
-        implicant
-    }
-    fn enforce(&self, ctx: &Ctx, store: &mut dyn Store) {
-        self.opt_enforce_if(Lit::TRUE, ctx, store);
-    }
-}
-
-impl<Ctx, T: BoolExpr<Ctx>> BoolExpr<Ctx> for &T {
-    fn enforce_if(&self, l: Lit, ctx: &Ctx, store: &mut dyn Store) {
-        (*self).enforce_if(l, ctx, store);
-    }
-
-    fn conj_scope(&self, ctx: &Ctx, store: &dyn Store) -> Lits {
-        (*self).conj_scope(ctx, store)
-    }
-    fn implicant(&self, ctx: &Ctx, store: &mut dyn Store) -> Lit {
-        (*self).implicant(ctx, store)
-    }
-
-    //TODO: - check that we call the right one
-    //      - implement all other methods to make sure we use the most specific implementation
-}
-
-pub type Lits = SmallVec<[Lit; 2]>;
-#[macro_export]
-macro_rules! lits {
-    ($($x:tt)*) => {smallvec::smallvec![$($x)*]}
-}
-
-impl<Ctx> BoolExpr<Ctx> for ReifExpr {
-    fn enforce_if(&self, l: Lit, _ctx: &Ctx, store: &mut dyn Store) {
-        store.add_implies(l, self.clone());
-    }
-
-    fn conj_scope(&self, _ctx: &Ctx, store: &dyn Store) -> Lits {
-        let vs = self.scope(|v| store.presence_of_var(v));
-        // TODO: give flattening context
-        let conj_scope = vs.to_conjunction(|_| Option::<[Lit; 0]>::None, |l| l == Lit::TRUE);
-        SmallVec::from_iter(conj_scope.literals())
-    }
-    fn implicant(&self, _ctx: &Ctx, store: &mut dyn Store) -> Lit {
-        if let ReifExpr::Lit(l) = self {
-            *l // short circuit happy case
-        } else {
-            store.get_implicant(self.clone())
-        }
-    }
-}
-
-// Derive `impl BoolExpr<_>` for Expression convertible to `ReifExpr`
-crate::impl_reif!(Lit);
-crate::impl_reif!(Or);
-crate::impl_reif!(And);
-crate::impl_reif!(Leq);
-
-#[macro_export]
-macro_rules! impl_reif {
-    ($A: ty) => {
-        impl<Ctx> BoolExpr<Ctx> for $A
-        where
-            $A: Clone,
-            ReifExpr: From<$A>,
-        {
-            fn enforce_if(&self, l: Lit, ctx: &Ctx, store: &mut dyn Store) {
-                ReifExpr::from(self.clone()).enforce_if(l, ctx, store);
-            }
-            fn conj_scope(&self, ctx: &Ctx, store: &dyn Store) -> Lits {
-                ReifExpr::from(self.clone()).conj_scope(ctx, store)
-            }
-            fn implicant(&self, _ctx: &Ctx, store: &mut dyn Store) -> Lit {
-                store.get_implicant(ReifExpr::from(self.clone()))
-            }
-        }
-    };
-}
-
-pub fn exclu_choice<T>(alt1: T, alt2: T) -> ExclusiveChoice<T> {
-    ExclusiveChoice { alt1, alt2 }
-}
-
-/// Represent a choice between two incompatible choices.
-/// `ExclusiveChoice(a, b) <=> a or b` however it is in addition known
-/// that  `(a -> !b) and (b -> !a)` (i.e. the two choices are mutually exclusive).
-///
-/// When enforced (half-reified to an always true literal),
-/// we can thus create a single variable `l` and impose:
-///   - `l -> a`
-///   - `!l -> b`
-pub struct ExclusiveChoice<T> {
-    /// First alternative (exclusive to the second one)
-    alt1: T,
-    /// Second alternative (exclusive to the first one)
-    alt2: T,
-}
-
-impl<Ctx, T: BoolExpr<Ctx>> BoolExpr<Ctx> for ExclusiveChoice<T> {
-    fn enforce_if(&self, l: Lit, ctx: &Ctx, store: &mut dyn Store) {
-        if store.entails(l) {
-            // a tautolgy, create a single variable representing both options
-            let choice_var = store.new_literal(store.presence_of_var(l.variable()));
-            self.alt1.opt_enforce_if(choice_var, ctx, store);
-            self.alt2.opt_enforce_if(!choice_var, ctx, store);
-        } else {
-            // no optimisation possible, resort to general formulation
-            let a = self.alt1.implicant(ctx, store);
-            let b = self.alt2.implicant(ctx, store);
-            or([a, b]).opt_enforce_if(l, ctx, store);
-        }
-    }
-    fn conj_scope(&self, ctx: &Ctx, store: &dyn Store) -> Lits {
-        let mut sa = self.alt1.conj_scope(ctx, store);
-        let sb = self.alt2.conj_scope(ctx, store);
-        sa.extend_from_slice(&sb);
-        sa
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use crate::{
-        model::{
-            extensions::DomainsExt,
-            lang::{
-                Atom, IAtom,
-                expr::{lt, neq},
-            },
-        },
-        solver::{SearchLimit, Solver},
-    };
-
-    use super::*;
-    use crate::core::state::Term;
-
-    /// All different with potentially optional variables
-    struct AllDifferent(Vec<IAtom>);
-
-    /// True if the the two atoms are different, and undefined if at least one is absent
-    struct Different(IAtom, IAtom);
-
-    fn prez(v: impl Term, store: &dyn Store) -> Lit {
-        store.presence_of_var(v.variable())
-    }
-
-    impl<Ctx> BoolExpr<Ctx> for AllDifferent {
-        fn enforce_if(&self, l: Lit, ctx: &Ctx, store: &mut dyn Store) {
-            for (i, t1) in self.0.iter().copied().enumerate() {
-                for t2 in self.0[i + 1..].iter().copied() {
-                    Different(t1, t2).opt_enforce_if(l, ctx, store);
-                }
-            }
-        }
-
-        fn conj_scope(&self, _ctx: &Ctx, _store: &dyn Store) -> Lits {
-            lits![]
-        }
-    }
-
-    impl<Ctx> BoolExpr<Ctx> for Different {
-        fn enforce_if(&self, l: Lit, ctx: &Ctx, store: &mut dyn Store) {
-            neq(self.0, self.1).opt_enforce_if(l, ctx, store);
-        }
-
-        fn conj_scope(&self, _ctx: &Ctx, store: &dyn Store) -> Lits {
-            lits![prez(self.0, store), prez(self.1, store)]
-        }
-    }
-
-    #[test]
-    fn test_alldiff_exp() {
-        let n = 2;
-        let mut m: Model<String> = Model::new();
-        let mut tasks = Vec::with_capacity(n);
-        for i in 1..=n {
-            let pi = m.new_presence_variable(Lit::TRUE, format!("p{i}")).true_lit();
-            let ti = m.new_optional_ivar(0, 1, pi, format!("t{i}"));
-            tasks.push(IAtom::from(ti));
-        }
-
-        let _activator = m.new_bvar("activator").true_lit();
-        let no = AllDifferent(tasks.clone());
-        no.opt_enforce_if(Lit::TRUE, &(), &mut m);
-        //no.opt_enforce_if(_activator, &mut m);
-        m.print_state();
-
-        let s = Solver::new(m);
-        let count = enumerate(s, &tasks);
-        assert_eq!(count, 7);
-    }
-    fn enumerate<L: Label>(mut s: Solver<L>, ints: &[IAtom]) -> i32 {
-        let mut vars = Vec::with_capacity(ints.len() * 2);
-        for &i in ints {
-            vars.push(i.variable());
-            vars.push(s.model.presence(i.variable()).variable());
-        }
-        vars.sort();
-        vars.dedup();
-        let mut counter = 0;
-        s.enumerate_with(
-            &vars,
-            |sol| {
-                counter += 1;
-                println!("Sol {}", &counter);
-                for i in ints {
-                    print!("  {i:?}: ");
-                    if sol.present(*i) == Some(true) {
-                        println!("{:?}", sol.evaluate(Atom::from(*i)).unwrap());
-                    } else {
-                        println!("-");
-                    }
-                }
-            },
-            SearchLimit::None,
-        )
-        .expect("error returned by enumerate");
-        counter
-    }
-
-    type TaskId = usize;
-    struct Starts(Vec<IAtom>);
-
-    struct Ordered(TaskId, TaskId);
-
-    impl BoolExpr<Starts> for Ordered {
-        fn enforce_if(&self, l: Lit, ctx: &Starts, store: &mut dyn Store) {
-            let c = lt(ctx.0[self.0], ctx.0[self.1]);
-            c.opt_enforce_if(l, ctx, store);
-        }
-
-        fn conj_scope(&self, ctx: &Starts, store: &dyn Store) -> Lits {
-            let c = lt(ctx.0[self.0], ctx.0[self.1]);
-            c.conj_scope(ctx, store)
-        }
-    }
-
-    #[test]
-    fn test_ctx2() {
-        let mut store: Model<String> = Model::new();
-        let s1 = store.new_ivar(0, 1000, "start1");
-        let s2 = store.new_ivar(0, 1000, "start2");
-        let s3 = store.new_ivar(0, 1000, "start3");
-        let starts = Starts(vec![s1.into(), s2.into(), s3.into()]);
-        let x = Ordered(1, 2);
-        let y: &dyn BoolExpr<_> = &x;
-
-        y.opt_enforce_if(Lit::FALSE, &starts, &mut store);
-
-        let e = ReifExpr::And(crate::core::literals::Lits::new());
-        e.opt_enforce_if(Lit::TRUE, &starts, &mut store);
-    }
-}
diff --git a/solver/src/model/lang/int.rs b/solver/src/model/lang/int.rs
index 2d4db6b2b..548e10aef 100644
--- a/solver/src/model/lang/int.rs
+++ b/solver/src/model/lang/int.rs
@@ -1,5 +1,4 @@
-use crate::core::state::Term;
-use crate::core::views::{Boundable, VarView};
+use crate::core::views::{Boundable, Term, VarView};
 use crate::core::*;
 use crate::model::lang::ConversionError;
 use crate::model::lang::linear::LinearTerm;
@@ -46,6 +45,11 @@ impl From<IVar> for VarRef {
         i.0
     }
 }
+impl From<VarRef> for IVar {
+    fn from(v: VarRef) -> Self {
+        IVar::new(v)
+    }
+}
 
 impl From<IVar> for SignedVar {
     fn from(value: IVar) -> Self {
@@ -115,6 +119,12 @@ impl IAtom {
         var: IVar::ZERO,
         shift: 0,
     };
+    pub const ONE: IAtom = IAtom {
+        var: IVar::ZERO,
+        shift: 1,
+    };
+    pub const TRUE: IAtom = Self::ONE;
+    pub const FALSE: IAtom = Self::ZERO;
     pub fn new(var: IVar, shift: IntCst) -> IAtom {
         IAtom { var, shift }
     }
diff --git a/solver/src/model/lang/int_expr.rs b/solver/src/model/lang/int_expr.rs
new file mode 100644
index 000000000..8fb936a06
--- /dev/null
+++ b/solver/src/model/lang/int_expr.rs
@@ -0,0 +1,39 @@
+use crate::{model::lang::Store, prelude::*};
+
+/// Represents an integer expression that can be reified or made equal to another variable
+pub trait IntExpr<Ctx: Store> {
+    /// Reifies the expression into a term with a single variable.
+    fn reify(&self, scope: impl Into<Conjunction>, ctx: &mut Ctx) -> LinTerm {
+        let scope = scope.into();
+        let scope = ctx.conjunctive_scope(scope.literals());
+        let (lb, ub) = self.bounds(ctx);
+        let reif = ctx.new_optional_var(lb, ub, scope);
+        let reif = LinTerm::from(reif);
+        self.enforce_eq(reif, ctx);
+        reif
+    }
+
+    /// Returns the lower and upper bounds of the expressions.
+    ///
+    /// The default implementation just returns the lower bound [`INT_CST_MIN`] and the upper bound  [`INT_CST_MAX`].`
+    fn bounds(&self, _ctx: &Ctx) -> (IntCst, IntCst) {
+        (INT_CST_MIN, INT_CST_MAX)
+    }
+
+    /// Attempts to provide a linearization of the expression. It must be the case that the expression is defined within the provided scope.
+    ///
+    /// The default implementation will simply reify the expression to a single variable and return the [`LinearSum`] with only this variable]
+    fn linearize(&self, scope: impl Into<Conjunction>, ctx: &mut Ctx) -> LinSum {
+        self.reify(scope, ctx).into()
+    }
+
+    /// Enforce that, whenever `variable` is defined, it has the same value as the expression.
+    fn enforce_eq(&self, variable: LinTerm, ctx: &mut Ctx) {
+        // Create an enabler that is always true and has the same scope as `variable`
+        let enabler = ctx.tautology_of_scope(ctx.presence_literal(variable));
+        self.enforce_eq_if(enabler, variable, ctx);
+    }
+
+    /// Enforces that when `implicant` is true and defined,
+    fn enforce_eq_if(&self, implicant: Lit, variable: LinTerm, ctx: &mut Ctx);
+}
diff --git a/solver/src/model/lang/linear.rs b/solver/src/model/lang/linear.rs
index 7e91d70ed..feec216f3 100644
--- a/solver/src/model/lang/linear.rs
+++ b/solver/src/model/lang/linear.rs
@@ -1,9 +1,15 @@
-use num_integer::lcm;
-
-use crate::core::{IntCst, Lit, VarRef};
-use crate::model::lang::{IAtom, IVar, ValidityScope};
+use num_integer::{div_ceil, div_floor, lcm};
+use smallvec::{SmallVec, smallvec};
+
+use crate::core::state::Evaluable;
+use crate::core::views::{Boundable, Dom, Term, VarView};
+use crate::core::{IntCst, Lit, QCst, SignedVar, VarRef};
+use crate::model::lang::expr::or;
+use crate::model::lang::{BoolExpr, IAtom, IVar, IntExpr, Store, ValidityScope};
+use crate::prelude::Conjunction;
 use crate::reif::ReifExpr;
 use std::collections::BTreeMap;
+use std::fmt::{Debug, Display};
 
 /* ========================================================================== */
 /*                                 LinearTerm                                 */
@@ -19,7 +25,7 @@ pub struct LinearTerm {
     denom: IntCst,
 }
 
-impl std::fmt::Display for LinearTerm {
+impl Display for LinearTerm {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         if self.factor != 1 {
             if self.factor == -1 {
@@ -322,6 +328,22 @@ impl From<IAtom> for LinearSum {
     }
 }
 
+impl From<SignedVar> for LinearTerm {
+    fn from(value: SignedVar) -> Self {
+        LinearTerm {
+            factor: if value.is_plus() { 1 } else { -1 },
+            var: IVar::new(value.variable()),
+            denom: 1,
+        }
+    }
+}
+
+impl From<SignedVar> for LinearSum {
+    fn from(value: SignedVar) -> Self {
+        LinearSum::from(LinearTerm::from(value))
+    }
+}
+
 impl TryFrom<Atom> for LinearSum {
     type Error = ConversionError;
 
@@ -401,15 +423,65 @@ impl std::ops::Neg for LinearSum {
     }
 }
 
+impl TryFrom<LinearSum> for IAtom {
+    type Error = ();
+
+    fn try_from(value: LinearSum) -> Result<Self, Self::Error> {
+        let value = value.simplify();
+        if value.denom != 1 {
+            return Err(());
+        }
+        let var = if value.terms.is_empty() {
+            IVar::ZERO
+        } else if value.terms.len() == 1 {
+            let term = value.terms[0];
+            debug_assert_eq!(term.denom, 1);
+            if term.factor() == 1 {
+                term.var
+            } else {
+                return Err(());
+            }
+        } else {
+            return Err(());
+        };
+        Ok(var + value.constant)
+    }
+}
+
 use crate::transitive_conversion;
 
 use super::{Atom, ConversionError, FAtom};
 transitive_conversion!(LinearSum, LinearTerm, IVar);
+transitive_conversion!(LinearSum, IVar, VarRef);
+
+impl Evaluable for LinearSum {
+    type Value = QCst;
+
+    fn evaluate(&self, solution: &crate::prelude::Solution) -> Option<Self::Value> {
+        let mut sum = QCst::new(self.constant, self.denom);
+        for term in &self.terms {
+            // add the contribution of each term, BUT
+            // we shortcircuit and return None if the term is absent
+            sum += term.evaluate(solution)?;
+        }
+        Some(sum)
+    }
+}
+
+impl Evaluable for LinearTerm {
+    type Value = QCst;
+
+    fn evaluate(&self, solution: &crate::prelude::Solution) -> Option<Self::Value> {
+        let var_value = self.var.evaluate(solution)?;
+        Some(QCst::new(self.factor, self.denom) * QCst::from_integer(var_value))
+    }
+}
 
 /* ========================================================================== */
 /*                                  LinearLeq                                 */
 /* ========================================================================== */
 
+#[derive(Clone)]
 pub struct LinearLeq {
     sum: LinearSum,
     ub: IntCst,
@@ -444,64 +516,498 @@ impl From<LinearLeq> for ReifExpr {
                 .or_insert(e.factor);
         }
         ReifExpr::Linear(NFLinearLeq {
-            sum: vars
-                .iter()
-                .map(|(&var, &factor)| NFLinearSumItem { var, factor })
-                .collect(),
+            sum: vars.iter().map(|(&var, &factor)| ScaledVar { var, factor }).collect(),
             upper_bound: value.ub - value.sum.constant,
         })
     }
 }
 
 /* ========================================================================== */
-/*                               NFLinearSumItem                              */
+/*                               ScaledVar                                    */
 /* ========================================================================== */
 
-#[derive(Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Hash, Debug)]
-pub struct NFLinearSumItem {
+/// A term of the form `a * X` where `X` is an integer variable and `a` is a integer constant.
+#[derive(Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
+pub struct ScaledVar {
+    /// Variable `X` to which the factor is applied
+    ///
+    /// Note that the order is important so that `Ord` considers first the variable when ordering a list.
+    /// This is relied upon when normalizing a linear sum.
     pub var: VarRef,
+    /// Factor `a` by which the variable is multiplied.
     pub factor: IntCst,
 }
 
-impl std::fmt::Display for NFLinearSumItem {
+impl ScaledVar {
+    pub const ZERO: ScaledVar = ScaledVar::new(VarRef::ZERO, 0);
+    pub const fn new(var: VarRef, factor: IntCst) -> Self {
+        Self { var, factor }
+    }
+
+    /// Returns true if the term is always equal to zero.
+    pub fn is_zero(&self) -> bool {
+        self.factor == 0 || self.var == VarRef::ZERO
+    }
+}
+
+impl Display for ScaledVar {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        if self.factor != 1 {
-            if self.factor == -1 {
-                write!(f, "-")?;
-            } else {
-                write!(f, "{}", self.factor)?;
-            }
+        match self.factor {
+            _ if self.is_zero() => write!(f, "0"),
+            1 => write!(f, "{:?}", self.var),
+            -1 => write!(f, "-{:?}", self.var),
+            _ => write!(f, "{}*{:?}", self.factor, self.var),
         }
-        if self.factor.abs() != 1 && self.var != VarRef::ONE {
-            write!(f, "*")?;
+    }
+}
+
+impl std::fmt::Debug for ScaledVar {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{self}")
+    }
+}
+
+impl From<SignedVar> for ScaledVar {
+    fn from(value: SignedVar) -> Self {
+        Self {
+            var: value.variable(),
+            factor: value.sign(),
         }
-        if self.var != VarRef::ONE {
-            write!(f, "{:?}", self.var)?;
-        } else if self.factor.abs() == 1 {
-            write!(f, "1")?;
+    }
+}
+
+impl VarView for ScaledVar {
+    type Value = IntCst;
+
+    fn upper_bound(&self, dom: impl crate::core::views::Dom) -> Self::Value {
+        let svar = if self.factor >= 0 {
+            SignedVar::plus(self.var)
+        } else {
+            SignedVar::minus(self.var)
+        };
+
+        svar.upper_bound(dom) * self.factor.abs()
+    }
+
+    fn lower_bound(&self, dom: impl crate::core::views::Dom) -> Self::Value {
+        -(-self).upper_bound(dom)
+    }
+}
+
+impl Boundable for ScaledVar {
+    type Value = IntCst;
+
+    fn leq(&self, ub: Self::Value) -> Lit {
+        // a*X <= ub
+        // X <= ub/a   (floor gets us the first integer value below)
+        self.var.leq(div_floor(ub, self.factor))
+    }
+
+    fn geq(&self, lb: Self::Value) -> Lit {
+        // a*X >= lb
+        // X >= lb/a
+        self.var.geq(div_ceil(lb, self.factor))
+    }
+}
+
+impl std::ops::Neg for ScaledVar {
+    type Output = ScaledVar;
+
+    fn neg(self) -> Self::Output {
+        ScaledVar::new(self.var, -self.factor)
+    }
+}
+impl std::ops::Neg for &ScaledVar {
+    type Output = ScaledVar;
+
+    fn neg(self) -> Self::Output {
+        ScaledVar::new(self.var, -self.factor)
+    }
+}
+impl Term for ScaledVar {
+    fn variable(self) -> VarRef {
+        self.var
+    }
+}
+
+/// A term of the form `a * X + b` where `X` is an integer variable and `a` and `b` are integer constants.
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct LinTerm {
+    scaled_var: ScaledVar,
+    constant: IntCst,
+}
+
+impl LinTerm {
+    const fn new(scaled_var: ScaledVar, constant: IntCst) -> Self {
+        Self { scaled_var, constant }
+    }
+    pub const fn int_cst(constant: IntCst) -> Self {
+        Self::new(ScaledVar::ZERO, constant)
+    }
+
+    pub const ZERO: Self = Self::int_cst(0);
+    pub const TRUE: Self = Self::int_cst(1);
+    pub const FALSE: Self = Self::int_cst(0);
+
+    pub fn eq<Rhs: Into<LinSum>>(&self, other: Rhs) -> LinEq {
+        LinSum::from(*self).eq(other.into())
+    }
+}
+
+impl Debug for LinTerm {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if self.scaled_var.is_zero() {
+            return write!(f, "{}", self.constant);
+        }
+        write!(f, "{:?}", self.scaled_var)?;
+        if self.constant > 0 {
+            write!(f, " + {}", self.constant)?;
+        } else if self.constant < 0 {
+            write!(f, " - {}", self.constant.abs())?;
         }
         Ok(())
     }
 }
 
-impl std::ops::Neg for NFLinearSumItem {
-    type Output = NFLinearSumItem;
+impl VarView for LinTerm {
+    type Value = IntCst;
+
+    fn upper_bound(&self, dom: impl crate::core::views::Dom) -> Self::Value {
+        self.scaled_var.upper_bound(dom) + self.constant
+    }
+
+    fn lower_bound(&self, dom: impl crate::core::views::Dom) -> Self::Value {
+        self.scaled_var.lower_bound(dom) + self.constant
+    }
+}
+
+impl Boundable for LinTerm {
+    type Value = IntCst;
+
+    fn leq(&self, ub: Self::Value) -> Lit {
+        // a*X + b <= ub
+        // a*X <= ub -b
+        self.scaled_var.leq(ub - self.constant)
+    }
+
+    fn geq(&self, lb: Self::Value) -> Lit {
+        // a*X + b >= lb
+        // a*X >= lb -b
+        self.scaled_var.geq(lb - self.constant)
+    }
+}
+impl Term for LinTerm {
+    fn variable(self) -> VarRef {
+        self.scaled_var.variable()
+    }
+}
+
+impl std::ops::Neg for LinTerm {
+    type Output = Self;
 
     fn neg(self) -> Self::Output {
-        NFLinearSumItem {
-            var: self.var,
-            factor: -self.factor,
+        Self::new(-self.scaled_var, -self.constant)
+    }
+}
+impl std::ops::Add<LinTerm> for LinTerm {
+    type Output = LinSum;
+
+    fn add(self, rhs: Self) -> Self::Output {
+        LinSum::from(self) + rhs
+    }
+}
+impl std::ops::Sub<LinTerm> for LinTerm {
+    type Output = LinSum;
+
+    fn sub(self, rhs: Self) -> Self::Output {
+        LinSum::from(self) - rhs
+    }
+}
+
+impl From<IntCst> for LinTerm {
+    fn from(value: IntCst) -> Self {
+        LinTerm::int_cst(value)
+    }
+}
+impl From<IAtom> for LinTerm {
+    fn from(value: IAtom) -> Self {
+        Self {
+            scaled_var: ScaledVar::new(value.var.variable(), 1),
+            constant: value.shift,
         }
     }
 }
+impl From<ScaledVar> for LinTerm {
+    fn from(value: ScaledVar) -> Self {
+        Self::new(value, 0)
+    }
+}
+
+impl TryFrom<LinTerm> for IntCst {
+    type Error = ();
+
+    fn try_from(value: LinTerm) -> Result<Self, Self::Error> {
+        if value.scaled_var.is_zero() {
+            Ok(value.constant)
+        } else {
+            Err(())
+        }
+    }
+}
+
+transitive_conversion!(LinTerm, ScaledVar, SignedVar);
+transitive_conversion!(LinTerm, IAtom, IVar);
+transitive_conversion!(LinTerm, SignedVar, VarRef);
+transitive_conversion!(LinSum, LinTerm, VarRef);
+transitive_conversion!(LinSum, LinTerm, SignedVar);
+transitive_conversion!(LinSum, LinTerm, IAtom);
+transitive_conversion!(LinSum, LinTerm, IVar);
+
+#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
+pub struct LinSum {
+    vars: SmallVec<[ScaledVar; 2]>,
+    constant: IntCst,
+}
+
+impl LinSum {
+    pub fn cst(constant: IntCst) -> Self {
+        Self {
+            vars: SmallVec::new(),
+            constant,
+        }
+    }
+    pub fn zero() -> Self {
+        Self::cst(0)
+    }
+    pub fn eq<Rhs: Into<LinSum>>(self, other: Rhs) -> LinEq {
+        LinEq(self - other)
+    }
+    pub fn neq<Rhs: Into<LinSum>>(self, other: Rhs) -> LinNeq {
+        LinNeq(self - other)
+    }
+    pub fn leq<Rhs: Into<LinSum>>(self, upper_bound: Rhs) -> LinLeq {
+        LinLeq(self - upper_bound)
+    }
+    pub fn geq<Rhs: Into<LinSum>>(self, lower_bound: Rhs) -> LinLeq {
+        LinLeq(lower_bound.into() - self)
+    }
+
+    /// Returns the conjunction of all presence literals of variables appearing in the sum.
+    pub fn conj_scope(&self, dom: impl Dom) -> Conjunction {
+        Conjunction::from_iter(self.vars.iter().map(|sv| dom.presence(sv.var)))
+    }
+}
+
+impl From<LinTerm> for LinSum {
+    fn from(value: LinTerm) -> Self {
+        Self {
+            vars: smallvec![value.scaled_var],
+            constant: value.constant,
+        }
+    }
+}
+impl From<IntCst> for LinSum {
+    fn from(value: IntCst) -> Self {
+        Self::cst(value)
+    }
+}
+
+impl TryFrom<LinSum> for LinTerm {
+    type Error = ();
+
+    fn try_from(value: LinSum) -> Result<Self, Self::Error> {
+        match *value.vars.as_slice() {
+            [] => Ok(LinTerm::int_cst(value.constant)),
+            [single] => Ok(LinTerm::new(single, value.constant)),
+            _ => Err(()),
+        }
+    }
+}
+
+impl<T: Into<Self>> std::ops::AddAssign<T> for LinSum {
+    fn add_assign(&mut self, rhs: T) {
+        let rhs = rhs.into();
+        self.vars.extend_from_slice(&rhs.vars);
+        self.constant += rhs.constant;
+    }
+}
+impl<T: Into<Self>> std::ops::Add<T> for LinSum {
+    type Output = Self;
+
+    fn add(mut self, rhs: T) -> Self::Output {
+        self += rhs;
+        self
+    }
+}
+impl std::ops::Neg for LinSum {
+    type Output = LinSum;
+
+    fn neg(mut self) -> Self::Output {
+        self *= -1;
+        self
+    }
+}
+impl<T: Into<Self>> std::ops::SubAssign<T> for LinSum {
+    fn sub_assign(&mut self, rhs: T) {
+        *self += -rhs.into();
+    }
+}
+impl<T: Into<Self>> std::ops::Sub<T> for LinSum {
+    type Output = Self;
+
+    fn sub(mut self, rhs: T) -> Self::Output {
+        self -= rhs;
+        self
+    }
+}
+impl std::ops::MulAssign<IntCst> for LinSum {
+    fn mul_assign(&mut self, rhs: IntCst) {
+        self.constant *= rhs;
+        self.vars.iter_mut().for_each(|sv| sv.factor *= rhs);
+    }
+}
+impl std::ops::Mul<IntCst> for LinSum {
+    type Output = Self;
+
+    fn mul(mut self, rhs: IntCst) -> Self::Output {
+        self *= rhs;
+        self
+    }
+}
+impl std::ops::Mul<LinSum> for IntCst {
+    type Output = LinSum;
+
+    fn mul(self, mut rhs: LinSum) -> Self::Output {
+        rhs *= self;
+        rhs
+    }
+}
+impl From<&LinSum> for LinearSum {
+    fn from(value: &LinSum) -> Self {
+        let mut out = LinearSum::constant_int(value.constant);
+        for t in &value.vars {
+            out.add_term(LinearTerm::int(t.factor, IVar::new(t.var)));
+        }
+        out
+    }
+}
+
+impl<Ctx: Store> IntExpr<Ctx> for LinSum {
+    fn enforce_eq_if(&self, implicant: Lit, variable: LinTerm, ctx: &mut Ctx) {
+        self.clone().eq(variable).enforce_if(implicant, ctx);
+    }
+}
+
+/// A linear inequality over integer variables.
+///
+/// The expression is true iff the linear sum is lesser than or equal to zero.
+pub struct LinLeq(LinSum);
+
+/// A linear equality over integer variables.
+///
+/// The expression is true iff the linear sum is equal to zero.
+pub struct LinEq(LinSum);
+
+/// A linear disequality over integer variables.
+///
+/// The expression is true iff the linear sum is *not* equal to zero.
+pub struct LinNeq(LinSum);
+
+impl std::ops::Not for LinEq {
+    type Output = LinNeq;
+
+    fn not(self) -> Self::Output {
+        LinNeq(self.0)
+    }
+}
+
+impl std::ops::Not for LinNeq {
+    type Output = LinEq;
+
+    fn not(self) -> Self::Output {
+        LinEq(self.0)
+    }
+}
+
+impl std::ops::Not for LinLeq {
+    type Output = LinLeq;
+
+    fn not(self) -> Self::Output {
+        self.0.geq(1)
+    }
+}
+impl std::ops::Not for &LinEq {
+    type Output = LinNeq;
+
+    fn not(self) -> Self::Output {
+        LinNeq(self.0.clone())
+    }
+}
+impl std::ops::Not for &LinNeq {
+    type Output = LinEq;
+
+    fn not(self) -> Self::Output {
+        LinEq(self.0.clone())
+    }
+}
+
+impl std::ops::Not for &LinLeq {
+    type Output = LinLeq;
+
+    fn not(self) -> Self::Output {
+        self.0.clone().geq(1)
+    }
+}
+
+// TODO: use native implementation
+impl<Ctx: Store> BoolExpr<Ctx> for LinLeq {
+    fn enforce_if(&self, implicant: Lit, ctx: &mut Ctx) {
+        LinearSum::from(&self.0).leq(0).enforce_if(implicant, ctx);
+    }
+
+    fn conj_scope(&self, ctx: &Ctx) -> crate::prelude::Conjunction {
+        self.0.conj_scope(ctx)
+    }
+}
+
+impl From<LinLeq> for ReifExpr {
+    fn from(value: LinLeq) -> Self {
+        LinearSum::from(&value.0).leq(0).into()
+    }
+}
+
+impl<Ctx: Store> BoolExpr<Ctx> for LinEq {
+    fn enforce_if(&self, implicant: Lit, ctx: &mut Ctx) {
+        let sum = &self.0;
+        sum.clone().leq(0).enforce_if(implicant, ctx);
+        sum.clone().geq(0).enforce_if(implicant, ctx);
+    }
+
+    fn conj_scope(&self, ctx: &Ctx) -> crate::prelude::Conjunction {
+        self.0.conj_scope(ctx)
+    }
+}
+
+impl<Ctx: Store> BoolExpr<Ctx> for LinNeq {
+    fn enforce_if(&self, implicant: Lit, ctx: &mut Ctx) {
+        let sum = &self.0;
+        let greater = sum.clone().geq(1).implicant(ctx);
+        let smaller = sum.clone().leq(-1).implicant(ctx);
+        or([greater, smaller]).enforce_if(implicant, ctx);
+    }
+
+    fn conj_scope(&self, ctx: &Ctx) -> Conjunction {
+        self.0.conj_scope(ctx)
+    }
+}
 
 /* ========================================================================== */
 /*                                 NFLinearLeq                                */
 /* ========================================================================== */
 
-#[derive(Eq, PartialEq, Hash, Debug, Clone)]
+#[derive(Eq, PartialEq, Hash, Clone)]
 pub struct NFLinearLeq {
-    pub sum: Vec<NFLinearSumItem>,
+    pub sum: Vec<ScaledVar>,
     pub upper_bound: IntCst,
 }
 
@@ -533,6 +1039,12 @@ impl std::fmt::Display for NFLinearLeq {
     }
 }
 
+impl Debug for NFLinearLeq {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{self}")
+    }
+}
+
 impl NFLinearLeq {
     pub(crate) fn validity_scope(&self, presence: impl Fn(VarRef) -> Lit) -> ValidityScope {
         // the expression is valid if all variables are present, except for those that do not evaluate to zero when absent
@@ -563,7 +1075,7 @@ impl NFLinearLeq {
                 .into_iter()
                 .filter(|(v, f)| *f != 0 && *v != VarRef::ZERO)
                 .filter(|(v, _)| *v != VarRef::ONE) // Has been grouped into the upper bound
-                .map(|(v, f)| NFLinearSumItem { var: v, factor: f })
+                .map(|(v, f)| ScaledVar { var: v, factor: f })
                 .collect(),
             upper_bound,
         }
@@ -1184,7 +1696,7 @@ mod tests {
         let var1 = VarRef::from_u32(5);
         let var2 = VarRef::from_u32(6);
 
-        let item = |factor: IntCst, var: VarRef| NFLinearSumItem { var, factor };
+        let item = |factor: IntCst, var: VarRef| ScaledVar { var, factor };
 
         let obj = NFLinearLeq {
             sum: vec![
diff --git a/solver/src/model/lang/max.rs b/solver/src/model/lang/max.rs
index a296ab4e9..516520268 100644
--- a/solver/src/model/lang/max.rs
+++ b/solver/src/model/lang/max.rs
@@ -1,4 +1,4 @@
-use crate::core::state::Term;
+use crate::core::views::Term;
 use crate::core::{IntCst, SignedVar};
 use crate::model::lang::IAtom;
 use crate::reif::ReifExpr;
@@ -6,6 +6,7 @@ use itertools::Itertools;
 use std::fmt::{Debug, Formatter};
 
 /// Constraint equivalent to `lhs = max { e | e \in rhs }`
+#[derive(Clone)]
 pub struct EqMax {
     lhs: IAtom,
     rhs: Vec<IAtom>,
@@ -21,6 +22,7 @@ impl EqMax {
 }
 
 /// Constraint equivalent to `lhs = min { e | e \in rhs }`
+#[derive(Clone)]
 pub struct EqMin {
     lhs: IAtom,
     rhs: Vec<IAtom>,
diff --git a/solver/src/model/lang/store.rs b/solver/src/model/lang/store.rs
new file mode 100644
index 000000000..68e490236
--- /dev/null
+++ b/solver/src/model/lang/store.rs
@@ -0,0 +1,121 @@
+use std::fmt::Debug;
+
+use crate::{
+    core::{state::Evaluable, views::Dom},
+    model::Label,
+    prelude::*,
+    reasoners::cp::UserPropagator,
+    reif::ReifExpr,
+};
+
+/// Trait that abstracts the core capabilities of a mutable [`Model`] and used as backend for posting constraints
+/// to the model.
+///
+/// TODO: the name `Store` is mostly historical and should be change to align it with other views.
+pub trait Store: Dom {
+    fn new_literal(&mut self, presence: Lit) -> Lit;
+    fn new_optional_var(&mut self, lb: IntCst, ub: IntCst, presence: Lit) -> VarRef;
+    fn get_implicant(&mut self, e: ReifExpr) -> Lit;
+    fn add_implies(&mut self, l: Lit, e: ReifExpr);
+
+    fn conjunctive_scope(&mut self, lits: &[Lit]) -> Lit;
+    fn tautology_of_scope(&mut self, scope: Lit) -> Lit;
+
+    fn enforce_user_propagator(&mut self, propagator: impl UserPropagator + 'static);
+
+    /// Adds a debug assertion on solutions, i.e., an expression that is assumed to always evaluate to true.
+    ///
+    /// IMPORTANT: the assertion has NO effect on the solving process and only checked when debug assertions are enabled (not in release mode)
+    ///
+    /// TODO: this could be provided on the `Model` it self to be more generally useful
+    #[track_caller]
+    fn add_assertion<Expr: Evaluable<Value = bool> + Debug + Send + Sync + 'static>(&mut self, condition: Expr) {
+        // The assertion is costly to create and evaluate so it is only active when debug assertions are activated
+        if cfg!(debug_assertions) {
+            // a specifying `UserPropagator` that never propagates but provides a method to check that it is satified
+            struct SolutionAssertion {
+                cond: std::sync::Arc<dyn Evaluable<Value = bool> + Send + Sync>,
+                debug: String,
+                source: String,
+            }
+            impl Debug for SolutionAssertion {
+                fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                    f.debug_struct("SolutionAssertion")
+                        .field("expression", &self.debug)
+                        .field("source", &self.source)
+                        .finish()
+                }
+            }
+
+            impl UserPropagator for SolutionAssertion {
+                fn get_propagators(&self) -> Vec<crate::reasoners::cp::DynPropagator> {
+                    // no propagators to record, so nothing will happen for this constraint
+                    vec![]
+                }
+
+                fn satisfied(&self, dom: &Domains) -> bool {
+                    // the extract solution step is unnecessarily costly (copying the domains of each assertion to validate)
+                    self.cond.as_ref().evaluate(&dom.extract_solution()) != Some(false)
+                }
+            }
+            let debug = format!("{condition:?}");
+            let caller = std::panic::Location::caller();
+            let source = format!("{}:{}", caller.file(), caller.line());
+            let checker = SolutionAssertion {
+                cond: std::sync::Arc::new(condition),
+                debug,
+                source,
+            };
+            self.enforce_user_propagator(checker);
+        }
+    }
+}
+
+/// Convenience trait for anything that wraps a [`Model`]. Implementing [`ModelWrapper`] will automatically derive
+/// [`Store`].
+pub trait ModelWrapper {
+    type Lbl: Label;
+    fn get_model(&self) -> &Model<Self::Lbl>;
+    fn get_model_mut(&mut self) -> &mut Model<Self::Lbl>;
+}
+impl<L: Label> ModelWrapper for Model<L> {
+    type Lbl = L;
+
+    fn get_model(&self) -> &Model<Self::Lbl> {
+        self
+    }
+
+    fn get_model_mut(&mut self) -> &mut Model<Self::Lbl> {
+        self
+    }
+}
+
+impl<T> Store for T
+where
+    T: ModelWrapper + Dom,
+{
+    fn new_literal(&mut self, presence: Lit) -> Lit {
+        self.get_model_mut().state.new_optional_var(0, 1, presence).geq(1)
+    }
+    fn new_optional_var(&mut self, lb: IntCst, ub: IntCst, presence: Lit) -> VarRef {
+        self.get_model_mut().state.new_optional_var(lb, ub, presence)
+    }
+    fn get_implicant(&mut self, e: ReifExpr) -> Lit {
+        self.get_model_mut().half_reify(e.clone())
+    }
+
+    fn add_implies(&mut self, l: Lit, e: ReifExpr) {
+        self.get_model_mut().enforce_if(l, e);
+    }
+
+    fn conjunctive_scope(&mut self, presence_variables: &[Lit]) -> Lit {
+        self.get_model_mut().get_conjunctive_scope(presence_variables)
+    }
+    fn tautology_of_scope(&mut self, scope: Lit) -> Lit {
+        self.get_model_mut().get_tautology_of_scope(scope)
+    }
+
+    fn enforce_user_propagator(&mut self, propagator: impl UserPropagator + 'static) {
+        self.get_model_mut().enforce_user_propagator(propagator);
+    }
+}
diff --git a/solver/src/model/model_impl.rs b/solver/src/model/model_impl.rs
index 3fe5d54e0..9242c0e2c 100644
--- a/solver/src/model/model_impl.rs
+++ b/solver/src/model/model_impl.rs
@@ -83,7 +83,7 @@ impl<Lbl: Label> ModelShape<Lbl> {
     }
     fn add_half_reification_constraint(&mut self, value: Lit, expr: ReifExpr) {
         let c = Constraint::HalfReified(expr, value);
-        tracing::trace!("Adding constraint: {}", c);
+        tracing::trace!("Post (hreif): {}", c);
         self.constraints.push(c)
     }
 
@@ -93,7 +93,7 @@ impl<Lbl: Label> ModelShape<Lbl> {
             Constraint::HalfReified(!expr, !value),
         ];
         for c in constraints {
-            tracing::trace!("Adding constraint: {}", c);
+            tracing::trace!("Post (reif): {}", c);
             self.constraints.push(c)
         }
     }
@@ -119,7 +119,10 @@ impl<Lbl: Label> ModelShape<Lbl> {
                         // validity scope of the literal.
                     }
                 }
-                Constraint::Propagator(user_propagator) => anyhow::ensure!(user_propagator.satisfied(assignment)),
+                Constraint::Propagator(user_propagator) => anyhow::ensure!(
+                    user_propagator.satisfied(assignment),
+                    "user propagator is not satisfied:\n{user_propagator:?}"
+                ),
             }
         }
         Ok(())
@@ -553,6 +556,12 @@ impl<Lbl: Label> Model<Lbl> {
     pub fn enforce_if<Expr: Reifiable<Lbl>>(&mut self, enabler: Lit, expr: Expr) {
         let mut expr = expr.decompose(self);
         self.simplify(&mut expr);
+        tracing::debug!(
+            "enforce if: [{:?}] {:?} => {}",
+            self.presence_literal(enabler),
+            enabler,
+            expr
+        );
         self.shape.add_half_reification_constraint(enabler, expr);
     }
 
diff --git a/solver/src/prelude.rs b/solver/src/prelude.rs
index 08bfd73b1..48176246e 100644
--- a/solver/src/prelude.rs
+++ b/solver/src/prelude.rs
@@ -1,11 +1,14 @@
 //! Module that re-export most commonly used types and traits to ease import.
 
+pub use crate::core::literals::Conjunction;
+pub use crate::core::literals::Disjunction;
 pub use crate::core::state::Domains;
 pub use crate::core::state::Solution;
 pub use crate::core::{IntCst, Lit, SignedVar, VarRef};
 pub use crate::model::Model;
 pub use crate::model::extensions::DomainsExt;
-pub use crate::model::lang::{IAtom, IVar};
+pub use crate::model::lang::linear::{LinSum, LinTerm};
+pub use crate::model::lang::{IAtom, IVar, LinearSum};
 pub use crate::solver::SearchLimit;
 pub use crate::solver::Solver;
 
diff --git a/solver/src/reasoners/cp/no_overlap.rs b/solver/src/reasoners/cp/no_overlap.rs
index 60c967a46..43fec015a 100644
--- a/solver/src/reasoners/cp/no_overlap.rs
+++ b/solver/src/reasoners/cp/no_overlap.rs
@@ -4,10 +4,9 @@ use hashbrown::HashSet;
 use itertools::Itertools;
 
 use crate::core::state::{DomainsSnapshot, Explanation, InvalidUpdate};
-use crate::core::views::{Boundable, Dom, VarView};
+use crate::core::views::{Boundable, Dom, Term, VarView};
 use crate::prelude::*;
 
-use crate::core::state::Term;
 use crate::reasoners::cp::no_overlap::neg_iatom::PMIAtom;
 use crate::reasoners::cp::propagator::justified::*;
 use crate::reasoners::cp::{DynPropagator, UserPropagator};
diff --git a/solver/src/reasoners/cp/no_overlap/neg_iatom.rs b/solver/src/reasoners/cp/no_overlap/neg_iatom.rs
index 23ad2fb41..8627d528d 100644
--- a/solver/src/reasoners/cp/no_overlap/neg_iatom.rs
+++ b/solver/src/reasoners/cp/no_overlap/neg_iatom.rs
@@ -1,8 +1,5 @@
 use crate::{
-    core::{
-        state::Term,
-        views::{Boundable, VarView},
-    },
+    core::views::{Boundable, Term, VarView},
     prelude::*,
 };
 
diff --git a/solver/src/solver/solver_impl.rs b/solver/src/solver/solver_impl.rs
index 22009ed54..1463e8685 100644
--- a/solver/src/solver/solver_impl.rs
+++ b/solver/src/solver/solver_impl.rs
@@ -2,10 +2,11 @@ use crate::backtrack::{Backtrack, DecLvl};
 use crate::collections::set::IterableRefSet;
 use crate::core::literals::{Disjunction, Lits};
 use crate::core::state::*;
-use crate::core::views::Dom;
+use crate::core::views::{Boundable, Dom, Term, VarView};
 use crate::core::*;
 use crate::model::extensions::{DisjunctionExt, DomainsExt, Shaped};
 use crate::model::lang::IAtom;
+use crate::model::lang::linear::LinearSum;
 use crate::model::{Constraint, Label, Model, ModelShape};
 use crate::reasoners::cp::max::{AtLeastOneGeq, MaxElem};
 use crate::reasoners::{Contradiction, ReasonerId, Reasoners};
@@ -200,8 +201,6 @@ impl<Lbl: Label> Solver<Lbl> {
         }
         match constraint {
             &ReifExpr::Lit(lit) => {
-                let expr_scope = self.model.presence_literal(lit.variable());
-                assert!(self.model.state.implies(scope, expr_scope), "Incompatible scopes");
                 self.add_clause([!enabler, lit], scope)?; // value => lit
                 Ok(())
             }
@@ -460,32 +459,10 @@ impl<Lbl: Label> Solver<Lbl> {
                 for item in &a.rhs {
                     let item_scope = self.model.state.presence(item.var);
                     debug_assert!(self.model.state.implies(item_scope, scope));
-                    // a.lhs >= item.var + item.cst
-                    // a.lhs - item.var >= item.cst
-                    // item.var - a.lhs <= -item.cst
                     let alt_value = self.model.get_tautology_of_scope(item_scope);
-                    if item.var.is_plus() {
-                        assert!(a.lhs.is_plus());
-                        self.post_constraint(&Constraint::HalfReified(
-                            ReifExpr::MaxDiff(DifferenceExpression::new(
-                                item.var.variable(),
-                                a.lhs.variable(),
-                                -item.cst,
-                            )),
-                            alt_value,
-                        ))?;
-                    } else {
-                        assert!(a.lhs.is_minus());
-                        // item.var - a.lhs <= -item.cst
-                        let x = item.var.variable();
-                        let y = a.lhs.variable();
-                        // (-x) - (-y) <= -item.cst
-                        // y - x <= -item.cst
-                        self.post_constraint(&Constraint::HalfReified(
-                            ReifExpr::MaxDiff(DifferenceExpression::new(y, x, -item.cst)),
-                            alt_value,
-                        ))?;
-                    }
+                    // a.lhs >= item.var + item.cst
+                    let constraint = LinearSum::from(a.lhs).geq(LinearSum::from(item.var) + item.cst);
+                    self.post_constraint(&Constraint::HalfReified(constraint.into(), alt_value))?;
                 }
 
                 let prez = |v: SignedVar| self.model.state.presence(v);
@@ -764,35 +741,8 @@ impl<Lbl: Label> Solver<Lbl> {
         assumptions: &[Lit],
         limit: SearchLimit,
     ) -> Result<Result<Solution, UnsatCore>, Exit> {
-        // make sure brancher has knowledge of all variables.
-        self.brancher.import_vars(&self.model);
-
-        assert_eq!(self.decision_level, DecLvl::ROOT);
-
-        match self.propagate_and_backtrack_to_consistent() {
-            Ok(()) => (),
-            Err(conflict) => {
-                // conflict at root, return empty unsat core
-                debug_assert!(conflict.is_empty());
-                return Ok(Err(Explanation::new()));
-            }
-        };
-        for &lit in assumptions {
-            if let Err(unsat_core) = self.assume_and_propagate(lit) {
-                return Ok(Err(unsat_core));
-            }
-        }
-        match self.search(limit)? {
-            SearchResult::AtSolution => Ok(Ok(self.model.state.extract_solution())),
-            SearchResult::ExternalSolution(s) => Ok(Ok(s)),
-            SearchResult::Unsat(conflict) => {
-                let unsat_core = self
-                    .model
-                    .state
-                    .extract_unsat_core_after_conflict(conflict, &mut self.reasoners);
-                Ok(Err(unsat_core))
-            }
-        }
+        // delegate to optimization with a constant objective
+        self.minimize_with_assumptions(VarRef::ZERO, assumptions, limit, |_sol| {})
     }
 
     /// Returns an iterable datastructure for computing all MUS and MCS.
@@ -957,14 +907,54 @@ impl<Lbl: Label> Solver<Lbl> {
     ) -> Result<Option<(IntCst, Solution)>, Exit> {
         assert_eq!(self.decision_level, DecLvl::ROOT);
         assert_eq!(self.last_assumption_level, DecLvl::ROOT);
-        // best solution found so far
-        let mut best = None;
 
-        if self.post_constraints().is_err() || self.propagate().is_err() {
-            // trivially UNSAT
-            return Ok(None);
+        let opt_var = if minimize {
+            SignedVar::plus(objective.var.variable())
+        } else {
+            SignedVar::minus(objective.var.variable())
+        };
+        if let Ok(sol) =
+            self.minimize_with_assumptions(opt_var, &[], limit, |sol| on_new_solution(sol.lb(objective), sol))?
+        {
+            Ok(Some((sol.lb(objective), sol)))
+        } else {
+            Ok(None)
         }
+    }
 
+    /// Solves the minimization problem under the given assumptions.
+    /// In case of unsatisfiability, returns an unsat core (composed of these assumptions).
+    ///
+    /// A callback can be given that will be invoked on each new solution with an improved cost, as soon as it is discovered.
+    ///
+    /// Invariant: the solver must be at the root decision level (meaning that there must be no prior assumptions/decisions on the stack)
+    pub fn minimize_with_assumptions<ObjVar: Boundable<Value = IntCst> + VarView<Value = IntCst>>(
+        &mut self,
+        objective: ObjVar,
+        assumptions: &[Lit],
+        limit: SearchLimit,
+        mut on_new_solution: impl FnMut(&Solution),
+    ) -> Result<Result<Solution, UnsatCore>, Exit> {
+        // make sure brancher has knowledge of all variables.
+        self.brancher.import_vars(&self.model);
+
+        assert_eq!(self.decision_level, DecLvl::ROOT);
+
+        match self.propagate_and_backtrack_to_consistent() {
+            Ok(()) => (),
+            Err(conflict) => {
+                // conflict at root, return empty unsat core
+                debug_assert!(conflict.is_empty());
+                return Ok(Err(Explanation::new()));
+            }
+        };
+        for &lit in assumptions {
+            if let Err(unsat_core) = self.assume_and_propagate(lit) {
+                return Ok(Err(unsat_core));
+            }
+        }
+        // best solution found so far
+        let mut best = None;
         loop {
             let sol = match self.search(limit)? {
                 SearchResult::AtSolution => {
@@ -972,29 +962,37 @@ impl<Lbl: Label> Solver<Lbl> {
                     // notify other solvers that we have found a new solution
                     let sol = self.model.state.extract_solution();
                     self.sync.notify_solution_found(sol.clone());
-                    let objective_value = sol.lb(objective);
+                    let objective_value = sol.lb(&objective);
                     if STATS_AT_SOLUTION.get() {
                         println!("*********  New sol: {objective_value} *********");
                         self.print_stats();
                     }
-                    on_new_solution(objective_value, &sol);
+                    on_new_solution(&sol);
                     sol
                 }
                 SearchResult::ExternalSolution(sol) => sol, // a solution was handed to us by another solver
-                SearchResult::Unsat(_conflict) => return Ok(best), // exhausted search space under the current wuality assumptions
+                SearchResult::Unsat(conflict) => {
+                    // exhausted search space under the current quality assumptions
+                    // 1) if we have a solution return it
+                    // 2) otherwise, the problem is unsatisfiable and we return the corresponding UNSAT core
+                    return match best {
+                        Some((_obj, best)) => Ok(Ok(best)),
+                        None => {
+                            let unsat_core = self
+                                .model
+                                .state
+                                .extract_unsat_core_after_conflict(conflict, &mut self.reasoners);
+                            Ok(Err(unsat_core))
+                        }
+                    };
+                }
             };
 
             // determine whether the solution found is an improvement on the previous one (might not be the case if sent by another solver)
-            let objective_value = sol.lb(objective);
+            let objective_value = sol.lb(&objective);
             let is_improvement = match best {
                 None => true,
-                Some((previous_best, _)) => {
-                    if minimize {
-                        objective_value < previous_best
-                    } else {
-                        objective_value > previous_best
-                    }
-                }
+                Some((previous_best, _)) => objective_value < previous_best,
             };
 
             if is_improvement {
@@ -1007,16 +1005,14 @@ impl<Lbl: Label> Solver<Lbl> {
                 // save the best solution
                 best = Some((objective_value, sol));
 
-                // force future solutions to improve on this one
-                let improvement_literal = if minimize {
-                    objective.lt_lit(objective_value)
-                } else {
-                    objective.gt_lit(objective_value)
-                };
+                // literal that forces future solutions to improve on this one
+                let improvement_literal = objective.leq(objective_value - 1);
+
+                // undo any decision and post a new assumption that the objective is improved
                 self.reset_search();
                 match self.assume_and_propagate(improvement_literal) {
                     Ok(_) => {}
-                    Err(_unsat_core) => return Ok(best), // no way to improve this bound
+                    Err(_unsat_core) => return Ok(Ok(best.unwrap().1)), // no way to improve this bound
                 }
             }
         }
@@ -1068,7 +1064,7 @@ impl<Lbl: Label> Solver<Lbl> {
     }
 
     /// Posts an assumptions on a new decision level, run all propagators and returns an `UnsatCore`
-    /// if the assumptions turns out to be incompatibly with previous ones.
+    /// if the assumptions turns out to be incompatible with previous ones.
     ///
     /// If the assumption is accepted returns an `Ok(x)` result where is true if the assumption was not already entailed
     /// (i.e. something changed in the domains).