reworked evaluate_probabilistic_propagation and evaluate_mixed_propagation in causable_reasoning.rs

Fixed downstream tests.

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

Author: marvin-hansen

deep_causality/src/traits/causable/causable_reasoning.rs

@@ -121,79 +121,61 @@ where
         }
 
         // Convert final probability to a deterministic outcome based on a threshold.
-        if cumulative_prob > 0.5 {
-            Ok(PropagatingEffect::Deterministic(true))
-        } else {
-            Ok(PropagatingEffect::Deterministic(false))
-        }
+        Ok(PropagatingEffect::Probabilistic(cumulative_prob))
     }
 
     /// Evaluates a linear chain of causes that may contain a mix of deterministic and
-    /// probabilistic effects, aggregating them into a final effect.
+    /// probabilistic effects, aggregating them into a final deterministic outcome.
+    ///
+    /// This method converts all effects (`Deterministic`, `Probabilistic`, `Numerical`)
+    /// into a numerical value (where true=1.0, false=0.0) and aggregates them by
+    /// multiplication. The final cumulative probability is then compared against a
+    /// threshold (0.5) to produce a final `Deterministic(true)` or `Deterministic(false)`.
+    ///
+    /// This approach is robust, order-independent, and provides a consistent result.
     ///
     /// # Arguments
     /// * `effect` - A single `PropagatingEffect` object that all causes will use.
     ///
     /// # Errors
