Updated tests for deterministic input-output causaloids. Updated test utils. Improved causality graph evaluation logical clarity.

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

Author: marvin-hansen

deep_causality/src/utils_test/test_utils.rs

@@ -139,6 +139,29 @@ pub fn get_test_causaloid_deterministic() -> BaseCausaloid {
     Causaloid::new(id, causal_fn, description)
 }
 
+pub fn get_test_causaloid_deterministic_input_output() -> BaseCausaloid {
+    let id: IdentificationValue = 2;
+    let description = "Inverts any input";
+
+    fn causal_fn(effect: &PropagatingEffect) -> Result<PropagatingEffect, CausalityError> {
+        let obs =
+            match effect {
+                // If it's the Deterministic variant, extract the inner value.
+                PropagatingEffect::Deterministic(val) => *val,
+                // For any other type of effect, this function cannot proceed, so return an error.
+                _ => return Err(CausalityError(
+                    "Causal function expected Numerical effect but received a different variant."
+                        .into(),
+                )),
+            };
+
+        // Just invert the value.
+        Ok(PropagatingEffect::Deterministic(!obs))
+    }
+
+    Causaloid::new(id, causal_fn, description)
+}
+
 // BaseContext is a type alias for a basic context that can be used for testing
 // It matches the type signature of the base causaloid also uses in these tests.
 // See src/types/alias_types/csm_types for definition.

deep_causality/tests/types/causal_types/causaloid/causaloid_tests.rs

@@ -352,24 +352,26 @@ fn test_explain_collection_success() {
     assert!(explanation.contains("evaluated to: PropagatingEffect::Deterministic(true)"));
     assert!(explanation.contains("evaluated to: PropagatingEffect::Deterministic(false)"));
 }
