Finalized Programmatic Verification of Model Assumptions #275

Signed-off-by: Marvin Hansen <[email protected]>

Author: marvin-hansen

deep_causality/src/errors/assumption_error.rs

@@ -9,12 +9,14 @@
 use std::error::Error;
 use std::fmt;
 
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum AssumptionError {
     /// Error returned when verification is attempted on a model with no assumptions.
     NoAssumptionsDefined,
     ///Error returned when verification is attempted without data i.e. empty collection.
     NoDataToTestDefined,
+    ///Error to capture the specific failed assumption
+    AssumptionFailed(String),
     /// Wraps an error that occurred during the execution of an assumption function.
     EvaluationFailed(String),
 }
@@ -30,6 +32,9 @@ impl fmt::Display for AssumptionError {
             AssumptionError::NoDataToTestDefined => {
                 write!(f, "No Data to test provided")
             }
+            AssumptionError::AssumptionFailed(a) => {
+                write!(f, "Assumption failed: {a}")
+            }
             AssumptionError::EvaluationFailed(msg) => {
                 write!(f, "Failed to evaluate assumption: {msg}")
             }

deep_causality/src/traits/transferable/mod.rs

@@ -4,19 +4,53 @@
  */
 
 //!
-//! Trait for model verification.
+//! Trait for assumption verification used in the Model type.
 //!
-use crate::{AssumptionError, PropagatingEffect};
+use crate::{Assumable, Assumption, AssumptionError, PropagatingEffect};
+use std::sync::Arc;
 
 pub trait Transferable {
+    fn get_assumptions(&self) -> &Option<Arc<Vec<Assumption>>>;
+
     /// Verifies the model's assumptions against a given PropagatingEffect.
     ///
+    /// The function iterates through all defined assumptions and checks them against
+    /// the provided data. It short-circuits and returns immediately on the first
+    /// failure or error.
+    ///
+    /// Overwrite the default implementation if you need customization.
+    ///
     /// # Arguments
-    /// * `effect` - The output of a model run or sample data to be tested.
+    /// * `effect` - Sample data to be tested. Details on sampling should be documented in each assumption.
     ///
     /// # Returns
-    /// * `Ok(true)` if all assumptions hold true.
-    /// * `Ok(false)` if any assumption fails evaluation.
-    /// * `Err(AssumptionError)` if the model has no assumptions or an evaluation error occurs.
-    fn verify_assumptions(&self, effect: &[PropagatingEffect]) -> Result<bool, AssumptionError>;
+    /// * `Ok(())` if all assumptions hold true.
+    /// * `Err(AssumptionError::AssumptionFailed(String))` if an assumption is not met.
+    /// * `Err(AssumptionError::NoAssumptionsDefined)` if the model has no assumptions.
+    /// * `Err(AssumptionError::NoDataToTestDefined)` if the effect slice is empty.
+    /// * `Err(AssumptionError::EvaluationError(...))` if an error occurs during evaluation.
+    ///
+    fn verify_assumptions(&self, effect: &[PropagatingEffect]) -> Result<(), AssumptionError> {
+        if effect.is_empty() {
+            return Err(AssumptionError::NoDataToTestDefined);
+        }
+
+        if self.get_assumptions().is_none() {
+            return Err(AssumptionError::NoAssumptionsDefined);
+        }
+
+        let assumptions = self.get_assumptions().as_ref().unwrap();
+
+        for assumption in assumptions.iter() {
+            // The `?` operator propagates any evaluation errors.
+            if !assumption.verify_assumption(effect)? {
+                // If an assumption returns `Ok(false)`, the check has failed.
+                // We now return an error containing the specific assumption that failed.
+                return Err(AssumptionError::AssumptionFailed(assumption.to_string()));
+            }
+        }
+
+        // If the loop completes, all assumptions passed.
+        Ok(())
+    }
 }

deep_causality/src/types/model_types/assumption/debug.rs

@@ -23,7 +23,7 @@ impl Assumption {
     fn fmt_write(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         write!(
             f,
-            "Assumption: id: {}, description: {}, assumption_fn: fn(&[PropagatingEffect]) -> Result<bool, AssumptionError>;, assumption_tested: {},assumption_valid: {}",
+            "Assumption: id: {}, description: {}, assumption_tested: {}, assumption_valid: {}",
             self.id,
             self.description,
             self.assumption_tested.read().unwrap().clone(),

deep_causality/src/types/model_types/model/transferable.rs

@@ -6,11 +6,10 @@
 //!
 //! Implementation of the Transferable trait for the Model struct.
 //!
+
 use crate::types::model_types::model::Model;
-use crate::{
-    Assumable, AssumptionError, Datable, PropagatingEffect, SpaceTemporal, Spatial, Symbolic,
-    Temporal, Transferable,
-};
+use crate::{Assumption, Datable, SpaceTemporal, Spatial, Symbolic, Temporal, Transferable};
+use std::sync::Arc;
 
 impl<D, S, T, ST, SYM, VS, VT> Transferable for Model<D, S, T, ST, SYM, VS, VT>
 where
@@ -22,23 +21,10 @@ where
     VS: Clone,
     VT: Clone,
 {
-    fn verify_assumptions(&self, effect: &[PropagatingEffect]) -> Result<bool, AssumptionError> {
-        if effect.is_empty() {
-            return Err(AssumptionError::NoDataToTestDefined);
-        }
-
-        if self.assumptions.is_none() {
-            return Err(AssumptionError::NoAssumptionsDefined);
-        }
-
-        let assumptions = self.assumptions.as_ref().unwrap();
-        for assumption in assumptions.iter() {
-            match assumption.verify_assumption(effect) {
-                Ok(true) => continue,          // Assumption holds, continue checking
-                Ok(false) => return Ok(false), // Assumption failed
-                Err(e) => return Err(e),       // An error occurred during evaluation
-            }
-        }
-        Ok(true) // All assumptions passed
+    fn get_assumptions(&self) -> &Option<Arc<Vec<Assumption>>> {
+        &self.assumptions
     }
+
+    // verify_assumptions is derived from the Transferable trait. Overwrite for customization.
+    // fn verify_assumptions(&self, effect: &[PropagatingEffect]) -> Result<bool, AssumptionError> {}
 }

deep_causality/src/utils_test/test_utils.rs

@@ -194,15 +194,41 @@ pub fn get_test_observation() -> Observation {
 pub fn get_test_assumption() -> Assumption {
     let id: IdentificationValue = 1;
     let description: String = "Test assumption that data are there".to_string() as DescriptionValue;
-    let assumption_fn: EvalFn = test_has_data;
+    let assumption_fn: EvalFn = test_fn_has_data;
 
     Assumption::new(id, description, assumption_fn)
 }
 
-fn test_has_data(data: &[PropagatingEffect]) -> Result<bool, AssumptionError> {
+fn test_fn_has_data(data: &[PropagatingEffect]) -> Result<bool, AssumptionError> {
     Ok(!data.is_empty()) // Data is NOT empty i.e. true when it is 
 }
 
+pub fn get_test_assumption_false() -> Assumption {
+    let id: IdentificationValue = 2;
+    let description: String =
+        "Test assumption that is always false".to_string() as DescriptionValue;
+    let assumption_fn: EvalFn = test_fn_is_false;
+    Assumption::new(id, description, assumption_fn)
+}
+
+fn test_fn_is_false(_data: &[PropagatingEffect]) -> Result<bool, AssumptionError> {
+    Ok(false)
+}
+
+pub fn get_test_assumption_error() -> Assumption {
+    let id: IdentificationValue = 2;
+    let description: String =
+        "Test assumption that raises an error".to_string() as DescriptionValue;
+    let assumption_fn: EvalFn = test_fn_is_error;
+    Assumption::new(id, description, assumption_fn)
+}
+
+fn test_fn_is_error(_data: &[PropagatingEffect]) -> Result<bool, AssumptionError> {
+    Err(AssumptionError::AssumptionFailed(String::from(
+        "Test error",
+    )))
+}
+
 pub fn get_test_num_array() -> [NumericalValue; 10] {
     [8.4, 8.5, 9.1, 9.3, 9.4, 9.5, 9.7, 9.7, 9.9, 9.9]
 }

deep_causality/tests/errors/assumption_error_tests.rs

@@ -4,6 +4,7 @@
  */
 
 use deep_causality::AssumptionError;
+use deep_causality::utils_test::test_utils;
 
 #[test]
 fn test_no_assumptions_defined_error() {
@@ -17,6 +18,16 @@ fn test_no_data_error() {
     assert_eq!(error.to_string(), "No Data to test provided");
 }
 
+#[test]
+fn test_assumption_failed_error() {
+    let assumption = test_utils::get_test_assumption();
+    let error = AssumptionError::AssumptionFailed(assumption.to_string());
+    assert_eq!(
+        error.to_string(),
+        "Assumption failed: Assumption: id: 1, description: Test assumption that data are there, assumption_tested: false, assumption_valid: false"
+    );
+}
+
 #[test]
 fn test_evaluation_failed_error() {
     let error = AssumptionError::EvaluationFailed("Test Error".to_string());

deep_causality/tests/types/model_types/assumption/assumption_tests.rs

@@ -124,7 +124,7 @@ fn test_assumption_debug() {
 
     // 1. Test initial state (before verification)
     let expected_initial = format!(
-        "Assumption: id: {}, description: {}, assumption_fn: fn(&[PropagatingEffect]) -> Result<bool, AssumptionError>;, assumption_tested: {},assumption_valid: {}",
+        "Assumption: id: {}, description: {}, assumption_tested: {}, assumption_valid: {}",
         id, description, false, false
     );
 
@@ -142,7 +142,7 @@ fn test_assumption_debug() {
 
     // 3. Test final state (after verification)
     let expected_after_verify = format!(
-        "Assumption: id: {}, description: {}, assumption_fn: fn(&[PropagatingEffect]) -> Result<bool, AssumptionError>;, assumption_tested: {},assumption_valid: {}",
+        "Assumption: id: {}, description: {}, assumption_tested: {}, assumption_valid: {}",
         id, description, true, true
     );
 
@@ -162,7 +162,7 @@ fn test_assumption_to_string() {
     assert_eq!(assumption.description(), description);
 
     let expected = format!(
-        "Assumption: id: {}, description: {}, assumption_fn: fn(&[PropagatingEffect]) -> Result<bool, AssumptionError>;, assumption_tested: {},assumption_valid: {}",
+        "Assumption: id: {}, description: {}, assumption_tested: {}, assumption_valid: {}",
         id, description, false, false
     );
     let actual = assumption.to_string();

deep_causality/tests/types/model_types/model/mod.rs

@@ -2,5 +2,6 @@
  * SPDX-License-Identifier: MIT
  * Copyright (c) "2025" . The DeepCausality Authors and Contributors. All Rights Reserved.
  */
+mod model_assumptions_tests;
 #[cfg(test)]
 mod model_tests;