feat(pumpkin-core): Make propagator API public

pumpkin-crates/core/src/api/mod.rs

@@ -128,8 +128,8 @@ pub mod state {
     pub use crate::engine::EmptyDomain;
     pub use crate::engine::EmptyDomainConflict;
     pub use crate::engine::State;
-    pub use crate::engine::propagation::CurrentNogood;
-    pub use crate::engine::propagation::PropagatorId;
+    pub use crate::propagation::CurrentNogood;
+    pub use crate::propagation::PropagatorId;
 }
 
 pub use crate::basic_types::Function;

pumpkin-crates/core/src/api/solver.rs

@@ -19,8 +19,6 @@ use crate::constraints::ConstraintPoster;
 use crate::containers::HashSet;
 use crate::engine::ConstraintSatisfactionSolver;
 use crate::engine::predicates::predicate::Predicate;
-use crate::engine::propagation::constructor::PropagatorConstructor;
-pub use crate::engine::propagation::store::PropagatorHandle;
 use crate::engine::termination::TerminationCondition;
 use crate::engine::variables::DomainId;
 use crate::engine::variables::IntegerVariable;
@@ -35,6 +33,8 @@ use crate::options::SolverOptions;
 #[cfg(doc)]
 use crate::predicates;
 use crate::proof::ConstraintTag;
+use crate::propagation::PropagatorConstructor;
+pub use crate::propagation::store::PropagatorHandle;
 use crate::results::solution_iterator::SolutionIterator;
 use crate::results::unsatisfiable::UnsatisfiableUnderAssumptions;
 use crate::statistics::StatisticLogger;