+
 // This test covers an error path in explain() for a Collection Causaloid.
 #[test]
 fn test_explain_collection_with_sub_explain_error() {
     // Setup: A collection where one causaloid will not be evaluated due to short-circuiting.
-    let true_causaloid = test_utils::get_test_causaloid_deterministic_true();
+    let evaluated_causaloid = test_utils::get_test_causaloid_deterministic_true();
     let unevaluated_causaloid = test_utils::get_test_causaloid_deterministic(); // This one will remain unevaluated.
 
-    let causal_coll = vec![true_causaloid, unevaluated_causaloid];
+    // Act: Evaluate the collection. The evaluation will stop after the first `true` effect.
+    let effect = PropagatingEffect::Numerical(0.0);
+    evaluated_causaloid.evaluate(&effect).unwrap();
+
+    // collection_causaloid is only partially evaluated.
+    let causal_coll = vec![evaluated_causaloid, unevaluated_causaloid];
     let collection_causaloid = Causaloid::from_causal_collection(
         105,
         Arc::new(causal_coll),
         "Sub-explain Error Collection",
     );
 
-    // Act: Evaluate the collection. The evaluation will stop after the first `true` effect.
-    let effect = PropagatingEffect::Numerical(0.0);
-    collection_causaloid.evaluate(&effect).unwrap();
-
     // Now, call explain. This will fail because the second causaloid was never evaluated.
     let result = collection_causaloid.explain();
 
@@ -414,7 +416,7 @@ fn test_evaluate_singleton_with_context() {
 }
 
 #[test]
-fn test_evaluate_collection_ignores_other_effects() {
+fn test_evaluate_collection_other_effect_err() {
     // Setup: A collection with causaloids that have effects other than Deterministic or Halting.
     let probabilistic_causaloid = test_utils::get_test_causaloid_probabilistic();
     let contextual_link_causaloid = test_utils::get_test_causaloid_contextual_link();
@@ -430,9 +432,9 @@ fn test_evaluate_collection_ignores_other_effects() {
 
     // Act
     let effect = PropagatingEffect::Numerical(0.0);
-    let res = collection_causaloid.evaluate(&effect).unwrap();
+    let res = collection_causaloid.evaluate(&effect);
 
-    // Assert: The aggregation logic should ignore Probabilistic and ContextualLink,
-    // resulting in an overall effect of Deterministic(false).
-    assert_eq!(res, PropagatingEffect::Deterministic(false));
+    // Assert: The collection should return an error because
+    // it contains a causaloid with an effect other than Deterministic or Probabilistic.
+    assert!(res.is_err())
 }

deep_causality/tests/types/causal_types/causaloid_graph/causality_graph_reasoning_all_tests.rs

@@ -18,34 +18,46 @@ fn test_graph_evaluate() {
     assert!(g.contains_causaloid(root_index));
 
     // Add causaloid A
-    let causaloid_a = test_utils::get_test_causaloid_deterministic();
+    let causaloid_a = test_utils::get_test_causaloid_deterministic_input_output();
     let idx_a = g
         .add_causaloid(causaloid_a)
         .expect("Failed to add causaloid A");
+
+    // Link A to root
     g.add_edge(root_index, idx_a).expect("Failed to add edge");
 
     // Add causaloid B
-    let causaloid_b = test_utils::get_test_causaloid_deterministic();
+    let causaloid_b = test_utils::get_test_causaloid_deterministic_input_output();
     let idx_b = g
         .add_causaloid(causaloid_b)
         .expect("Failed to add causaloid B");
-    g.add_edge(root_index, idx_b).expect("Failed to add edge");
 
-    // Add causaloid C
-    let causaloid_c = test_utils::get_test_causaloid_deterministic();
-    let idx_c = g
-        .add_causaloid(causaloid_c)
-        .expect("Failed to add causaloid C");
-    g.add_edge(idx_a, idx_c).expect("Failed to add edge");
+    // Link A to B
+    g.add_edge(idx_a, idx_b).expect("Failed to add edge");
 
+    // Now, we have a graph like this:
+    // root -> A -> B
     g.freeze();
 
-    // Evaluate the graph using the Causable::evaluate method
+    // Create an initial effect to be applied to the root node
     let effect = PropagatingEffect::Numerical(0.99); // A value that will activate all nodes
-    let res = g.evaluate(&effect);
+    // Here we evaluate the effect on the root node only,
+    let res = g.evaluate_shortest_path_between_causes(root_index, root_index, &effect);
+    assert!(res.is_ok());
+    // The root node returns Deterministic(true) because its causal function evaluates to true w.r.t. to effect
+    assert_eq!(res.unwrap(), PropagatingEffect::Deterministic(true));
+
+    // Now, we evaluate the effect propagating from root to A
+    // Root evaluates from Numerical to true; and A evaluates from Boolean true to Boolean false
+    let res = g.evaluate_shortest_path_between_causes(root_index, idx_a, &effect);
+    assert!(res.is_ok());
+    assert_eq!(res.unwrap(), PropagatingEffect::Deterministic(false));
 
-    // Assert that evaluation was successful and the effect is as expected.
-    // The graph's evaluate returns Deterministic(true) because the sink node C becomes active.
+    // Now, we evaluate the effect propagating from  root -> A -> B
+    // Root evaluates from Numerical to true;
+    // A evaluates from Boolean true to Boolean false;
+    // B evaluates from Boolean false to Boolean true
+    let res = g.evaluate_shortest_path_between_causes(root_index, idx_b, &effect);
     assert!(res.is_ok());
     assert_eq!(res.unwrap(), PropagatingEffect::Deterministic(true));
 }

deep_causality/tests/types/causal_types/causaloid_graph/causality_graph_reasoning_sub_tests.rs

@@ -10,37 +10,42 @@ use deep_causality::*;
 fn test_evaluate_subgraph_from_cause() {
     let mut g = CausaloidGraph::new(0);
 
-    // Build a graph: root -> A, root -> B; A -> C
+    // Add root causaloid
     let root_causaloid = test_utils::get_test_causaloid_deterministic();
     let root_index = g
         .add_root_causaloid(root_causaloid)
         .expect("Failed to add root index");
+    assert!(g.contains_causaloid(root_index));
 
-    let causaloid_a = test_utils::get_test_causaloid_deterministic();
+    // Add causaloid A
+    let causaloid_a = test_utils::get_test_causaloid_deterministic_input_output();
     let idx_a = g
         .add_causaloid(causaloid_a)
         .expect("Failed to add causaloid A");
+
+    // Link A to root
     g.add_edge(root_index, idx_a).expect("Failed to add edge");
 
-    let causaloid_b = test_utils::get_test_causaloid_deterministic();
+    // Add causaloid B
+    let causaloid_b = test_utils::get_test_causaloid_deterministic_input_output();
     let idx_b = g
         .add_causaloid(causaloid_b)
         .expect("Failed to add causaloid B");
-    g.add_edge(root_index, idx_b).expect("Failed to add edge");
 
-    let causaloid_c = test_utils::get_test_causaloid_deterministic();
-    let idx_c = g
-        .add_causaloid(causaloid_c)
-        .expect("Failed to add causaloid C");
-    g.add_edge(idx_a, idx_c).expect("Failed to add edge");
+    // Link A to B
+    g.add_edge(idx_a, idx_b).expect("Failed to add edge");
 
+    // Now, we have a graph like this:
+    // root -> A -> B
     g.freeze();
 
-    // 2. Evaluate a subgraph starting from node A. This should activate nodes A and C.
-    let effect = PropagatingEffect::Numerical(0.99);
+    // 2. Evaluate a subgraph starting from node A. This should activate nodes A and B.
+    let effect = PropagatingEffect::Deterministic(true);
     let res = g.evaluate_subgraph_from_cause(idx_a, &effect);
-
     assert!(res.is_ok());
+    // A evaluates from Boolean true to Boolean false;
+    // B evaluates from Boolean false to Boolean true;
+    // Thus the final effect is Deterministic(true)
     assert_eq!(res.unwrap(), PropagatingEffect::Deterministic(true));
 }