-    /// Returns a `CausalityError` if a `ContextualLink` is encountered.
+    /// Returns a `CausalityError` if a `ContextualLink` is encountered, as it cannot be
+    /// converted to a numerical probability.
     fn evaluate_mixed_propagation(
         &self,
         effect: &PropagatingEffect,
         _logic: &AggregateLogic,
     ) -> Result<PropagatingEffect, CausalityError> {
-        // The chain starts as deterministically true. It can transition to probabilistic.
-        let mut aggregated_effect = PropagatingEffect::Deterministic(true);
+        // Start with 1.0, the multiplicative identity, to aggregate all effects numerically.
+        let mut cumulative_prob: NumericalValue = 1.0;
 
         for cause in self.get_all_items() {
             let current_effect = cause.evaluate(effect)?;
 
-            // Update the aggregated effect based on the current effect.
-            aggregated_effect = match (aggregated_effect, current_effect) {
-                // Deterministic false breaks the chain.
-                (_, PropagatingEffect::Deterministic(false)) => {
-                    return Ok(PropagatingEffect::Deterministic(false));
-                }
-
-                // ContextualLink is invalid in this context.
-                (_, PropagatingEffect::ContextualLink(_, _)) => {
-                    return Err(CausalityError(
-                        "Encountered a ContextualLink in a mixed-chain evaluation.".into(),
-                    ));
-                }
-
-                // If the chain is deterministic and the new effect is true, it remains deterministic true.
-                (
-                    PropagatingEffect::Deterministic(true),
-                    PropagatingEffect::Deterministic(true),
-                ) => PropagatingEffect::Deterministic(true),
-
-                // If the chain is deterministic and the new effect is probabilistic, the chain becomes probabilistic.
-                (PropagatingEffect::Deterministic(true), PropagatingEffect::Probabilistic(p)) => {
-                    PropagatingEffect::Probabilistic(p)
-                }
-
-                // If the chain is already probabilistic and the new effect is true, the probability is unchanged.
-                (PropagatingEffect::Probabilistic(p), PropagatingEffect::Deterministic(true)) => {
-                    PropagatingEffect::Probabilistic(p)
-                }
-
-                // If the chain is probabilistic and the new effect is also probabilistic, multiply them.
-                (PropagatingEffect::Probabilistic(p1), PropagatingEffect::Probabilistic(p2)) => {
-                    PropagatingEffect::Probabilistic(p1 * p2)
-                }
-
-                // Other combinations should not be possible due to the guards above.
-                (agg, curr) => {
+            // Convert every effect to a numerical probability to ensure consistent, order-independent aggregation.
+            let current_prob = match current_effect {
+                PropagatingEffect::Deterministic(true) => 1.0,
+                PropagatingEffect::Deterministic(false) => 0.0,
+                PropagatingEffect::Probabilistic(p) => p,
+                PropagatingEffect::Numerical(p) => p,
+                // .
+                _ => {
+                    // Other variants are not handled in this mode.
                     return Err(CausalityError(format!(
-                        "Unhandled effect combination in mixed chain: Agg: {agg:?}, Curr: {curr:?}"
+                        "evaluate_mixed_propagation encountered an unsupported effect: {effect:?}. Only probabilistic, deterministic, or numerical effects are allowed."
                     )));
                 }
             };
+
+            cumulative_prob *= current_prob;
         }
 
-        Ok(aggregated_effect)
+        // Convert the final aggregated probability to a deterministic outcome based on a standard threshold.
+        if cumulative_prob > 0.5 {
+            Ok(PropagatingEffect::Deterministic(true))
+        } else {
+            Ok(PropagatingEffect::Deterministic(false))
+        }
     }
-
     /// Generates an explanation by concatenating the `explain()` text of all causes.
     ///
     /// Each explanation is formatted and separated by newlines.

deep_causality/src/utils_test/test_utils.rs

@@ -34,12 +34,18 @@ pub fn get_test_inf_vec() -> Vec<Inference> {
     Vec::from_iter([i1, i2])
 }
 
-pub fn get_test_causality_vec() -> BaseCausaloidVec {
+pub fn get_deterministic_test_causality_vec() -> BaseCausaloidVec {
     let q1 = get_test_causaloid_deterministic();
     let q2 = get_test_causaloid_deterministic();
     let q3 = get_test_causaloid_deterministic();
     Vec::from_iter([q1, q2, q3])
 }
+pub fn get_probabilistic_test_causality_vec() -> BaseCausaloidVec {
+    let q1 = get_test_causaloid_probabilistic();
+    let q2 = get_test_causaloid_probabilistic();
+    let q3 = get_test_causaloid_probabilistic();
+    Vec::from_iter([q1, q2, q3])
+}
 
 pub fn get_test_single_data(val: NumericalValue) -> PropagatingEffect {
     PropagatingEffect::Numerical(val)
@@ -87,7 +93,7 @@ pub fn get_test_causaloid_probabilistic() -> BaseCausaloid {
 
                 //  If it's the Probabilistic, extract the inner value.
                 PropagatingEffect::Probabilistic(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."

deep_causality/tests/extensions/causable/causable_arr_tests.rs

@@ -24,7 +24,7 @@ pub fn get_test_causality_array_mixed() -> [BaseCausaloid; 20] {
 
     // Combine a1 and a2
     a1.into_iter()
-        .chain(a2.into_iter())
+        .chain(a2)
         .collect::<Vec<_>>()
         .try_into()
         .unwrap()

deep_causality/tests/extensions/causable/causable_btree_map_tests.rs

@@ -12,14 +12,22 @@ use deep_causality::*;
 type TestBTreeMap = BTreeMap<i8, BaseCausaloid>;
 
 // Helper function to create a standard test BTreeMap.
-fn get_test_causality_btree_map() -> TestBTreeMap {
+fn get_test_causality_btree_map_deterministic() -> TestBTreeMap {
     BTreeMap::from([
         (1, get_test_causaloid_deterministic()),
         (2, get_test_causaloid_deterministic()),
         (3, get_test_causaloid_deterministic()),
     ])
 }
 
+fn get_test_causality_btree_map_probabilistic() -> TestBTreeMap {
+    BTreeMap::from([
+        (1, get_test_causaloid_probabilistic()),
+        (2, get_test_causaloid_probabilistic()),
+        (3, get_test_causaloid_probabilistic()),
+    ])
+}
+
 // Helper to activate all causes in a collection for testing purposes.
 fn activate_all_causes(map: &TestBTreeMap) {
     // A value that ensures the default test causaloid (threshold 0.55) becomes active.
@@ -32,7 +40,7 @@ fn activate_all_causes(map: &TestBTreeMap) {
 
 #[test]
 fn test_add() {
-    let mut map = get_test_causality_btree_map();
+    let mut map = get_test_causality_btree_map_deterministic();
     assert_eq!(3, map.len());
 
     let q = get_test_causaloid_deterministic();
@@ -42,7 +50,7 @@ fn test_add() {
 
 #[test]
 fn test_contains() {
-    let mut map = get_test_causality_btree_map();
+    let mut map = get_test_causality_btree_map_deterministic();
     assert_eq!(3, map.len());
     assert!(map.contains_key(&1));
 
@@ -54,7 +62,7 @@ fn test_contains() {
 
 #[test]
 fn test_remove() {
-    let mut map = get_test_causality_btree_map();
+    let mut map = get_test_causality_btree_map_deterministic();
     assert_eq!(3, map.len());
     assert!(map.contains_key(&1));
 
@@ -65,7 +73,7 @@ fn test_remove() {
 
 #[test]
 fn test_get_all_items() {
-    let col = get_test_causality_btree_map();
+    let col = get_test_causality_btree_map_deterministic();
     let all_items = col.get_all_items();
 
     let exp_len = col.len();
@@ -75,7 +83,7 @@ fn test_get_all_items() {
 
 #[test]
 fn test_evaluate_deterministic_propagation() {
-    let map = get_test_causality_btree_map();
+    let map = get_test_causality_btree_map_deterministic();
 
     // Case 1: All succeed, chain should be deterministically true.
     let effect_success = PropagatingEffect::Numerical(0.99);
@@ -94,7 +102,7 @@ fn test_evaluate_deterministic_propagation() {
 
 #[test]
 fn test_evaluate_probabilistic_propagation() {
-    let map = get_test_causality_btree_map();
+    let map = get_test_causality_btree_map_probabilistic();
 
     // Case 1: All succeed (Deterministic(true) is treated as probability 1.0).
     // The cumulative probability should be 1.0.
@@ -115,7 +123,7 @@ fn test_evaluate_probabilistic_propagation() {
 
 #[test]
 fn test_evaluate_mixed_propagation() {
-    let map = get_test_causality_btree_map();
+    let map = get_test_causality_btree_map_deterministic();
 
     // Case 1: All succeed, chain remains deterministically true.
     let effect_success = PropagatingEffect::Numerical(0.99);
@@ -134,7 +142,7 @@ fn test_evaluate_mixed_propagation() {
 
 #[test]
 fn test_explain() {
-    let map = get_test_causality_btree_map();
+    let map = get_test_causality_btree_map_deterministic();
     activate_all_causes(&map);
 
     let single_explanation = "Causaloid: 1 'tests whether data exceeds threshold of 0.55' evaluated to: PropagatingEffect::Deterministic(true)";
@@ -148,18 +156,18 @@ fn test_explain() {
 
 #[test]
 fn test_len() {
-    let map = get_test_causality_btree_map();
+    let map = get_test_causality_btree_map_deterministic();
     assert_eq!(3, map.len());
 }
 
 #[test]
 fn test_is_empty() {
-    let map = get_test_causality_btree_map();
+    let map = get_test_causality_btree_map_deterministic();
     assert!(!map.is_empty());
 }
 
 #[test]
 fn test_to_vec() {
-    let map = get_test_causality_btree_map();
+    let map = get_test_causality_btree_map_deterministic();
     assert_eq!(3, map.to_vec().len());
 }

deep_causality/tests/extensions/causable/causable_map_tests.rs

@@ -12,14 +12,22 @@ use deep_causality::*;
 type TestHashMap = HashMap<i8, BaseCausaloid>;
 
 // Helper function to create a standard test HashMap.
-fn get_test_causality_map() -> TestHashMap {
+fn get_deterministic_test_causality_map() -> TestHashMap {
     HashMap::from([
         (1, get_test_causaloid_deterministic()),
         (2, get_test_causaloid_deterministic()),
         (3, get_test_causaloid_deterministic()),
     ])
 }
 
+fn get_probabilistic_test_causality_map() -> TestHashMap {
+    HashMap::from([
+        (1, get_test_causaloid_probabilistic()),
+        (2, get_test_causaloid_probabilistic()),
+        (3, get_test_causaloid_probabilistic()),
+    ])
+}
+
 fn get_mixed_test_causality_map() -> TestHashMap {
     HashMap::from([
         (1, get_test_causaloid_deterministic_true()),
@@ -48,7 +56,7 @@ fn activate_all_causes(map: &TestHashMap) {
 
 #[test]
 fn test_add() {
-    let mut map = get_test_causality_map();
+    let mut map = get_deterministic_test_causality_map();
     assert_eq!(3, map.len());
 
     let q = get_test_causaloid_deterministic();
@@ -58,7 +66,7 @@ fn test_add() {
 
 #[test]
 fn test_contains() {
-    let mut map = get_test_causality_map();
+    let mut map = get_deterministic_test_causality_map();
     assert_eq!(3, map.len());
     assert!(map.contains_key(&1));
 
@@ -70,7 +78,7 @@ fn test_contains() {
 
 #[test]
 fn test_remove() {
-    let mut map = get_test_causality_map();
+    let mut map = get_deterministic_test_causality_map();
     assert_eq!(3, map.len());
     assert!(map.contains_key(&1));
 
@@ -81,7 +89,7 @@ fn test_remove() {
 
 #[test]
 fn test_get_all_items() {
-    let col = get_test_causality_map();
+    let col = get_deterministic_test_causality_map();
     let all_items = col.get_all_items();
 
     let exp_len = col.len();
@@ -91,7 +99,7 @@ fn test_get_all_items() {
 
 #[test]
 fn test_evaluate_deterministic_propagation() {
-    let map = get_test_causality_map();
+    let map = get_deterministic_test_causality_map();
 
     // Case 1: All succeed, chain should be deterministically true.
     let effect_success = PropagatingEffect::Numerical(0.99);
@@ -110,7 +118,7 @@ fn test_evaluate_deterministic_propagation() {
 
 #[test]
 fn test_evaluate_probabilistic_propagation() {
-    let map = get_test_causality_map();
+    let map = get_probabilistic_test_causality_map();
 
     // Case 1: All succeed (Deterministic(true) is treated as probability 1.0).
     // The cumulative probability should be 1.0.
@@ -138,8 +146,8 @@ fn test_evaluate_mixed_propagation() {
     let res_success = map
         .evaluate_mixed_propagation(&effect_success, &AggregateLogic::All)
         .unwrap();
-    // This is false b/c the AggregateLogic fails i.e. not all causes evaluate
-    assert_eq!(res_success, PropagatingEffect::Probabilistic(0.0));
+    // All mixed cased evaluate
+    assert_eq!(res_success, PropagatingEffect::Deterministic(true));
 }
 
 #[test]
@@ -154,7 +162,7 @@ fn test_evaluate_mixed_propagation_err() {
 
 #[test]
 fn test_explain() {
-    let map = get_test_causality_map();
+    let map = get_deterministic_test_causality_map();
     activate_all_causes(&map);
 
     let single_explanation = "Causaloid: 1 'tests whether data exceeds threshold of 0.55' evaluated to: PropagatingEffect::Deterministic(true)";
@@ -167,18 +175,18 @@ fn test_explain() {
 
 #[test]
 fn test_len() {
-    let map = get_test_causality_map();
+    let map = get_deterministic_test_causality_map();
     assert_eq!(3, map.len());
 }
 
 #[test]
 fn test_is_empty() {
-    let map = get_test_causality_map();
+    let map = get_deterministic_test_causality_map();
     assert!(!map.is_empty());
 }
 
 #[test]
 fn test_to_vec() {
-    let map = get_test_causality_map();
+    let map = get_deterministic_test_causality_map();
     assert_eq!(3, map.to_vec().len());
 }