@@ -495,7 +495,7 @@ impl Solver {
     /// If the solver is already in a conflicting state, i.e. a previous call to this method
     /// already returned `false`, calling this again will not alter the solver in any way, and
     /// `false` will be returned again.
-    pub(crate) fn add_propagator<Constructor>(
+    pub fn add_propagator<Constructor>(
         &mut self,
         constructor: Constructor,
     ) -> Result<PropagatorHandle<Constructor::PropagatorImpl>, ConstraintOperationError>

pumpkin-crates/core/src/basic_types/mod.rs

@@ -16,7 +16,7 @@ pub use constraint_operation_error::ConstraintOperationError;
 pub(crate) use csp_solver_execution_flag::CSPSolverExecutionFlag;
 pub use function::Function;
 pub(crate) use predicate_id_generators::DeletablePredicateIdGenerator;
-pub(crate) use predicate_id_generators::PredicateId;
+pub use predicate_id_generators::PredicateId;
 pub(crate) use predicate_id_generators::PredicateIdGenerator;
 pub use propagation_status_cp::*;
 pub use propositional_conjunction::PropositionalConjunction;

pumpkin-crates/core/src/basic_types/predicate_id_generators/mod.rs

@@ -2,5 +2,5 @@ mod deletable_predicate_id_generator;
 mod predicate_id_generator;
 
 pub(crate) use deletable_predicate_id_generator::DeletablePredicateIdGenerator;
-pub(crate) use predicate_id_generator::PredicateId;
+pub use predicate_id_generator::PredicateId;
 pub(crate) use predicate_id_generator::PredicateIdGenerator;

pumpkin-crates/core/src/basic_types/predicate_id_generators/predicate_id_generator.rs

@@ -104,8 +104,9 @@ impl Iterator for PredicateIdIterator {
     }
 }
 
+/// An ID for a predicate which has its truth-value tracked by the solver.
 #[derive(Debug, Clone, Copy, Eq, PartialEq, Hash, Ord, PartialOrd)]
-pub(crate) struct PredicateId {
+pub struct PredicateId {
     pub(crate) id: u32,
 }
 

pumpkin-crates/core/src/basic_types/solution.rs

@@ -1,13 +1,21 @@
 use crate::engine::Assignments;
-use crate::engine::propagation::contexts::HasAssignments;
 use crate::engine::variables::DomainGeneratorIterator;
 use crate::engine::variables::DomainId;
 use crate::engine::variables::Literal;
-use crate::predicates::Predicate;
+use crate::propagation::HasAssignments;
 use crate::variables::IntegerVariable;
 
 /// A trait which specifies the common behaviours of [`Solution`] and [`SolutionReference`].
-pub trait ProblemSolution: HasAssignments {
+pub trait ProblemSolution {
+    /// Returns the number of defined [`DomainId`]s.
+    fn num_domains(&self) -> usize;
+
+    fn get_integer_value<Var: IntegerVariable>(&self, var: Var) -> i32;
+
+    fn get_literal_value(&self, literal: Literal) -> bool;
+}
+
+impl<T: HasAssignments> ProblemSolution for T {
     /// Returns the number of defined [`DomainId`]s.
     fn num_domains(&self) -> usize {
         self.assignments().num_domains() as usize
@@ -33,7 +41,7 @@ pub struct SolutionReference<'a> {
 }
 
 impl<'a> SolutionReference<'a> {
-    pub fn new(assignments: &'a Assignments) -> SolutionReference<'a> {
+    pub(crate) fn new(assignments: &'a Assignments) -> SolutionReference<'a> {
         SolutionReference { assignments }
     }
 
@@ -43,19 +51,15 @@ impl<'a> SolutionReference<'a> {
     }
 }
 
-impl ProblemSolution for SolutionReference<'_> {}
-
 /// A solution which takes ownership of its inner structures.
+///
+/// Implements [`ProblemSolution`].
 #[derive(Clone, Debug, Default)]
 pub struct Solution {
     assignments: Assignments,
 }
 
 impl Solution {
-    pub fn new(assignments: Assignments) -> Self {
-        Self { assignments }
-    }
-
     pub fn get_domains(&self) -> DomainGeneratorIterator {
         self.assignments.get_domains()
         // todo: Should we skip the first element as it could be the always true domain id?
@@ -70,14 +74,14 @@ impl Solution {
     pub fn contains_domain_id(&self, domain_id: DomainId) -> bool {
         domain_id.id() < self.assignments.num_domains()
     }
+}
 
-    pub fn is_predicate_satisfied(&self, predicate: Predicate) -> bool {
-        self.assignments.is_predicate_satisfied(predicate)
+impl From<Assignments> for Solution {
+    fn from(value: Assignments) -> Self {
+        Self { assignments: value }
     }
 }
 
-impl ProblemSolution for Solution {}
-
 impl From<SolutionReference<'_>> for Solution {
     fn from(value: SolutionReference) -> Self {
         Self {
@@ -90,10 +94,26 @@ impl<'a> HasAssignments for SolutionReference<'a> {
     fn assignments(&self) -> &'a Assignments {
         self.assignments
     }
+
+    fn trailed_values(&self) -> &crate::engine::TrailedValues {
+        unimplemented!("Currently, this information cannot be retrieved using this structure")
+    }
+
+    fn trailed_values_mut(&mut self) -> &mut crate::engine::TrailedValues {
+        unimplemented!("Currently, this information cannot be retrieved using this structure")
+    }
 }
 
 impl HasAssignments for Solution {
     fn assignments(&self) -> &Assignments {
         &self.assignments
     }
+
+    fn trailed_values(&self) -> &crate::engine::TrailedValues {
+        unimplemented!("Currently, this information cannot be retrieved using this structure")
+    }
+
+    fn trailed_values_mut(&mut self) -> &mut crate::engine::TrailedValues {
+        unimplemented!("Currently, this information cannot be retrieved using this structure")
+    }
 }

pumpkin-crates/core/src/basic_types/stored_conflict_info.rs

@@ -3,10 +3,10 @@ use crate::ConstraintOperationError;
 #[cfg(doc)]
 use crate::engine::ConstraintSatisfactionSolver;
 use crate::engine::EmptyDomainConflict;
-#[cfg(doc)]
-use crate::engine::propagation::Propagator;
 use crate::engine::state::Conflict;
 use crate::predicates::Predicate;
+#[cfg(doc)]
+use crate::propagation::Propagator;
 
 /// a conflict info which can be stored in the solver.
 /// two (related) conflicts can happen:

pumpkin-crates/core/src/branching/branchers/alternating/strategies/until_solution.rs

@@ -143,7 +143,7 @@ mod tests {
         ));
         assert!(!brancher.is_using_default_brancher());
 
-        brancher.on_solution(Solution::new(assignments.clone()).as_reference());
+        brancher.on_solution(Solution::from(assignments.clone()).as_reference());
         let _ = brancher.next_decision(&mut SelectionContext::new(
             &assignments,
             &mut TestRandom::default(),
@@ -164,7 +164,7 @@ mod tests {
         ));
         assert!(brancher.is_using_default_brancher());
 
-        brancher.on_solution(Solution::new(assignments.clone()).as_reference());
+        brancher.on_solution(Solution::from(assignments.clone()).as_reference());
         let _ = brancher.next_decision(&mut SelectionContext::new(
             &assignments,
             &mut TestRandom::default(),
@@ -198,7 +198,7 @@ mod tests {
         ));
         assert!(!brancher.is_using_default_brancher());
 
-        brancher.on_solution(Solution::new(assignments.clone()).as_reference());
+        brancher.on_solution(Solution::from(assignments.clone()).as_reference());
         let _ = brancher.next_decision(&mut SelectionContext::new(
             &assignments,
             &mut TestRandom::default(),
@@ -219,7 +219,7 @@ mod tests {
         ));
         assert!(brancher.is_using_default_brancher());
 
-        brancher.on_solution(Solution::new(assignments.clone()).as_reference());
+        brancher.on_solution(Solution::from(assignments.clone()).as_reference());
         let _ = brancher.next_decision(&mut SelectionContext::new(
             &assignments,
             &mut TestRandom::default(),

pumpkin-crates/core/src/branching/branchers/autonomous_search.rs

@@ -15,6 +15,7 @@ use crate::containers::StorageKey;
 use crate::create_statistics_struct;
 use crate::engine::Assignments;
 use crate::engine::predicates::predicate::Predicate;
+use crate::propagation::ReadDomains;
 use crate::results::Solution;
 use crate::statistics::Statistic;
 use crate::statistics::StatisticLogger;
@@ -239,7 +240,7 @@ impl<BackupSelector> AutonomousSearch<BackupSelector> {
                 return predicate;
             }
             // Match the truth value according to the best solution.
-            if solution.is_predicate_satisfied(predicate) {
+            if solution.evaluate_predicate(predicate) == Some(true) {
                 predicate
             } else {
                 !predicate

pumpkin-crates/core/src/branching/selection_context.rs

@@ -7,12 +7,12 @@ use crate::engine::Assignments;
 #[cfg(test)]
 use crate::engine::notifications::NotificationEngine;
 use crate::engine::predicates::predicate::Predicate;
-#[cfg(doc)]
-use crate::engine::propagation::PropagationContext;
 use crate::engine::variables::DomainGeneratorIterator;
 #[cfg(doc)]
 use crate::engine::variables::DomainId;
 use crate::engine::variables::IntegerVariable;
+#[cfg(doc)]
+use crate::propagation::Domains;
 
 /// The context provided to the [`Brancher`],
 /// it allows the retrieval of domain values of variables and access to methods from a [`Random`]

pumpkin-crates/core/src/constraints/mod.rs

@@ -49,7 +49,7 @@ pub use table::*;
 
 use crate::ConstraintOperationError;
 use crate::Solver;
-use crate::engine::propagation::constructor::PropagatorConstructor;
+use crate::propagation::PropagatorConstructor;
 use crate::propagators::ReifiedPropagatorArgs;
 use crate::variables::Literal;
 

pumpkin-crates/core/src/engine/conflict_analysis/conflict_analysis_context.rs

@@ -12,15 +12,15 @@ use crate::engine::State;
 use crate::engine::constraint_satisfaction_solver::CSPSolverState;
 use crate::engine::predicates::predicate::Predicate;
 use crate::engine::predicates::predicate::PredicateType;
-use crate::engine::propagation::CurrentNogood;
-use crate::engine::propagation::ExplanationContext;
 use crate::engine::solver_statistics::SolverStatistics;
 use crate::predicate;
 use crate::predicates::PropositionalConjunction;
 use crate::proof::InferenceCode;
 use crate::proof::ProofLog;
 use crate::proof::RootExplanationContext;
 use crate::proof::explain_root_assignment;
+use crate::propagation::CurrentNogood;
+use crate::propagation::ExplanationContext;
 use crate::propagators::nogoods::NogoodPropagator;
 use crate::pumpkin_assert_eq_simple;
 use crate::pumpkin_assert_simple;

pumpkin-crates/core/src/engine/conflict_analysis/minimisers/minimisation_context.rs

@@ -2,12 +2,12 @@ use crate::containers::HashMap;
 use crate::engine::Assignments;
 use crate::engine::SolverStatistics;
 use crate::engine::conflict_analysis::ConflictAnalysisContext;
-#[cfg(doc)]
-use crate::engine::propagation::ReadDomains;
-use crate::engine::propagation::contexts::HasAssignments;
 use crate::predicates::Predicate;
 use crate::proof::InferenceCode;
 use crate::proof::ProofLog;
+use crate::propagation::HasAssignments;
+#[cfg(doc)]
+use crate::propagation::ReadDomains;
 use crate::state::CurrentNogood;
 use crate::state::State;
 
@@ -50,4 +50,12 @@ impl<'a> HasAssignments for MinimisationContext<'a> {
     fn assignments(&self) -> &Assignments {
         &self.state.assignments
     }
+
+    fn trailed_values(&self) -> &crate::engine::TrailedValues {
+        &self.state.trailed_values
+    }
+
+    fn trailed_values_mut(&mut self) -> &mut crate::engine::TrailedValues {
+        &mut self.state.trailed_values
+    }
 }

pumpkin-crates/core/src/engine/conflict_analysis/minimisers/recursive_minimiser.rs

@@ -1,18 +1,18 @@
-use super::MinimisationContext;
 use crate::basic_types::moving_averages::MovingAverage;
 use crate::containers::HashMap;
 use crate::containers::HashSet;
 use crate::engine::Assignments;
+use crate::engine::conflict_analysis::MinimisationContext;
 use crate::engine::conflict_analysis::NogoodMinimiser;
-use crate::engine::propagation::ReadDomains;
-use crate::engine::propagation::contexts::HasAssignments;
 use crate::predicates::Predicate;
 use crate::proof::RootExplanationContext;
 use crate::proof::explain_root_assignment;
+use crate::propagation::CurrentNogood;
+use crate::propagation::HasAssignments;
+use crate::propagation::ReadDomains;
 use crate::pumpkin_assert_eq_moderate;
 use crate::pumpkin_assert_moderate;
 use crate::pumpkin_assert_simple;
-use crate::state::CurrentNogood;
 
 #[derive(Debug, Clone, Default)]
 pub(crate) struct RecursiveMinimiser {
@@ -100,7 +100,7 @@ impl RecursiveMinimiser {
         // If the predicate is a decision predicate, it cannot be a predicate from the original
         // learned nogood since those are labelled as part of initialisation.
         // Therefore the decision literal is labelled as poison and then return.
-        if context.is_decision_predicate(&input_predicate) {
+        if context.is_decision_predicate(input_predicate) {
             self.assign_predicate_label(input_predicate, Label::Poison);
             self.current_depth -= 1;
             return;
@@ -110,7 +110,7 @@ impl RecursiveMinimiser {
         // (levels from the original learned clause) cannot be removed.
         if !self.is_decision_level_allowed(
             context
-                .get_checkpoint_for_predicate(&input_predicate)
+                .get_checkpoint_for_predicate(input_predicate)
                 .unwrap(),
         ) {
             self.assign_predicate_label(input_predicate, Label::Poison);
@@ -130,7 +130,7 @@ impl RecursiveMinimiser {
         for antecedent_predicate in reason.iter().copied() {
             // Root assignments can be safely ignored.
             if context
-                .get_checkpoint_for_predicate(&antecedent_predicate)
+                .get_checkpoint_for_predicate(antecedent_predicate)
                 .unwrap()
                 == 0
             {

pumpkin-crates/core/src/engine/conflict_analysis/minimisers/semantic_minimiser.rs

@@ -1,14 +1,14 @@
 use std::cmp;
 
-use super::MinimisationContext;
 use crate::containers::HashSet;
 use crate::containers::KeyedVec;
 use crate::containers::SparseSet;
+use crate::engine::conflict_analysis::MinimisationContext;
 use crate::engine::conflict_analysis::NogoodMinimiser;
 use crate::engine::predicates::predicate::PredicateType;
-use crate::engine::propagation::contexts::HasAssignments;
 use crate::predicate;
 use crate::predicates::Predicate;
+use crate::propagation::HasAssignments;
 use crate::variables::DomainId;
 
 #[derive(Clone, Debug)]

pumpkin-crates/core/src/engine/conflict_analysis/resolvers/resolution_resolver.rs

@@ -14,11 +14,11 @@ use crate::engine::conflict_analysis::Mode;
 use crate::engine::conflict_analysis::NogoodMinimiser;
 use crate::engine::conflict_analysis::RecursiveMinimiser;
 use crate::engine::constraint_satisfaction_solver::NogoodLabel;
-use crate::engine::propagation::CurrentNogood;
 use crate::predicates::Predicate;
 use crate::proof::InferenceCode;
 use crate::proof::RootExplanationContext;
 use crate::proof::explain_root_assignment;
+use crate::propagation::CurrentNogood;
 use crate::propagators::nogoods::NogoodPropagator;
 use crate::pumpkin_assert_advanced;
 use crate::pumpkin_assert_moderate;